blob: 5a553513b41cc63933afca9c89304f094b3ab89a [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
Richard Trieuf81e5a92011-09-09 02:00:50 +00003354void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *BaseE,
Douglas Gregor81b747b2009-09-17 21:32:03 +00003355 SourceLocation OpLoc,
3356 bool IsArrow) {
3357 if (!BaseE || !CodeCompleter)
3358 return;
3359
John McCall0a2c5e22010-08-25 06:19:51 +00003360 typedef CodeCompletionResult Result;
Douglas Gregor86d9a522009-09-21 16:56:56 +00003361
Douglas Gregor81b747b2009-09-17 21:32:03 +00003362 Expr *Base = static_cast<Expr *>(BaseE);
3363 QualType BaseType = Base->getType();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003364
3365 if (IsArrow) {
3366 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
3367 BaseType = Ptr->getPointeeType();
3368 else if (BaseType->isObjCObjectPointerType())
Douglas Gregor3cdee122010-08-26 16:36:48 +00003369 /*Do nothing*/ ;
Douglas Gregor86d9a522009-09-21 16:56:56 +00003370 else
3371 return;
3372 }
3373
Douglas Gregor3da626b2011-07-07 16:03:39 +00003374 enum CodeCompletionContext::Kind contextKind;
3375
3376 if (IsArrow) {
3377 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess;
3378 }
3379 else {
3380 if (BaseType->isObjCObjectPointerType() ||
3381 BaseType->isObjCObjectOrInterfaceType()) {
3382 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
3383 }
3384 else {
3385 contextKind = CodeCompletionContext::CCC_DotMemberAccess;
3386 }
3387 }
3388
Douglas Gregor218937c2011-02-01 19:23:04 +00003389 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor3da626b2011-07-07 16:03:39 +00003390 CodeCompletionContext(contextKind,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003391 BaseType),
3392 &ResultBuilder::IsMember);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003393 Results.EnterNewScope();
3394 if (const RecordType *Record = BaseType->getAs<RecordType>()) {
Douglas Gregor3cdee122010-08-26 16:36:48 +00003395 // Indicate that we are performing a member access, and the cv-qualifiers
3396 // for the base object type.
3397 Results.setObjectTypeQualifiers(BaseType.getQualifiers());
3398
Douglas Gregor95ac6552009-11-18 01:29:26 +00003399 // Access to a C/C++ class, struct, or union.
Douglas Gregor45bcd432010-01-14 03:21:49 +00003400 Results.allowNestedNameSpecifiers();
Douglas Gregor0cc84042010-01-14 15:47:35 +00003401 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00003402 LookupVisibleDecls(Record->getDecl(), LookupMemberName, Consumer,
3403 CodeCompleter->includeGlobals());
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003404
Douglas Gregor95ac6552009-11-18 01:29:26 +00003405 if (getLangOptions().CPlusPlus) {
3406 if (!Results.empty()) {
3407 // The "template" keyword can follow "->" or "." in the grammar.
3408 // However, we only want to suggest the template keyword if something
3409 // is dependent.
3410 bool IsDependent = BaseType->isDependentType();
3411 if (!IsDependent) {
3412 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
3413 if (DeclContext *Ctx = (DeclContext *)DepScope->getEntity()) {
3414 IsDependent = Ctx->isDependentContext();
3415 break;
3416 }
3417 }
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003418
Douglas Gregor95ac6552009-11-18 01:29:26 +00003419 if (IsDependent)
Douglas Gregora4477812010-01-14 16:01:26 +00003420 Results.AddResult(Result("template"));
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003421 }
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003422 }
Douglas Gregor95ac6552009-11-18 01:29:26 +00003423 } else if (!IsArrow && BaseType->getAsObjCInterfacePointerType()) {
3424 // Objective-C property reference.
Douglas Gregor73449212010-12-09 23:01:55 +00003425 AddedPropertiesSet AddedProperties;
Douglas Gregor95ac6552009-11-18 01:29:26 +00003426
3427 // Add property results based on our interface.
3428 const ObjCObjectPointerType *ObjCPtr
3429 = BaseType->getAsObjCInterfacePointerType();
3430 assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003431 AddObjCProperties(ObjCPtr->getInterfaceDecl(), true,
3432 /*AllowNullaryMethods=*/true, CurContext,
Douglas Gregor73449212010-12-09 23:01:55 +00003433 AddedProperties, Results);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003434
3435 // Add properties from the protocols in a qualified interface.
3436 for (ObjCObjectPointerType::qual_iterator I = ObjCPtr->qual_begin(),
3437 E = ObjCPtr->qual_end();
3438 I != E; ++I)
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003439 AddObjCProperties(*I, true, /*AllowNullaryMethods=*/true, CurContext,
3440 AddedProperties, Results);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003441 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
John McCallc12c5bb2010-05-15 11:32:37 +00003442 (!IsArrow && BaseType->isObjCObjectType())) {
Douglas Gregor95ac6552009-11-18 01:29:26 +00003443 // Objective-C instance variable access.
3444 ObjCInterfaceDecl *Class = 0;
3445 if (const ObjCObjectPointerType *ObjCPtr
3446 = BaseType->getAs<ObjCObjectPointerType>())
3447 Class = ObjCPtr->getInterfaceDecl();
3448 else
John McCallc12c5bb2010-05-15 11:32:37 +00003449 Class = BaseType->getAs<ObjCObjectType>()->getInterface();
Douglas Gregor95ac6552009-11-18 01:29:26 +00003450
3451 // Add all ivars from this class and its superclasses.
Douglas Gregor80f4f4c2010-01-14 16:08:12 +00003452 if (Class) {
3453 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3454 Results.setFilter(&ResultBuilder::IsObjCIvar);
Douglas Gregor8071e422010-08-15 06:18:01 +00003455 LookupVisibleDecls(Class, LookupMemberName, Consumer,
3456 CodeCompleter->includeGlobals());
Douglas Gregor95ac6552009-11-18 01:29:26 +00003457 }
Douglas Gregor86d9a522009-09-21 16:56:56 +00003458 }
Douglas Gregor95ac6552009-11-18 01:29:26 +00003459
3460 // FIXME: How do we cope with isa?
3461
3462 Results.ExitScope();
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003463
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003464 // Hand off the results found for code completion.
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003465 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003466 Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003467 Results.data(),Results.size());
Douglas Gregor81b747b2009-09-17 21:32:03 +00003468}
3469
Douglas Gregor374929f2009-09-18 15:37:17 +00003470void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
3471 if (!CodeCompleter)
3472 return;
3473
John McCall0a2c5e22010-08-25 06:19:51 +00003474 typedef CodeCompletionResult Result;
Douglas Gregor86d9a522009-09-21 16:56:56 +00003475 ResultBuilder::LookupFilter Filter = 0;
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003476 enum CodeCompletionContext::Kind ContextKind
3477 = CodeCompletionContext::CCC_Other;
Douglas Gregor374929f2009-09-18 15:37:17 +00003478 switch ((DeclSpec::TST)TagSpec) {
3479 case DeclSpec::TST_enum:
Douglas Gregor86d9a522009-09-21 16:56:56 +00003480 Filter = &ResultBuilder::IsEnum;
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003481 ContextKind = CodeCompletionContext::CCC_EnumTag;
Douglas Gregor374929f2009-09-18 15:37:17 +00003482 break;
3483
3484 case DeclSpec::TST_union:
Douglas Gregor86d9a522009-09-21 16:56:56 +00003485 Filter = &ResultBuilder::IsUnion;
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003486 ContextKind = CodeCompletionContext::CCC_UnionTag;
Douglas Gregor374929f2009-09-18 15:37:17 +00003487 break;
3488
3489 case DeclSpec::TST_struct:
Douglas Gregor374929f2009-09-18 15:37:17 +00003490 case DeclSpec::TST_class:
Douglas Gregor86d9a522009-09-21 16:56:56 +00003491 Filter = &ResultBuilder::IsClassOrStruct;
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003492 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag;
Douglas Gregor374929f2009-09-18 15:37:17 +00003493 break;
3494
3495 default:
David Blaikieb219cfc2011-09-23 05:06:16 +00003496 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
Douglas Gregor374929f2009-09-18 15:37:17 +00003497 }
Douglas Gregor86d9a522009-09-21 16:56:56 +00003498
Douglas Gregor218937c2011-02-01 19:23:04 +00003499 ResultBuilder Results(*this, CodeCompleter->getAllocator(), ContextKind);
Douglas Gregor5d2fc402010-01-14 03:27:13 +00003500 CodeCompletionDeclConsumer Consumer(Results, CurContext);
John McCall0d6b1642010-04-23 18:46:30 +00003501
3502 // First pass: look for tags.
3503 Results.setFilter(Filter);
Douglas Gregor8071e422010-08-15 06:18:01 +00003504 LookupVisibleDecls(S, LookupTagName, Consumer,
3505 CodeCompleter->includeGlobals());
John McCall0d6b1642010-04-23 18:46:30 +00003506
Douglas Gregor8071e422010-08-15 06:18:01 +00003507 if (CodeCompleter->includeGlobals()) {
3508 // Second pass: look for nested name specifiers.
3509 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
3510 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer);
3511 }
Douglas Gregor86d9a522009-09-21 16:56:56 +00003512
Douglas Gregor52779fb2010-09-23 23:01:17 +00003513 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003514 Results.data(),Results.size());
Douglas Gregor374929f2009-09-18 15:37:17 +00003515}
3516
Douglas Gregor1a480c42010-08-27 17:35:51 +00003517void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) {
Douglas Gregor218937c2011-02-01 19:23:04 +00003518 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3519 CodeCompletionContext::CCC_TypeQualifiers);
Douglas Gregor1a480c42010-08-27 17:35:51 +00003520 Results.EnterNewScope();
3521 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
3522 Results.AddResult("const");
3523 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
3524 Results.AddResult("volatile");
3525 if (getLangOptions().C99 &&
3526 !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
3527 Results.AddResult("restrict");
3528 Results.ExitScope();
3529 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003530 Results.getCompletionContext(),
Douglas Gregor1a480c42010-08-27 17:35:51 +00003531 Results.data(), Results.size());
3532}
3533
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003534void Sema::CodeCompleteCase(Scope *S) {
John McCall781472f2010-08-25 08:40:02 +00003535 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003536 return;
John McCalla8e0cd82011-08-06 07:30:58 +00003537
John McCall781472f2010-08-25 08:40:02 +00003538 SwitchStmt *Switch = getCurFunction()->SwitchStack.back();
John McCalla8e0cd82011-08-06 07:30:58 +00003539 QualType type = Switch->getCond()->IgnoreImplicit()->getType();
3540 if (!type->isEnumeralType()) {
3541 CodeCompleteExpressionData Data(type);
Douglas Gregorfb629412010-08-23 21:17:50 +00003542 Data.IntegralConstantExpression = true;
3543 CodeCompleteExpression(S, Data);
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003544 return;
Douglas Gregorf9578432010-07-28 21:50:18 +00003545 }
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003546
3547 // Code-complete the cases of a switch statement over an enumeration type
3548 // by providing the list of
John McCalla8e0cd82011-08-06 07:30:58 +00003549 EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003550
3551 // Determine which enumerators we have already seen in the switch statement.
3552 // FIXME: Ideally, we would also be able to look *past* the code-completion
3553 // token, in case we are code-completing in the middle of the switch and not
3554 // at the end. However, we aren't able to do so at the moment.
3555 llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen;
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00003556 NestedNameSpecifier *Qualifier = 0;
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003557 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
3558 SC = SC->getNextSwitchCase()) {
3559 CaseStmt *Case = dyn_cast<CaseStmt>(SC);
3560 if (!Case)
3561 continue;
3562
3563 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
3564 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal))
3565 if (EnumConstantDecl *Enumerator
3566 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
3567 // We look into the AST of the case statement to determine which
3568 // enumerator was named. Alternatively, we could compute the value of
3569 // the integral constant expression, then compare it against the
3570 // values of each enumerator. However, value-based approach would not
3571 // work as well with C++ templates where enumerators declared within a
3572 // template are type- and value-dependent.
3573 EnumeratorsSeen.insert(Enumerator);
3574
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00003575 // If this is a qualified-id, keep track of the nested-name-specifier
3576 // so that we can reproduce it as part of code completion, e.g.,
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003577 //
3578 // switch (TagD.getKind()) {
3579 // case TagDecl::TK_enum:
3580 // break;
3581 // case XXX
3582 //
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00003583 // At the XXX, our completions are TagDecl::TK_union,
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003584 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
3585 // TK_struct, and TK_class.
Douglas Gregora2813ce2009-10-23 18:54:35 +00003586 Qualifier = DRE->getQualifier();
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003587 }
3588 }
3589
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00003590 if (getLangOptions().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) {
3591 // If there are no prior enumerators in C++, check whether we have to
3592 // qualify the names of the enumerators that we suggest, because they
3593 // may not be visible in this scope.
3594 Qualifier = getRequiredQualification(Context, CurContext,
3595 Enum->getDeclContext());
3596
3597 // FIXME: Scoped enums need to start with "EnumDecl" as the context!
3598 }
3599
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003600 // Add any enumerators that have not yet been mentioned.
Douglas Gregor218937c2011-02-01 19:23:04 +00003601 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3602 CodeCompletionContext::CCC_Expression);
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003603 Results.EnterNewScope();
3604 for (EnumDecl::enumerator_iterator E = Enum->enumerator_begin(),
3605 EEnd = Enum->enumerator_end();
3606 E != EEnd; ++E) {
3607 if (EnumeratorsSeen.count(*E))
3608 continue;
3609
Douglas Gregor5c722c702011-02-18 23:30:37 +00003610 CodeCompletionResult R(*E, Qualifier);
3611 R.Priority = CCP_EnumInCase;
3612 Results.AddResult(R, CurContext, 0, false);
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003613 }
3614 Results.ExitScope();
Douglas Gregor2f880e42010-04-06 20:02:15 +00003615
Douglas Gregor3da626b2011-07-07 16:03:39 +00003616 //We need to make sure we're setting the right context,
3617 //so only say we include macros if the code completer says we do
3618 enum CodeCompletionContext::Kind kind = CodeCompletionContext::CCC_Other;
3619 if (CodeCompleter->includeMacros()) {
Douglas Gregorbca403c2010-01-13 23:51:12 +00003620 AddMacroResults(PP, Results);
Douglas Gregor3da626b2011-07-07 16:03:39 +00003621 kind = CodeCompletionContext::CCC_OtherWithMacros;
3622 }
3623
3624
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003625 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor3da626b2011-07-07 16:03:39 +00003626 kind,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003627 Results.data(),Results.size());
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003628}
3629
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003630namespace {
3631 struct IsBetterOverloadCandidate {
3632 Sema &S;
John McCall5769d612010-02-08 23:07:23 +00003633 SourceLocation Loc;
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003634
3635 public:
John McCall5769d612010-02-08 23:07:23 +00003636 explicit IsBetterOverloadCandidate(Sema &S, SourceLocation Loc)
3637 : S(S), Loc(Loc) { }
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003638
3639 bool
3640 operator()(const OverloadCandidate &X, const OverloadCandidate &Y) const {
John McCall120d63c2010-08-24 20:38:10 +00003641 return isBetterOverloadCandidate(S, X, Y, Loc);
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003642 }
3643 };
3644}
3645
Douglas Gregord28dcd72010-05-30 06:10:08 +00003646static bool anyNullArguments(Expr **Args, unsigned NumArgs) {
3647 if (NumArgs && !Args)
3648 return true;
3649
3650 for (unsigned I = 0; I != NumArgs; ++I)
3651 if (!Args[I])
3652 return true;
3653
3654 return false;
3655}
3656
Richard Trieuf81e5a92011-09-09 02:00:50 +00003657void Sema::CodeCompleteCall(Scope *S, Expr *FnIn,
3658 Expr **ArgsIn, unsigned NumArgs) {
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003659 if (!CodeCompleter)
3660 return;
Douglas Gregoref96eac2009-12-11 19:06:04 +00003661
3662 // When we're code-completing for a call, we fall back to ordinary
3663 // name code-completion whenever we can't produce specific
3664 // results. We may want to revisit this strategy in the future,
3665 // e.g., by merging the two kinds of results.
3666
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003667 Expr *Fn = (Expr *)FnIn;
3668 Expr **Args = (Expr **)ArgsIn;
Douglas Gregoref96eac2009-12-11 19:06:04 +00003669
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003670 // Ignore type-dependent call expressions entirely.
Douglas Gregord28dcd72010-05-30 06:10:08 +00003671 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args, NumArgs) ||
Douglas Gregoref96eac2009-12-11 19:06:04 +00003672 Expr::hasAnyTypeDependentArguments(Args, NumArgs)) {
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003673 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003674 return;
Douglas Gregoref96eac2009-12-11 19:06:04 +00003675 }
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003676
John McCall3b4294e2009-12-16 12:17:52 +00003677 // Build an overload candidate set based on the functions we find.
John McCall5769d612010-02-08 23:07:23 +00003678 SourceLocation Loc = Fn->getExprLoc();
3679 OverloadCandidateSet CandidateSet(Loc);
John McCall3b4294e2009-12-16 12:17:52 +00003680
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003681 // FIXME: What if we're calling something that isn't a function declaration?
3682 // FIXME: What if we're calling a pseudo-destructor?
3683 // FIXME: What if we're calling a member function?
3684
Douglas Gregorc0265402010-01-21 15:46:19 +00003685 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate;
Chris Lattner5f9e2722011-07-23 10:55:15 +00003686 SmallVector<ResultCandidate, 8> Results;
Douglas Gregorc0265402010-01-21 15:46:19 +00003687
John McCall3b4294e2009-12-16 12:17:52 +00003688 Expr *NakedFn = Fn->IgnoreParenCasts();
3689 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
3690 AddOverloadedCallCandidates(ULE, Args, NumArgs, CandidateSet,
3691 /*PartialOverloading=*/ true);
3692 else if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(NakedFn)) {
3693 FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
Douglas Gregorc0265402010-01-21 15:46:19 +00003694 if (FDecl) {
Douglas Gregord28dcd72010-05-30 06:10:08 +00003695 if (!getLangOptions().CPlusPlus ||
3696 !FDecl->getType()->getAs<FunctionProtoType>())
Douglas Gregorc0265402010-01-21 15:46:19 +00003697 Results.push_back(ResultCandidate(FDecl));
3698 else
John McCall86820f52010-01-26 01:37:31 +00003699 // FIXME: access?
John McCall9aa472c2010-03-19 07:35:19 +00003700 AddOverloadCandidate(FDecl, DeclAccessPair::make(FDecl, AS_none),
3701 Args, NumArgs, CandidateSet,
Douglas Gregorc27d6c52010-04-16 17:41:49 +00003702 false, /*PartialOverloading*/true);
Douglas Gregorc0265402010-01-21 15:46:19 +00003703 }
John McCall3b4294e2009-12-16 12:17:52 +00003704 }
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003705
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003706 QualType ParamType;
3707
Douglas Gregorc0265402010-01-21 15:46:19 +00003708 if (!CandidateSet.empty()) {
3709 // Sort the overload candidate set by placing the best overloads first.
3710 std::stable_sort(CandidateSet.begin(), CandidateSet.end(),
John McCall5769d612010-02-08 23:07:23 +00003711 IsBetterOverloadCandidate(*this, Loc));
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003712
Douglas Gregorc0265402010-01-21 15:46:19 +00003713 // Add the remaining viable overload candidates as code-completion reslults.
3714 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(),
3715 CandEnd = CandidateSet.end();
3716 Cand != CandEnd; ++Cand) {
3717 if (Cand->Viable)
3718 Results.push_back(ResultCandidate(Cand->Function));
3719 }
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003720
3721 // From the viable candidates, try to determine the type of this parameter.
3722 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
3723 if (const FunctionType *FType = Results[I].getFunctionType())
3724 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FType))
3725 if (NumArgs < Proto->getNumArgs()) {
3726 if (ParamType.isNull())
3727 ParamType = Proto->getArgType(NumArgs);
3728 else if (!Context.hasSameUnqualifiedType(
3729 ParamType.getNonReferenceType(),
3730 Proto->getArgType(NumArgs).getNonReferenceType())) {
3731 ParamType = QualType();
3732 break;
3733 }
3734 }
3735 }
3736 } else {
3737 // Try to determine the parameter type from the type of the expression
3738 // being called.
3739 QualType FunctionType = Fn->getType();
3740 if (const PointerType *Ptr = FunctionType->getAs<PointerType>())
3741 FunctionType = Ptr->getPointeeType();
3742 else if (const BlockPointerType *BlockPtr
3743 = FunctionType->getAs<BlockPointerType>())
3744 FunctionType = BlockPtr->getPointeeType();
3745 else if (const MemberPointerType *MemPtr
3746 = FunctionType->getAs<MemberPointerType>())
3747 FunctionType = MemPtr->getPointeeType();
3748
3749 if (const FunctionProtoType *Proto
3750 = FunctionType->getAs<FunctionProtoType>()) {
3751 if (NumArgs < Proto->getNumArgs())
3752 ParamType = Proto->getArgType(NumArgs);
3753 }
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003754 }
Douglas Gregoref96eac2009-12-11 19:06:04 +00003755
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003756 if (ParamType.isNull())
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003757 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003758 else
3759 CodeCompleteExpression(S, ParamType);
3760
Douglas Gregor2e4c7a52010-04-06 20:19:47 +00003761 if (!Results.empty())
Douglas Gregoref96eac2009-12-11 19:06:04 +00003762 CodeCompleter->ProcessOverloadCandidates(*this, NumArgs, Results.data(),
3763 Results.size());
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003764}
3765
John McCalld226f652010-08-21 09:40:31 +00003766void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
3767 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003768 if (!VD) {
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003769 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003770 return;
3771 }
3772
3773 CodeCompleteExpression(S, VD->getType());
3774}
3775
3776void Sema::CodeCompleteReturn(Scope *S) {
3777 QualType ResultType;
3778 if (isa<BlockDecl>(CurContext)) {
3779 if (BlockScopeInfo *BSI = getCurBlock())
3780 ResultType = BSI->ReturnType;
3781 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext))
3782 ResultType = Function->getResultType();
3783 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext))
3784 ResultType = Method->getResultType();
3785
3786 if (ResultType.isNull())
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003787 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003788 else
3789 CodeCompleteExpression(S, ResultType);
3790}
3791
Douglas Gregord2d8be62011-07-30 08:36:53 +00003792void Sema::CodeCompleteAfterIf(Scope *S) {
3793 typedef CodeCompletionResult Result;
3794 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3795 mapCodeCompletionContext(*this, PCC_Statement));
3796 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3797 Results.EnterNewScope();
3798
3799 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3800 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3801 CodeCompleter->includeGlobals());
3802
3803 AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
3804
3805 // "else" block
3806 CodeCompletionBuilder Builder(Results.getAllocator());
3807 Builder.AddTypedTextChunk("else");
3808 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3809 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
3810 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3811 Builder.AddPlaceholderChunk("statements");
3812 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3813 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
3814 Results.AddResult(Builder.TakeString());
3815
3816 // "else if" block
3817 Builder.AddTypedTextChunk("else");
3818 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3819 Builder.AddTextChunk("if");
3820 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3821 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3822 if (getLangOptions().CPlusPlus)
3823 Builder.AddPlaceholderChunk("condition");
3824 else
3825 Builder.AddPlaceholderChunk("expression");
3826 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3827 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3828 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
3829 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3830 Builder.AddPlaceholderChunk("statements");
3831 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3832 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
3833 Results.AddResult(Builder.TakeString());
3834
3835 Results.ExitScope();
3836
3837 if (S->getFnParent())
3838 AddPrettyFunctionResults(PP.getLangOptions(), Results);
3839
3840 if (CodeCompleter->includeMacros())
3841 AddMacroResults(PP, Results);
3842
3843 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3844 Results.data(),Results.size());
3845}
3846
Richard Trieuf81e5a92011-09-09 02:00:50 +00003847void Sema::CodeCompleteAssignmentRHS(Scope *S, Expr *LHS) {
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003848 if (LHS)
3849 CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType());
3850 else
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003851 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003852}
3853
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00003854void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
Douglas Gregor81b747b2009-09-17 21:32:03 +00003855 bool EnteringContext) {
3856 if (!SS.getScopeRep() || !CodeCompleter)
3857 return;
3858
Douglas Gregor86d9a522009-09-21 16:56:56 +00003859 DeclContext *Ctx = computeDeclContext(SS, EnteringContext);
3860 if (!Ctx)
3861 return;
Douglas Gregord1cd31a2009-12-11 18:28:39 +00003862
3863 // Try to instantiate any non-dependent declaration contexts before
3864 // we look in them.
John McCall77bb1aa2010-05-01 00:40:08 +00003865 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
Douglas Gregord1cd31a2009-12-11 18:28:39 +00003866 return;
3867
Douglas Gregor218937c2011-02-01 19:23:04 +00003868 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3869 CodeCompletionContext::CCC_Name);
Douglas Gregorf6961522010-08-27 21:18:54 +00003870 Results.EnterNewScope();
Douglas Gregor52779fb2010-09-23 23:01:17 +00003871
Douglas Gregor86d9a522009-09-21 16:56:56 +00003872 // The "template" keyword can follow "::" in the grammar, but only
3873 // put it into the grammar if the nested-name-specifier is dependent.
3874 NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep();
3875 if (!Results.empty() && NNS->isDependent())
Douglas Gregora4477812010-01-14 16:01:26 +00003876 Results.AddResult("template");
Douglas Gregorf6961522010-08-27 21:18:54 +00003877
3878 // Add calls to overridden virtual functions, if there are any.
3879 //
3880 // FIXME: This isn't wonderful, because we don't know whether we're actually
3881 // in a context that permits expressions. This is a general issue with
3882 // qualified-id completions.
3883 if (!EnteringContext)
3884 MaybeAddOverrideCalls(*this, Ctx, Results);
3885 Results.ExitScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003886
Douglas Gregorf6961522010-08-27 21:18:54 +00003887 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3888 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer);
3889
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003890 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor430d7a12011-07-25 17:48:11 +00003891 Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003892 Results.data(),Results.size());
Douglas Gregor81b747b2009-09-17 21:32:03 +00003893}
Douglas Gregor49f40bd2009-09-18 19:03:04 +00003894
3895void Sema::CodeCompleteUsing(Scope *S) {
3896 if (!CodeCompleter)
3897 return;
3898
Douglas Gregor218937c2011-02-01 19:23:04 +00003899 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00003900 CodeCompletionContext::CCC_PotentiallyQualifiedName,
3901 &ResultBuilder::IsNestedNameSpecifier);
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003902 Results.EnterNewScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003903
3904 // If we aren't in class scope, we could see the "namespace" keyword.
3905 if (!S->isClassScope())
John McCall0a2c5e22010-08-25 06:19:51 +00003906 Results.AddResult(CodeCompletionResult("namespace"));
Douglas Gregor86d9a522009-09-21 16:56:56 +00003907
3908 // After "using", we can see anything that would start a
3909 // nested-name-specifier.
Douglas Gregor5d2fc402010-01-14 03:27:13 +00003910 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00003911 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3912 CodeCompleter->includeGlobals());
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003913 Results.ExitScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003914
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003915 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003916 CodeCompletionContext::CCC_PotentiallyQualifiedName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003917 Results.data(),Results.size());
Douglas Gregor49f40bd2009-09-18 19:03:04 +00003918}
3919
3920void Sema::CodeCompleteUsingDirective(Scope *S) {
3921 if (!CodeCompleter)
3922 return;
3923
Douglas Gregor86d9a522009-09-21 16:56:56 +00003924 // After "using namespace", we expect to see a namespace name or namespace
3925 // alias.
Douglas Gregor218937c2011-02-01 19:23:04 +00003926 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3927 CodeCompletionContext::CCC_Namespace,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003928 &ResultBuilder::IsNamespaceOrAlias);
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003929 Results.EnterNewScope();
Douglas Gregor5d2fc402010-01-14 03:27:13 +00003930 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00003931 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3932 CodeCompleter->includeGlobals());
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003933 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003934 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor8071e422010-08-15 06:18:01 +00003935 CodeCompletionContext::CCC_Namespace,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003936 Results.data(),Results.size());
Douglas Gregor49f40bd2009-09-18 19:03:04 +00003937}
3938
3939void Sema::CodeCompleteNamespaceDecl(Scope *S) {
3940 if (!CodeCompleter)
3941 return;
3942
Douglas Gregor86d9a522009-09-21 16:56:56 +00003943 DeclContext *Ctx = (DeclContext *)S->getEntity();
3944 if (!S->getParent())
3945 Ctx = Context.getTranslationUnitDecl();
3946
Douglas Gregor52779fb2010-09-23 23:01:17 +00003947 bool SuppressedGlobalResults
3948 = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
3949
Douglas Gregor218937c2011-02-01 19:23:04 +00003950 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00003951 SuppressedGlobalResults
3952 ? CodeCompletionContext::CCC_Namespace
3953 : CodeCompletionContext::CCC_Other,
3954 &ResultBuilder::IsNamespace);
3955
3956 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
Douglas Gregor86d9a522009-09-21 16:56:56 +00003957 // We only want to see those namespaces that have already been defined
3958 // within this scope, because its likely that the user is creating an
3959 // extended namespace declaration. Keep track of the most recent
3960 // definition of each namespace.
3961 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
3962 for (DeclContext::specific_decl_iterator<NamespaceDecl>
3963 NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end());
3964 NS != NSEnd; ++NS)
3965 OrigToLatest[NS->getOriginalNamespace()] = *NS;
3966
3967 // Add the most recent definition (or extended definition) of each
3968 // namespace to the list of results.
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003969 Results.EnterNewScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003970 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
3971 NS = OrigToLatest.begin(), NSEnd = OrigToLatest.end();
3972 NS != NSEnd; ++NS)
John McCall0a2c5e22010-08-25 06:19:51 +00003973 Results.AddResult(CodeCompletionResult(NS->second, 0),
Douglas Gregor608300b2010-01-14 16:14:35 +00003974 CurContext, 0, false);
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003975 Results.ExitScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003976 }
3977
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003978 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003979 Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003980 Results.data(),Results.size());
Douglas Gregor49f40bd2009-09-18 19:03:04 +00003981}
3982
3983void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) {
3984 if (!CodeCompleter)
3985 return;
3986
Douglas Gregor86d9a522009-09-21 16:56:56 +00003987 // After "namespace", we expect to see a namespace or alias.
Douglas Gregor218937c2011-02-01 19:23:04 +00003988 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3989 CodeCompletionContext::CCC_Namespace,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003990 &ResultBuilder::IsNamespaceOrAlias);
Douglas Gregor5d2fc402010-01-14 03:27:13 +00003991 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00003992 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3993 CodeCompleter->includeGlobals());
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003994 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003995 Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003996 Results.data(),Results.size());
Douglas Gregor49f40bd2009-09-18 19:03:04 +00003997}
3998
Douglas Gregored8d3222009-09-18 20:05:18 +00003999void Sema::CodeCompleteOperatorName(Scope *S) {
4000 if (!CodeCompleter)
4001 return;
Douglas Gregor86d9a522009-09-21 16:56:56 +00004002
John McCall0a2c5e22010-08-25 06:19:51 +00004003 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004004 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4005 CodeCompletionContext::CCC_Type,
Douglas Gregor52779fb2010-09-23 23:01:17 +00004006 &ResultBuilder::IsType);
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00004007 Results.EnterNewScope();
Douglas Gregored8d3222009-09-18 20:05:18 +00004008
Douglas Gregor86d9a522009-09-21 16:56:56 +00004009 // Add the names of overloadable operators.
4010#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4011 if (std::strcmp(Spelling, "?")) \
Douglas Gregora4477812010-01-14 16:01:26 +00004012 Results.AddResult(Result(Spelling));
Douglas Gregor86d9a522009-09-21 16:56:56 +00004013#include "clang/Basic/OperatorKinds.def"
4014
4015 // Add any type names visible from the current scope
Douglas Gregor45bcd432010-01-14 03:21:49 +00004016 Results.allowNestedNameSpecifiers();
Douglas Gregor5d2fc402010-01-14 03:27:13 +00004017 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00004018 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4019 CodeCompleter->includeGlobals());
Douglas Gregor86d9a522009-09-21 16:56:56 +00004020
4021 // Add any type specifiers
Douglas Gregorbca403c2010-01-13 23:51:12 +00004022 AddTypeSpecifierResults(getLangOptions(), Results);
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00004023 Results.ExitScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00004024
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004025 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor8071e422010-08-15 06:18:01 +00004026 CodeCompletionContext::CCC_Type,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004027 Results.data(),Results.size());
Douglas Gregored8d3222009-09-18 20:05:18 +00004028}
Douglas Gregor49f40bd2009-09-18 19:03:04 +00004029
Douglas Gregor0133f522010-08-28 00:00:50 +00004030void Sema::CodeCompleteConstructorInitializer(Decl *ConstructorD,
Sean Huntcbb67482011-01-08 20:30:50 +00004031 CXXCtorInitializer** Initializers,
Douglas Gregor0133f522010-08-28 00:00:50 +00004032 unsigned NumInitializers) {
Douglas Gregor8987b232011-09-27 23:30:47 +00004033 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
Douglas Gregor0133f522010-08-28 00:00:50 +00004034 CXXConstructorDecl *Constructor
4035 = static_cast<CXXConstructorDecl *>(ConstructorD);
4036 if (!Constructor)
4037 return;
4038
Douglas Gregor218937c2011-02-01 19:23:04 +00004039 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00004040 CodeCompletionContext::CCC_PotentiallyQualifiedName);
Douglas Gregor0133f522010-08-28 00:00:50 +00004041 Results.EnterNewScope();
4042
4043 // Fill in any already-initialized fields or base classes.
4044 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
4045 llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
4046 for (unsigned I = 0; I != NumInitializers; ++I) {
4047 if (Initializers[I]->isBaseInitializer())
4048 InitializedBases.insert(
4049 Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
4050 else
Francois Pichet00eb3f92010-12-04 09:14:42 +00004051 InitializedFields.insert(cast<FieldDecl>(
4052 Initializers[I]->getAnyMember()));
Douglas Gregor0133f522010-08-28 00:00:50 +00004053 }
4054
4055 // Add completions for base classes.
Douglas Gregor218937c2011-02-01 19:23:04 +00004056 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor0c431c82010-08-29 19:27:27 +00004057 bool SawLastInitializer = (NumInitializers == 0);
Douglas Gregor0133f522010-08-28 00:00:50 +00004058 CXXRecordDecl *ClassDecl = Constructor->getParent();
4059 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
4060 BaseEnd = ClassDecl->bases_end();
4061 Base != BaseEnd; ++Base) {
Douglas Gregor0c431c82010-08-29 19:27:27 +00004062 if (!InitializedBases.insert(Context.getCanonicalType(Base->getType()))) {
4063 SawLastInitializer
4064 = NumInitializers > 0 &&
4065 Initializers[NumInitializers - 1]->isBaseInitializer() &&
4066 Context.hasSameUnqualifiedType(Base->getType(),
4067 QualType(Initializers[NumInitializers - 1]->getBaseClass(), 0));
Douglas Gregor0133f522010-08-28 00:00:50 +00004068 continue;
Douglas Gregor0c431c82010-08-29 19:27:27 +00004069 }
Douglas Gregor0133f522010-08-28 00:00:50 +00004070
Douglas Gregor218937c2011-02-01 19:23:04 +00004071 Builder.AddTypedTextChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00004072 Results.getAllocator().CopyString(
John McCallf85e1932011-06-15 23:02:42 +00004073 Base->getType().getAsString(Policy)));
Douglas Gregor218937c2011-02-01 19:23:04 +00004074 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4075 Builder.AddPlaceholderChunk("args");
4076 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4077 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
Douglas Gregor0c431c82010-08-29 19:27:27 +00004078 SawLastInitializer? CCP_NextInitializer
4079 : CCP_MemberDeclaration));
4080 SawLastInitializer = false;
Douglas Gregor0133f522010-08-28 00:00:50 +00004081 }
4082
4083 // Add completions for virtual base classes.
4084 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
4085 BaseEnd = ClassDecl->vbases_end();
4086 Base != BaseEnd; ++Base) {
Douglas Gregor0c431c82010-08-29 19:27:27 +00004087 if (!InitializedBases.insert(Context.getCanonicalType(Base->getType()))) {
4088 SawLastInitializer
4089 = NumInitializers > 0 &&
4090 Initializers[NumInitializers - 1]->isBaseInitializer() &&
4091 Context.hasSameUnqualifiedType(Base->getType(),
4092 QualType(Initializers[NumInitializers - 1]->getBaseClass(), 0));
Douglas Gregor0133f522010-08-28 00:00:50 +00004093 continue;
Douglas Gregor0c431c82010-08-29 19:27:27 +00004094 }
Douglas Gregor0133f522010-08-28 00:00:50 +00004095
Douglas Gregor218937c2011-02-01 19:23:04 +00004096 Builder.AddTypedTextChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00004097 Builder.getAllocator().CopyString(
John McCallf85e1932011-06-15 23:02:42 +00004098 Base->getType().getAsString(Policy)));
Douglas Gregor218937c2011-02-01 19:23:04 +00004099 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4100 Builder.AddPlaceholderChunk("args");
4101 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4102 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
Douglas Gregor0c431c82010-08-29 19:27:27 +00004103 SawLastInitializer? CCP_NextInitializer
4104 : CCP_MemberDeclaration));
4105 SawLastInitializer = false;
Douglas Gregor0133f522010-08-28 00:00:50 +00004106 }
4107
4108 // Add completions for members.
4109 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
4110 FieldEnd = ClassDecl->field_end();
4111 Field != FieldEnd; ++Field) {
Douglas Gregor0c431c82010-08-29 19:27:27 +00004112 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))) {
4113 SawLastInitializer
4114 = NumInitializers > 0 &&
Francois Pichet00eb3f92010-12-04 09:14:42 +00004115 Initializers[NumInitializers - 1]->isAnyMemberInitializer() &&
4116 Initializers[NumInitializers - 1]->getAnyMember() == *Field;
Douglas Gregor0133f522010-08-28 00:00:50 +00004117 continue;
Douglas Gregor0c431c82010-08-29 19:27:27 +00004118 }
Douglas Gregor0133f522010-08-28 00:00:50 +00004119
4120 if (!Field->getDeclName())
4121 continue;
4122
Douglas Gregordae68752011-02-01 22:57:45 +00004123 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00004124 Field->getIdentifier()->getName()));
4125 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4126 Builder.AddPlaceholderChunk("args");
4127 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4128 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
Douglas Gregor0c431c82010-08-29 19:27:27 +00004129 SawLastInitializer? CCP_NextInitializer
Douglas Gregora67e03f2010-09-09 21:42:20 +00004130 : CCP_MemberDeclaration,
4131 CXCursor_MemberRef));
Douglas Gregor0c431c82010-08-29 19:27:27 +00004132 SawLastInitializer = false;
Douglas Gregor0133f522010-08-28 00:00:50 +00004133 }
4134 Results.ExitScope();
4135
Douglas Gregor52779fb2010-09-23 23:01:17 +00004136 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregor0133f522010-08-28 00:00:50 +00004137 Results.data(), Results.size());
4138}
4139
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004140// Macro that expands to @Keyword or Keyword, depending on whether NeedAt is
4141// true or false.
4142#define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) NeedAt? "@" #Keyword : #Keyword
Douglas Gregorbca403c2010-01-13 23:51:12 +00004143static void AddObjCImplementationResults(const LangOptions &LangOpts,
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004144 ResultBuilder &Results,
4145 bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004146 typedef CodeCompletionResult Result;
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004147 // Since we have an implementation, we can end it.
Douglas Gregora4477812010-01-14 16:01:26 +00004148 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,end)));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004149
Douglas Gregor218937c2011-02-01 19:23:04 +00004150 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004151 if (LangOpts.ObjC2) {
4152 // @dynamic
Douglas Gregor218937c2011-02-01 19:23:04 +00004153 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,dynamic));
4154 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4155 Builder.AddPlaceholderChunk("property");
4156 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004157
4158 // @synthesize
Douglas Gregor218937c2011-02-01 19:23:04 +00004159 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,synthesize));
4160 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4161 Builder.AddPlaceholderChunk("property");
4162 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004163 }
4164}
4165
Douglas Gregorbca403c2010-01-13 23:51:12 +00004166static void AddObjCInterfaceResults(const LangOptions &LangOpts,
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004167 ResultBuilder &Results,
4168 bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004169 typedef CodeCompletionResult Result;
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004170
4171 // Since we have an interface or protocol, we can end it.
Douglas Gregora4477812010-01-14 16:01:26 +00004172 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,end)));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004173
4174 if (LangOpts.ObjC2) {
4175 // @property
Douglas Gregora4477812010-01-14 16:01:26 +00004176 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,property)));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004177
4178 // @required
Douglas Gregora4477812010-01-14 16:01:26 +00004179 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,required)));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004180
4181 // @optional
Douglas Gregora4477812010-01-14 16:01:26 +00004182 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,optional)));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004183 }
4184}
4185
Douglas Gregorbca403c2010-01-13 23:51:12 +00004186static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004187 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004188 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004189
4190 // @class name ;
Douglas Gregor218937c2011-02-01 19:23:04 +00004191 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,class));
4192 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4193 Builder.AddPlaceholderChunk("name");
4194 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004195
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004196 if (Results.includeCodePatterns()) {
4197 // @interface name
4198 // FIXME: Could introduce the whole pattern, including superclasses and
4199 // such.
Douglas Gregor218937c2011-02-01 19:23:04 +00004200 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,interface));
4201 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4202 Builder.AddPlaceholderChunk("class");
4203 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004204
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004205 // @protocol name
Douglas Gregor218937c2011-02-01 19:23:04 +00004206 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,protocol));
4207 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4208 Builder.AddPlaceholderChunk("protocol");
4209 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004210
4211 // @implementation name
Douglas Gregor218937c2011-02-01 19:23:04 +00004212 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,implementation));
4213 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4214 Builder.AddPlaceholderChunk("class");
4215 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004216 }
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004217
4218 // @compatibility_alias name
Douglas Gregor218937c2011-02-01 19:23:04 +00004219 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,compatibility_alias));
4220 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4221 Builder.AddPlaceholderChunk("alias");
4222 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4223 Builder.AddPlaceholderChunk("class");
4224 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004225}
4226
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004227void Sema::CodeCompleteObjCAtDirective(Scope *S) {
John McCall0a2c5e22010-08-25 06:19:51 +00004228 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004229 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4230 CodeCompletionContext::CCC_Other);
Douglas Gregorc464ae82009-12-07 09:27:33 +00004231 Results.EnterNewScope();
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004232 if (isa<ObjCImplDecl>(CurContext))
Douglas Gregorbca403c2010-01-13 23:51:12 +00004233 AddObjCImplementationResults(getLangOptions(), Results, false);
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004234 else if (CurContext->isObjCContainer())
Douglas Gregorbca403c2010-01-13 23:51:12 +00004235 AddObjCInterfaceResults(getLangOptions(), Results, false);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004236 else
Douglas Gregorbca403c2010-01-13 23:51:12 +00004237 AddObjCTopLevelResults(Results, false);
Douglas Gregorc464ae82009-12-07 09:27:33 +00004238 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004239 HandleCodeCompleteResults(this, CodeCompleter,
4240 CodeCompletionContext::CCC_Other,
4241 Results.data(),Results.size());
Douglas Gregorc464ae82009-12-07 09:27:33 +00004242}
4243
Douglas Gregorbca403c2010-01-13 23:51:12 +00004244static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004245 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004246 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004247
4248 // @encode ( type-name )
Douglas Gregor8ca72082011-10-18 21:20:17 +00004249 const char *EncodeType = "char[]";
4250 if (Results.getSema().getLangOptions().CPlusPlus ||
4251 Results.getSema().getLangOptions().ConstStrings)
4252 EncodeType = " const char[]";
4253 Builder.AddResultTypeChunk(EncodeType);
Douglas Gregor218937c2011-02-01 19:23:04 +00004254 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,encode));
4255 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4256 Builder.AddPlaceholderChunk("type-name");
4257 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4258 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004259
4260 // @protocol ( protocol-name )
Douglas Gregor8ca72082011-10-18 21:20:17 +00004261 Builder.AddResultTypeChunk("Protocol *");
Douglas Gregor218937c2011-02-01 19:23:04 +00004262 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,protocol));
4263 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4264 Builder.AddPlaceholderChunk("protocol-name");
4265 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4266 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004267
4268 // @selector ( selector )
Douglas Gregor8ca72082011-10-18 21:20:17 +00004269 Builder.AddResultTypeChunk("SEL");
Douglas Gregor218937c2011-02-01 19:23:04 +00004270 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,selector));
4271 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4272 Builder.AddPlaceholderChunk("selector");
4273 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4274 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004275}
4276
Douglas Gregorbca403c2010-01-13 23:51:12 +00004277static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004278 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004279 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004280
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004281 if (Results.includeCodePatterns()) {
4282 // @try { statements } @catch ( declaration ) { statements } @finally
4283 // { statements }
Douglas Gregor218937c2011-02-01 19:23:04 +00004284 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,try));
4285 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4286 Builder.AddPlaceholderChunk("statements");
4287 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4288 Builder.AddTextChunk("@catch");
4289 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4290 Builder.AddPlaceholderChunk("parameter");
4291 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4292 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4293 Builder.AddPlaceholderChunk("statements");
4294 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4295 Builder.AddTextChunk("@finally");
4296 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4297 Builder.AddPlaceholderChunk("statements");
4298 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4299 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004300 }
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004301
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004302 // @throw
Douglas Gregor218937c2011-02-01 19:23:04 +00004303 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,throw));
4304 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4305 Builder.AddPlaceholderChunk("expression");
4306 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004307
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004308 if (Results.includeCodePatterns()) {
4309 // @synchronized ( expression ) { statements }
Douglas Gregor218937c2011-02-01 19:23:04 +00004310 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,synchronized));
4311 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4312 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4313 Builder.AddPlaceholderChunk("expression");
4314 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4315 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4316 Builder.AddPlaceholderChunk("statements");
4317 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4318 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004319 }
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004320}
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004321
Douglas Gregorbca403c2010-01-13 23:51:12 +00004322static void AddObjCVisibilityResults(const LangOptions &LangOpts,
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004323 ResultBuilder &Results,
4324 bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004325 typedef CodeCompletionResult Result;
Douglas Gregora4477812010-01-14 16:01:26 +00004326 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,private)));
4327 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,protected)));
4328 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,public)));
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004329 if (LangOpts.ObjC2)
Douglas Gregora4477812010-01-14 16:01:26 +00004330 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,package)));
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004331}
4332
4333void Sema::CodeCompleteObjCAtVisibility(Scope *S) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004334 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4335 CodeCompletionContext::CCC_Other);
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004336 Results.EnterNewScope();
Douglas Gregorbca403c2010-01-13 23:51:12 +00004337 AddObjCVisibilityResults(getLangOptions(), Results, false);
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004338 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004339 HandleCodeCompleteResults(this, CodeCompleter,
4340 CodeCompletionContext::CCC_Other,
4341 Results.data(),Results.size());
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004342}
4343
4344void Sema::CodeCompleteObjCAtStatement(Scope *S) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004345 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4346 CodeCompletionContext::CCC_Other);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004347 Results.EnterNewScope();
Douglas Gregorbca403c2010-01-13 23:51:12 +00004348 AddObjCStatementResults(Results, false);
4349 AddObjCExpressionResults(Results, false);
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004350 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004351 HandleCodeCompleteResults(this, CodeCompleter,
4352 CodeCompletionContext::CCC_Other,
4353 Results.data(),Results.size());
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004354}
4355
4356void Sema::CodeCompleteObjCAtExpression(Scope *S) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004357 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4358 CodeCompletionContext::CCC_Other);
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004359 Results.EnterNewScope();
Douglas Gregorbca403c2010-01-13 23:51:12 +00004360 AddObjCExpressionResults(Results, false);
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004361 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004362 HandleCodeCompleteResults(this, CodeCompleter,
4363 CodeCompletionContext::CCC_Other,
4364 Results.data(),Results.size());
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004365}
4366
Douglas Gregor988358f2009-11-19 00:14:45 +00004367/// \brief Determine whether the addition of the given flag to an Objective-C
4368/// property's attributes will cause a conflict.
4369static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
4370 // Check if we've already added this flag.
4371 if (Attributes & NewFlag)
4372 return true;
4373
4374 Attributes |= NewFlag;
4375
4376 // Check for collisions with "readonly".
4377 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
4378 (Attributes & (ObjCDeclSpec::DQ_PR_readwrite |
4379 ObjCDeclSpec::DQ_PR_assign |
John McCallf85e1932011-06-15 23:02:42 +00004380 ObjCDeclSpec::DQ_PR_unsafe_unretained |
Douglas Gregor988358f2009-11-19 00:14:45 +00004381 ObjCDeclSpec::DQ_PR_copy |
John McCallf85e1932011-06-15 23:02:42 +00004382 ObjCDeclSpec::DQ_PR_retain |
4383 ObjCDeclSpec::DQ_PR_strong)))
Douglas Gregor988358f2009-11-19 00:14:45 +00004384 return true;
4385
John McCallf85e1932011-06-15 23:02:42 +00004386 // Check for more than one of { assign, copy, retain, strong }.
Douglas Gregor988358f2009-11-19 00:14:45 +00004387 unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign |
John McCallf85e1932011-06-15 23:02:42 +00004388 ObjCDeclSpec::DQ_PR_unsafe_unretained |
Douglas Gregor988358f2009-11-19 00:14:45 +00004389 ObjCDeclSpec::DQ_PR_copy |
John McCallf85e1932011-06-15 23:02:42 +00004390 ObjCDeclSpec::DQ_PR_retain|
4391 ObjCDeclSpec::DQ_PR_strong);
Douglas Gregor988358f2009-11-19 00:14:45 +00004392 if (AssignCopyRetMask &&
4393 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
John McCallf85e1932011-06-15 23:02:42 +00004394 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
Douglas Gregor988358f2009-11-19 00:14:45 +00004395 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
John McCallf85e1932011-06-15 23:02:42 +00004396 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
4397 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong)
Douglas Gregor988358f2009-11-19 00:14:45 +00004398 return true;
4399
4400 return false;
4401}
4402
Douglas Gregora93b1082009-11-18 23:08:07 +00004403void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) {
Steve Naroffece8e712009-10-08 21:55:05 +00004404 if (!CodeCompleter)
4405 return;
Douglas Gregord3c68542009-11-19 01:08:35 +00004406
Steve Naroffece8e712009-10-08 21:55:05 +00004407 unsigned Attributes = ODS.getPropertyAttributes();
4408
John McCall0a2c5e22010-08-25 06:19:51 +00004409 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004410 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4411 CodeCompletionContext::CCC_Other);
Steve Naroffece8e712009-10-08 21:55:05 +00004412 Results.EnterNewScope();
Douglas Gregor988358f2009-11-19 00:14:45 +00004413 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly))
John McCall0a2c5e22010-08-25 06:19:51 +00004414 Results.AddResult(CodeCompletionResult("readonly"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004415 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign))
John McCall0a2c5e22010-08-25 06:19:51 +00004416 Results.AddResult(CodeCompletionResult("assign"));
John McCallf85e1932011-06-15 23:02:42 +00004417 if (!ObjCPropertyFlagConflicts(Attributes,
4418 ObjCDeclSpec::DQ_PR_unsafe_unretained))
4419 Results.AddResult(CodeCompletionResult("unsafe_unretained"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004420 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite))
John McCall0a2c5e22010-08-25 06:19:51 +00004421 Results.AddResult(CodeCompletionResult("readwrite"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004422 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain))
John McCall0a2c5e22010-08-25 06:19:51 +00004423 Results.AddResult(CodeCompletionResult("retain"));
John McCallf85e1932011-06-15 23:02:42 +00004424 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_strong))
4425 Results.AddResult(CodeCompletionResult("strong"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004426 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy))
John McCall0a2c5e22010-08-25 06:19:51 +00004427 Results.AddResult(CodeCompletionResult("copy"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004428 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic))
John McCall0a2c5e22010-08-25 06:19:51 +00004429 Results.AddResult(CodeCompletionResult("nonatomic"));
Fariborz Jahanian27f45232011-06-11 17:14:27 +00004430 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_atomic))
4431 Results.AddResult(CodeCompletionResult("atomic"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004432 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004433 CodeCompletionBuilder Setter(Results.getAllocator());
4434 Setter.AddTypedTextChunk("setter");
4435 Setter.AddTextChunk(" = ");
4436 Setter.AddPlaceholderChunk("method");
4437 Results.AddResult(CodeCompletionResult(Setter.TakeString()));
Douglas Gregor54f01612009-11-19 00:01:57 +00004438 }
Douglas Gregor988358f2009-11-19 00:14:45 +00004439 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004440 CodeCompletionBuilder Getter(Results.getAllocator());
4441 Getter.AddTypedTextChunk("getter");
4442 Getter.AddTextChunk(" = ");
4443 Getter.AddPlaceholderChunk("method");
4444 Results.AddResult(CodeCompletionResult(Getter.TakeString()));
Douglas Gregor54f01612009-11-19 00:01:57 +00004445 }
Steve Naroffece8e712009-10-08 21:55:05 +00004446 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004447 HandleCodeCompleteResults(this, CodeCompleter,
4448 CodeCompletionContext::CCC_Other,
4449 Results.data(),Results.size());
Steve Naroffece8e712009-10-08 21:55:05 +00004450}
Steve Naroffc4df6d22009-11-07 02:08:14 +00004451
Douglas Gregor4ad96852009-11-19 07:41:15 +00004452/// \brief Descripts the kind of Objective-C method that we want to find
4453/// via code completion.
4454enum ObjCMethodKind {
4455 MK_Any, //< Any kind of method, provided it means other specified criteria.
4456 MK_ZeroArgSelector, //< Zero-argument (unary) selector.
4457 MK_OneArgSelector //< One-argument selector.
4458};
4459
Douglas Gregor458433d2010-08-26 15:07:07 +00004460static bool isAcceptableObjCSelector(Selector Sel,
4461 ObjCMethodKind WantKind,
4462 IdentifierInfo **SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004463 unsigned NumSelIdents,
4464 bool AllowSameLength = true) {
Douglas Gregor458433d2010-08-26 15:07:07 +00004465 if (NumSelIdents > Sel.getNumArgs())
4466 return false;
4467
4468 switch (WantKind) {
4469 case MK_Any: break;
4470 case MK_ZeroArgSelector: return Sel.isUnarySelector();
4471 case MK_OneArgSelector: return Sel.getNumArgs() == 1;
4472 }
4473
Douglas Gregorcf544262010-11-17 21:36:08 +00004474 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
4475 return false;
4476
Douglas Gregor458433d2010-08-26 15:07:07 +00004477 for (unsigned I = 0; I != NumSelIdents; ++I)
4478 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
4479 return false;
4480
4481 return true;
4482}
4483
Douglas Gregor4ad96852009-11-19 07:41:15 +00004484static bool isAcceptableObjCMethod(ObjCMethodDecl *Method,
4485 ObjCMethodKind WantKind,
4486 IdentifierInfo **SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004487 unsigned NumSelIdents,
4488 bool AllowSameLength = true) {
Douglas Gregor458433d2010-08-26 15:07:07 +00004489 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004490 NumSelIdents, AllowSameLength);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004491}
Douglas Gregord36adf52010-09-16 16:06:31 +00004492
4493namespace {
4494 /// \brief A set of selectors, which is used to avoid introducing multiple
4495 /// completions with the same selector into the result set.
4496 typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
4497}
4498
Douglas Gregor36ecb042009-11-17 23:22:23 +00004499/// \brief Add all of the Objective-C methods in the given Objective-C
4500/// container to the set of results.
4501///
4502/// The container will be a class, protocol, category, or implementation of
4503/// any of the above. This mether will recurse to include methods from
4504/// the superclasses of classes along with their categories, protocols, and
4505/// implementations.
4506///
4507/// \param Container the container in which we'll look to find methods.
4508///
4509/// \param WantInstance whether to add instance methods (only); if false, this
4510/// routine will add factory methods (only).
4511///
4512/// \param CurContext the context in which we're performing the lookup that
4513/// finds methods.
4514///
Douglas Gregorcf544262010-11-17 21:36:08 +00004515/// \param AllowSameLength Whether we allow a method to be added to the list
4516/// when it has the same number of parameters as we have selector identifiers.
4517///
Douglas Gregor36ecb042009-11-17 23:22:23 +00004518/// \param Results the structure into which we'll add results.
4519static void AddObjCMethods(ObjCContainerDecl *Container,
4520 bool WantInstanceMethods,
Douglas Gregor4ad96852009-11-19 07:41:15 +00004521 ObjCMethodKind WantKind,
Douglas Gregord3c68542009-11-19 01:08:35 +00004522 IdentifierInfo **SelIdents,
4523 unsigned NumSelIdents,
Douglas Gregor36ecb042009-11-17 23:22:23 +00004524 DeclContext *CurContext,
Douglas Gregord36adf52010-09-16 16:06:31 +00004525 VisitedSelectorSet &Selectors,
Douglas Gregorcf544262010-11-17 21:36:08 +00004526 bool AllowSameLength,
Douglas Gregor408be5a2010-08-25 01:08:01 +00004527 ResultBuilder &Results,
4528 bool InOriginalClass = true) {
John McCall0a2c5e22010-08-25 06:19:51 +00004529 typedef CodeCompletionResult Result;
Douglas Gregor36ecb042009-11-17 23:22:23 +00004530 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(),
4531 MEnd = Container->meth_end();
4532 M != MEnd; ++M) {
Douglas Gregord3c68542009-11-19 01:08:35 +00004533 if ((*M)->isInstanceMethod() == WantInstanceMethods) {
4534 // Check whether the selector identifiers we've been given are a
4535 // subset of the identifiers for this particular method.
Douglas Gregorcf544262010-11-17 21:36:08 +00004536 if (!isAcceptableObjCMethod(*M, WantKind, SelIdents, NumSelIdents,
4537 AllowSameLength))
Douglas Gregord3c68542009-11-19 01:08:35 +00004538 continue;
Douglas Gregor4ad96852009-11-19 07:41:15 +00004539
Douglas Gregord36adf52010-09-16 16:06:31 +00004540 if (!Selectors.insert((*M)->getSelector()))
4541 continue;
4542
Douglas Gregord3c68542009-11-19 01:08:35 +00004543 Result R = Result(*M, 0);
4544 R.StartParameter = NumSelIdents;
Douglas Gregor4ad96852009-11-19 07:41:15 +00004545 R.AllParametersAreInformative = (WantKind != MK_Any);
Douglas Gregor408be5a2010-08-25 01:08:01 +00004546 if (!InOriginalClass)
4547 R.Priority += CCD_InBaseClass;
Douglas Gregord3c68542009-11-19 01:08:35 +00004548 Results.MaybeAddResult(R, CurContext);
4549 }
Douglas Gregor36ecb042009-11-17 23:22:23 +00004550 }
4551
Douglas Gregore396c7b2010-09-16 15:34:59 +00004552 // Visit the protocols of protocols.
4553 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +00004554 if (Protocol->hasDefinition()) {
4555 const ObjCList<ObjCProtocolDecl> &Protocols
4556 = Protocol->getReferencedProtocols();
4557 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
4558 E = Protocols.end();
4559 I != E; ++I)
4560 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
4561 NumSelIdents, CurContext, Selectors, AllowSameLength,
4562 Results, false);
4563 }
Douglas Gregore396c7b2010-09-16 15:34:59 +00004564 }
4565
Douglas Gregor36ecb042009-11-17 23:22:23 +00004566 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
Douglas Gregor2e5c15b2011-12-15 05:27:12 +00004567 if (!IFace || !IFace->hasDefinition())
Douglas Gregor36ecb042009-11-17 23:22:23 +00004568 return;
4569
4570 // Add methods in protocols.
4571 const ObjCList<ObjCProtocolDecl> &Protocols= IFace->getReferencedProtocols();
4572 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
4573 E = Protocols.end();
4574 I != E; ++I)
Douglas Gregor4ad96852009-11-19 07:41:15 +00004575 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, NumSelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004576 CurContext, Selectors, AllowSameLength, Results, false);
Douglas Gregor36ecb042009-11-17 23:22:23 +00004577
4578 // Add methods in categories.
4579 for (ObjCCategoryDecl *CatDecl = IFace->getCategoryList(); CatDecl;
4580 CatDecl = CatDecl->getNextClassCategory()) {
Douglas Gregor4ad96852009-11-19 07:41:15 +00004581 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004582 NumSelIdents, CurContext, Selectors, AllowSameLength,
4583 Results, InOriginalClass);
Douglas Gregor36ecb042009-11-17 23:22:23 +00004584
4585 // Add a categories protocol methods.
4586 const ObjCList<ObjCProtocolDecl> &Protocols
4587 = CatDecl->getReferencedProtocols();
4588 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
4589 E = Protocols.end();
4590 I != E; ++I)
Douglas Gregor4ad96852009-11-19 07:41:15 +00004591 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004592 NumSelIdents, CurContext, Selectors, AllowSameLength,
4593 Results, false);
Douglas Gregor36ecb042009-11-17 23:22:23 +00004594
4595 // Add methods in category implementations.
4596 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
Douglas Gregor4ad96852009-11-19 07:41:15 +00004597 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004598 NumSelIdents, CurContext, Selectors, AllowSameLength,
4599 Results, InOriginalClass);
Douglas Gregor36ecb042009-11-17 23:22:23 +00004600 }
4601
4602 // Add methods in superclass.
4603 if (IFace->getSuperClass())
Douglas Gregor4ad96852009-11-19 07:41:15 +00004604 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
Douglas Gregorcf544262010-11-17 21:36:08 +00004605 SelIdents, NumSelIdents, CurContext, Selectors,
4606 AllowSameLength, Results, false);
Douglas Gregor36ecb042009-11-17 23:22:23 +00004607
4608 // Add methods in our implementation, if any.
4609 if (ObjCImplementationDecl *Impl = IFace->getImplementation())
Douglas Gregor4ad96852009-11-19 07:41:15 +00004610 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004611 NumSelIdents, CurContext, Selectors, AllowSameLength,
4612 Results, InOriginalClass);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004613}
4614
4615
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004616void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
John McCall0a2c5e22010-08-25 06:19:51 +00004617 typedef CodeCompletionResult Result;
Douglas Gregor4ad96852009-11-19 07:41:15 +00004618
4619 // Try to find the interface where getters might live.
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004620 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004621 if (!Class) {
4622 if (ObjCCategoryDecl *Category
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004623 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
Douglas Gregor4ad96852009-11-19 07:41:15 +00004624 Class = Category->getClassInterface();
4625
4626 if (!Class)
4627 return;
4628 }
4629
4630 // Find all of the potential getters.
Douglas Gregor218937c2011-02-01 19:23:04 +00004631 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4632 CodeCompletionContext::CCC_Other);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004633 Results.EnterNewScope();
4634
Douglas Gregord36adf52010-09-16 16:06:31 +00004635 VisitedSelectorSet Selectors;
4636 AddObjCMethods(Class, true, MK_ZeroArgSelector, 0, 0, CurContext, Selectors,
Douglas Gregorcf544262010-11-17 21:36:08 +00004637 /*AllowSameLength=*/true, Results);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004638 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004639 HandleCodeCompleteResults(this, CodeCompleter,
4640 CodeCompletionContext::CCC_Other,
4641 Results.data(),Results.size());
Douglas Gregor4ad96852009-11-19 07:41:15 +00004642}
4643
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004644void Sema::CodeCompleteObjCPropertySetter(Scope *S) {
John McCall0a2c5e22010-08-25 06:19:51 +00004645 typedef CodeCompletionResult Result;
Douglas Gregor4ad96852009-11-19 07:41:15 +00004646
4647 // Try to find the interface where setters might live.
4648 ObjCInterfaceDecl *Class
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004649 = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004650 if (!Class) {
4651 if (ObjCCategoryDecl *Category
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004652 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
Douglas Gregor4ad96852009-11-19 07:41:15 +00004653 Class = Category->getClassInterface();
4654
4655 if (!Class)
4656 return;
4657 }
4658
4659 // Find all of the potential getters.
Douglas Gregor218937c2011-02-01 19:23:04 +00004660 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4661 CodeCompletionContext::CCC_Other);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004662 Results.EnterNewScope();
4663
Douglas Gregord36adf52010-09-16 16:06:31 +00004664 VisitedSelectorSet Selectors;
4665 AddObjCMethods(Class, true, MK_OneArgSelector, 0, 0, CurContext,
Douglas Gregorcf544262010-11-17 21:36:08 +00004666 Selectors, /*AllowSameLength=*/true, Results);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004667
4668 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004669 HandleCodeCompleteResults(this, CodeCompleter,
4670 CodeCompletionContext::CCC_Other,
4671 Results.data(),Results.size());
Douglas Gregor36ecb042009-11-17 23:22:23 +00004672}
4673
Douglas Gregorafc45782011-02-15 22:19:42 +00004674void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
4675 bool IsParameter) {
John McCall0a2c5e22010-08-25 06:19:51 +00004676 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004677 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4678 CodeCompletionContext::CCC_Type);
Douglas Gregord32b0222010-08-24 01:06:58 +00004679 Results.EnterNewScope();
4680
4681 // Add context-sensitive, Objective-C parameter-passing keywords.
4682 bool AddedInOut = false;
4683 if ((DS.getObjCDeclQualifier() &
4684 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) {
4685 Results.AddResult("in");
4686 Results.AddResult("inout");
4687 AddedInOut = true;
4688 }
4689 if ((DS.getObjCDeclQualifier() &
4690 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) {
4691 Results.AddResult("out");
4692 if (!AddedInOut)
4693 Results.AddResult("inout");
4694 }
4695 if ((DS.getObjCDeclQualifier() &
4696 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref |
4697 ObjCDeclSpec::DQ_Oneway)) == 0) {
4698 Results.AddResult("bycopy");
4699 Results.AddResult("byref");
4700 Results.AddResult("oneway");
4701 }
4702
Douglas Gregorafc45782011-02-15 22:19:42 +00004703 // If we're completing the return type of an Objective-C method and the
4704 // identifier IBAction refers to a macro, provide a completion item for
4705 // an action, e.g.,
4706 // IBAction)<#selector#>:(id)sender
4707 if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
4708 Context.Idents.get("IBAction").hasMacroDefinition()) {
4709 typedef CodeCompletionString::Chunk Chunk;
4710 CodeCompletionBuilder Builder(Results.getAllocator(), CCP_CodePattern,
4711 CXAvailability_Available);
4712 Builder.AddTypedTextChunk("IBAction");
4713 Builder.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
4714 Builder.AddPlaceholderChunk("selector");
4715 Builder.AddChunk(Chunk(CodeCompletionString::CK_Colon));
4716 Builder.AddChunk(Chunk(CodeCompletionString::CK_LeftParen));
4717 Builder.AddTextChunk("id");
4718 Builder.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
4719 Builder.AddTextChunk("sender");
4720 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
4721 }
4722
Douglas Gregord32b0222010-08-24 01:06:58 +00004723 // Add various builtin type names and specifiers.
4724 AddOrdinaryNameResults(PCC_Type, S, *this, Results);
4725 Results.ExitScope();
4726
4727 // Add the various type names
4728 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
4729 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4730 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4731 CodeCompleter->includeGlobals());
4732
4733 if (CodeCompleter->includeMacros())
4734 AddMacroResults(PP, Results);
4735
4736 HandleCodeCompleteResults(this, CodeCompleter,
4737 CodeCompletionContext::CCC_Type,
4738 Results.data(), Results.size());
4739}
4740
Douglas Gregor22f56992010-04-06 19:22:33 +00004741/// \brief When we have an expression with type "id", we may assume
4742/// that it has some more-specific class type based on knowledge of
4743/// common uses of Objective-C. This routine returns that class type,
4744/// or NULL if no better result could be determined.
4745static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
Douglas Gregor78edf512010-09-15 16:23:04 +00004746 ObjCMessageExpr *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
Douglas Gregor22f56992010-04-06 19:22:33 +00004747 if (!Msg)
4748 return 0;
4749
4750 Selector Sel = Msg->getSelector();
4751 if (Sel.isNull())
4752 return 0;
4753
4754 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0);
4755 if (!Id)
4756 return 0;
4757
4758 ObjCMethodDecl *Method = Msg->getMethodDecl();
4759 if (!Method)
4760 return 0;
4761
4762 // Determine the class that we're sending the message to.
Douglas Gregor04badcf2010-04-21 00:45:42 +00004763 ObjCInterfaceDecl *IFace = 0;
4764 switch (Msg->getReceiverKind()) {
4765 case ObjCMessageExpr::Class:
John McCallc12c5bb2010-05-15 11:32:37 +00004766 if (const ObjCObjectType *ObjType
4767 = Msg->getClassReceiver()->getAs<ObjCObjectType>())
4768 IFace = ObjType->getInterface();
Douglas Gregor04badcf2010-04-21 00:45:42 +00004769 break;
4770
4771 case ObjCMessageExpr::Instance: {
4772 QualType T = Msg->getInstanceReceiver()->getType();
4773 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
4774 IFace = Ptr->getInterfaceDecl();
4775 break;
4776 }
4777
4778 case ObjCMessageExpr::SuperInstance:
4779 case ObjCMessageExpr::SuperClass:
4780 break;
Douglas Gregor22f56992010-04-06 19:22:33 +00004781 }
4782
4783 if (!IFace)
4784 return 0;
4785
4786 ObjCInterfaceDecl *Super = IFace->getSuperClass();
4787 if (Method->isInstanceMethod())
4788 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
4789 .Case("retain", IFace)
John McCallf85e1932011-06-15 23:02:42 +00004790 .Case("strong", IFace)
Douglas Gregor22f56992010-04-06 19:22:33 +00004791 .Case("autorelease", IFace)
4792 .Case("copy", IFace)
4793 .Case("copyWithZone", IFace)
4794 .Case("mutableCopy", IFace)
4795 .Case("mutableCopyWithZone", IFace)
4796 .Case("awakeFromCoder", IFace)
4797 .Case("replacementObjectFromCoder", IFace)
4798 .Case("class", IFace)
4799 .Case("classForCoder", IFace)
4800 .Case("superclass", Super)
4801 .Default(0);
4802
4803 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
4804 .Case("new", IFace)
4805 .Case("alloc", IFace)
4806 .Case("allocWithZone", IFace)
4807 .Case("class", IFace)
4808 .Case("superclass", Super)
4809 .Default(0);
4810}
4811
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004812// Add a special completion for a message send to "super", which fills in the
4813// most likely case of forwarding all of our arguments to the superclass
4814// function.
4815///
4816/// \param S The semantic analysis object.
4817///
4818/// \param S NeedSuperKeyword Whether we need to prefix this completion with
4819/// the "super" keyword. Otherwise, we just need to provide the arguments.
4820///
4821/// \param SelIdents The identifiers in the selector that have already been
4822/// provided as arguments for a send to "super".
4823///
4824/// \param NumSelIdents The number of identifiers in \p SelIdents.
4825///
4826/// \param Results The set of results to augment.
4827///
4828/// \returns the Objective-C method declaration that would be invoked by
4829/// this "super" completion. If NULL, no completion was added.
4830static ObjCMethodDecl *AddSuperSendCompletion(Sema &S, bool NeedSuperKeyword,
4831 IdentifierInfo **SelIdents,
4832 unsigned NumSelIdents,
4833 ResultBuilder &Results) {
4834 ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
4835 if (!CurMethod)
4836 return 0;
4837
4838 ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
4839 if (!Class)
4840 return 0;
4841
4842 // Try to find a superclass method with the same selector.
4843 ObjCMethodDecl *SuperMethod = 0;
Douglas Gregor78bcd912011-02-16 00:51:18 +00004844 while ((Class = Class->getSuperClass()) && !SuperMethod) {
4845 // Check in the class
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004846 SuperMethod = Class->getMethod(CurMethod->getSelector(),
4847 CurMethod->isInstanceMethod());
4848
Douglas Gregor78bcd912011-02-16 00:51:18 +00004849 // Check in categories or class extensions.
4850 if (!SuperMethod) {
4851 for (ObjCCategoryDecl *Category = Class->getCategoryList(); Category;
4852 Category = Category->getNextClassCategory())
4853 if ((SuperMethod = Category->getMethod(CurMethod->getSelector(),
4854 CurMethod->isInstanceMethod())))
4855 break;
4856 }
4857 }
4858
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004859 if (!SuperMethod)
4860 return 0;
4861
4862 // Check whether the superclass method has the same signature.
4863 if (CurMethod->param_size() != SuperMethod->param_size() ||
4864 CurMethod->isVariadic() != SuperMethod->isVariadic())
4865 return 0;
4866
4867 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
4868 CurPEnd = CurMethod->param_end(),
4869 SuperP = SuperMethod->param_begin();
4870 CurP != CurPEnd; ++CurP, ++SuperP) {
4871 // Make sure the parameter types are compatible.
4872 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
4873 (*SuperP)->getType()))
4874 return 0;
4875
4876 // Make sure we have a parameter name to forward!
4877 if (!(*CurP)->getIdentifier())
4878 return 0;
4879 }
4880
4881 // We have a superclass method. Now, form the send-to-super completion.
Douglas Gregor218937c2011-02-01 19:23:04 +00004882 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004883
4884 // Give this completion a return type.
Douglas Gregor8987b232011-09-27 23:30:47 +00004885 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod,
4886 Builder);
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004887
4888 // If we need the "super" keyword, add it (plus some spacing).
4889 if (NeedSuperKeyword) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004890 Builder.AddTypedTextChunk("super");
4891 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004892 }
4893
4894 Selector Sel = CurMethod->getSelector();
4895 if (Sel.isUnarySelector()) {
4896 if (NeedSuperKeyword)
Douglas Gregordae68752011-02-01 22:57:45 +00004897 Builder.AddTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00004898 Sel.getNameForSlot(0)));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004899 else
Douglas Gregordae68752011-02-01 22:57:45 +00004900 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00004901 Sel.getNameForSlot(0)));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004902 } else {
4903 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
4904 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
4905 if (I > NumSelIdents)
Douglas Gregor218937c2011-02-01 19:23:04 +00004906 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004907
4908 if (I < NumSelIdents)
Douglas Gregor218937c2011-02-01 19:23:04 +00004909 Builder.AddInformativeChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00004910 Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00004911 Sel.getNameForSlot(I) + ":"));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004912 else if (NeedSuperKeyword || I > NumSelIdents) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004913 Builder.AddTextChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00004914 Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00004915 Sel.getNameForSlot(I) + ":"));
Douglas Gregordae68752011-02-01 22:57:45 +00004916 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00004917 (*CurP)->getIdentifier()->getName()));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004918 } else {
Douglas Gregor218937c2011-02-01 19:23:04 +00004919 Builder.AddTypedTextChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00004920 Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00004921 Sel.getNameForSlot(I) + ":"));
Douglas Gregordae68752011-02-01 22:57:45 +00004922 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00004923 (*CurP)->getIdentifier()->getName()));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004924 }
4925 }
4926 }
4927
Douglas Gregor218937c2011-02-01 19:23:04 +00004928 Results.AddResult(CodeCompletionResult(Builder.TakeString(), CCP_SuperCompletion,
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004929 SuperMethod->isInstanceMethod()
4930 ? CXCursor_ObjCInstanceMethodDecl
4931 : CXCursor_ObjCClassMethodDecl));
4932 return SuperMethod;
4933}
4934
Douglas Gregor8e254cf2010-05-27 23:06:34 +00004935void Sema::CodeCompleteObjCMessageReceiver(Scope *S) {
John McCall0a2c5e22010-08-25 06:19:51 +00004936 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004937 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4938 CodeCompletionContext::CCC_ObjCMessageReceiver,
Douglas Gregor52779fb2010-09-23 23:01:17 +00004939 &ResultBuilder::IsObjCMessageReceiver);
Douglas Gregor8e254cf2010-05-27 23:06:34 +00004940
Douglas Gregor8e254cf2010-05-27 23:06:34 +00004941 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4942 Results.EnterNewScope();
Douglas Gregor8071e422010-08-15 06:18:01 +00004943 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4944 CodeCompleter->includeGlobals());
Douglas Gregor8e254cf2010-05-27 23:06:34 +00004945
4946 // If we are in an Objective-C method inside a class that has a superclass,
4947 // add "super" as an option.
4948 if (ObjCMethodDecl *Method = getCurMethodDecl())
4949 if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004950 if (Iface->getSuperClass()) {
Douglas Gregor8e254cf2010-05-27 23:06:34 +00004951 Results.AddResult(Result("super"));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004952
4953 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, 0, 0, Results);
4954 }
Douglas Gregor8e254cf2010-05-27 23:06:34 +00004955
4956 Results.ExitScope();
4957
4958 if (CodeCompleter->includeMacros())
4959 AddMacroResults(PP, Results);
Douglas Gregorcee9ff12010-09-20 22:39:41 +00004960 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004961 Results.data(), Results.size());
Douglas Gregor8e254cf2010-05-27 23:06:34 +00004962
4963}
4964
Douglas Gregor2725ca82010-04-21 19:57:20 +00004965void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
4966 IdentifierInfo **SelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00004967 unsigned NumSelIdents,
4968 bool AtArgumentExpression) {
Douglas Gregor2725ca82010-04-21 19:57:20 +00004969 ObjCInterfaceDecl *CDecl = 0;
4970 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
4971 // Figure out which interface we're in.
4972 CDecl = CurMethod->getClassInterface();
4973 if (!CDecl)
4974 return;
4975
4976 // Find the superclass of this class.
4977 CDecl = CDecl->getSuperClass();
4978 if (!CDecl)
4979 return;
4980
4981 if (CurMethod->isInstanceMethod()) {
4982 // We are inside an instance method, which means that the message
4983 // send [super ...] is actually calling an instance method on the
Douglas Gregor6b0656a2010-10-13 21:24:53 +00004984 // current object.
4985 return CodeCompleteObjCInstanceMessage(S, 0,
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004986 SelIdents, NumSelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00004987 AtArgumentExpression,
Douglas Gregor6b0656a2010-10-13 21:24:53 +00004988 CDecl);
Douglas Gregor2725ca82010-04-21 19:57:20 +00004989 }
4990
4991 // Fall through to send to the superclass in CDecl.
4992 } else {
4993 // "super" may be the name of a type or variable. Figure out which
4994 // it is.
4995 IdentifierInfo *Super = &Context.Idents.get("super");
4996 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc,
4997 LookupOrdinaryName);
4998 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
4999 // "super" names an interface. Use it.
5000 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
John McCallc12c5bb2010-05-15 11:32:37 +00005001 if (const ObjCObjectType *Iface
5002 = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
5003 CDecl = Iface->getInterface();
Douglas Gregor2725ca82010-04-21 19:57:20 +00005004 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
5005 // "super" names an unresolved type; we can't be more specific.
5006 } else {
5007 // Assume that "super" names some kind of value and parse that way.
5008 CXXScopeSpec SS;
5009 UnqualifiedId id;
5010 id.setIdentifier(Super, SuperLoc);
John McCall60d7b3a2010-08-24 06:29:42 +00005011 ExprResult SuperExpr = ActOnIdExpression(S, SS, id, false, false);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005012 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005013 SelIdents, NumSelIdents,
5014 AtArgumentExpression);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005015 }
5016
5017 // Fall through
5018 }
5019
John McCallb3d87482010-08-24 05:47:05 +00005020 ParsedType Receiver;
Douglas Gregor2725ca82010-04-21 19:57:20 +00005021 if (CDecl)
John McCallb3d87482010-08-24 05:47:05 +00005022 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
Douglas Gregor2725ca82010-04-21 19:57:20 +00005023 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005024 NumSelIdents, AtArgumentExpression,
5025 /*IsSuper=*/true);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005026}
5027
Douglas Gregorb9d77572010-09-21 00:03:25 +00005028/// \brief Given a set of code-completion results for the argument of a message
5029/// send, determine the preferred type (if any) for that argument expression.
5030static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
5031 unsigned NumSelIdents) {
5032 typedef CodeCompletionResult Result;
5033 ASTContext &Context = Results.getSema().Context;
5034
5035 QualType PreferredType;
5036 unsigned BestPriority = CCP_Unlikely * 2;
5037 Result *ResultsData = Results.data();
5038 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
5039 Result &R = ResultsData[I];
5040 if (R.Kind == Result::RK_Declaration &&
5041 isa<ObjCMethodDecl>(R.Declaration)) {
5042 if (R.Priority <= BestPriority) {
5043 ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
5044 if (NumSelIdents <= Method->param_size()) {
5045 QualType MyPreferredType = Method->param_begin()[NumSelIdents - 1]
5046 ->getType();
5047 if (R.Priority < BestPriority || PreferredType.isNull()) {
5048 BestPriority = R.Priority;
5049 PreferredType = MyPreferredType;
5050 } else if (!Context.hasSameUnqualifiedType(PreferredType,
5051 MyPreferredType)) {
5052 PreferredType = QualType();
5053 }
5054 }
5055 }
5056 }
5057 }
5058
5059 return PreferredType;
5060}
5061
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005062static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
5063 ParsedType Receiver,
5064 IdentifierInfo **SelIdents,
5065 unsigned NumSelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005066 bool AtArgumentExpression,
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005067 bool IsSuper,
5068 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00005069 typedef CodeCompletionResult Result;
Douglas Gregor24a069f2009-11-17 17:59:40 +00005070 ObjCInterfaceDecl *CDecl = 0;
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005071
Douglas Gregor24a069f2009-11-17 17:59:40 +00005072 // If the given name refers to an interface type, retrieve the
5073 // corresponding declaration.
Douglas Gregor2725ca82010-04-21 19:57:20 +00005074 if (Receiver) {
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005075 QualType T = SemaRef.GetTypeFromParser(Receiver, 0);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005076 if (!T.isNull())
John McCallc12c5bb2010-05-15 11:32:37 +00005077 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
5078 CDecl = Interface->getInterface();
Douglas Gregor24a069f2009-11-17 17:59:40 +00005079 }
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005080
Douglas Gregor36ecb042009-11-17 23:22:23 +00005081 // Add all of the factory methods in this Objective-C class, its protocols,
5082 // superclasses, categories, implementation, etc.
Steve Naroffc4df6d22009-11-07 02:08:14 +00005083 Results.EnterNewScope();
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005084
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005085 // If this is a send-to-super, try to add the special "super" send
5086 // completion.
5087 if (IsSuper) {
5088 if (ObjCMethodDecl *SuperMethod
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005089 = AddSuperSendCompletion(SemaRef, false, SelIdents, NumSelIdents,
5090 Results))
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005091 Results.Ignore(SuperMethod);
5092 }
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005093
Douglas Gregor265f7492010-08-27 15:29:55 +00005094 // If we're inside an Objective-C method definition, prefer its selector to
5095 // others.
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005096 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
Douglas Gregor265f7492010-08-27 15:29:55 +00005097 Results.setPreferredSelector(CurMethod->getSelector());
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005098
Douglas Gregord36adf52010-09-16 16:06:31 +00005099 VisitedSelectorSet Selectors;
Douglas Gregor13438f92010-04-06 16:40:00 +00005100 if (CDecl)
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005101 AddObjCMethods(CDecl, false, MK_Any, SelIdents, NumSelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00005102 SemaRef.CurContext, Selectors, AtArgumentExpression,
5103 Results);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005104 else {
Douglas Gregor13438f92010-04-06 16:40:00 +00005105 // We're messaging "id" as a type; provide all class/factory methods.
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005106
Douglas Gregor719770d2010-04-06 17:30:22 +00005107 // If we have an external source, load the entire class method
Sebastian Redl3c7f4132010-08-18 23:57:06 +00005108 // pool from the AST file.
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005109 if (SemaRef.ExternalSource) {
5110 for (uint32_t I = 0,
5111 N = SemaRef.ExternalSource->GetNumExternalSelectors();
John McCall76bd1f32010-06-01 09:23:16 +00005112 I != N; ++I) {
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005113 Selector Sel = SemaRef.ExternalSource->GetExternalSelector(I);
5114 if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
Douglas Gregor719770d2010-04-06 17:30:22 +00005115 continue;
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005116
5117 SemaRef.ReadMethodPool(Sel);
Douglas Gregor719770d2010-04-06 17:30:22 +00005118 }
5119 }
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005120
5121 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
5122 MEnd = SemaRef.MethodPool.end();
Sebastian Redldb9d2142010-08-02 23:18:59 +00005123 M != MEnd; ++M) {
5124 for (ObjCMethodList *MethList = &M->second.second;
5125 MethList && MethList->Method;
Douglas Gregor13438f92010-04-06 16:40:00 +00005126 MethList = MethList->Next) {
5127 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents,
5128 NumSelIdents))
5129 continue;
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005130
Douglas Gregor13438f92010-04-06 16:40:00 +00005131 Result R(MethList->Method, 0);
5132 R.StartParameter = NumSelIdents;
5133 R.AllParametersAreInformative = false;
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005134 Results.MaybeAddResult(R, SemaRef.CurContext);
Douglas Gregor13438f92010-04-06 16:40:00 +00005135 }
5136 }
5137 }
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005138
5139 Results.ExitScope();
5140}
Douglas Gregor13438f92010-04-06 16:40:00 +00005141
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005142void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
5143 IdentifierInfo **SelIdents,
5144 unsigned NumSelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005145 bool AtArgumentExpression,
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005146 bool IsSuper) {
Douglas Gregore081a612011-07-21 01:05:26 +00005147
5148 QualType T = this->GetTypeFromParser(Receiver);
5149
Douglas Gregor218937c2011-02-01 19:23:04 +00005150 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregore081a612011-07-21 01:05:26 +00005151 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage,
Douglas Gregor0a47d692011-07-26 15:24:30 +00005152 T, SelIdents, NumSelIdents));
Douglas Gregore081a612011-07-21 01:05:26 +00005153
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005154 AddClassMessageCompletions(*this, S, Receiver, SelIdents, NumSelIdents,
5155 AtArgumentExpression, IsSuper, Results);
Douglas Gregorb9d77572010-09-21 00:03:25 +00005156
5157 // If we're actually at the argument expression (rather than prior to the
5158 // selector), we're actually performing code completion for an expression.
5159 // Determine whether we have a single, best method. If so, we can
5160 // code-complete the expression using the corresponding parameter type as
5161 // our preferred type, improving completion results.
5162 if (AtArgumentExpression) {
5163 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
Douglas Gregore081a612011-07-21 01:05:26 +00005164 NumSelIdents);
Douglas Gregorb9d77572010-09-21 00:03:25 +00005165 if (PreferredType.isNull())
5166 CodeCompleteOrdinaryName(S, PCC_Expression);
5167 else
5168 CodeCompleteExpression(S, PreferredType);
5169 return;
5170 }
5171
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005172 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregore081a612011-07-21 01:05:26 +00005173 Results.getCompletionContext(),
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005174 Results.data(), Results.size());
Steve Naroffc4df6d22009-11-07 02:08:14 +00005175}
5176
Richard Trieuf81e5a92011-09-09 02:00:50 +00005177void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
Douglas Gregord3c68542009-11-19 01:08:35 +00005178 IdentifierInfo **SelIdents,
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005179 unsigned NumSelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005180 bool AtArgumentExpression,
Douglas Gregor6b0656a2010-10-13 21:24:53 +00005181 ObjCInterfaceDecl *Super) {
John McCall0a2c5e22010-08-25 06:19:51 +00005182 typedef CodeCompletionResult Result;
Steve Naroffc4df6d22009-11-07 02:08:14 +00005183
5184 Expr *RecExpr = static_cast<Expr *>(Receiver);
Steve Naroffc4df6d22009-11-07 02:08:14 +00005185
Douglas Gregor36ecb042009-11-17 23:22:23 +00005186 // If necessary, apply function/array conversion to the receiver.
5187 // C99 6.7.5.3p[7,8].
John Wiegley429bb272011-04-08 18:41:53 +00005188 if (RecExpr) {
5189 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
5190 if (Conv.isInvalid()) // conversion failed. bail.
5191 return;
5192 RecExpr = Conv.take();
5193 }
Douglas Gregor6b0656a2010-10-13 21:24:53 +00005194 QualType ReceiverType = RecExpr? RecExpr->getType()
5195 : Super? Context.getObjCObjectPointerType(
5196 Context.getObjCInterfaceType(Super))
5197 : Context.getObjCIdType();
Steve Naroffc4df6d22009-11-07 02:08:14 +00005198
Douglas Gregorda892642010-11-08 21:12:30 +00005199 // If we're messaging an expression with type "id" or "Class", check
5200 // whether we know something special about the receiver that allows
5201 // us to assume a more-specific receiver type.
5202 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType())
5203 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
5204 if (ReceiverType->isObjCClassType())
5205 return CodeCompleteObjCClassMessage(S,
5206 ParsedType::make(Context.getObjCInterfaceType(IFace)),
5207 SelIdents, NumSelIdents,
5208 AtArgumentExpression, Super);
5209
5210 ReceiverType = Context.getObjCObjectPointerType(
5211 Context.getObjCInterfaceType(IFace));
5212 }
5213
Douglas Gregor36ecb042009-11-17 23:22:23 +00005214 // Build the set of methods we can see.
Douglas Gregor218937c2011-02-01 19:23:04 +00005215 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregore081a612011-07-21 01:05:26 +00005216 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage,
Douglas Gregor0a47d692011-07-26 15:24:30 +00005217 ReceiverType, SelIdents, NumSelIdents));
Douglas Gregore081a612011-07-21 01:05:26 +00005218
Douglas Gregor36ecb042009-11-17 23:22:23 +00005219 Results.EnterNewScope();
Douglas Gregor22f56992010-04-06 19:22:33 +00005220
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005221 // If this is a send-to-super, try to add the special "super" send
5222 // completion.
Douglas Gregor6b0656a2010-10-13 21:24:53 +00005223 if (Super) {
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005224 if (ObjCMethodDecl *SuperMethod
5225 = AddSuperSendCompletion(*this, false, SelIdents, NumSelIdents,
5226 Results))
5227 Results.Ignore(SuperMethod);
5228 }
5229
Douglas Gregor265f7492010-08-27 15:29:55 +00005230 // If we're inside an Objective-C method definition, prefer its selector to
5231 // others.
5232 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
5233 Results.setPreferredSelector(CurMethod->getSelector());
Douglas Gregor36ecb042009-11-17 23:22:23 +00005234
Douglas Gregord36adf52010-09-16 16:06:31 +00005235 // Keep track of the selectors we've already added.
5236 VisitedSelectorSet Selectors;
5237
Douglas Gregorf74a4192009-11-18 00:06:18 +00005238 // Handle messages to Class. This really isn't a message to an instance
5239 // method, so we treat it the same way we would treat a message send to a
5240 // class method.
5241 if (ReceiverType->isObjCClassType() ||
5242 ReceiverType->isObjCQualifiedClassType()) {
5243 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5244 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
Douglas Gregor4ad96852009-11-19 07:41:15 +00005245 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents, NumSelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00005246 CurContext, Selectors, AtArgumentExpression, Results);
Douglas Gregorf74a4192009-11-18 00:06:18 +00005247 }
5248 }
5249 // Handle messages to a qualified ID ("id<foo>").
5250 else if (const ObjCObjectPointerType *QualID
5251 = ReceiverType->getAsObjCQualifiedIdType()) {
5252 // Search protocols for instance methods.
5253 for (ObjCObjectPointerType::qual_iterator I = QualID->qual_begin(),
5254 E = QualID->qual_end();
5255 I != E; ++I)
Douglas Gregor4ad96852009-11-19 07:41:15 +00005256 AddObjCMethods(*I, true, MK_Any, SelIdents, NumSelIdents, CurContext,
Douglas Gregorcf544262010-11-17 21:36:08 +00005257 Selectors, AtArgumentExpression, Results);
Douglas Gregorf74a4192009-11-18 00:06:18 +00005258 }
5259 // Handle messages to a pointer to interface type.
5260 else if (const ObjCObjectPointerType *IFacePtr
5261 = ReceiverType->getAsObjCInterfacePointerType()) {
5262 // Search the class, its superclasses, etc., for instance methods.
Douglas Gregor4ad96852009-11-19 07:41:15 +00005263 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00005264 NumSelIdents, CurContext, Selectors, AtArgumentExpression,
5265 Results);
Douglas Gregorf74a4192009-11-18 00:06:18 +00005266
5267 // Search protocols for instance methods.
5268 for (ObjCObjectPointerType::qual_iterator I = IFacePtr->qual_begin(),
5269 E = IFacePtr->qual_end();
5270 I != E; ++I)
Douglas Gregor4ad96852009-11-19 07:41:15 +00005271 AddObjCMethods(*I, true, MK_Any, SelIdents, NumSelIdents, CurContext,
Douglas Gregorcf544262010-11-17 21:36:08 +00005272 Selectors, AtArgumentExpression, Results);
Douglas Gregorf74a4192009-11-18 00:06:18 +00005273 }
Douglas Gregor13438f92010-04-06 16:40:00 +00005274 // Handle messages to "id".
5275 else if (ReceiverType->isObjCIdType()) {
Douglas Gregor719770d2010-04-06 17:30:22 +00005276 // We're messaging "id", so provide all instance methods we know
5277 // about as code-completion results.
5278
5279 // If we have an external source, load the entire class method
Sebastian Redl3c7f4132010-08-18 23:57:06 +00005280 // pool from the AST file.
Douglas Gregor719770d2010-04-06 17:30:22 +00005281 if (ExternalSource) {
John McCall76bd1f32010-06-01 09:23:16 +00005282 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5283 I != N; ++I) {
5284 Selector Sel = ExternalSource->GetExternalSelector(I);
Sebastian Redldb9d2142010-08-02 23:18:59 +00005285 if (Sel.isNull() || MethodPool.count(Sel))
Douglas Gregor719770d2010-04-06 17:30:22 +00005286 continue;
5287
Sebastian Redldb9d2142010-08-02 23:18:59 +00005288 ReadMethodPool(Sel);
Douglas Gregor719770d2010-04-06 17:30:22 +00005289 }
5290 }
5291
Sebastian Redldb9d2142010-08-02 23:18:59 +00005292 for (GlobalMethodPool::iterator M = MethodPool.begin(),
5293 MEnd = MethodPool.end();
5294 M != MEnd; ++M) {
5295 for (ObjCMethodList *MethList = &M->second.first;
5296 MethList && MethList->Method;
Douglas Gregor13438f92010-04-06 16:40:00 +00005297 MethList = MethList->Next) {
5298 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents,
5299 NumSelIdents))
5300 continue;
Douglas Gregord36adf52010-09-16 16:06:31 +00005301
5302 if (!Selectors.insert(MethList->Method->getSelector()))
5303 continue;
5304
Douglas Gregor13438f92010-04-06 16:40:00 +00005305 Result R(MethList->Method, 0);
5306 R.StartParameter = NumSelIdents;
5307 R.AllParametersAreInformative = false;
5308 Results.MaybeAddResult(R, CurContext);
5309 }
5310 }
5311 }
Steve Naroffc4df6d22009-11-07 02:08:14 +00005312 Results.ExitScope();
Douglas Gregorb9d77572010-09-21 00:03:25 +00005313
5314
5315 // If we're actually at the argument expression (rather than prior to the
5316 // selector), we're actually performing code completion for an expression.
5317 // Determine whether we have a single, best method. If so, we can
5318 // code-complete the expression using the corresponding parameter type as
5319 // our preferred type, improving completion results.
5320 if (AtArgumentExpression) {
5321 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
5322 NumSelIdents);
5323 if (PreferredType.isNull())
5324 CodeCompleteOrdinaryName(S, PCC_Expression);
5325 else
5326 CodeCompleteExpression(S, PreferredType);
5327 return;
5328 }
5329
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005330 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregore081a612011-07-21 01:05:26 +00005331 Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005332 Results.data(),Results.size());
Steve Naroffc4df6d22009-11-07 02:08:14 +00005333}
Douglas Gregor55385fe2009-11-18 04:19:12 +00005334
Douglas Gregorfb629412010-08-23 21:17:50 +00005335void Sema::CodeCompleteObjCForCollection(Scope *S,
5336 DeclGroupPtrTy IterationVar) {
5337 CodeCompleteExpressionData Data;
5338 Data.ObjCCollection = true;
5339
5340 if (IterationVar.getAsOpaquePtr()) {
5341 DeclGroupRef DG = IterationVar.getAsVal<DeclGroupRef>();
5342 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
5343 if (*I)
5344 Data.IgnoreDecls.push_back(*I);
5345 }
5346 }
5347
5348 CodeCompleteExpression(S, Data);
5349}
5350
Douglas Gregor458433d2010-08-26 15:07:07 +00005351void Sema::CodeCompleteObjCSelector(Scope *S, IdentifierInfo **SelIdents,
5352 unsigned NumSelIdents) {
5353 // If we have an external source, load the entire class method
5354 // pool from the AST file.
5355 if (ExternalSource) {
5356 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5357 I != N; ++I) {
5358 Selector Sel = ExternalSource->GetExternalSelector(I);
5359 if (Sel.isNull() || MethodPool.count(Sel))
5360 continue;
5361
5362 ReadMethodPool(Sel);
5363 }
5364 }
5365
Douglas Gregor218937c2011-02-01 19:23:04 +00005366 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5367 CodeCompletionContext::CCC_SelectorName);
Douglas Gregor458433d2010-08-26 15:07:07 +00005368 Results.EnterNewScope();
5369 for (GlobalMethodPool::iterator M = MethodPool.begin(),
5370 MEnd = MethodPool.end();
5371 M != MEnd; ++M) {
5372
5373 Selector Sel = M->first;
5374 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents, NumSelIdents))
5375 continue;
5376
Douglas Gregor218937c2011-02-01 19:23:04 +00005377 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor458433d2010-08-26 15:07:07 +00005378 if (Sel.isUnarySelector()) {
Douglas Gregordae68752011-02-01 22:57:45 +00005379 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00005380 Sel.getNameForSlot(0)));
Douglas Gregor218937c2011-02-01 19:23:04 +00005381 Results.AddResult(Builder.TakeString());
Douglas Gregor458433d2010-08-26 15:07:07 +00005382 continue;
5383 }
5384
Douglas Gregor2d9e21f2010-08-26 16:46:39 +00005385 std::string Accumulator;
Douglas Gregor458433d2010-08-26 15:07:07 +00005386 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
Douglas Gregor2d9e21f2010-08-26 16:46:39 +00005387 if (I == NumSelIdents) {
5388 if (!Accumulator.empty()) {
Douglas Gregordae68752011-02-01 22:57:45 +00005389 Builder.AddInformativeChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00005390 Accumulator));
Douglas Gregor2d9e21f2010-08-26 16:46:39 +00005391 Accumulator.clear();
5392 }
5393 }
5394
Benjamin Kramera0651c52011-07-26 16:59:25 +00005395 Accumulator += Sel.getNameForSlot(I);
Douglas Gregor2d9e21f2010-08-26 16:46:39 +00005396 Accumulator += ':';
Douglas Gregor458433d2010-08-26 15:07:07 +00005397 }
Douglas Gregordae68752011-02-01 22:57:45 +00005398 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( Accumulator));
Douglas Gregor218937c2011-02-01 19:23:04 +00005399 Results.AddResult(Builder.TakeString());
Douglas Gregor458433d2010-08-26 15:07:07 +00005400 }
5401 Results.ExitScope();
5402
5403 HandleCodeCompleteResults(this, CodeCompleter,
5404 CodeCompletionContext::CCC_SelectorName,
5405 Results.data(), Results.size());
5406}
5407
Douglas Gregor55385fe2009-11-18 04:19:12 +00005408/// \brief Add all of the protocol declarations that we find in the given
5409/// (translation unit) context.
5410static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
Douglas Gregor083128f2009-11-18 04:49:41 +00005411 bool OnlyForwardDeclarations,
Douglas Gregor55385fe2009-11-18 04:19:12 +00005412 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00005413 typedef CodeCompletionResult Result;
Douglas Gregor55385fe2009-11-18 04:19:12 +00005414
5415 for (DeclContext::decl_iterator D = Ctx->decls_begin(),
5416 DEnd = Ctx->decls_end();
5417 D != DEnd; ++D) {
5418 // Record any protocols we find.
5419 if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(*D))
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +00005420 if (!OnlyForwardDeclarations || !Proto->hasDefinition())
Douglas Gregor608300b2010-01-14 16:14:35 +00005421 Results.AddResult(Result(Proto, 0), CurContext, 0, false);
Douglas Gregor55385fe2009-11-18 04:19:12 +00005422 }
5423}
5424
5425void Sema::CodeCompleteObjCProtocolReferences(IdentifierLocPair *Protocols,
5426 unsigned NumProtocols) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005427 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5428 CodeCompletionContext::CCC_ObjCProtocolName);
Douglas Gregor55385fe2009-11-18 04:19:12 +00005429
Douglas Gregor70c23352010-12-09 21:44:02 +00005430 if (CodeCompleter && CodeCompleter->includeGlobals()) {
5431 Results.EnterNewScope();
5432
5433 // Tell the result set to ignore all of the protocols we have
5434 // already seen.
5435 // FIXME: This doesn't work when caching code-completion results.
5436 for (unsigned I = 0; I != NumProtocols; ++I)
5437 if (ObjCProtocolDecl *Protocol = LookupProtocol(Protocols[I].first,
5438 Protocols[I].second))
5439 Results.Ignore(Protocol);
Douglas Gregor55385fe2009-11-18 04:19:12 +00005440
Douglas Gregor70c23352010-12-09 21:44:02 +00005441 // Add all protocols.
5442 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
5443 Results);
Douglas Gregor083128f2009-11-18 04:49:41 +00005444
Douglas Gregor70c23352010-12-09 21:44:02 +00005445 Results.ExitScope();
5446 }
5447
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005448 HandleCodeCompleteResults(this, CodeCompleter,
5449 CodeCompletionContext::CCC_ObjCProtocolName,
5450 Results.data(),Results.size());
Douglas Gregor083128f2009-11-18 04:49:41 +00005451}
5452
5453void Sema::CodeCompleteObjCProtocolDecl(Scope *) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005454 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5455 CodeCompletionContext::CCC_ObjCProtocolName);
Douglas Gregor083128f2009-11-18 04:49:41 +00005456
Douglas Gregor70c23352010-12-09 21:44:02 +00005457 if (CodeCompleter && CodeCompleter->includeGlobals()) {
5458 Results.EnterNewScope();
5459
5460 // Add all protocols.
5461 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
5462 Results);
Douglas Gregor55385fe2009-11-18 04:19:12 +00005463
Douglas Gregor70c23352010-12-09 21:44:02 +00005464 Results.ExitScope();
5465 }
5466
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005467 HandleCodeCompleteResults(this, CodeCompleter,
5468 CodeCompletionContext::CCC_ObjCProtocolName,
5469 Results.data(),Results.size());
Douglas Gregor55385fe2009-11-18 04:19:12 +00005470}
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005471
5472/// \brief Add all of the Objective-C interface declarations that we find in
5473/// the given (translation unit) context.
5474static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
5475 bool OnlyForwardDeclarations,
5476 bool OnlyUnimplemented,
5477 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00005478 typedef CodeCompletionResult Result;
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005479
5480 for (DeclContext::decl_iterator D = Ctx->decls_begin(),
5481 DEnd = Ctx->decls_end();
5482 D != DEnd; ++D) {
Douglas Gregordeacbdc2010-08-11 12:19:30 +00005483 // Record any interfaces we find.
5484 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(*D))
Douglas Gregor7723fec2011-12-15 20:29:51 +00005485 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
Douglas Gregordeacbdc2010-08-11 12:19:30 +00005486 (!OnlyUnimplemented || !Class->getImplementation()))
5487 Results.AddResult(Result(Class, 0), CurContext, 0, false);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005488 }
5489}
5490
5491void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005492 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5493 CodeCompletionContext::CCC_Other);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005494 Results.EnterNewScope();
5495
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005496 if (CodeCompleter->includeGlobals()) {
5497 // Add all classes.
5498 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
5499 false, Results);
5500 }
5501
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005502 Results.ExitScope();
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005503
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005504 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005505 CodeCompletionContext::CCC_ObjCInterfaceName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005506 Results.data(),Results.size());
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005507}
5508
Douglas Gregorc83c6872010-04-15 22:33:43 +00005509void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName,
5510 SourceLocation ClassNameLoc) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005511 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005512 CodeCompletionContext::CCC_ObjCInterfaceName);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005513 Results.EnterNewScope();
5514
5515 // Make sure that we ignore the class we're currently defining.
5516 NamedDecl *CurClass
Douglas Gregorc83c6872010-04-15 22:33:43 +00005517 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005518 if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005519 Results.Ignore(CurClass);
5520
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005521 if (CodeCompleter->includeGlobals()) {
5522 // Add all classes.
5523 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
5524 false, Results);
5525 }
5526
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005527 Results.ExitScope();
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005528
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005529 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005530 CodeCompletionContext::CCC_ObjCInterfaceName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005531 Results.data(),Results.size());
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005532}
5533
5534void Sema::CodeCompleteObjCImplementationDecl(Scope *S) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005535 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5536 CodeCompletionContext::CCC_Other);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005537 Results.EnterNewScope();
5538
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005539 if (CodeCompleter->includeGlobals()) {
5540 // Add all unimplemented classes.
5541 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
5542 true, Results);
5543 }
5544
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005545 Results.ExitScope();
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005546
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005547 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005548 CodeCompletionContext::CCC_ObjCInterfaceName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005549 Results.data(),Results.size());
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005550}
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005551
5552void Sema::CodeCompleteObjCInterfaceCategory(Scope *S,
Douglas Gregorc83c6872010-04-15 22:33:43 +00005553 IdentifierInfo *ClassName,
5554 SourceLocation ClassNameLoc) {
John McCall0a2c5e22010-08-25 06:19:51 +00005555 typedef CodeCompletionResult Result;
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005556
Douglas Gregor218937c2011-02-01 19:23:04 +00005557 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor3da626b2011-07-07 16:03:39 +00005558 CodeCompletionContext::CCC_ObjCCategoryName);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005559
5560 // Ignore any categories we find that have already been implemented by this
5561 // interface.
5562 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
5563 NamedDecl *CurClass
Douglas Gregorc83c6872010-04-15 22:33:43 +00005564 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005565 if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass))
5566 for (ObjCCategoryDecl *Category = Class->getCategoryList(); Category;
5567 Category = Category->getNextClassCategory())
5568 CategoryNames.insert(Category->getIdentifier());
5569
5570 // Add all of the categories we know about.
5571 Results.EnterNewScope();
5572 TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
5573 for (DeclContext::decl_iterator D = TU->decls_begin(),
5574 DEnd = TU->decls_end();
5575 D != DEnd; ++D)
5576 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(*D))
5577 if (CategoryNames.insert(Category->getIdentifier()))
Douglas Gregor608300b2010-01-14 16:14:35 +00005578 Results.AddResult(Result(Category, 0), CurContext, 0, false);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005579 Results.ExitScope();
5580
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005581 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor3da626b2011-07-07 16:03:39 +00005582 CodeCompletionContext::CCC_ObjCCategoryName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005583 Results.data(),Results.size());
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005584}
5585
5586void Sema::CodeCompleteObjCImplementationCategory(Scope *S,
Douglas Gregorc83c6872010-04-15 22:33:43 +00005587 IdentifierInfo *ClassName,
5588 SourceLocation ClassNameLoc) {
John McCall0a2c5e22010-08-25 06:19:51 +00005589 typedef CodeCompletionResult Result;
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005590
5591 // Find the corresponding interface. If we couldn't find the interface, the
5592 // program itself is ill-formed. However, we'll try to be helpful still by
5593 // providing the list of all of the categories we know about.
5594 NamedDecl *CurClass
Douglas Gregorc83c6872010-04-15 22:33:43 +00005595 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005596 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
5597 if (!Class)
Douglas Gregorc83c6872010-04-15 22:33:43 +00005598 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005599
Douglas Gregor218937c2011-02-01 19:23:04 +00005600 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor3da626b2011-07-07 16:03:39 +00005601 CodeCompletionContext::CCC_ObjCCategoryName);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005602
5603 // Add all of the categories that have have corresponding interface
5604 // declarations in this class and any of its superclasses, except for
5605 // already-implemented categories in the class itself.
5606 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
5607 Results.EnterNewScope();
5608 bool IgnoreImplemented = true;
5609 while (Class) {
5610 for (ObjCCategoryDecl *Category = Class->getCategoryList(); Category;
5611 Category = Category->getNextClassCategory())
5612 if ((!IgnoreImplemented || !Category->getImplementation()) &&
5613 CategoryNames.insert(Category->getIdentifier()))
Douglas Gregor608300b2010-01-14 16:14:35 +00005614 Results.AddResult(Result(Category, 0), CurContext, 0, false);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005615
5616 Class = Class->getSuperClass();
5617 IgnoreImplemented = false;
5618 }
5619 Results.ExitScope();
5620
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005621 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor3da626b2011-07-07 16:03:39 +00005622 CodeCompletionContext::CCC_ObjCCategoryName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005623 Results.data(),Results.size());
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005624}
Douglas Gregor322328b2009-11-18 22:32:06 +00005625
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00005626void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) {
John McCall0a2c5e22010-08-25 06:19:51 +00005627 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00005628 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5629 CodeCompletionContext::CCC_Other);
Douglas Gregor322328b2009-11-18 22:32:06 +00005630
5631 // Figure out where this @synthesize lives.
5632 ObjCContainerDecl *Container
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00005633 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
Douglas Gregor322328b2009-11-18 22:32:06 +00005634 if (!Container ||
5635 (!isa<ObjCImplementationDecl>(Container) &&
5636 !isa<ObjCCategoryImplDecl>(Container)))
5637 return;
5638
5639 // Ignore any properties that have already been implemented.
5640 for (DeclContext::decl_iterator D = Container->decls_begin(),
5641 DEnd = Container->decls_end();
5642 D != DEnd; ++D)
5643 if (ObjCPropertyImplDecl *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(*D))
5644 Results.Ignore(PropertyImpl->getPropertyDecl());
5645
5646 // Add any properties that we find.
Douglas Gregor73449212010-12-09 23:01:55 +00005647 AddedPropertiesSet AddedProperties;
Douglas Gregor322328b2009-11-18 22:32:06 +00005648 Results.EnterNewScope();
5649 if (ObjCImplementationDecl *ClassImpl
5650 = dyn_cast<ObjCImplementationDecl>(Container))
Douglas Gregor4b81cde2011-05-05 15:50:42 +00005651 AddObjCProperties(ClassImpl->getClassInterface(), false,
5652 /*AllowNullaryMethods=*/false, CurContext,
Douglas Gregor73449212010-12-09 23:01:55 +00005653 AddedProperties, Results);
Douglas Gregor322328b2009-11-18 22:32:06 +00005654 else
5655 AddObjCProperties(cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
Douglas Gregor4b81cde2011-05-05 15:50:42 +00005656 false, /*AllowNullaryMethods=*/false, CurContext,
5657 AddedProperties, Results);
Douglas Gregor322328b2009-11-18 22:32:06 +00005658 Results.ExitScope();
5659
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005660 HandleCodeCompleteResults(this, CodeCompleter,
5661 CodeCompletionContext::CCC_Other,
5662 Results.data(),Results.size());
Douglas Gregor322328b2009-11-18 22:32:06 +00005663}
5664
5665void Sema::CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00005666 IdentifierInfo *PropertyName) {
John McCall0a2c5e22010-08-25 06:19:51 +00005667 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00005668 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5669 CodeCompletionContext::CCC_Other);
Douglas Gregor322328b2009-11-18 22:32:06 +00005670
5671 // Figure out where this @synthesize lives.
5672 ObjCContainerDecl *Container
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00005673 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
Douglas Gregor322328b2009-11-18 22:32:06 +00005674 if (!Container ||
5675 (!isa<ObjCImplementationDecl>(Container) &&
5676 !isa<ObjCCategoryImplDecl>(Container)))
5677 return;
5678
5679 // Figure out which interface we're looking into.
5680 ObjCInterfaceDecl *Class = 0;
5681 if (ObjCImplementationDecl *ClassImpl
5682 = dyn_cast<ObjCImplementationDecl>(Container))
5683 Class = ClassImpl->getClassInterface();
5684 else
5685 Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl()
5686 ->getClassInterface();
5687
Douglas Gregore8426052011-04-18 14:40:46 +00005688 // Determine the type of the property we're synthesizing.
5689 QualType PropertyType = Context.getObjCIdType();
5690 if (Class) {
5691 if (ObjCPropertyDecl *Property
5692 = Class->FindPropertyDeclaration(PropertyName)) {
5693 PropertyType
5694 = Property->getType().getNonReferenceType().getUnqualifiedType();
5695
5696 // Give preference to ivars
5697 Results.setPreferredType(PropertyType);
5698 }
5699 }
5700
Douglas Gregor322328b2009-11-18 22:32:06 +00005701 // Add all of the instance variables in this class and its superclasses.
5702 Results.EnterNewScope();
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005703 bool SawSimilarlyNamedIvar = false;
5704 std::string NameWithPrefix;
5705 NameWithPrefix += '_';
Benjamin Kramera0651c52011-07-26 16:59:25 +00005706 NameWithPrefix += PropertyName->getName();
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005707 std::string NameWithSuffix = PropertyName->getName().str();
5708 NameWithSuffix += '_';
Douglas Gregor322328b2009-11-18 22:32:06 +00005709 for(; Class; Class = Class->getSuperClass()) {
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005710 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
5711 Ivar = Ivar->getNextIvar()) {
Douglas Gregore8426052011-04-18 14:40:46 +00005712 Results.AddResult(Result(Ivar, 0), CurContext, 0, false);
5713
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005714 // Determine whether we've seen an ivar with a name similar to the
5715 // property.
Douglas Gregore8426052011-04-18 14:40:46 +00005716 if ((PropertyName == Ivar->getIdentifier() ||
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005717 NameWithPrefix == Ivar->getName() ||
Douglas Gregore8426052011-04-18 14:40:46 +00005718 NameWithSuffix == Ivar->getName())) {
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005719 SawSimilarlyNamedIvar = true;
Douglas Gregore8426052011-04-18 14:40:46 +00005720
5721 // Reduce the priority of this result by one, to give it a slight
5722 // advantage over other results whose names don't match so closely.
5723 if (Results.size() &&
5724 Results.data()[Results.size() - 1].Kind
5725 == CodeCompletionResult::RK_Declaration &&
5726 Results.data()[Results.size() - 1].Declaration == Ivar)
5727 Results.data()[Results.size() - 1].Priority--;
5728 }
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005729 }
Douglas Gregor322328b2009-11-18 22:32:06 +00005730 }
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005731
5732 if (!SawSimilarlyNamedIvar) {
5733 // Create ivar result _propName, that the user can use to synthesize
Douglas Gregore8426052011-04-18 14:40:46 +00005734 // an ivar of the appropriate type.
5735 unsigned Priority = CCP_MemberDeclaration + 1;
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005736 typedef CodeCompletionResult Result;
5737 CodeCompletionAllocator &Allocator = Results.getAllocator();
5738 CodeCompletionBuilder Builder(Allocator, Priority,CXAvailability_Available);
5739
Douglas Gregor8987b232011-09-27 23:30:47 +00005740 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
Douglas Gregore8426052011-04-18 14:40:46 +00005741 Builder.AddResultTypeChunk(GetCompletionTypeString(PropertyType, Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00005742 Policy, Allocator));
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005743 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
5744 Results.AddResult(Result(Builder.TakeString(), Priority,
5745 CXCursor_ObjCIvarDecl));
5746 }
5747
Douglas Gregor322328b2009-11-18 22:32:06 +00005748 Results.ExitScope();
5749
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005750 HandleCodeCompleteResults(this, CodeCompleter,
5751 CodeCompletionContext::CCC_Other,
5752 Results.data(),Results.size());
Douglas Gregor322328b2009-11-18 22:32:06 +00005753}
Douglas Gregore8f5a172010-04-07 00:21:17 +00005754
Douglas Gregor408be5a2010-08-25 01:08:01 +00005755// Mapping from selectors to the methods that implement that selector, along
5756// with the "in original class" flag.
5757typedef llvm::DenseMap<Selector, std::pair<ObjCMethodDecl *, bool> >
5758 KnownMethodsMap;
Douglas Gregore8f5a172010-04-07 00:21:17 +00005759
5760/// \brief Find all of the methods that reside in the given container
5761/// (and its superclasses, protocols, etc.) that meet the given
5762/// criteria. Insert those methods into the map of known methods,
5763/// indexed by selector so they can be easily found.
5764static void FindImplementableMethods(ASTContext &Context,
5765 ObjCContainerDecl *Container,
5766 bool WantInstanceMethods,
5767 QualType ReturnType,
Douglas Gregor408be5a2010-08-25 01:08:01 +00005768 KnownMethodsMap &KnownMethods,
5769 bool InOriginalClass = true) {
Douglas Gregore8f5a172010-04-07 00:21:17 +00005770 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
5771 // Recurse into protocols.
Douglas Gregor2e5c15b2011-12-15 05:27:12 +00005772 if (!IFace->hasDefinition())
5773 return;
5774
Douglas Gregore8f5a172010-04-07 00:21:17 +00005775 const ObjCList<ObjCProtocolDecl> &Protocols
5776 = IFace->getReferencedProtocols();
5777 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
Douglas Gregorea766182010-10-18 18:21:28 +00005778 E = Protocols.end();
Douglas Gregore8f5a172010-04-07 00:21:17 +00005779 I != E; ++I)
5780 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
Douglas Gregorea766182010-10-18 18:21:28 +00005781 KnownMethods, InOriginalClass);
Douglas Gregore8f5a172010-04-07 00:21:17 +00005782
Douglas Gregorea766182010-10-18 18:21:28 +00005783 // Add methods from any class extensions and categories.
5784 for (const ObjCCategoryDecl *Cat = IFace->getCategoryList(); Cat;
5785 Cat = Cat->getNextClassCategory())
Fariborz Jahanian80aa1cd2010-06-22 23:20:40 +00005786 FindImplementableMethods(Context, const_cast<ObjCCategoryDecl*>(Cat),
5787 WantInstanceMethods, ReturnType,
Douglas Gregorea766182010-10-18 18:21:28 +00005788 KnownMethods, false);
5789
5790 // Visit the superclass.
5791 if (IFace->getSuperClass())
5792 FindImplementableMethods(Context, IFace->getSuperClass(),
5793 WantInstanceMethods, ReturnType,
5794 KnownMethods, false);
Douglas Gregore8f5a172010-04-07 00:21:17 +00005795 }
5796
5797 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
5798 // Recurse into protocols.
5799 const ObjCList<ObjCProtocolDecl> &Protocols
5800 = Category->getReferencedProtocols();
5801 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
Douglas Gregorea766182010-10-18 18:21:28 +00005802 E = Protocols.end();
Douglas Gregore8f5a172010-04-07 00:21:17 +00005803 I != E; ++I)
5804 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
Douglas Gregorea766182010-10-18 18:21:28 +00005805 KnownMethods, InOriginalClass);
5806
5807 // If this category is the original class, jump to the interface.
5808 if (InOriginalClass && Category->getClassInterface())
5809 FindImplementableMethods(Context, Category->getClassInterface(),
5810 WantInstanceMethods, ReturnType, KnownMethods,
5811 false);
Douglas Gregore8f5a172010-04-07 00:21:17 +00005812 }
5813
5814 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +00005815 if (Protocol->hasDefinition()) {
5816 // Recurse into protocols.
5817 const ObjCList<ObjCProtocolDecl> &Protocols
5818 = Protocol->getReferencedProtocols();
5819 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5820 E = Protocols.end();
5821 I != E; ++I)
5822 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
5823 KnownMethods, false);
5824 }
Douglas Gregore8f5a172010-04-07 00:21:17 +00005825 }
5826
5827 // Add methods in this container. This operation occurs last because
5828 // we want the methods from this container to override any methods
5829 // we've previously seen with the same selector.
5830 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(),
5831 MEnd = Container->meth_end();
5832 M != MEnd; ++M) {
5833 if ((*M)->isInstanceMethod() == WantInstanceMethods) {
5834 if (!ReturnType.isNull() &&
5835 !Context.hasSameUnqualifiedType(ReturnType, (*M)->getResultType()))
5836 continue;
5837
Douglas Gregor408be5a2010-08-25 01:08:01 +00005838 KnownMethods[(*M)->getSelector()] = std::make_pair(*M, InOriginalClass);
Douglas Gregore8f5a172010-04-07 00:21:17 +00005839 }
5840 }
5841}
5842
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005843/// \brief Add the parenthesized return or parameter type chunk to a code
5844/// completion string.
5845static void AddObjCPassingTypeChunk(QualType Type,
5846 ASTContext &Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00005847 const PrintingPolicy &Policy,
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005848 CodeCompletionBuilder &Builder) {
5849 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
Douglas Gregor8987b232011-09-27 23:30:47 +00005850 Builder.AddTextChunk(GetCompletionTypeString(Type, Context, Policy,
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005851 Builder.getAllocator()));
5852 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5853}
5854
5855/// \brief Determine whether the given class is or inherits from a class by
5856/// the given name.
5857static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class,
Chris Lattner5f9e2722011-07-23 10:55:15 +00005858 StringRef Name) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005859 if (!Class)
5860 return false;
5861
5862 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
5863 return true;
5864
5865 return InheritsFromClassNamed(Class->getSuperClass(), Name);
5866}
5867
5868/// \brief Add code completions for Objective-C Key-Value Coding (KVC) and
5869/// Key-Value Observing (KVO).
5870static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property,
5871 bool IsInstanceMethod,
5872 QualType ReturnType,
5873 ASTContext &Context,
Douglas Gregore74c25c2011-05-04 23:50:46 +00005874 VisitedSelectorSet &KnownSelectors,
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005875 ResultBuilder &Results) {
5876 IdentifierInfo *PropName = Property->getIdentifier();
5877 if (!PropName || PropName->getLength() == 0)
5878 return;
5879
Douglas Gregor8987b232011-09-27 23:30:47 +00005880 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
5881
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005882 // Builder that will create each code completion.
5883 typedef CodeCompletionResult Result;
5884 CodeCompletionAllocator &Allocator = Results.getAllocator();
5885 CodeCompletionBuilder Builder(Allocator);
5886
5887 // The selector table.
5888 SelectorTable &Selectors = Context.Selectors;
5889
5890 // The property name, copied into the code completion allocation region
5891 // on demand.
5892 struct KeyHolder {
5893 CodeCompletionAllocator &Allocator;
Chris Lattner5f9e2722011-07-23 10:55:15 +00005894 StringRef Key;
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005895 const char *CopiedKey;
5896
Chris Lattner5f9e2722011-07-23 10:55:15 +00005897 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005898 : Allocator(Allocator), Key(Key), CopiedKey(0) { }
5899
5900 operator const char *() {
5901 if (CopiedKey)
5902 return CopiedKey;
5903
5904 return CopiedKey = Allocator.CopyString(Key);
5905 }
5906 } Key(Allocator, PropName->getName());
5907
5908 // The uppercased name of the property name.
5909 std::string UpperKey = PropName->getName();
5910 if (!UpperKey.empty())
5911 UpperKey[0] = toupper(UpperKey[0]);
5912
5913 bool ReturnTypeMatchesProperty = ReturnType.isNull() ||
5914 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
5915 Property->getType());
5916 bool ReturnTypeMatchesVoid
5917 = ReturnType.isNull() || ReturnType->isVoidType();
5918
5919 // Add the normal accessor -(type)key.
5920 if (IsInstanceMethod &&
Douglas Gregore74c25c2011-05-04 23:50:46 +00005921 KnownSelectors.insert(Selectors.getNullarySelector(PropName)) &&
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005922 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
5923 if (ReturnType.isNull())
Douglas Gregor8987b232011-09-27 23:30:47 +00005924 AddObjCPassingTypeChunk(Property->getType(), Context, Policy, Builder);
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005925
5926 Builder.AddTypedTextChunk(Key);
5927 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
5928 CXCursor_ObjCInstanceMethodDecl));
5929 }
5930
5931 // If we have an integral or boolean property (or the user has provided
5932 // an integral or boolean return type), add the accessor -(type)isKey.
5933 if (IsInstanceMethod &&
5934 ((!ReturnType.isNull() &&
5935 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
5936 (ReturnType.isNull() &&
5937 (Property->getType()->isIntegerType() ||
5938 Property->getType()->isBooleanType())))) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00005939 std::string SelectorName = (Twine("is") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00005940 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00005941 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005942 if (ReturnType.isNull()) {
5943 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5944 Builder.AddTextChunk("BOOL");
5945 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5946 }
5947
5948 Builder.AddTypedTextChunk(
5949 Allocator.CopyString(SelectorId->getName()));
5950 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
5951 CXCursor_ObjCInstanceMethodDecl));
5952 }
5953 }
5954
5955 // Add the normal mutator.
5956 if (IsInstanceMethod && ReturnTypeMatchesVoid &&
5957 !Property->getSetterMethodDecl()) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00005958 std::string SelectorName = (Twine("set") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00005959 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00005960 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005961 if (ReturnType.isNull()) {
5962 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5963 Builder.AddTextChunk("void");
5964 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5965 }
5966
5967 Builder.AddTypedTextChunk(
5968 Allocator.CopyString(SelectorId->getName()));
5969 Builder.AddTypedTextChunk(":");
Douglas Gregor8987b232011-09-27 23:30:47 +00005970 AddObjCPassingTypeChunk(Property->getType(), Context, Policy, Builder);
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005971 Builder.AddTextChunk(Key);
5972 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
5973 CXCursor_ObjCInstanceMethodDecl));
5974 }
5975 }
5976
5977 // Indexed and unordered accessors
5978 unsigned IndexedGetterPriority = CCP_CodePattern;
5979 unsigned IndexedSetterPriority = CCP_CodePattern;
5980 unsigned UnorderedGetterPriority = CCP_CodePattern;
5981 unsigned UnorderedSetterPriority = CCP_CodePattern;
5982 if (const ObjCObjectPointerType *ObjCPointer
5983 = Property->getType()->getAs<ObjCObjectPointerType>()) {
5984 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
5985 // If this interface type is not provably derived from a known
5986 // collection, penalize the corresponding completions.
5987 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
5988 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
5989 if (!InheritsFromClassNamed(IFace, "NSArray"))
5990 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
5991 }
5992
5993 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
5994 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
5995 if (!InheritsFromClassNamed(IFace, "NSSet"))
5996 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
5997 }
5998 }
5999 } else {
6000 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6001 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6002 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6003 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6004 }
6005
6006 // Add -(NSUInteger)countOf<key>
6007 if (IsInstanceMethod &&
6008 (ReturnType.isNull() || ReturnType->isIntegerType())) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006009 std::string SelectorName = (Twine("countOf") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006010 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006011 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006012 if (ReturnType.isNull()) {
6013 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6014 Builder.AddTextChunk("NSUInteger");
6015 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6016 }
6017
6018 Builder.AddTypedTextChunk(
6019 Allocator.CopyString(SelectorId->getName()));
6020 Results.AddResult(Result(Builder.TakeString(),
6021 std::min(IndexedGetterPriority,
6022 UnorderedGetterPriority),
6023 CXCursor_ObjCInstanceMethodDecl));
6024 }
6025 }
6026
6027 // Indexed getters
6028 // Add -(id)objectInKeyAtIndex:(NSUInteger)index
6029 if (IsInstanceMethod &&
6030 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
Douglas Gregor62041592011-02-17 03:19:26 +00006031 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006032 = (Twine("objectIn") + UpperKey + "AtIndex").str();
Douglas Gregor62041592011-02-17 03:19:26 +00006033 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006034 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006035 if (ReturnType.isNull()) {
6036 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6037 Builder.AddTextChunk("id");
6038 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6039 }
6040
6041 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6042 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6043 Builder.AddTextChunk("NSUInteger");
6044 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6045 Builder.AddTextChunk("index");
6046 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6047 CXCursor_ObjCInstanceMethodDecl));
6048 }
6049 }
6050
6051 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
6052 if (IsInstanceMethod &&
6053 (ReturnType.isNull() ||
6054 (ReturnType->isObjCObjectPointerType() &&
6055 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6056 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6057 ->getName() == "NSArray"))) {
Douglas Gregor62041592011-02-17 03:19:26 +00006058 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006059 = (Twine(Property->getName()) + "AtIndexes").str();
Douglas Gregor62041592011-02-17 03:19:26 +00006060 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006061 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006062 if (ReturnType.isNull()) {
6063 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6064 Builder.AddTextChunk("NSArray *");
6065 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6066 }
6067
6068 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6069 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6070 Builder.AddTextChunk("NSIndexSet *");
6071 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6072 Builder.AddTextChunk("indexes");
6073 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6074 CXCursor_ObjCInstanceMethodDecl));
6075 }
6076 }
6077
6078 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
6079 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006080 std::string SelectorName = (Twine("get") + UpperKey).str();
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006081 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor62041592011-02-17 03:19:26 +00006082 &Context.Idents.get(SelectorName),
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006083 &Context.Idents.get("range")
6084 };
6085
Douglas Gregore74c25c2011-05-04 23:50:46 +00006086 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006087 if (ReturnType.isNull()) {
6088 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6089 Builder.AddTextChunk("void");
6090 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6091 }
6092
6093 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6094 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6095 Builder.AddPlaceholderChunk("object-type");
6096 Builder.AddTextChunk(" **");
6097 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6098 Builder.AddTextChunk("buffer");
6099 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6100 Builder.AddTypedTextChunk("range:");
6101 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6102 Builder.AddTextChunk("NSRange");
6103 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6104 Builder.AddTextChunk("inRange");
6105 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6106 CXCursor_ObjCInstanceMethodDecl));
6107 }
6108 }
6109
6110 // Mutable indexed accessors
6111
6112 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
6113 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006114 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006115 IdentifierInfo *SelectorIds[2] = {
6116 &Context.Idents.get("insertObject"),
Douglas Gregor62041592011-02-17 03:19:26 +00006117 &Context.Idents.get(SelectorName)
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006118 };
6119
Douglas Gregore74c25c2011-05-04 23:50:46 +00006120 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006121 if (ReturnType.isNull()) {
6122 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6123 Builder.AddTextChunk("void");
6124 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6125 }
6126
6127 Builder.AddTypedTextChunk("insertObject:");
6128 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6129 Builder.AddPlaceholderChunk("object-type");
6130 Builder.AddTextChunk(" *");
6131 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6132 Builder.AddTextChunk("object");
6133 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6134 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6135 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6136 Builder.AddPlaceholderChunk("NSUInteger");
6137 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6138 Builder.AddTextChunk("index");
6139 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6140 CXCursor_ObjCInstanceMethodDecl));
6141 }
6142 }
6143
6144 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
6145 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006146 std::string SelectorName = (Twine("insert") + UpperKey).str();
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006147 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor62041592011-02-17 03:19:26 +00006148 &Context.Idents.get(SelectorName),
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006149 &Context.Idents.get("atIndexes")
6150 };
6151
Douglas Gregore74c25c2011-05-04 23:50:46 +00006152 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006153 if (ReturnType.isNull()) {
6154 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6155 Builder.AddTextChunk("void");
6156 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6157 }
6158
6159 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6160 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6161 Builder.AddTextChunk("NSArray *");
6162 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6163 Builder.AddTextChunk("array");
6164 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6165 Builder.AddTypedTextChunk("atIndexes:");
6166 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6167 Builder.AddPlaceholderChunk("NSIndexSet *");
6168 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6169 Builder.AddTextChunk("indexes");
6170 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6171 CXCursor_ObjCInstanceMethodDecl));
6172 }
6173 }
6174
6175 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
6176 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006177 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006178 = (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
Douglas Gregor62041592011-02-17 03:19:26 +00006179 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006180 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006181 if (ReturnType.isNull()) {
6182 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6183 Builder.AddTextChunk("void");
6184 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6185 }
6186
6187 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6188 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6189 Builder.AddTextChunk("NSUInteger");
6190 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6191 Builder.AddTextChunk("index");
6192 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6193 CXCursor_ObjCInstanceMethodDecl));
6194 }
6195 }
6196
6197 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
6198 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006199 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006200 = (Twine("remove") + UpperKey + "AtIndexes").str();
Douglas Gregor62041592011-02-17 03:19:26 +00006201 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006202 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006203 if (ReturnType.isNull()) {
6204 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6205 Builder.AddTextChunk("void");
6206 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6207 }
6208
6209 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6210 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6211 Builder.AddTextChunk("NSIndexSet *");
6212 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6213 Builder.AddTextChunk("indexes");
6214 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6215 CXCursor_ObjCInstanceMethodDecl));
6216 }
6217 }
6218
6219 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
6220 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006221 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006222 = (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006223 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor62041592011-02-17 03:19:26 +00006224 &Context.Idents.get(SelectorName),
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006225 &Context.Idents.get("withObject")
6226 };
6227
Douglas Gregore74c25c2011-05-04 23:50:46 +00006228 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006229 if (ReturnType.isNull()) {
6230 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6231 Builder.AddTextChunk("void");
6232 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6233 }
6234
6235 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6236 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6237 Builder.AddPlaceholderChunk("NSUInteger");
6238 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6239 Builder.AddTextChunk("index");
6240 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6241 Builder.AddTypedTextChunk("withObject:");
6242 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6243 Builder.AddTextChunk("id");
6244 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6245 Builder.AddTextChunk("object");
6246 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6247 CXCursor_ObjCInstanceMethodDecl));
6248 }
6249 }
6250
6251 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
6252 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006253 std::string SelectorName1
Chris Lattner5f9e2722011-07-23 10:55:15 +00006254 = (Twine("replace") + UpperKey + "AtIndexes").str();
6255 std::string SelectorName2 = (Twine("with") + UpperKey).str();
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006256 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor62041592011-02-17 03:19:26 +00006257 &Context.Idents.get(SelectorName1),
6258 &Context.Idents.get(SelectorName2)
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006259 };
6260
Douglas Gregore74c25c2011-05-04 23:50:46 +00006261 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006262 if (ReturnType.isNull()) {
6263 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6264 Builder.AddTextChunk("void");
6265 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6266 }
6267
6268 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
6269 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6270 Builder.AddPlaceholderChunk("NSIndexSet *");
6271 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6272 Builder.AddTextChunk("indexes");
6273 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6274 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
6275 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6276 Builder.AddTextChunk("NSArray *");
6277 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6278 Builder.AddTextChunk("array");
6279 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6280 CXCursor_ObjCInstanceMethodDecl));
6281 }
6282 }
6283
6284 // Unordered getters
6285 // - (NSEnumerator *)enumeratorOfKey
6286 if (IsInstanceMethod &&
6287 (ReturnType.isNull() ||
6288 (ReturnType->isObjCObjectPointerType() &&
6289 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6290 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6291 ->getName() == "NSEnumerator"))) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006292 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006293 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006294 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006295 if (ReturnType.isNull()) {
6296 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6297 Builder.AddTextChunk("NSEnumerator *");
6298 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6299 }
6300
6301 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6302 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6303 CXCursor_ObjCInstanceMethodDecl));
6304 }
6305 }
6306
6307 // - (type *)memberOfKey:(type *)object
6308 if (IsInstanceMethod &&
6309 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006310 std::string SelectorName = (Twine("memberOf") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006311 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006312 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006313 if (ReturnType.isNull()) {
6314 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6315 Builder.AddPlaceholderChunk("object-type");
6316 Builder.AddTextChunk(" *");
6317 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6318 }
6319
6320 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6321 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6322 if (ReturnType.isNull()) {
6323 Builder.AddPlaceholderChunk("object-type");
6324 Builder.AddTextChunk(" *");
6325 } else {
6326 Builder.AddTextChunk(GetCompletionTypeString(ReturnType, Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00006327 Policy,
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006328 Builder.getAllocator()));
6329 }
6330 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6331 Builder.AddTextChunk("object");
6332 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6333 CXCursor_ObjCInstanceMethodDecl));
6334 }
6335 }
6336
6337 // Mutable unordered accessors
6338 // - (void)addKeyObject:(type *)object
6339 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006340 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006341 = (Twine("add") + UpperKey + Twine("Object")).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006342 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006343 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006344 if (ReturnType.isNull()) {
6345 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6346 Builder.AddTextChunk("void");
6347 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6348 }
6349
6350 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6351 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6352 Builder.AddPlaceholderChunk("object-type");
6353 Builder.AddTextChunk(" *");
6354 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6355 Builder.AddTextChunk("object");
6356 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6357 CXCursor_ObjCInstanceMethodDecl));
6358 }
6359 }
6360
6361 // - (void)addKey:(NSSet *)objects
6362 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006363 std::string SelectorName = (Twine("add") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006364 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006365 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006366 if (ReturnType.isNull()) {
6367 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6368 Builder.AddTextChunk("void");
6369 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6370 }
6371
6372 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6373 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6374 Builder.AddTextChunk("NSSet *");
6375 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6376 Builder.AddTextChunk("objects");
6377 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6378 CXCursor_ObjCInstanceMethodDecl));
6379 }
6380 }
6381
6382 // - (void)removeKeyObject:(type *)object
6383 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006384 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006385 = (Twine("remove") + UpperKey + Twine("Object")).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006386 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006387 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006388 if (ReturnType.isNull()) {
6389 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6390 Builder.AddTextChunk("void");
6391 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6392 }
6393
6394 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6395 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6396 Builder.AddPlaceholderChunk("object-type");
6397 Builder.AddTextChunk(" *");
6398 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6399 Builder.AddTextChunk("object");
6400 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6401 CXCursor_ObjCInstanceMethodDecl));
6402 }
6403 }
6404
6405 // - (void)removeKey:(NSSet *)objects
6406 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006407 std::string SelectorName = (Twine("remove") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006408 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006409 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006410 if (ReturnType.isNull()) {
6411 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6412 Builder.AddTextChunk("void");
6413 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6414 }
6415
6416 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6417 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6418 Builder.AddTextChunk("NSSet *");
6419 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6420 Builder.AddTextChunk("objects");
6421 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6422 CXCursor_ObjCInstanceMethodDecl));
6423 }
6424 }
6425
6426 // - (void)intersectKey:(NSSet *)objects
6427 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006428 std::string SelectorName = (Twine("intersect") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006429 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006430 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006431 if (ReturnType.isNull()) {
6432 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6433 Builder.AddTextChunk("void");
6434 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6435 }
6436
6437 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6438 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6439 Builder.AddTextChunk("NSSet *");
6440 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6441 Builder.AddTextChunk("objects");
6442 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6443 CXCursor_ObjCInstanceMethodDecl));
6444 }
6445 }
6446
6447 // Key-Value Observing
6448 // + (NSSet *)keyPathsForValuesAffectingKey
6449 if (!IsInstanceMethod &&
6450 (ReturnType.isNull() ||
6451 (ReturnType->isObjCObjectPointerType() &&
6452 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6453 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6454 ->getName() == "NSSet"))) {
Douglas Gregor62041592011-02-17 03:19:26 +00006455 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006456 = (Twine("keyPathsForValuesAffecting") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006457 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006458 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006459 if (ReturnType.isNull()) {
6460 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6461 Builder.AddTextChunk("NSSet *");
6462 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6463 }
6464
6465 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6466 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
Douglas Gregor3f828d12011-06-02 04:02:27 +00006467 CXCursor_ObjCClassMethodDecl));
6468 }
6469 }
6470
6471 // + (BOOL)automaticallyNotifiesObserversForKey
6472 if (!IsInstanceMethod &&
6473 (ReturnType.isNull() ||
6474 ReturnType->isIntegerType() ||
6475 ReturnType->isBooleanType())) {
6476 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006477 = (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
Douglas Gregor3f828d12011-06-02 04:02:27 +00006478 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6479 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
6480 if (ReturnType.isNull()) {
6481 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6482 Builder.AddTextChunk("BOOL");
6483 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6484 }
6485
6486 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6487 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6488 CXCursor_ObjCClassMethodDecl));
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006489 }
6490 }
6491}
6492
Douglas Gregore8f5a172010-04-07 00:21:17 +00006493void Sema::CodeCompleteObjCMethodDecl(Scope *S,
6494 bool IsInstanceMethod,
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00006495 ParsedType ReturnTy) {
Douglas Gregore8f5a172010-04-07 00:21:17 +00006496 // Determine the return type of the method we're declaring, if
6497 // provided.
6498 QualType ReturnType = GetTypeFromParser(ReturnTy);
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00006499 Decl *IDecl = 0;
6500 if (CurContext->isObjCContainer()) {
6501 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
6502 IDecl = cast<Decl>(OCD);
6503 }
Douglas Gregorea766182010-10-18 18:21:28 +00006504 // Determine where we should start searching for methods.
6505 ObjCContainerDecl *SearchDecl = 0;
Douglas Gregore8f5a172010-04-07 00:21:17 +00006506 bool IsInImplementation = false;
John McCalld226f652010-08-21 09:40:31 +00006507 if (Decl *D = IDecl) {
Douglas Gregore8f5a172010-04-07 00:21:17 +00006508 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
6509 SearchDecl = Impl->getClassInterface();
Douglas Gregore8f5a172010-04-07 00:21:17 +00006510 IsInImplementation = true;
6511 } else if (ObjCCategoryImplDecl *CatImpl
Douglas Gregorea766182010-10-18 18:21:28 +00006512 = dyn_cast<ObjCCategoryImplDecl>(D)) {
Douglas Gregore8f5a172010-04-07 00:21:17 +00006513 SearchDecl = CatImpl->getCategoryDecl();
Douglas Gregore8f5a172010-04-07 00:21:17 +00006514 IsInImplementation = true;
Douglas Gregorea766182010-10-18 18:21:28 +00006515 } else
Douglas Gregore8f5a172010-04-07 00:21:17 +00006516 SearchDecl = dyn_cast<ObjCContainerDecl>(D);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006517 }
6518
6519 if (!SearchDecl && S) {
Douglas Gregorea766182010-10-18 18:21:28 +00006520 if (DeclContext *DC = static_cast<DeclContext *>(S->getEntity()))
Douglas Gregore8f5a172010-04-07 00:21:17 +00006521 SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006522 }
6523
Douglas Gregorea766182010-10-18 18:21:28 +00006524 if (!SearchDecl) {
Douglas Gregore6b1bb62010-08-11 21:23:17 +00006525 HandleCodeCompleteResults(this, CodeCompleter,
6526 CodeCompletionContext::CCC_Other,
6527 0, 0);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006528 return;
6529 }
6530
6531 // Find all of the methods that we could declare/implement here.
6532 KnownMethodsMap KnownMethods;
6533 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod,
Douglas Gregorea766182010-10-18 18:21:28 +00006534 ReturnType, KnownMethods);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006535
Douglas Gregore8f5a172010-04-07 00:21:17 +00006536 // Add declarations or definitions for each of the known methods.
John McCall0a2c5e22010-08-25 06:19:51 +00006537 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00006538 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6539 CodeCompletionContext::CCC_Other);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006540 Results.EnterNewScope();
Douglas Gregor8987b232011-09-27 23:30:47 +00006541 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006542 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
6543 MEnd = KnownMethods.end();
6544 M != MEnd; ++M) {
Douglas Gregor408be5a2010-08-25 01:08:01 +00006545 ObjCMethodDecl *Method = M->second.first;
Douglas Gregor218937c2011-02-01 19:23:04 +00006546 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregore8f5a172010-04-07 00:21:17 +00006547
6548 // If the result type was not already provided, add it to the
6549 // pattern as (type).
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006550 if (ReturnType.isNull())
Douglas Gregor8987b232011-09-27 23:30:47 +00006551 AddObjCPassingTypeChunk(Method->getResultType(), Context, Policy,
6552 Builder);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006553
6554 Selector Sel = Method->getSelector();
6555
6556 // Add the first part of the selector to the pattern.
Douglas Gregordae68752011-02-01 22:57:45 +00006557 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00006558 Sel.getNameForSlot(0)));
Douglas Gregore8f5a172010-04-07 00:21:17 +00006559
6560 // Add parameters to the pattern.
6561 unsigned I = 0;
6562 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
6563 PEnd = Method->param_end();
6564 P != PEnd; (void)++P, ++I) {
6565 // Add the part of the selector name.
6566 if (I == 0)
Douglas Gregor218937c2011-02-01 19:23:04 +00006567 Builder.AddTypedTextChunk(":");
Douglas Gregore8f5a172010-04-07 00:21:17 +00006568 else if (I < Sel.getNumArgs()) {
Douglas Gregor218937c2011-02-01 19:23:04 +00006569 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6570 Builder.AddTypedTextChunk(
Douglas Gregor813d8342011-02-18 22:29:55 +00006571 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
Douglas Gregore8f5a172010-04-07 00:21:17 +00006572 } else
6573 break;
6574
6575 // Add the parameter type.
Douglas Gregor8987b232011-09-27 23:30:47 +00006576 AddObjCPassingTypeChunk((*P)->getOriginalType(), Context, Policy,
6577 Builder);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006578
6579 if (IdentifierInfo *Id = (*P)->getIdentifier())
Douglas Gregordae68752011-02-01 22:57:45 +00006580 Builder.AddTextChunk(Builder.getAllocator().CopyString( Id->getName()));
Douglas Gregore8f5a172010-04-07 00:21:17 +00006581 }
6582
6583 if (Method->isVariadic()) {
6584 if (Method->param_size() > 0)
Douglas Gregor218937c2011-02-01 19:23:04 +00006585 Builder.AddChunk(CodeCompletionString::CK_Comma);
6586 Builder.AddTextChunk("...");
Douglas Gregore17794f2010-08-31 05:13:43 +00006587 }
Douglas Gregore8f5a172010-04-07 00:21:17 +00006588
Douglas Gregor447107d2010-05-28 00:57:46 +00006589 if (IsInImplementation && Results.includeCodePatterns()) {
Douglas Gregore8f5a172010-04-07 00:21:17 +00006590 // We will be defining the method here, so add a compound statement.
Douglas Gregor218937c2011-02-01 19:23:04 +00006591 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6592 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
6593 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006594 if (!Method->getResultType()->isVoidType()) {
6595 // If the result type is not void, add a return clause.
Douglas Gregor218937c2011-02-01 19:23:04 +00006596 Builder.AddTextChunk("return");
6597 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6598 Builder.AddPlaceholderChunk("expression");
6599 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006600 } else
Douglas Gregor218937c2011-02-01 19:23:04 +00006601 Builder.AddPlaceholderChunk("statements");
Douglas Gregore8f5a172010-04-07 00:21:17 +00006602
Douglas Gregor218937c2011-02-01 19:23:04 +00006603 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
6604 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006605 }
6606
Douglas Gregor408be5a2010-08-25 01:08:01 +00006607 unsigned Priority = CCP_CodePattern;
6608 if (!M->second.second)
6609 Priority += CCD_InBaseClass;
6610
Douglas Gregor218937c2011-02-01 19:23:04 +00006611 Results.AddResult(Result(Builder.TakeString(), Priority,
Douglas Gregor16ed9ad2010-08-17 16:06:07 +00006612 Method->isInstanceMethod()
6613 ? CXCursor_ObjCInstanceMethodDecl
6614 : CXCursor_ObjCClassMethodDecl));
Douglas Gregore8f5a172010-04-07 00:21:17 +00006615 }
6616
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006617 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
6618 // the properties in this class and its categories.
6619 if (Context.getLangOptions().ObjC2) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006620 SmallVector<ObjCContainerDecl *, 4> Containers;
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006621 Containers.push_back(SearchDecl);
6622
Douglas Gregore74c25c2011-05-04 23:50:46 +00006623 VisitedSelectorSet KnownSelectors;
6624 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
6625 MEnd = KnownMethods.end();
6626 M != MEnd; ++M)
6627 KnownSelectors.insert(M->first);
6628
6629
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006630 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
6631 if (!IFace)
6632 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
6633 IFace = Category->getClassInterface();
6634
6635 if (IFace) {
6636 for (ObjCCategoryDecl *Category = IFace->getCategoryList(); Category;
6637 Category = Category->getNextClassCategory())
6638 Containers.push_back(Category);
6639 }
6640
6641 for (unsigned I = 0, N = Containers.size(); I != N; ++I) {
6642 for (ObjCContainerDecl::prop_iterator P = Containers[I]->prop_begin(),
6643 PEnd = Containers[I]->prop_end();
6644 P != PEnd; ++P) {
6645 AddObjCKeyValueCompletions(*P, IsInstanceMethod, ReturnType, Context,
Douglas Gregore74c25c2011-05-04 23:50:46 +00006646 KnownSelectors, Results);
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006647 }
6648 }
6649 }
6650
Douglas Gregore8f5a172010-04-07 00:21:17 +00006651 Results.ExitScope();
6652
Douglas Gregore6b1bb62010-08-11 21:23:17 +00006653 HandleCodeCompleteResults(this, CodeCompleter,
6654 CodeCompletionContext::CCC_Other,
6655 Results.data(),Results.size());
Douglas Gregore8f5a172010-04-07 00:21:17 +00006656}
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006657
6658void Sema::CodeCompleteObjCMethodDeclSelector(Scope *S,
6659 bool IsInstanceMethod,
Douglas Gregor40ed9a12010-07-08 23:37:41 +00006660 bool AtParameterName,
John McCallb3d87482010-08-24 05:47:05 +00006661 ParsedType ReturnTy,
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006662 IdentifierInfo **SelIdents,
6663 unsigned NumSelIdents) {
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006664 // If we have an external source, load the entire class method
Sebastian Redl3c7f4132010-08-18 23:57:06 +00006665 // pool from the AST file.
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006666 if (ExternalSource) {
6667 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6668 I != N; ++I) {
6669 Selector Sel = ExternalSource->GetExternalSelector(I);
Sebastian Redldb9d2142010-08-02 23:18:59 +00006670 if (Sel.isNull() || MethodPool.count(Sel))
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006671 continue;
Sebastian Redldb9d2142010-08-02 23:18:59 +00006672
6673 ReadMethodPool(Sel);
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006674 }
6675 }
6676
6677 // Build the set of methods we can see.
John McCall0a2c5e22010-08-25 06:19:51 +00006678 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00006679 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6680 CodeCompletionContext::CCC_Other);
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006681
6682 if (ReturnTy)
6683 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
Sebastian Redldb9d2142010-08-02 23:18:59 +00006684
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006685 Results.EnterNewScope();
Sebastian Redldb9d2142010-08-02 23:18:59 +00006686 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6687 MEnd = MethodPool.end();
6688 M != MEnd; ++M) {
6689 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first :
6690 &M->second.second;
6691 MethList && MethList->Method;
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006692 MethList = MethList->Next) {
6693 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents,
6694 NumSelIdents))
6695 continue;
6696
Douglas Gregor40ed9a12010-07-08 23:37:41 +00006697 if (AtParameterName) {
6698 // Suggest parameter names we've seen before.
6699 if (NumSelIdents && NumSelIdents <= MethList->Method->param_size()) {
6700 ParmVarDecl *Param = MethList->Method->param_begin()[NumSelIdents-1];
6701 if (Param->getIdentifier()) {
Douglas Gregor218937c2011-02-01 19:23:04 +00006702 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregordae68752011-02-01 22:57:45 +00006703 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00006704 Param->getIdentifier()->getName()));
6705 Results.AddResult(Builder.TakeString());
Douglas Gregor40ed9a12010-07-08 23:37:41 +00006706 }
6707 }
6708
6709 continue;
6710 }
6711
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006712 Result R(MethList->Method, 0);
6713 R.StartParameter = NumSelIdents;
6714 R.AllParametersAreInformative = false;
6715 R.DeclaringEntity = true;
6716 Results.MaybeAddResult(R, CurContext);
6717 }
6718 }
6719
6720 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00006721 HandleCodeCompleteResults(this, CodeCompleter,
6722 CodeCompletionContext::CCC_Other,
6723 Results.data(),Results.size());
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006724}
Douglas Gregor87c08a52010-08-13 22:48:40 +00006725
Douglas Gregorf29c5232010-08-24 22:20:20 +00006726void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
Douglas Gregor218937c2011-02-01 19:23:04 +00006727 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00006728 CodeCompletionContext::CCC_PreprocessorDirective);
Douglas Gregorf44e8542010-08-24 19:08:16 +00006729 Results.EnterNewScope();
6730
6731 // #if <condition>
Douglas Gregor218937c2011-02-01 19:23:04 +00006732 CodeCompletionBuilder Builder(Results.getAllocator());
6733 Builder.AddTypedTextChunk("if");
6734 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6735 Builder.AddPlaceholderChunk("condition");
6736 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006737
6738 // #ifdef <macro>
Douglas Gregor218937c2011-02-01 19:23:04 +00006739 Builder.AddTypedTextChunk("ifdef");
6740 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6741 Builder.AddPlaceholderChunk("macro");
6742 Results.AddResult(Builder.TakeString());
6743
Douglas Gregorf44e8542010-08-24 19:08:16 +00006744 // #ifndef <macro>
Douglas Gregor218937c2011-02-01 19:23:04 +00006745 Builder.AddTypedTextChunk("ifndef");
6746 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6747 Builder.AddPlaceholderChunk("macro");
6748 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006749
6750 if (InConditional) {
6751 // #elif <condition>
Douglas Gregor218937c2011-02-01 19:23:04 +00006752 Builder.AddTypedTextChunk("elif");
6753 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6754 Builder.AddPlaceholderChunk("condition");
6755 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006756
6757 // #else
Douglas Gregor218937c2011-02-01 19:23:04 +00006758 Builder.AddTypedTextChunk("else");
6759 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006760
6761 // #endif
Douglas Gregor218937c2011-02-01 19:23:04 +00006762 Builder.AddTypedTextChunk("endif");
6763 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006764 }
6765
6766 // #include "header"
Douglas Gregor218937c2011-02-01 19:23:04 +00006767 Builder.AddTypedTextChunk("include");
6768 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6769 Builder.AddTextChunk("\"");
6770 Builder.AddPlaceholderChunk("header");
6771 Builder.AddTextChunk("\"");
6772 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006773
6774 // #include <header>
Douglas Gregor218937c2011-02-01 19:23:04 +00006775 Builder.AddTypedTextChunk("include");
6776 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6777 Builder.AddTextChunk("<");
6778 Builder.AddPlaceholderChunk("header");
6779 Builder.AddTextChunk(">");
6780 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006781
6782 // #define <macro>
Douglas Gregor218937c2011-02-01 19:23:04 +00006783 Builder.AddTypedTextChunk("define");
6784 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6785 Builder.AddPlaceholderChunk("macro");
6786 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006787
6788 // #define <macro>(<args>)
Douglas Gregor218937c2011-02-01 19:23:04 +00006789 Builder.AddTypedTextChunk("define");
6790 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6791 Builder.AddPlaceholderChunk("macro");
6792 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6793 Builder.AddPlaceholderChunk("args");
6794 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6795 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006796
6797 // #undef <macro>
Douglas Gregor218937c2011-02-01 19:23:04 +00006798 Builder.AddTypedTextChunk("undef");
6799 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6800 Builder.AddPlaceholderChunk("macro");
6801 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006802
6803 // #line <number>
Douglas Gregor218937c2011-02-01 19:23:04 +00006804 Builder.AddTypedTextChunk("line");
6805 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6806 Builder.AddPlaceholderChunk("number");
6807 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006808
6809 // #line <number> "filename"
Douglas Gregor218937c2011-02-01 19:23:04 +00006810 Builder.AddTypedTextChunk("line");
6811 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6812 Builder.AddPlaceholderChunk("number");
6813 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6814 Builder.AddTextChunk("\"");
6815 Builder.AddPlaceholderChunk("filename");
6816 Builder.AddTextChunk("\"");
6817 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006818
6819 // #error <message>
Douglas Gregor218937c2011-02-01 19:23:04 +00006820 Builder.AddTypedTextChunk("error");
6821 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6822 Builder.AddPlaceholderChunk("message");
6823 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006824
6825 // #pragma <arguments>
Douglas Gregor218937c2011-02-01 19:23:04 +00006826 Builder.AddTypedTextChunk("pragma");
6827 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6828 Builder.AddPlaceholderChunk("arguments");
6829 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006830
6831 if (getLangOptions().ObjC1) {
6832 // #import "header"
Douglas Gregor218937c2011-02-01 19:23:04 +00006833 Builder.AddTypedTextChunk("import");
6834 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6835 Builder.AddTextChunk("\"");
6836 Builder.AddPlaceholderChunk("header");
6837 Builder.AddTextChunk("\"");
6838 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006839
6840 // #import <header>
Douglas Gregor218937c2011-02-01 19:23:04 +00006841 Builder.AddTypedTextChunk("import");
6842 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6843 Builder.AddTextChunk("<");
6844 Builder.AddPlaceholderChunk("header");
6845 Builder.AddTextChunk(">");
6846 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006847 }
6848
6849 // #include_next "header"
Douglas Gregor218937c2011-02-01 19:23:04 +00006850 Builder.AddTypedTextChunk("include_next");
6851 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6852 Builder.AddTextChunk("\"");
6853 Builder.AddPlaceholderChunk("header");
6854 Builder.AddTextChunk("\"");
6855 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006856
6857 // #include_next <header>
Douglas Gregor218937c2011-02-01 19:23:04 +00006858 Builder.AddTypedTextChunk("include_next");
6859 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6860 Builder.AddTextChunk("<");
6861 Builder.AddPlaceholderChunk("header");
6862 Builder.AddTextChunk(">");
6863 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006864
6865 // #warning <message>
Douglas Gregor218937c2011-02-01 19:23:04 +00006866 Builder.AddTypedTextChunk("warning");
6867 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6868 Builder.AddPlaceholderChunk("message");
6869 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006870
6871 // Note: #ident and #sccs are such crazy anachronisms that we don't provide
6872 // completions for them. And __include_macros is a Clang-internal extension
6873 // that we don't want to encourage anyone to use.
6874
6875 // FIXME: we don't support #assert or #unassert, so don't suggest them.
6876 Results.ExitScope();
6877
Douglas Gregorf44e8542010-08-24 19:08:16 +00006878 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor721f3592010-08-25 18:41:16 +00006879 CodeCompletionContext::CCC_PreprocessorDirective,
Douglas Gregorf44e8542010-08-24 19:08:16 +00006880 Results.data(), Results.size());
6881}
6882
6883void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
Douglas Gregorf29c5232010-08-24 22:20:20 +00006884 CodeCompleteOrdinaryName(S,
John McCallf312b1e2010-08-26 23:41:50 +00006885 S->getFnParent()? Sema::PCC_RecoveryInFunction
6886 : Sema::PCC_Namespace);
Douglas Gregorf44e8542010-08-24 19:08:16 +00006887}
6888
Douglas Gregorf29c5232010-08-24 22:20:20 +00006889void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
Douglas Gregor218937c2011-02-01 19:23:04 +00006890 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00006891 IsDefinition? CodeCompletionContext::CCC_MacroName
6892 : CodeCompletionContext::CCC_MacroNameUse);
Douglas Gregor1fbb4472010-08-24 20:21:13 +00006893 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
6894 // Add just the names of macros, not their arguments.
Douglas Gregor218937c2011-02-01 19:23:04 +00006895 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor1fbb4472010-08-24 20:21:13 +00006896 Results.EnterNewScope();
6897 for (Preprocessor::macro_iterator M = PP.macro_begin(),
6898 MEnd = PP.macro_end();
6899 M != MEnd; ++M) {
Douglas Gregordae68752011-02-01 22:57:45 +00006900 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00006901 M->first->getName()));
6902 Results.AddResult(Builder.TakeString());
Douglas Gregor1fbb4472010-08-24 20:21:13 +00006903 }
6904 Results.ExitScope();
6905 } else if (IsDefinition) {
6906 // FIXME: Can we detect when the user just wrote an include guard above?
6907 }
6908
Douglas Gregor52779fb2010-09-23 23:01:17 +00006909 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregor1fbb4472010-08-24 20:21:13 +00006910 Results.data(), Results.size());
6911}
6912
Douglas Gregorf29c5232010-08-24 22:20:20 +00006913void Sema::CodeCompletePreprocessorExpression() {
Douglas Gregor218937c2011-02-01 19:23:04 +00006914 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00006915 CodeCompletionContext::CCC_PreprocessorExpression);
Douglas Gregorf29c5232010-08-24 22:20:20 +00006916
6917 if (!CodeCompleter || CodeCompleter->includeMacros())
6918 AddMacroResults(PP, Results);
6919
6920 // defined (<macro>)
6921 Results.EnterNewScope();
Douglas Gregor218937c2011-02-01 19:23:04 +00006922 CodeCompletionBuilder Builder(Results.getAllocator());
6923 Builder.AddTypedTextChunk("defined");
6924 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6925 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6926 Builder.AddPlaceholderChunk("macro");
6927 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6928 Results.AddResult(Builder.TakeString());
Douglas Gregorf29c5232010-08-24 22:20:20 +00006929 Results.ExitScope();
6930
6931 HandleCodeCompleteResults(this, CodeCompleter,
6932 CodeCompletionContext::CCC_PreprocessorExpression,
6933 Results.data(), Results.size());
6934}
6935
6936void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
6937 IdentifierInfo *Macro,
6938 MacroInfo *MacroInfo,
6939 unsigned Argument) {
6940 // FIXME: In the future, we could provide "overload" results, much like we
6941 // do for function calls.
6942
Argyrios Kyrtzidis5c5f03e2011-08-18 19:41:28 +00006943 // Now just ignore this. There will be another code-completion callback
6944 // for the expanded tokens.
Douglas Gregorf29c5232010-08-24 22:20:20 +00006945}
6946
Douglas Gregor55817af2010-08-25 17:04:25 +00006947void Sema::CodeCompleteNaturalLanguage() {
Douglas Gregor55817af2010-08-25 17:04:25 +00006948 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregoraf1c6b52010-08-25 17:10:00 +00006949 CodeCompletionContext::CCC_NaturalLanguage,
Douglas Gregor55817af2010-08-25 17:04:25 +00006950 0, 0);
6951}
6952
Douglas Gregordae68752011-02-01 22:57:45 +00006953void Sema::GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
Chris Lattner5f9e2722011-07-23 10:55:15 +00006954 SmallVectorImpl<CodeCompletionResult> &Results) {
Douglas Gregor218937c2011-02-01 19:23:04 +00006955 ResultBuilder Builder(*this, Allocator, CodeCompletionContext::CCC_Recovery);
Douglas Gregor8071e422010-08-15 06:18:01 +00006956 if (!CodeCompleter || CodeCompleter->includeGlobals()) {
6957 CodeCompletionDeclConsumer Consumer(Builder,
6958 Context.getTranslationUnitDecl());
6959 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
6960 Consumer);
6961 }
Douglas Gregor87c08a52010-08-13 22:48:40 +00006962
6963 if (!CodeCompleter || CodeCompleter->includeMacros())
6964 AddMacroResults(PP, Builder);
6965
6966 Results.clear();
6967 Results.insert(Results.end(),
6968 Builder.data(), Builder.data() + Builder.size());
6969}