blob: 21a5cfa79d1bd3aec46c917d7a596b81d70c8840 [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 Gregorc5b2e582012-01-29 18:15:03 +000023#include "clang/Lex/HeaderSearch.h"
Douglas Gregor3f7c7f42009-10-30 16:50:04 +000024#include "clang/Lex/MacroInfo.h"
25#include "clang/Lex/Preprocessor.h"
Douglas Gregord36adf52010-09-16 16:06:31 +000026#include "llvm/ADT/DenseSet.h"
Benjamin Kramer013b3662012-01-30 16:17:39 +000027#include "llvm/ADT/SmallBitVector.h"
Douglas Gregor86d9a522009-09-21 16:56:56 +000028#include "llvm/ADT/SmallPtrSet.h"
Benjamin Kramer8fe83e12012-02-04 13:45:25 +000029#include "llvm/ADT/SmallString.h"
Douglas Gregor6a684032009-09-28 03:51:44 +000030#include "llvm/ADT/StringExtras.h"
Douglas Gregor22f56992010-04-06 19:22:33 +000031#include "llvm/ADT/StringSwitch.h"
Douglas Gregor458433d2010-08-26 15:07:07 +000032#include "llvm/ADT/Twine.h"
Douglas Gregor86d9a522009-09-21 16:56:56 +000033#include <list>
34#include <map>
35#include <vector>
Douglas Gregor81b747b2009-09-17 21:32:03 +000036
37using namespace clang;
John McCall781472f2010-08-25 08:40:02 +000038using namespace sema;
Douglas Gregor81b747b2009-09-17 21:32:03 +000039
Douglas Gregor86d9a522009-09-21 16:56:56 +000040namespace {
41 /// \brief A container of code-completion results.
42 class ResultBuilder {
43 public:
44 /// \brief The type of a name-lookup filter, which can be provided to the
45 /// name-lookup routines to specify which declarations should be included in
46 /// the result set (when it returns true) and which declarations should be
47 /// filtered out (returns false).
48 typedef bool (ResultBuilder::*LookupFilter)(NamedDecl *) const;
49
John McCall0a2c5e22010-08-25 06:19:51 +000050 typedef CodeCompletionResult Result;
Douglas Gregor86d9a522009-09-21 16:56:56 +000051
52 private:
53 /// \brief The actual results we have found.
54 std::vector<Result> Results;
55
56 /// \brief A record of all of the declarations we have found and placed
57 /// into the result set, used to ensure that no declaration ever gets into
58 /// the result set twice.
59 llvm::SmallPtrSet<Decl*, 16> AllDeclsFound;
60
Douglas Gregorfbcb5d62009-12-06 20:23:50 +000061 typedef std::pair<NamedDecl *, unsigned> DeclIndexPair;
62
63 /// \brief An entry in the shadow map, which is optimized to store
64 /// a single (declaration, index) mapping (the common case) but
65 /// can also store a list of (declaration, index) mappings.
66 class ShadowMapEntry {
Chris Lattner5f9e2722011-07-23 10:55:15 +000067 typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector;
Douglas Gregorfbcb5d62009-12-06 20:23:50 +000068
69 /// \brief Contains either the solitary NamedDecl * or a vector
70 /// of (declaration, index) pairs.
71 llvm::PointerUnion<NamedDecl *, DeclIndexPairVector*> DeclOrVector;
72
73 /// \brief When the entry contains a single declaration, this is
74 /// the index associated with that entry.
75 unsigned SingleDeclIndex;
76
77 public:
78 ShadowMapEntry() : DeclOrVector(), SingleDeclIndex(0) { }
79
80 void Add(NamedDecl *ND, unsigned Index) {
81 if (DeclOrVector.isNull()) {
82 // 0 - > 1 elements: just set the single element information.
83 DeclOrVector = ND;
84 SingleDeclIndex = Index;
85 return;
86 }
87
88 if (NamedDecl *PrevND = DeclOrVector.dyn_cast<NamedDecl *>()) {
89 // 1 -> 2 elements: create the vector of results and push in the
90 // existing declaration.
91 DeclIndexPairVector *Vec = new DeclIndexPairVector;
92 Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex));
93 DeclOrVector = Vec;
94 }
95
96 // Add the new element to the end of the vector.
97 DeclOrVector.get<DeclIndexPairVector*>()->push_back(
98 DeclIndexPair(ND, Index));
99 }
100
101 void Destroy() {
102 if (DeclIndexPairVector *Vec
103 = DeclOrVector.dyn_cast<DeclIndexPairVector *>()) {
104 delete Vec;
105 DeclOrVector = ((NamedDecl *)0);
106 }
107 }
108
109 // Iteration.
110 class iterator;
111 iterator begin() const;
112 iterator end() const;
113 };
114
Douglas Gregor86d9a522009-09-21 16:56:56 +0000115 /// \brief A mapping from declaration names to the declarations that have
116 /// this name within a particular scope and their index within the list of
117 /// results.
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000118 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000119
120 /// \brief The semantic analysis object for which results are being
121 /// produced.
122 Sema &SemaRef;
Douglas Gregor218937c2011-02-01 19:23:04 +0000123
124 /// \brief The allocator used to allocate new code-completion strings.
Douglas Gregordae68752011-02-01 22:57:45 +0000125 CodeCompletionAllocator &Allocator;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000126
127 /// \brief If non-NULL, a filter function used to remove any code-completion
128 /// results that are not desirable.
129 LookupFilter Filter;
Douglas Gregor45bcd432010-01-14 03:21:49 +0000130
131 /// \brief Whether we should allow declarations as
132 /// nested-name-specifiers that would otherwise be filtered out.
133 bool AllowNestedNameSpecifiers;
134
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +0000135 /// \brief If set, the type that we would prefer our resulting value
136 /// declarations to have.
137 ///
138 /// Closely matching the preferred type gives a boost to a result's
139 /// priority.
140 CanQualType PreferredType;
141
Douglas Gregor86d9a522009-09-21 16:56:56 +0000142 /// \brief A list of shadow maps, which is used to model name hiding at
143 /// different levels of, e.g., the inheritance hierarchy.
144 std::list<ShadowMap> ShadowMaps;
145
Douglas Gregor3cdee122010-08-26 16:36:48 +0000146 /// \brief If we're potentially referring to a C++ member function, the set
147 /// of qualifiers applied to the object type.
148 Qualifiers ObjectTypeQualifiers;
149
150 /// \brief Whether the \p ObjectTypeQualifiers field is active.
151 bool HasObjectTypeQualifiers;
152
Douglas Gregor265f7492010-08-27 15:29:55 +0000153 /// \brief The selector that we prefer.
154 Selector PreferredSelector;
155
Douglas Gregorca45da02010-11-02 20:36:02 +0000156 /// \brief The completion context in which we are gathering results.
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000157 CodeCompletionContext CompletionContext;
158
Douglas Gregorca45da02010-11-02 20:36:02 +0000159 /// \brief If we are in an instance method definition, the @implementation
160 /// object.
161 ObjCImplementationDecl *ObjCImplementation;
162
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000163 void AdjustResultPriorityForDecl(Result &R);
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000164
Douglas Gregor6f942b22010-09-21 16:06:22 +0000165 void MaybeAddConstructorResults(Result R);
166
Douglas Gregor86d9a522009-09-21 16:56:56 +0000167 public:
Douglas Gregordae68752011-02-01 22:57:45 +0000168 explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator,
Douglas Gregor52779fb2010-09-23 23:01:17 +0000169 const CodeCompletionContext &CompletionContext,
170 LookupFilter Filter = 0)
Douglas Gregor218937c2011-02-01 19:23:04 +0000171 : SemaRef(SemaRef), Allocator(Allocator), Filter(Filter),
172 AllowNestedNameSpecifiers(false), HasObjectTypeQualifiers(false),
Douglas Gregorca45da02010-11-02 20:36:02 +0000173 CompletionContext(CompletionContext),
174 ObjCImplementation(0)
175 {
176 // If this is an Objective-C instance method definition, dig out the
177 // corresponding implementation.
178 switch (CompletionContext.getKind()) {
179 case CodeCompletionContext::CCC_Expression:
180 case CodeCompletionContext::CCC_ObjCMessageReceiver:
181 case CodeCompletionContext::CCC_ParenthesizedExpression:
182 case CodeCompletionContext::CCC_Statement:
183 case CodeCompletionContext::CCC_Recovery:
184 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl())
185 if (Method->isInstanceMethod())
186 if (ObjCInterfaceDecl *Interface = Method->getClassInterface())
187 ObjCImplementation = Interface->getImplementation();
188 break;
189
190 default:
191 break;
192 }
193 }
Douglas Gregor86d9a522009-09-21 16:56:56 +0000194
Douglas Gregord8e8a582010-05-25 21:41:55 +0000195 /// \brief Whether we should include code patterns in the completion
196 /// results.
197 bool includeCodePatterns() const {
198 return SemaRef.CodeCompleter &&
Douglas Gregorf6961522010-08-27 21:18:54 +0000199 SemaRef.CodeCompleter->includeCodePatterns();
Douglas Gregord8e8a582010-05-25 21:41:55 +0000200 }
201
Douglas Gregor86d9a522009-09-21 16:56:56 +0000202 /// \brief Set the filter used for code-completion results.
203 void setFilter(LookupFilter Filter) {
204 this->Filter = Filter;
205 }
206
Douglas Gregor86d9a522009-09-21 16:56:56 +0000207 Result *data() { return Results.empty()? 0 : &Results.front(); }
208 unsigned size() const { return Results.size(); }
209 bool empty() const { return Results.empty(); }
210
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +0000211 /// \brief Specify the preferred type.
212 void setPreferredType(QualType T) {
213 PreferredType = SemaRef.Context.getCanonicalType(T);
214 }
215
Douglas Gregor3cdee122010-08-26 16:36:48 +0000216 /// \brief Set the cv-qualifiers on the object type, for us in filtering
217 /// calls to member functions.
218 ///
219 /// When there are qualifiers in this set, they will be used to filter
220 /// out member functions that aren't available (because there will be a
221 /// cv-qualifier mismatch) or prefer functions with an exact qualifier
222 /// match.
223 void setObjectTypeQualifiers(Qualifiers Quals) {
224 ObjectTypeQualifiers = Quals;
225 HasObjectTypeQualifiers = true;
226 }
227
Douglas Gregor265f7492010-08-27 15:29:55 +0000228 /// \brief Set the preferred selector.
229 ///
230 /// When an Objective-C method declaration result is added, and that
231 /// method's selector matches this preferred selector, we give that method
232 /// a slight priority boost.
233 void setPreferredSelector(Selector Sel) {
234 PreferredSelector = Sel;
235 }
Douglas Gregorca45da02010-11-02 20:36:02 +0000236
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000237 /// \brief Retrieve the code-completion context for which results are
238 /// being collected.
239 const CodeCompletionContext &getCompletionContext() const {
240 return CompletionContext;
241 }
242
Douglas Gregor45bcd432010-01-14 03:21:49 +0000243 /// \brief Specify whether nested-name-specifiers are allowed.
244 void allowNestedNameSpecifiers(bool Allow = true) {
245 AllowNestedNameSpecifiers = Allow;
246 }
247
Douglas Gregorb9d77572010-09-21 00:03:25 +0000248 /// \brief Return the semantic analysis object for which we are collecting
249 /// code completion results.
250 Sema &getSema() const { return SemaRef; }
251
Douglas Gregor218937c2011-02-01 19:23:04 +0000252 /// \brief Retrieve the allocator used to allocate code completion strings.
Douglas Gregordae68752011-02-01 22:57:45 +0000253 CodeCompletionAllocator &getAllocator() const { return Allocator; }
Douglas Gregor218937c2011-02-01 19:23:04 +0000254
Douglas Gregore495b7f2010-01-14 00:20:49 +0000255 /// \brief Determine whether the given declaration is at all interesting
256 /// as a code-completion result.
Douglas Gregor45bcd432010-01-14 03:21:49 +0000257 ///
258 /// \param ND the declaration that we are inspecting.
259 ///
260 /// \param AsNestedNameSpecifier will be set true if this declaration is
261 /// only interesting when it is a nested-name-specifier.
262 bool isInterestingDecl(NamedDecl *ND, bool &AsNestedNameSpecifier) const;
Douglas Gregor6660d842010-01-14 00:41:07 +0000263
264 /// \brief Check whether the result is hidden by the Hiding declaration.
265 ///
266 /// \returns true if the result is hidden and cannot be found, false if
267 /// the hidden result could still be found. When false, \p R may be
268 /// modified to describe how the result can be found (e.g., via extra
269 /// qualification).
270 bool CheckHiddenResult(Result &R, DeclContext *CurContext,
271 NamedDecl *Hiding);
272
Douglas Gregor86d9a522009-09-21 16:56:56 +0000273 /// \brief Add a new result to this result set (if it isn't already in one
274 /// of the shadow maps), or replace an existing result (for, e.g., a
275 /// redeclaration).
Douglas Gregor456c4a12009-09-21 20:12:40 +0000276 ///
Douglas Gregor81f3bff2012-02-15 15:34:24 +0000277 /// \param R the result to add (if it is unique).
Douglas Gregor456c4a12009-09-21 20:12:40 +0000278 ///
Douglas Gregor81f3bff2012-02-15 15:34:24 +0000279 /// \param CurContext the context in which this result will be named.
Douglas Gregor456c4a12009-09-21 20:12:40 +0000280 void MaybeAddResult(Result R, DeclContext *CurContext = 0);
Douglas Gregor86d9a522009-09-21 16:56:56 +0000281
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000282 /// \brief Add a new result to this result set, where we already know
283 /// the hiding declation (if any).
284 ///
285 /// \param R the result to add (if it is unique).
286 ///
287 /// \param CurContext the context in which this result will be named.
288 ///
289 /// \param Hiding the declaration that hides the result.
Douglas Gregor0cc84042010-01-14 15:47:35 +0000290 ///
291 /// \param InBaseClass whether the result was found in a base
292 /// class of the searched context.
293 void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding,
294 bool InBaseClass);
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000295
Douglas Gregora4477812010-01-14 16:01:26 +0000296 /// \brief Add a new non-declaration result to this result set.
297 void AddResult(Result R);
298
Douglas Gregor86d9a522009-09-21 16:56:56 +0000299 /// \brief Enter into a new scope.
300 void EnterNewScope();
301
302 /// \brief Exit from the current scope.
303 void ExitScope();
304
Douglas Gregor55385fe2009-11-18 04:19:12 +0000305 /// \brief Ignore this declaration, if it is seen again.
306 void Ignore(Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); }
307
Douglas Gregor86d9a522009-09-21 16:56:56 +0000308 /// \name Name lookup predicates
309 ///
310 /// These predicates can be passed to the name lookup functions to filter the
311 /// results of name lookup. All of the predicates have the same type, so that
312 ///
313 //@{
Douglas Gregor791215b2009-09-21 20:51:25 +0000314 bool IsOrdinaryName(NamedDecl *ND) const;
Douglas Gregor4710e5b2010-05-28 00:49:12 +0000315 bool IsOrdinaryNonTypeName(NamedDecl *ND) const;
Douglas Gregorf9578432010-07-28 21:50:18 +0000316 bool IsIntegralConstantValue(NamedDecl *ND) const;
Douglas Gregor01dfea02010-01-10 23:08:15 +0000317 bool IsOrdinaryNonValueName(NamedDecl *ND) const;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000318 bool IsNestedNameSpecifier(NamedDecl *ND) const;
319 bool IsEnum(NamedDecl *ND) const;
320 bool IsClassOrStruct(NamedDecl *ND) const;
321 bool IsUnion(NamedDecl *ND) const;
322 bool IsNamespace(NamedDecl *ND) const;
323 bool IsNamespaceOrAlias(NamedDecl *ND) const;
324 bool IsType(NamedDecl *ND) const;
Douglas Gregoreb5758b2009-09-23 22:26:46 +0000325 bool IsMember(NamedDecl *ND) const;
Douglas Gregor80f4f4c2010-01-14 16:08:12 +0000326 bool IsObjCIvar(NamedDecl *ND) const;
Douglas Gregor8e254cf2010-05-27 23:06:34 +0000327 bool IsObjCMessageReceiver(NamedDecl *ND) const;
Douglas Gregor81f3bff2012-02-15 15:34:24 +0000328 bool IsObjCMessageReceiverOrLambdaCapture(NamedDecl *ND) const;
Douglas Gregorfb629412010-08-23 21:17:50 +0000329 bool IsObjCCollection(NamedDecl *ND) const;
Douglas Gregor52779fb2010-09-23 23:01:17 +0000330 bool IsImpossibleToSatisfy(NamedDecl *ND) const;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000331 //@}
332 };
333}
334
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000335class ResultBuilder::ShadowMapEntry::iterator {
336 llvm::PointerUnion<NamedDecl*, const DeclIndexPair*> DeclOrIterator;
337 unsigned SingleDeclIndex;
338
339public:
340 typedef DeclIndexPair value_type;
341 typedef value_type reference;
342 typedef std::ptrdiff_t difference_type;
343 typedef std::input_iterator_tag iterator_category;
344
345 class pointer {
346 DeclIndexPair Value;
347
348 public:
349 pointer(const DeclIndexPair &Value) : Value(Value) { }
350
351 const DeclIndexPair *operator->() const {
352 return &Value;
353 }
354 };
355
356 iterator() : DeclOrIterator((NamedDecl *)0), SingleDeclIndex(0) { }
357
358 iterator(NamedDecl *SingleDecl, unsigned Index)
359 : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) { }
360
361 iterator(const DeclIndexPair *Iterator)
362 : DeclOrIterator(Iterator), SingleDeclIndex(0) { }
363
364 iterator &operator++() {
365 if (DeclOrIterator.is<NamedDecl *>()) {
366 DeclOrIterator = (NamedDecl *)0;
367 SingleDeclIndex = 0;
368 return *this;
369 }
370
371 const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair*>();
372 ++I;
373 DeclOrIterator = I;
374 return *this;
375 }
376
Chris Lattner66392d42010-09-04 18:12:20 +0000377 /*iterator operator++(int) {
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000378 iterator tmp(*this);
379 ++(*this);
380 return tmp;
Chris Lattner66392d42010-09-04 18:12:20 +0000381 }*/
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000382
383 reference operator*() const {
384 if (NamedDecl *ND = DeclOrIterator.dyn_cast<NamedDecl *>())
385 return reference(ND, SingleDeclIndex);
386
Douglas Gregord490f952009-12-06 21:27:58 +0000387 return *DeclOrIterator.get<const DeclIndexPair*>();
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000388 }
389
390 pointer operator->() const {
391 return pointer(**this);
392 }
393
394 friend bool operator==(const iterator &X, const iterator &Y) {
Douglas Gregord490f952009-12-06 21:27:58 +0000395 return X.DeclOrIterator.getOpaqueValue()
396 == Y.DeclOrIterator.getOpaqueValue() &&
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000397 X.SingleDeclIndex == Y.SingleDeclIndex;
398 }
399
400 friend bool operator!=(const iterator &X, const iterator &Y) {
Douglas Gregord490f952009-12-06 21:27:58 +0000401 return !(X == Y);
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000402 }
403};
404
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000405ResultBuilder::ShadowMapEntry::iterator
406ResultBuilder::ShadowMapEntry::begin() const {
407 if (DeclOrVector.isNull())
408 return iterator();
409
410 if (NamedDecl *ND = DeclOrVector.dyn_cast<NamedDecl *>())
411 return iterator(ND, SingleDeclIndex);
412
413 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin());
414}
415
416ResultBuilder::ShadowMapEntry::iterator
417ResultBuilder::ShadowMapEntry::end() const {
418 if (DeclOrVector.is<NamedDecl *>() || DeclOrVector.isNull())
419 return iterator();
420
421 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end());
422}
423
Douglas Gregor456c4a12009-09-21 20:12:40 +0000424/// \brief Compute the qualification required to get from the current context
425/// (\p CurContext) to the target context (\p TargetContext).
426///
427/// \param Context the AST context in which the qualification will be used.
428///
429/// \param CurContext the context where an entity is being named, which is
430/// typically based on the current scope.
431///
432/// \param TargetContext the context in which the named entity actually
433/// resides.
434///
435/// \returns a nested name specifier that refers into the target context, or
436/// NULL if no qualification is needed.
437static NestedNameSpecifier *
438getRequiredQualification(ASTContext &Context,
439 DeclContext *CurContext,
440 DeclContext *TargetContext) {
Chris Lattner5f9e2722011-07-23 10:55:15 +0000441 SmallVector<DeclContext *, 4> TargetParents;
Douglas Gregor456c4a12009-09-21 20:12:40 +0000442
443 for (DeclContext *CommonAncestor = TargetContext;
444 CommonAncestor && !CommonAncestor->Encloses(CurContext);
445 CommonAncestor = CommonAncestor->getLookupParent()) {
446 if (CommonAncestor->isTransparentContext() ||
447 CommonAncestor->isFunctionOrMethod())
448 continue;
449
450 TargetParents.push_back(CommonAncestor);
451 }
452
453 NestedNameSpecifier *Result = 0;
454 while (!TargetParents.empty()) {
455 DeclContext *Parent = TargetParents.back();
456 TargetParents.pop_back();
457
Douglas Gregorfb629412010-08-23 21:17:50 +0000458 if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Parent)) {
459 if (!Namespace->getIdentifier())
460 continue;
461
Douglas Gregor456c4a12009-09-21 20:12:40 +0000462 Result = NestedNameSpecifier::Create(Context, Result, Namespace);
Douglas Gregorfb629412010-08-23 21:17:50 +0000463 }
Douglas Gregor456c4a12009-09-21 20:12:40 +0000464 else if (TagDecl *TD = dyn_cast<TagDecl>(Parent))
465 Result = NestedNameSpecifier::Create(Context, Result,
466 false,
467 Context.getTypeDeclType(TD).getTypePtr());
Douglas Gregor0c8296d2009-11-07 00:00:49 +0000468 }
Douglas Gregor456c4a12009-09-21 20:12:40 +0000469 return Result;
470}
471
Douglas Gregor45bcd432010-01-14 03:21:49 +0000472bool ResultBuilder::isInterestingDecl(NamedDecl *ND,
473 bool &AsNestedNameSpecifier) const {
474 AsNestedNameSpecifier = false;
475
Douglas Gregore495b7f2010-01-14 00:20:49 +0000476 ND = ND->getUnderlyingDecl();
477 unsigned IDNS = ND->getIdentifierNamespace();
Douglas Gregorf52cede2009-10-09 22:16:47 +0000478
479 // Skip unnamed entities.
Douglas Gregore495b7f2010-01-14 00:20:49 +0000480 if (!ND->getDeclName())
481 return false;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000482
483 // Friend declarations and declarations introduced due to friends are never
484 // added as results.
John McCall92b7f702010-03-11 07:50:04 +0000485 if (IDNS & (Decl::IDNS_OrdinaryFriend | Decl::IDNS_TagFriend))
Douglas Gregore495b7f2010-01-14 00:20:49 +0000486 return false;
487
Douglas Gregor76282942009-12-11 17:31:05 +0000488 // Class template (partial) specializations are never added as results.
Douglas Gregore495b7f2010-01-14 00:20:49 +0000489 if (isa<ClassTemplateSpecializationDecl>(ND) ||
490 isa<ClassTemplatePartialSpecializationDecl>(ND))
491 return false;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000492
Douglas Gregor76282942009-12-11 17:31:05 +0000493 // Using declarations themselves are never added as results.
Douglas Gregore495b7f2010-01-14 00:20:49 +0000494 if (isa<UsingDecl>(ND))
495 return false;
496
497 // Some declarations have reserved names that we don't want to ever show.
498 if (const IdentifierInfo *Id = ND->getIdentifier()) {
Douglas Gregor86d9a522009-09-21 16:56:56 +0000499 // __va_list_tag is a freak of nature. Find it and skip it.
500 if (Id->isStr("__va_list_tag") || Id->isStr("__builtin_va_list"))
Douglas Gregore495b7f2010-01-14 00:20:49 +0000501 return false;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000502
Douglas Gregorf52cede2009-10-09 22:16:47 +0000503 // Filter out names reserved for the implementation (C99 7.1.3,
Douglas Gregor797efb52010-07-14 17:44:04 +0000504 // C++ [lib.global.names]) if they come from a system header.
Daniel Dunbare013d682009-10-18 20:26:12 +0000505 //
506 // FIXME: Add predicate for this.
Douglas Gregorf52cede2009-10-09 22:16:47 +0000507 if (Id->getLength() >= 2) {
Daniel Dunbare013d682009-10-18 20:26:12 +0000508 const char *Name = Id->getNameStart();
Douglas Gregorf52cede2009-10-09 22:16:47 +0000509 if (Name[0] == '_' &&
Douglas Gregor797efb52010-07-14 17:44:04 +0000510 (Name[1] == '_' || (Name[1] >= 'A' && Name[1] <= 'Z')) &&
511 (ND->getLocation().isInvalid() ||
512 SemaRef.SourceMgr.isInSystemHeader(
513 SemaRef.SourceMgr.getSpellingLoc(ND->getLocation()))))
Douglas Gregore495b7f2010-01-14 00:20:49 +0000514 return false;
Douglas Gregorf52cede2009-10-09 22:16:47 +0000515 }
Douglas Gregor86d9a522009-09-21 16:56:56 +0000516 }
Douglas Gregor6f942b22010-09-21 16:06:22 +0000517
Douglas Gregor9b0ba872010-11-09 03:59:40 +0000518 // Skip out-of-line declarations and definitions.
519 // NOTE: Unless it's an Objective-C property, method, or ivar, where
520 // the contexts can be messy.
521 if (!ND->getDeclContext()->Equals(ND->getLexicalDeclContext()) &&
522 !(isa<ObjCPropertyDecl>(ND) || isa<ObjCIvarDecl>(ND) ||
523 isa<ObjCMethodDecl>(ND)))
524 return false;
525
Douglas Gregora5fb7c32010-08-16 23:05:20 +0000526 if (Filter == &ResultBuilder::IsNestedNameSpecifier ||
527 ((isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) &&
528 Filter != &ResultBuilder::IsNamespace &&
Douglas Gregor52779fb2010-09-23 23:01:17 +0000529 Filter != &ResultBuilder::IsNamespaceOrAlias &&
530 Filter != 0))
Douglas Gregora5fb7c32010-08-16 23:05:20 +0000531 AsNestedNameSpecifier = true;
532
Douglas Gregor86d9a522009-09-21 16:56:56 +0000533 // Filter out any unwanted results.
Douglas Gregor45bcd432010-01-14 03:21:49 +0000534 if (Filter && !(this->*Filter)(ND)) {
535 // Check whether it is interesting as a nested-name-specifier.
David Blaikie4e4d0842012-03-11 07:00:24 +0000536 if (AllowNestedNameSpecifiers && SemaRef.getLangOpts().CPlusPlus &&
Douglas Gregor45bcd432010-01-14 03:21:49 +0000537 IsNestedNameSpecifier(ND) &&
538 (Filter != &ResultBuilder::IsMember ||
539 (isa<CXXRecordDecl>(ND) &&
540 cast<CXXRecordDecl>(ND)->isInjectedClassName()))) {
541 AsNestedNameSpecifier = true;
542 return true;
543 }
544
Douglas Gregore495b7f2010-01-14 00:20:49 +0000545 return false;
Douglas Gregora5fb7c32010-08-16 23:05:20 +0000546 }
Douglas Gregore495b7f2010-01-14 00:20:49 +0000547 // ... then it must be interesting!
548 return true;
549}
550
Douglas Gregor6660d842010-01-14 00:41:07 +0000551bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext,
552 NamedDecl *Hiding) {
553 // In C, there is no way to refer to a hidden name.
554 // FIXME: This isn't true; we can find a tag name hidden by an ordinary
555 // name if we introduce the tag type.
David Blaikie4e4d0842012-03-11 07:00:24 +0000556 if (!SemaRef.getLangOpts().CPlusPlus)
Douglas Gregor6660d842010-01-14 00:41:07 +0000557 return true;
558
Sebastian Redl7a126a42010-08-31 00:36:30 +0000559 DeclContext *HiddenCtx = R.Declaration->getDeclContext()->getRedeclContext();
Douglas Gregor6660d842010-01-14 00:41:07 +0000560
561 // There is no way to qualify a name declared in a function or method.
562 if (HiddenCtx->isFunctionOrMethod())
563 return true;
564
Sebastian Redl7a126a42010-08-31 00:36:30 +0000565 if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext())
Douglas Gregor6660d842010-01-14 00:41:07 +0000566 return true;
567
568 // We can refer to the result with the appropriate qualification. Do it.
569 R.Hidden = true;
570 R.QualifierIsInformative = false;
571
572 if (!R.Qualifier)
573 R.Qualifier = getRequiredQualification(SemaRef.Context,
574 CurContext,
575 R.Declaration->getDeclContext());
576 return false;
577}
578
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000579/// \brief A simplified classification of types used to determine whether two
580/// types are "similar enough" when adjusting priorities.
Douglas Gregor1827e102010-08-16 16:18:59 +0000581SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) {
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000582 switch (T->getTypeClass()) {
583 case Type::Builtin:
584 switch (cast<BuiltinType>(T)->getKind()) {
585 case BuiltinType::Void:
586 return STC_Void;
587
588 case BuiltinType::NullPtr:
589 return STC_Pointer;
590
591 case BuiltinType::Overload:
592 case BuiltinType::Dependent:
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000593 return STC_Other;
594
595 case BuiltinType::ObjCId:
596 case BuiltinType::ObjCClass:
597 case BuiltinType::ObjCSel:
598 return STC_ObjectiveC;
599
600 default:
601 return STC_Arithmetic;
602 }
David Blaikie7530c032012-01-17 06:56:22 +0000603
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000604 case Type::Complex:
605 return STC_Arithmetic;
606
607 case Type::Pointer:
608 return STC_Pointer;
609
610 case Type::BlockPointer:
611 return STC_Block;
612
613 case Type::LValueReference:
614 case Type::RValueReference:
615 return getSimplifiedTypeClass(T->getAs<ReferenceType>()->getPointeeType());
616
617 case Type::ConstantArray:
618 case Type::IncompleteArray:
619 case Type::VariableArray:
620 case Type::DependentSizedArray:
621 return STC_Array;
622
623 case Type::DependentSizedExtVector:
624 case Type::Vector:
625 case Type::ExtVector:
626 return STC_Arithmetic;
627
628 case Type::FunctionProto:
629 case Type::FunctionNoProto:
630 return STC_Function;
631
632 case Type::Record:
633 return STC_Record;
634
635 case Type::Enum:
636 return STC_Arithmetic;
637
638 case Type::ObjCObject:
639 case Type::ObjCInterface:
640 case Type::ObjCObjectPointer:
641 return STC_ObjectiveC;
642
643 default:
644 return STC_Other;
645 }
646}
647
648/// \brief Get the type that a given expression will have if this declaration
649/// is used as an expression in its "typical" code-completion form.
Douglas Gregor1827e102010-08-16 16:18:59 +0000650QualType clang::getDeclUsageType(ASTContext &C, NamedDecl *ND) {
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000651 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
652
653 if (TypeDecl *Type = dyn_cast<TypeDecl>(ND))
654 return C.getTypeDeclType(Type);
655 if (ObjCInterfaceDecl *Iface = dyn_cast<ObjCInterfaceDecl>(ND))
656 return C.getObjCInterfaceType(Iface);
657
658 QualType T;
659 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(ND))
Douglas Gregor5291c3c2010-07-13 08:18:22 +0000660 T = Function->getCallResultType();
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000661 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND))
Douglas Gregor5291c3c2010-07-13 08:18:22 +0000662 T = Method->getSendResultType();
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000663 else if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND))
Douglas Gregor5291c3c2010-07-13 08:18:22 +0000664 T = FunTmpl->getTemplatedDecl()->getCallResultType();
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000665 else if (EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
666 T = C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext()));
667 else if (ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND))
668 T = Property->getType();
669 else if (ValueDecl *Value = dyn_cast<ValueDecl>(ND))
670 T = Value->getType();
671 else
672 return QualType();
Douglas Gregor3e64d562011-04-14 20:33:34 +0000673
674 // Dig through references, function pointers, and block pointers to
675 // get down to the likely type of an expression when the entity is
676 // used.
677 do {
678 if (const ReferenceType *Ref = T->getAs<ReferenceType>()) {
679 T = Ref->getPointeeType();
680 continue;
681 }
682
683 if (const PointerType *Pointer = T->getAs<PointerType>()) {
684 if (Pointer->getPointeeType()->isFunctionType()) {
685 T = Pointer->getPointeeType();
686 continue;
687 }
688
689 break;
690 }
691
692 if (const BlockPointerType *Block = T->getAs<BlockPointerType>()) {
693 T = Block->getPointeeType();
694 continue;
695 }
696
697 if (const FunctionType *Function = T->getAs<FunctionType>()) {
698 T = Function->getResultType();
699 continue;
700 }
701
702 break;
703 } while (true);
704
705 return T;
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000706}
707
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000708void ResultBuilder::AdjustResultPriorityForDecl(Result &R) {
709 // If this is an Objective-C method declaration whose selector matches our
710 // preferred selector, give it a priority boost.
711 if (!PreferredSelector.isNull())
712 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(R.Declaration))
713 if (PreferredSelector == Method->getSelector())
714 R.Priority += CCD_SelectorMatch;
Douglas Gregor08f43cd2010-09-20 23:11:55 +0000715
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000716 // If we have a preferred type, adjust the priority for results with exactly-
717 // matching or nearly-matching types.
718 if (!PreferredType.isNull()) {
719 QualType T = getDeclUsageType(SemaRef.Context, R.Declaration);
720 if (!T.isNull()) {
721 CanQualType TC = SemaRef.Context.getCanonicalType(T);
722 // Check for exactly-matching types (modulo qualifiers).
723 if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC))
724 R.Priority /= CCF_ExactTypeMatch;
725 // Check for nearly-matching types, based on classification of each.
726 else if ((getSimplifiedTypeClass(PreferredType)
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000727 == getSimplifiedTypeClass(TC)) &&
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000728 !(PreferredType->isEnumeralType() && TC->isEnumeralType()))
729 R.Priority /= CCF_SimilarTypeMatch;
730 }
731 }
Douglas Gregor1f5537a2010-07-08 23:20:03 +0000732}
733
Douglas Gregor6f942b22010-09-21 16:06:22 +0000734void ResultBuilder::MaybeAddConstructorResults(Result R) {
David Blaikie4e4d0842012-03-11 07:00:24 +0000735 if (!SemaRef.getLangOpts().CPlusPlus || !R.Declaration ||
Douglas Gregor6f942b22010-09-21 16:06:22 +0000736 !CompletionContext.wantConstructorResults())
737 return;
738
739 ASTContext &Context = SemaRef.Context;
740 NamedDecl *D = R.Declaration;
741 CXXRecordDecl *Record = 0;
742 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D))
743 Record = ClassTemplate->getTemplatedDecl();
744 else if ((Record = dyn_cast<CXXRecordDecl>(D))) {
745 // Skip specializations and partial specializations.
746 if (isa<ClassTemplateSpecializationDecl>(Record))
747 return;
748 } else {
749 // There are no constructors here.
750 return;
751 }
752
753 Record = Record->getDefinition();
754 if (!Record)
755 return;
756
757
758 QualType RecordTy = Context.getTypeDeclType(Record);
759 DeclarationName ConstructorName
760 = Context.DeclarationNames.getCXXConstructorName(
761 Context.getCanonicalType(RecordTy));
762 for (DeclContext::lookup_result Ctors = Record->lookup(ConstructorName);
763 Ctors.first != Ctors.second; ++Ctors.first) {
764 R.Declaration = *Ctors.first;
765 R.CursorKind = getCursorKindForDecl(R.Declaration);
766 Results.push_back(R);
767 }
768}
769
Douglas Gregore495b7f2010-01-14 00:20:49 +0000770void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) {
771 assert(!ShadowMaps.empty() && "Must enter into a results scope");
772
773 if (R.Kind != Result::RK_Declaration) {
774 // For non-declaration results, just add the result.
775 Results.push_back(R);
776 return;
777 }
778
779 // Look through using declarations.
780 if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
781 MaybeAddResult(Result(Using->getTargetDecl(), R.Qualifier), CurContext);
782 return;
783 }
784
785 Decl *CanonDecl = R.Declaration->getCanonicalDecl();
786 unsigned IDNS = CanonDecl->getIdentifierNamespace();
787
Douglas Gregor45bcd432010-01-14 03:21:49 +0000788 bool AsNestedNameSpecifier = false;
789 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
Douglas Gregore495b7f2010-01-14 00:20:49 +0000790 return;
791
Douglas Gregor6f942b22010-09-21 16:06:22 +0000792 // C++ constructors are never found by name lookup.
793 if (isa<CXXConstructorDecl>(R.Declaration))
794 return;
795
Douglas Gregor86d9a522009-09-21 16:56:56 +0000796 ShadowMap &SMap = ShadowMaps.back();
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000797 ShadowMapEntry::iterator I, IEnd;
798 ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName());
799 if (NamePos != SMap.end()) {
800 I = NamePos->second.begin();
801 IEnd = NamePos->second.end();
802 }
803
804 for (; I != IEnd; ++I) {
805 NamedDecl *ND = I->first;
806 unsigned Index = I->second;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000807 if (ND->getCanonicalDecl() == CanonDecl) {
808 // This is a redeclaration. Always pick the newer declaration.
Douglas Gregor86d9a522009-09-21 16:56:56 +0000809 Results[Index].Declaration = R.Declaration;
810
Douglas Gregor86d9a522009-09-21 16:56:56 +0000811 // We're done.
812 return;
813 }
814 }
815
816 // This is a new declaration in this scope. However, check whether this
817 // declaration name is hidden by a similarly-named declaration in an outer
818 // scope.
819 std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end();
820 --SMEnd;
821 for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) {
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000822 ShadowMapEntry::iterator I, IEnd;
823 ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName());
824 if (NamePos != SM->end()) {
825 I = NamePos->second.begin();
826 IEnd = NamePos->second.end();
827 }
828 for (; I != IEnd; ++I) {
Douglas Gregor86d9a522009-09-21 16:56:56 +0000829 // A tag declaration does not hide a non-tag declaration.
John McCall0d6b1642010-04-23 18:46:30 +0000830 if (I->first->hasTagIdentifierNamespace() &&
Douglas Gregor86d9a522009-09-21 16:56:56 +0000831 (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary |
832 Decl::IDNS_ObjCProtocol)))
833 continue;
834
835 // Protocols are in distinct namespaces from everything else.
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000836 if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol)
Douglas Gregor86d9a522009-09-21 16:56:56 +0000837 || (IDNS & Decl::IDNS_ObjCProtocol)) &&
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000838 I->first->getIdentifierNamespace() != IDNS)
Douglas Gregor86d9a522009-09-21 16:56:56 +0000839 continue;
840
841 // The newly-added result is hidden by an entry in the shadow map.
Douglas Gregor6660d842010-01-14 00:41:07 +0000842 if (CheckHiddenResult(R, CurContext, I->first))
Douglas Gregor86d9a522009-09-21 16:56:56 +0000843 return;
Douglas Gregor86d9a522009-09-21 16:56:56 +0000844
845 break;
846 }
847 }
848
849 // Make sure that any given declaration only shows up in the result set once.
850 if (!AllDeclsFound.insert(CanonDecl))
851 return;
Douglas Gregor265f7492010-08-27 15:29:55 +0000852
Douglas Gregoreb5758b2009-09-23 22:26:46 +0000853 // If the filter is for nested-name-specifiers, then this result starts a
854 // nested-name-specifier.
Douglas Gregor12e13132010-05-26 22:00:08 +0000855 if (AsNestedNameSpecifier) {
Douglas Gregoreb5758b2009-09-23 22:26:46 +0000856 R.StartsNestedNameSpecifier = true;
Douglas Gregor12e13132010-05-26 22:00:08 +0000857 R.Priority = CCP_NestedNameSpecifier;
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000858 } else
859 AdjustResultPriorityForDecl(R);
Douglas Gregor265f7492010-08-27 15:29:55 +0000860
Douglas Gregor0563c262009-09-22 23:15:58 +0000861 // If this result is supposed to have an informative qualifier, add one.
Douglas Gregoreb5758b2009-09-23 22:26:46 +0000862 if (R.QualifierIsInformative && !R.Qualifier &&
863 !R.StartsNestedNameSpecifier) {
Douglas Gregor0563c262009-09-22 23:15:58 +0000864 DeclContext *Ctx = R.Declaration->getDeclContext();
865 if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
866 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, Namespace);
867 else if (TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
868 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, false,
869 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
870 else
871 R.QualifierIsInformative = false;
872 }
Douglas Gregoreb5758b2009-09-23 22:26:46 +0000873
Douglas Gregor86d9a522009-09-21 16:56:56 +0000874 // Insert this result into the set of results and into the current shadow
875 // map.
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000876 SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
Douglas Gregor86d9a522009-09-21 16:56:56 +0000877 Results.push_back(R);
Douglas Gregor6f942b22010-09-21 16:06:22 +0000878
879 if (!AsNestedNameSpecifier)
880 MaybeAddConstructorResults(R);
Douglas Gregor86d9a522009-09-21 16:56:56 +0000881}
882
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000883void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
Douglas Gregor0cc84042010-01-14 15:47:35 +0000884 NamedDecl *Hiding, bool InBaseClass = false) {
Douglas Gregora4477812010-01-14 16:01:26 +0000885 if (R.Kind != Result::RK_Declaration) {
886 // For non-declaration results, just add the result.
887 Results.push_back(R);
888 return;
889 }
890
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000891 // Look through using declarations.
892 if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
893 AddResult(Result(Using->getTargetDecl(), R.Qualifier), CurContext, Hiding);
894 return;
895 }
896
Douglas Gregor45bcd432010-01-14 03:21:49 +0000897 bool AsNestedNameSpecifier = false;
898 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000899 return;
900
Douglas Gregor6f942b22010-09-21 16:06:22 +0000901 // C++ constructors are never found by name lookup.
902 if (isa<CXXConstructorDecl>(R.Declaration))
903 return;
904
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000905 if (Hiding && CheckHiddenResult(R, CurContext, Hiding))
906 return;
907
908 // Make sure that any given declaration only shows up in the result set once.
909 if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()))
910 return;
911
912 // If the filter is for nested-name-specifiers, then this result starts a
913 // nested-name-specifier.
Douglas Gregor12e13132010-05-26 22:00:08 +0000914 if (AsNestedNameSpecifier) {
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000915 R.StartsNestedNameSpecifier = true;
Douglas Gregor12e13132010-05-26 22:00:08 +0000916 R.Priority = CCP_NestedNameSpecifier;
917 }
Douglas Gregor0cc84042010-01-14 15:47:35 +0000918 else if (Filter == &ResultBuilder::IsMember && !R.Qualifier && InBaseClass &&
919 isa<CXXRecordDecl>(R.Declaration->getDeclContext()
Sebastian Redl7a126a42010-08-31 00:36:30 +0000920 ->getRedeclContext()))
Douglas Gregor0cc84042010-01-14 15:47:35 +0000921 R.QualifierIsInformative = true;
922
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000923 // If this result is supposed to have an informative qualifier, add one.
924 if (R.QualifierIsInformative && !R.Qualifier &&
925 !R.StartsNestedNameSpecifier) {
926 DeclContext *Ctx = R.Declaration->getDeclContext();
927 if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
928 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, Namespace);
929 else if (TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
930 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, false,
Douglas Gregor45bcd432010-01-14 03:21:49 +0000931 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000932 else
933 R.QualifierIsInformative = false;
934 }
935
Douglas Gregor12e13132010-05-26 22:00:08 +0000936 // Adjust the priority if this result comes from a base class.
937 if (InBaseClass)
938 R.Priority += CCD_InBaseClass;
939
Douglas Gregorcee9ff12010-09-20 22:39:41 +0000940 AdjustResultPriorityForDecl(R);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +0000941
Douglas Gregor3cdee122010-08-26 16:36:48 +0000942 if (HasObjectTypeQualifiers)
943 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
944 if (Method->isInstance()) {
945 Qualifiers MethodQuals
946 = Qualifiers::fromCVRMask(Method->getTypeQualifiers());
947 if (ObjectTypeQualifiers == MethodQuals)
948 R.Priority += CCD_ObjectQualifierMatch;
949 else if (ObjectTypeQualifiers - MethodQuals) {
950 // The method cannot be invoked, because doing so would drop
951 // qualifiers.
952 return;
953 }
954 }
955
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000956 // Insert this result into the set of results.
957 Results.push_back(R);
Douglas Gregor6f942b22010-09-21 16:06:22 +0000958
959 if (!AsNestedNameSpecifier)
960 MaybeAddConstructorResults(R);
Douglas Gregor1ca6ae82010-01-14 01:09:38 +0000961}
962
Douglas Gregora4477812010-01-14 16:01:26 +0000963void ResultBuilder::AddResult(Result R) {
964 assert(R.Kind != Result::RK_Declaration &&
965 "Declaration results need more context");
966 Results.push_back(R);
967}
968
Douglas Gregor86d9a522009-09-21 16:56:56 +0000969/// \brief Enter into a new scope.
970void ResultBuilder::EnterNewScope() {
971 ShadowMaps.push_back(ShadowMap());
972}
973
974/// \brief Exit from the current scope.
975void ResultBuilder::ExitScope() {
Douglas Gregorfbcb5d62009-12-06 20:23:50 +0000976 for (ShadowMap::iterator E = ShadowMaps.back().begin(),
977 EEnd = ShadowMaps.back().end();
978 E != EEnd;
979 ++E)
980 E->second.Destroy();
981
Douglas Gregor86d9a522009-09-21 16:56:56 +0000982 ShadowMaps.pop_back();
983}
984
Douglas Gregor791215b2009-09-21 20:51:25 +0000985/// \brief Determines whether this given declaration will be found by
986/// ordinary name lookup.
987bool ResultBuilder::IsOrdinaryName(NamedDecl *ND) const {
Douglas Gregor4710e5b2010-05-28 00:49:12 +0000988 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
989
Douglas Gregor791215b2009-09-21 20:51:25 +0000990 unsigned IDNS = Decl::IDNS_Ordinary;
David Blaikie4e4d0842012-03-11 07:00:24 +0000991 if (SemaRef.getLangOpts().CPlusPlus)
Douglas Gregor9b30b262010-06-15 20:26:51 +0000992 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
David Blaikie4e4d0842012-03-11 07:00:24 +0000993 else if (SemaRef.getLangOpts().ObjC1) {
Douglas Gregorca45da02010-11-02 20:36:02 +0000994 if (isa<ObjCIvarDecl>(ND))
995 return true;
Douglas Gregorca45da02010-11-02 20:36:02 +0000996 }
997
Douglas Gregor791215b2009-09-21 20:51:25 +0000998 return ND->getIdentifierNamespace() & IDNS;
999}
1000
Douglas Gregor01dfea02010-01-10 23:08:15 +00001001/// \brief Determines whether this given declaration will be found by
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001002/// ordinary name lookup but is not a type name.
1003bool ResultBuilder::IsOrdinaryNonTypeName(NamedDecl *ND) const {
1004 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1005 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND))
1006 return false;
1007
1008 unsigned IDNS = Decl::IDNS_Ordinary;
David Blaikie4e4d0842012-03-11 07:00:24 +00001009 if (SemaRef.getLangOpts().CPlusPlus)
Douglas Gregor9b30b262010-06-15 20:26:51 +00001010 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
David Blaikie4e4d0842012-03-11 07:00:24 +00001011 else if (SemaRef.getLangOpts().ObjC1) {
Douglas Gregorca45da02010-11-02 20:36:02 +00001012 if (isa<ObjCIvarDecl>(ND))
1013 return true;
Douglas Gregorca45da02010-11-02 20:36:02 +00001014 }
1015
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001016 return ND->getIdentifierNamespace() & IDNS;
1017}
1018
Douglas Gregorf9578432010-07-28 21:50:18 +00001019bool ResultBuilder::IsIntegralConstantValue(NamedDecl *ND) const {
1020 if (!IsOrdinaryNonTypeName(ND))
1021 return 0;
1022
1023 if (ValueDecl *VD = dyn_cast<ValueDecl>(ND->getUnderlyingDecl()))
1024 if (VD->getType()->isIntegralOrEnumerationType())
1025 return true;
1026
1027 return false;
1028}
1029
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001030/// \brief Determines whether this given declaration will be found by
Douglas Gregor01dfea02010-01-10 23:08:15 +00001031/// ordinary name lookup.
1032bool ResultBuilder::IsOrdinaryNonValueName(NamedDecl *ND) const {
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001033 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1034
Douglas Gregor01dfea02010-01-10 23:08:15 +00001035 unsigned IDNS = Decl::IDNS_Ordinary;
David Blaikie4e4d0842012-03-11 07:00:24 +00001036 if (SemaRef.getLangOpts().CPlusPlus)
John McCall0d6b1642010-04-23 18:46:30 +00001037 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace;
Douglas Gregor01dfea02010-01-10 23:08:15 +00001038
1039 return (ND->getIdentifierNamespace() & IDNS) &&
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001040 !isa<ValueDecl>(ND) && !isa<FunctionTemplateDecl>(ND) &&
1041 !isa<ObjCPropertyDecl>(ND);
Douglas Gregor01dfea02010-01-10 23:08:15 +00001042}
1043
Douglas Gregor86d9a522009-09-21 16:56:56 +00001044/// \brief Determines whether the given declaration is suitable as the
1045/// start of a C++ nested-name-specifier, e.g., a class or namespace.
1046bool ResultBuilder::IsNestedNameSpecifier(NamedDecl *ND) const {
1047 // Allow us to find class templates, too.
1048 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1049 ND = ClassTemplate->getTemplatedDecl();
1050
1051 return SemaRef.isAcceptableNestedNameSpecifier(ND);
1052}
1053
1054/// \brief Determines whether the given declaration is an enumeration.
1055bool ResultBuilder::IsEnum(NamedDecl *ND) const {
1056 return isa<EnumDecl>(ND);
1057}
1058
1059/// \brief Determines whether the given declaration is a class or struct.
1060bool ResultBuilder::IsClassOrStruct(NamedDecl *ND) const {
1061 // Allow us to find class templates, too.
1062 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1063 ND = ClassTemplate->getTemplatedDecl();
1064
1065 if (RecordDecl *RD = dyn_cast<RecordDecl>(ND))
Abramo Bagnara465d41b2010-05-11 21:36:43 +00001066 return RD->getTagKind() == TTK_Class ||
1067 RD->getTagKind() == TTK_Struct;
Douglas Gregor86d9a522009-09-21 16:56:56 +00001068
1069 return false;
1070}
1071
1072/// \brief Determines whether the given declaration is a union.
1073bool ResultBuilder::IsUnion(NamedDecl *ND) const {
1074 // Allow us to find class templates, too.
1075 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1076 ND = ClassTemplate->getTemplatedDecl();
1077
1078 if (RecordDecl *RD = dyn_cast<RecordDecl>(ND))
Abramo Bagnara465d41b2010-05-11 21:36:43 +00001079 return RD->getTagKind() == TTK_Union;
Douglas Gregor86d9a522009-09-21 16:56:56 +00001080
1081 return false;
1082}
1083
1084/// \brief Determines whether the given declaration is a namespace.
1085bool ResultBuilder::IsNamespace(NamedDecl *ND) const {
1086 return isa<NamespaceDecl>(ND);
1087}
1088
1089/// \brief Determines whether the given declaration is a namespace or
1090/// namespace alias.
1091bool ResultBuilder::IsNamespaceOrAlias(NamedDecl *ND) const {
1092 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
1093}
1094
Douglas Gregor76282942009-12-11 17:31:05 +00001095/// \brief Determines whether the given declaration is a type.
Douglas Gregor86d9a522009-09-21 16:56:56 +00001096bool ResultBuilder::IsType(NamedDecl *ND) const {
Douglas Gregord32b0222010-08-24 01:06:58 +00001097 if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(ND))
1098 ND = Using->getTargetDecl();
1099
1100 return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
Douglas Gregor86d9a522009-09-21 16:56:56 +00001101}
1102
Douglas Gregor76282942009-12-11 17:31:05 +00001103/// \brief Determines which members of a class should be visible via
1104/// "." or "->". Only value declarations, nested name specifiers, and
1105/// using declarations thereof should show up.
Douglas Gregoreb5758b2009-09-23 22:26:46 +00001106bool ResultBuilder::IsMember(NamedDecl *ND) const {
Douglas Gregor76282942009-12-11 17:31:05 +00001107 if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(ND))
1108 ND = Using->getTargetDecl();
1109
Douglas Gregorce821962009-12-11 18:14:22 +00001110 return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||
1111 isa<ObjCPropertyDecl>(ND);
Douglas Gregoreb5758b2009-09-23 22:26:46 +00001112}
1113
Douglas Gregor8e254cf2010-05-27 23:06:34 +00001114static bool isObjCReceiverType(ASTContext &C, QualType T) {
1115 T = C.getCanonicalType(T);
1116 switch (T->getTypeClass()) {
1117 case Type::ObjCObject:
1118 case Type::ObjCInterface:
1119 case Type::ObjCObjectPointer:
1120 return true;
1121
1122 case Type::Builtin:
1123 switch (cast<BuiltinType>(T)->getKind()) {
1124 case BuiltinType::ObjCId:
1125 case BuiltinType::ObjCClass:
1126 case BuiltinType::ObjCSel:
1127 return true;
1128
1129 default:
1130 break;
1131 }
1132 return false;
1133
1134 default:
1135 break;
1136 }
1137
David Blaikie4e4d0842012-03-11 07:00:24 +00001138 if (!C.getLangOpts().CPlusPlus)
Douglas Gregor8e254cf2010-05-27 23:06:34 +00001139 return false;
1140
1141 // FIXME: We could perform more analysis here to determine whether a
1142 // particular class type has any conversions to Objective-C types. For now,
1143 // just accept all class types.
1144 return T->isDependentType() || T->isRecordType();
1145}
1146
1147bool ResultBuilder::IsObjCMessageReceiver(NamedDecl *ND) const {
1148 QualType T = getDeclUsageType(SemaRef.Context, ND);
1149 if (T.isNull())
1150 return false;
1151
1152 T = SemaRef.Context.getBaseElementType(T);
1153 return isObjCReceiverType(SemaRef.Context, T);
1154}
1155
Douglas Gregor81f3bff2012-02-15 15:34:24 +00001156bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture(NamedDecl *ND) const {
1157 if (IsObjCMessageReceiver(ND))
1158 return true;
1159
1160 VarDecl *Var = dyn_cast<VarDecl>(ND);
1161 if (!Var)
1162 return false;
1163
1164 return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>();
1165}
1166
Douglas Gregorfb629412010-08-23 21:17:50 +00001167bool ResultBuilder::IsObjCCollection(NamedDecl *ND) const {
David Blaikie4e4d0842012-03-11 07:00:24 +00001168 if ((SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) ||
1169 (!SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND)))
Douglas Gregorfb629412010-08-23 21:17:50 +00001170 return false;
1171
1172 QualType T = getDeclUsageType(SemaRef.Context, ND);
1173 if (T.isNull())
1174 return false;
1175
1176 T = SemaRef.Context.getBaseElementType(T);
1177 return T->isObjCObjectType() || T->isObjCObjectPointerType() ||
1178 T->isObjCIdType() ||
David Blaikie4e4d0842012-03-11 07:00:24 +00001179 (SemaRef.getLangOpts().CPlusPlus && T->isRecordType());
Douglas Gregorfb629412010-08-23 21:17:50 +00001180}
Douglas Gregor8e254cf2010-05-27 23:06:34 +00001181
Douglas Gregor52779fb2010-09-23 23:01:17 +00001182bool ResultBuilder::IsImpossibleToSatisfy(NamedDecl *ND) const {
1183 return false;
1184}
1185
Douglas Gregor80f4f4c2010-01-14 16:08:12 +00001186/// \rief Determines whether the given declaration is an Objective-C
1187/// instance variable.
1188bool ResultBuilder::IsObjCIvar(NamedDecl *ND) const {
1189 return isa<ObjCIvarDecl>(ND);
1190}
1191
Douglas Gregor1ca6ae82010-01-14 01:09:38 +00001192namespace {
1193 /// \brief Visible declaration consumer that adds a code-completion result
1194 /// for each visible declaration.
1195 class CodeCompletionDeclConsumer : public VisibleDeclConsumer {
1196 ResultBuilder &Results;
1197 DeclContext *CurContext;
1198
1199 public:
1200 CodeCompletionDeclConsumer(ResultBuilder &Results, DeclContext *CurContext)
1201 : Results(Results), CurContext(CurContext) { }
1202
Erik Verbruggend1205962011-10-06 07:27:49 +00001203 virtual void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
1204 bool InBaseClass) {
1205 bool Accessible = true;
Douglas Gregor17015ef2011-11-03 16:51:37 +00001206 if (Ctx)
1207 Accessible = Results.getSema().IsSimplyAccessible(ND, Ctx);
1208
Erik Verbruggend1205962011-10-06 07:27:49 +00001209 ResultBuilder::Result Result(ND, 0, false, Accessible);
1210 Results.AddResult(Result, CurContext, Hiding, InBaseClass);
Douglas Gregor1ca6ae82010-01-14 01:09:38 +00001211 }
1212 };
1213}
1214
Douglas Gregor86d9a522009-09-21 16:56:56 +00001215/// \brief Add type specifiers for the current language as keyword results.
Douglas Gregorbca403c2010-01-13 23:51:12 +00001216static void AddTypeSpecifierResults(const LangOptions &LangOpts,
Douglas Gregor86d9a522009-09-21 16:56:56 +00001217 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00001218 typedef CodeCompletionResult Result;
Douglas Gregor12e13132010-05-26 22:00:08 +00001219 Results.AddResult(Result("short", CCP_Type));
1220 Results.AddResult(Result("long", CCP_Type));
1221 Results.AddResult(Result("signed", CCP_Type));
1222 Results.AddResult(Result("unsigned", CCP_Type));
1223 Results.AddResult(Result("void", CCP_Type));
1224 Results.AddResult(Result("char", CCP_Type));
1225 Results.AddResult(Result("int", CCP_Type));
1226 Results.AddResult(Result("float", CCP_Type));
1227 Results.AddResult(Result("double", CCP_Type));
1228 Results.AddResult(Result("enum", CCP_Type));
1229 Results.AddResult(Result("struct", CCP_Type));
1230 Results.AddResult(Result("union", CCP_Type));
1231 Results.AddResult(Result("const", CCP_Type));
1232 Results.AddResult(Result("volatile", CCP_Type));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001233
Douglas Gregor86d9a522009-09-21 16:56:56 +00001234 if (LangOpts.C99) {
1235 // C99-specific
Douglas Gregor12e13132010-05-26 22:00:08 +00001236 Results.AddResult(Result("_Complex", CCP_Type));
1237 Results.AddResult(Result("_Imaginary", CCP_Type));
1238 Results.AddResult(Result("_Bool", CCP_Type));
1239 Results.AddResult(Result("restrict", CCP_Type));
Douglas Gregor86d9a522009-09-21 16:56:56 +00001240 }
1241
Douglas Gregor218937c2011-02-01 19:23:04 +00001242 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor86d9a522009-09-21 16:56:56 +00001243 if (LangOpts.CPlusPlus) {
1244 // C++-specific
Douglas Gregorb05496d2010-09-20 21:11:48 +00001245 Results.AddResult(Result("bool", CCP_Type +
1246 (LangOpts.ObjC1? CCD_bool_in_ObjC : 0)));
Douglas Gregor12e13132010-05-26 22:00:08 +00001247 Results.AddResult(Result("class", CCP_Type));
1248 Results.AddResult(Result("wchar_t", CCP_Type));
Douglas Gregor86d9a522009-09-21 16:56:56 +00001249
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001250 // typename qualified-id
Douglas Gregor218937c2011-02-01 19:23:04 +00001251 Builder.AddTypedTextChunk("typename");
1252 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1253 Builder.AddPlaceholderChunk("qualifier");
1254 Builder.AddTextChunk("::");
1255 Builder.AddPlaceholderChunk("name");
1256 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregord8e8a582010-05-25 21:41:55 +00001257
Douglas Gregor86d9a522009-09-21 16:56:56 +00001258 if (LangOpts.CPlusPlus0x) {
Douglas Gregor12e13132010-05-26 22:00:08 +00001259 Results.AddResult(Result("auto", CCP_Type));
1260 Results.AddResult(Result("char16_t", CCP_Type));
1261 Results.AddResult(Result("char32_t", CCP_Type));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001262
Douglas Gregor218937c2011-02-01 19:23:04 +00001263 Builder.AddTypedTextChunk("decltype");
1264 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1265 Builder.AddPlaceholderChunk("expression");
1266 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1267 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor86d9a522009-09-21 16:56:56 +00001268 }
1269 }
1270
1271 // GNU extensions
1272 if (LangOpts.GNUMode) {
1273 // FIXME: Enable when we actually support decimal floating point.
Douglas Gregora4477812010-01-14 16:01:26 +00001274 // Results.AddResult(Result("_Decimal32"));
1275 // Results.AddResult(Result("_Decimal64"));
1276 // Results.AddResult(Result("_Decimal128"));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001277
Douglas Gregor218937c2011-02-01 19:23:04 +00001278 Builder.AddTypedTextChunk("typeof");
1279 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1280 Builder.AddPlaceholderChunk("expression");
1281 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001282
Douglas Gregor218937c2011-02-01 19:23:04 +00001283 Builder.AddTypedTextChunk("typeof");
1284 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1285 Builder.AddPlaceholderChunk("type");
1286 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1287 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor86d9a522009-09-21 16:56:56 +00001288 }
1289}
1290
John McCallf312b1e2010-08-26 23:41:50 +00001291static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC,
Douglas Gregor01dfea02010-01-10 23:08:15 +00001292 const LangOptions &LangOpts,
Douglas Gregor01dfea02010-01-10 23:08:15 +00001293 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00001294 typedef CodeCompletionResult Result;
Douglas Gregor01dfea02010-01-10 23:08:15 +00001295 // Note: we don't suggest either "auto" or "register", because both
1296 // are pointless as storage specifiers. Elsewhere, we suggest "auto"
1297 // in C++0x as a type specifier.
Douglas Gregora4477812010-01-14 16:01:26 +00001298 Results.AddResult(Result("extern"));
1299 Results.AddResult(Result("static"));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001300}
1301
John McCallf312b1e2010-08-26 23:41:50 +00001302static void AddFunctionSpecifiers(Sema::ParserCompletionContext CCC,
Douglas Gregor01dfea02010-01-10 23:08:15 +00001303 const LangOptions &LangOpts,
Douglas Gregor01dfea02010-01-10 23:08:15 +00001304 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00001305 typedef CodeCompletionResult Result;
Douglas Gregor01dfea02010-01-10 23:08:15 +00001306 switch (CCC) {
John McCallf312b1e2010-08-26 23:41:50 +00001307 case Sema::PCC_Class:
1308 case Sema::PCC_MemberTemplate:
Douglas Gregor01dfea02010-01-10 23:08:15 +00001309 if (LangOpts.CPlusPlus) {
Douglas Gregora4477812010-01-14 16:01:26 +00001310 Results.AddResult(Result("explicit"));
1311 Results.AddResult(Result("friend"));
1312 Results.AddResult(Result("mutable"));
1313 Results.AddResult(Result("virtual"));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001314 }
1315 // Fall through
1316
John McCallf312b1e2010-08-26 23:41:50 +00001317 case Sema::PCC_ObjCInterface:
1318 case Sema::PCC_ObjCImplementation:
1319 case Sema::PCC_Namespace:
1320 case Sema::PCC_Template:
Douglas Gregor01dfea02010-01-10 23:08:15 +00001321 if (LangOpts.CPlusPlus || LangOpts.C99)
Douglas Gregora4477812010-01-14 16:01:26 +00001322 Results.AddResult(Result("inline"));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001323 break;
1324
John McCallf312b1e2010-08-26 23:41:50 +00001325 case Sema::PCC_ObjCInstanceVariableList:
1326 case Sema::PCC_Expression:
1327 case Sema::PCC_Statement:
1328 case Sema::PCC_ForInit:
1329 case Sema::PCC_Condition:
1330 case Sema::PCC_RecoveryInFunction:
1331 case Sema::PCC_Type:
Douglas Gregor02688102010-09-14 23:59:36 +00001332 case Sema::PCC_ParenthesizedExpression:
Douglas Gregor68e3c2e2011-02-15 20:33:25 +00001333 case Sema::PCC_LocalDeclarationSpecifiers:
Douglas Gregor01dfea02010-01-10 23:08:15 +00001334 break;
1335 }
1336}
1337
Douglas Gregorbca403c2010-01-13 23:51:12 +00001338static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt);
1339static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt);
1340static void AddObjCVisibilityResults(const LangOptions &LangOpts,
Douglas Gregorc38c3e12010-01-13 21:54:15 +00001341 ResultBuilder &Results,
1342 bool NeedAt);
Douglas Gregorbca403c2010-01-13 23:51:12 +00001343static void AddObjCImplementationResults(const LangOptions &LangOpts,
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001344 ResultBuilder &Results,
1345 bool NeedAt);
Douglas Gregorbca403c2010-01-13 23:51:12 +00001346static void AddObjCInterfaceResults(const LangOptions &LangOpts,
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001347 ResultBuilder &Results,
1348 bool NeedAt);
Douglas Gregorbca403c2010-01-13 23:51:12 +00001349static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001350
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001351static void AddTypedefResult(ResultBuilder &Results) {
Douglas Gregor218937c2011-02-01 19:23:04 +00001352 CodeCompletionBuilder Builder(Results.getAllocator());
1353 Builder.AddTypedTextChunk("typedef");
1354 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1355 Builder.AddPlaceholderChunk("type");
1356 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1357 Builder.AddPlaceholderChunk("name");
1358 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001359}
1360
John McCallf312b1e2010-08-26 23:41:50 +00001361static bool WantTypesInContext(Sema::ParserCompletionContext CCC,
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001362 const LangOptions &LangOpts) {
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001363 switch (CCC) {
John McCallf312b1e2010-08-26 23:41:50 +00001364 case Sema::PCC_Namespace:
1365 case Sema::PCC_Class:
1366 case Sema::PCC_ObjCInstanceVariableList:
1367 case Sema::PCC_Template:
1368 case Sema::PCC_MemberTemplate:
1369 case Sema::PCC_Statement:
1370 case Sema::PCC_RecoveryInFunction:
1371 case Sema::PCC_Type:
Douglas Gregor02688102010-09-14 23:59:36 +00001372 case Sema::PCC_ParenthesizedExpression:
Douglas Gregor68e3c2e2011-02-15 20:33:25 +00001373 case Sema::PCC_LocalDeclarationSpecifiers:
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001374 return true;
1375
John McCallf312b1e2010-08-26 23:41:50 +00001376 case Sema::PCC_Expression:
1377 case Sema::PCC_Condition:
Douglas Gregor02688102010-09-14 23:59:36 +00001378 return LangOpts.CPlusPlus;
1379
1380 case Sema::PCC_ObjCInterface:
1381 case Sema::PCC_ObjCImplementation:
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001382 return false;
1383
John McCallf312b1e2010-08-26 23:41:50 +00001384 case Sema::PCC_ForInit:
Douglas Gregor02688102010-09-14 23:59:36 +00001385 return LangOpts.CPlusPlus || LangOpts.ObjC1 || LangOpts.C99;
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001386 }
David Blaikie7530c032012-01-17 06:56:22 +00001387
1388 llvm_unreachable("Invalid ParserCompletionContext!");
Douglas Gregor4710e5b2010-05-28 00:49:12 +00001389}
1390
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00001391static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context,
1392 const Preprocessor &PP) {
1393 PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
Douglas Gregor8ca72082011-10-18 21:20:17 +00001394 Policy.AnonymousTagLocations = false;
1395 Policy.SuppressStrongLifetime = true;
Douglas Gregor25270b62011-11-03 00:16:13 +00001396 Policy.SuppressUnwrittenScope = true;
Douglas Gregor8ca72082011-10-18 21:20:17 +00001397 return Policy;
1398}
1399
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00001400/// \brief Retrieve a printing policy suitable for code completion.
1401static PrintingPolicy getCompletionPrintingPolicy(Sema &S) {
1402 return getCompletionPrintingPolicy(S.Context, S.PP);
1403}
1404
Douglas Gregor8ca72082011-10-18 21:20:17 +00001405/// \brief Retrieve the string representation of the given type as a string
1406/// that has the appropriate lifetime for code completion.
1407///
1408/// This routine provides a fast path where we provide constant strings for
1409/// common type names.
1410static const char *GetCompletionTypeString(QualType T,
1411 ASTContext &Context,
1412 const PrintingPolicy &Policy,
1413 CodeCompletionAllocator &Allocator) {
1414 if (!T.getLocalQualifiers()) {
1415 // Built-in type names are constant strings.
1416 if (const BuiltinType *BT = dyn_cast<BuiltinType>(T))
1417 return BT->getName(Policy);
1418
1419 // Anonymous tag types are constant strings.
1420 if (const TagType *TagT = dyn_cast<TagType>(T))
1421 if (TagDecl *Tag = TagT->getDecl())
1422 if (!Tag->getIdentifier() && !Tag->getTypedefNameForAnonDecl()) {
1423 switch (Tag->getTagKind()) {
1424 case TTK_Struct: return "struct <anonymous>";
1425 case TTK_Class: return "class <anonymous>";
1426 case TTK_Union: return "union <anonymous>";
1427 case TTK_Enum: return "enum <anonymous>";
1428 }
1429 }
1430 }
1431
1432 // Slow path: format the type as a string.
1433 std::string Result;
1434 T.getAsStringInternal(Result, Policy);
1435 return Allocator.CopyString(Result);
1436}
1437
Douglas Gregor81f3bff2012-02-15 15:34:24 +00001438/// \brief Add a completion for "this", if we're in a member function.
1439static void addThisCompletion(Sema &S, ResultBuilder &Results) {
1440 QualType ThisTy = S.getCurrentThisType();
1441 if (ThisTy.isNull())
1442 return;
1443
1444 CodeCompletionAllocator &Allocator = Results.getAllocator();
1445 CodeCompletionBuilder Builder(Allocator);
1446 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
1447 Builder.AddResultTypeChunk(GetCompletionTypeString(ThisTy,
1448 S.Context,
1449 Policy,
1450 Allocator));
1451 Builder.AddTypedTextChunk("this");
1452 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1453}
1454
Douglas Gregor01dfea02010-01-10 23:08:15 +00001455/// \brief Add language constructs that show up for "ordinary" names.
John McCallf312b1e2010-08-26 23:41:50 +00001456static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC,
Douglas Gregor01dfea02010-01-10 23:08:15 +00001457 Scope *S,
1458 Sema &SemaRef,
Douglas Gregor01dfea02010-01-10 23:08:15 +00001459 ResultBuilder &Results) {
Douglas Gregor8ca72082011-10-18 21:20:17 +00001460 CodeCompletionAllocator &Allocator = Results.getAllocator();
1461 CodeCompletionBuilder Builder(Allocator);
1462 PrintingPolicy Policy = getCompletionPrintingPolicy(SemaRef);
Douglas Gregor218937c2011-02-01 19:23:04 +00001463
John McCall0a2c5e22010-08-25 06:19:51 +00001464 typedef CodeCompletionResult Result;
Douglas Gregor01dfea02010-01-10 23:08:15 +00001465 switch (CCC) {
John McCallf312b1e2010-08-26 23:41:50 +00001466 case Sema::PCC_Namespace:
David Blaikie4e4d0842012-03-11 07:00:24 +00001467 if (SemaRef.getLangOpts().CPlusPlus) {
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001468 if (Results.includeCodePatterns()) {
1469 // namespace <identifier> { declarations }
Douglas Gregor218937c2011-02-01 19:23:04 +00001470 Builder.AddTypedTextChunk("namespace");
1471 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1472 Builder.AddPlaceholderChunk("identifier");
1473 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1474 Builder.AddPlaceholderChunk("declarations");
1475 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1476 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1477 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001478 }
1479
Douglas Gregor01dfea02010-01-10 23:08:15 +00001480 // namespace identifier = identifier ;
Douglas Gregor218937c2011-02-01 19:23:04 +00001481 Builder.AddTypedTextChunk("namespace");
1482 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1483 Builder.AddPlaceholderChunk("name");
1484 Builder.AddChunk(CodeCompletionString::CK_Equal);
1485 Builder.AddPlaceholderChunk("namespace");
1486 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001487
1488 // Using directives
Douglas Gregor218937c2011-02-01 19:23:04 +00001489 Builder.AddTypedTextChunk("using");
1490 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1491 Builder.AddTextChunk("namespace");
1492 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1493 Builder.AddPlaceholderChunk("identifier");
1494 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001495
1496 // asm(string-literal)
Douglas Gregor218937c2011-02-01 19:23:04 +00001497 Builder.AddTypedTextChunk("asm");
1498 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1499 Builder.AddPlaceholderChunk("string-literal");
1500 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1501 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001502
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001503 if (Results.includeCodePatterns()) {
1504 // Explicit template instantiation
Douglas Gregor218937c2011-02-01 19:23:04 +00001505 Builder.AddTypedTextChunk("template");
1506 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1507 Builder.AddPlaceholderChunk("declaration");
1508 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001509 }
Douglas Gregor01dfea02010-01-10 23:08:15 +00001510 }
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001511
David Blaikie4e4d0842012-03-11 07:00:24 +00001512 if (SemaRef.getLangOpts().ObjC1)
Douglas Gregorbca403c2010-01-13 23:51:12 +00001513 AddObjCTopLevelResults(Results, true);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001514
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001515 AddTypedefResult(Results);
Douglas Gregor01dfea02010-01-10 23:08:15 +00001516 // Fall through
1517
John McCallf312b1e2010-08-26 23:41:50 +00001518 case Sema::PCC_Class:
David Blaikie4e4d0842012-03-11 07:00:24 +00001519 if (SemaRef.getLangOpts().CPlusPlus) {
Douglas Gregor01dfea02010-01-10 23:08:15 +00001520 // Using declaration
Douglas Gregor218937c2011-02-01 19:23:04 +00001521 Builder.AddTypedTextChunk("using");
1522 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1523 Builder.AddPlaceholderChunk("qualifier");
1524 Builder.AddTextChunk("::");
1525 Builder.AddPlaceholderChunk("name");
1526 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001527
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001528 // using typename qualifier::name (only in a dependent context)
Douglas Gregor01dfea02010-01-10 23:08:15 +00001529 if (SemaRef.CurContext->isDependentContext()) {
Douglas Gregor218937c2011-02-01 19:23:04 +00001530 Builder.AddTypedTextChunk("using");
1531 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1532 Builder.AddTextChunk("typename");
1533 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1534 Builder.AddPlaceholderChunk("qualifier");
1535 Builder.AddTextChunk("::");
1536 Builder.AddPlaceholderChunk("name");
1537 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001538 }
1539
John McCallf312b1e2010-08-26 23:41:50 +00001540 if (CCC == Sema::PCC_Class) {
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001541 AddTypedefResult(Results);
1542
Douglas Gregor01dfea02010-01-10 23:08:15 +00001543 // public:
Douglas Gregor218937c2011-02-01 19:23:04 +00001544 Builder.AddTypedTextChunk("public");
1545 Builder.AddChunk(CodeCompletionString::CK_Colon);
1546 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001547
1548 // protected:
Douglas Gregor218937c2011-02-01 19:23:04 +00001549 Builder.AddTypedTextChunk("protected");
1550 Builder.AddChunk(CodeCompletionString::CK_Colon);
1551 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001552
1553 // private:
Douglas Gregor218937c2011-02-01 19:23:04 +00001554 Builder.AddTypedTextChunk("private");
1555 Builder.AddChunk(CodeCompletionString::CK_Colon);
1556 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001557 }
1558 }
1559 // Fall through
1560
John McCallf312b1e2010-08-26 23:41:50 +00001561 case Sema::PCC_Template:
1562 case Sema::PCC_MemberTemplate:
David Blaikie4e4d0842012-03-11 07:00:24 +00001563 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
Douglas Gregor01dfea02010-01-10 23:08:15 +00001564 // template < parameters >
Douglas Gregor218937c2011-02-01 19:23:04 +00001565 Builder.AddTypedTextChunk("template");
1566 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1567 Builder.AddPlaceholderChunk("parameters");
1568 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1569 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001570 }
1571
David Blaikie4e4d0842012-03-11 07:00:24 +00001572 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1573 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
Douglas Gregor01dfea02010-01-10 23:08:15 +00001574 break;
1575
John McCallf312b1e2010-08-26 23:41:50 +00001576 case Sema::PCC_ObjCInterface:
David Blaikie4e4d0842012-03-11 07:00:24 +00001577 AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true);
1578 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1579 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001580 break;
1581
John McCallf312b1e2010-08-26 23:41:50 +00001582 case Sema::PCC_ObjCImplementation:
David Blaikie4e4d0842012-03-11 07:00:24 +00001583 AddObjCImplementationResults(SemaRef.getLangOpts(), Results, true);
1584 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1585 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001586 break;
1587
John McCallf312b1e2010-08-26 23:41:50 +00001588 case Sema::PCC_ObjCInstanceVariableList:
David Blaikie4e4d0842012-03-11 07:00:24 +00001589 AddObjCVisibilityResults(SemaRef.getLangOpts(), Results, true);
Douglas Gregorc38c3e12010-01-13 21:54:15 +00001590 break;
1591
John McCallf312b1e2010-08-26 23:41:50 +00001592 case Sema::PCC_RecoveryInFunction:
1593 case Sema::PCC_Statement: {
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001594 AddTypedefResult(Results);
Douglas Gregor01dfea02010-01-10 23:08:15 +00001595
David Blaikie4e4d0842012-03-11 07:00:24 +00001596 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() &&
1597 SemaRef.getLangOpts().CXXExceptions) {
Douglas Gregor218937c2011-02-01 19:23:04 +00001598 Builder.AddTypedTextChunk("try");
1599 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1600 Builder.AddPlaceholderChunk("statements");
1601 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1602 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1603 Builder.AddTextChunk("catch");
1604 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1605 Builder.AddPlaceholderChunk("declaration");
1606 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1607 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1608 Builder.AddPlaceholderChunk("statements");
1609 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1610 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1611 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001612 }
David Blaikie4e4d0842012-03-11 07:00:24 +00001613 if (SemaRef.getLangOpts().ObjC1)
Douglas Gregorbca403c2010-01-13 23:51:12 +00001614 AddObjCStatementResults(Results, true);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00001615
Douglas Gregord8e8a582010-05-25 21:41:55 +00001616 if (Results.includeCodePatterns()) {
1617 // if (condition) { statements }
Douglas Gregor218937c2011-02-01 19:23:04 +00001618 Builder.AddTypedTextChunk("if");
1619 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
David Blaikie4e4d0842012-03-11 07:00:24 +00001620 if (SemaRef.getLangOpts().CPlusPlus)
Douglas Gregor218937c2011-02-01 19:23:04 +00001621 Builder.AddPlaceholderChunk("condition");
Douglas Gregord8e8a582010-05-25 21:41:55 +00001622 else
Douglas Gregor218937c2011-02-01 19:23:04 +00001623 Builder.AddPlaceholderChunk("expression");
1624 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1625 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1626 Builder.AddPlaceholderChunk("statements");
1627 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1628 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1629 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001630
Douglas Gregord8e8a582010-05-25 21:41:55 +00001631 // switch (condition) { }
Douglas Gregor218937c2011-02-01 19:23:04 +00001632 Builder.AddTypedTextChunk("switch");
1633 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
David Blaikie4e4d0842012-03-11 07:00:24 +00001634 if (SemaRef.getLangOpts().CPlusPlus)
Douglas Gregor218937c2011-02-01 19:23:04 +00001635 Builder.AddPlaceholderChunk("condition");
Douglas Gregord8e8a582010-05-25 21:41:55 +00001636 else
Douglas Gregor218937c2011-02-01 19:23:04 +00001637 Builder.AddPlaceholderChunk("expression");
1638 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1639 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1640 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1641 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1642 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregord8e8a582010-05-25 21:41:55 +00001643 }
1644
Douglas Gregor01dfea02010-01-10 23:08:15 +00001645 // Switch-specific statements.
John McCall781472f2010-08-25 08:40:02 +00001646 if (!SemaRef.getCurFunction()->SwitchStack.empty()) {
Douglas Gregor01dfea02010-01-10 23:08:15 +00001647 // case expression:
Douglas Gregor218937c2011-02-01 19:23:04 +00001648 Builder.AddTypedTextChunk("case");
1649 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1650 Builder.AddPlaceholderChunk("expression");
1651 Builder.AddChunk(CodeCompletionString::CK_Colon);
1652 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001653
1654 // default:
Douglas Gregor218937c2011-02-01 19:23:04 +00001655 Builder.AddTypedTextChunk("default");
1656 Builder.AddChunk(CodeCompletionString::CK_Colon);
1657 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001658 }
1659
Douglas Gregord8e8a582010-05-25 21:41:55 +00001660 if (Results.includeCodePatterns()) {
1661 /// while (condition) { statements }
Douglas Gregor218937c2011-02-01 19:23:04 +00001662 Builder.AddTypedTextChunk("while");
1663 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
David Blaikie4e4d0842012-03-11 07:00:24 +00001664 if (SemaRef.getLangOpts().CPlusPlus)
Douglas Gregor218937c2011-02-01 19:23:04 +00001665 Builder.AddPlaceholderChunk("condition");
Douglas Gregord8e8a582010-05-25 21:41:55 +00001666 else
Douglas Gregor218937c2011-02-01 19:23:04 +00001667 Builder.AddPlaceholderChunk("expression");
1668 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1669 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1670 Builder.AddPlaceholderChunk("statements");
1671 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1672 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1673 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregord8e8a582010-05-25 21:41:55 +00001674
1675 // do { statements } while ( expression );
Douglas Gregor218937c2011-02-01 19:23:04 +00001676 Builder.AddTypedTextChunk("do");
1677 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1678 Builder.AddPlaceholderChunk("statements");
1679 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1680 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1681 Builder.AddTextChunk("while");
1682 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1683 Builder.AddPlaceholderChunk("expression");
1684 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1685 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001686
Douglas Gregord8e8a582010-05-25 21:41:55 +00001687 // for ( for-init-statement ; condition ; expression ) { statements }
Douglas Gregor218937c2011-02-01 19:23:04 +00001688 Builder.AddTypedTextChunk("for");
1689 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
David Blaikie4e4d0842012-03-11 07:00:24 +00001690 if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99)
Douglas Gregor218937c2011-02-01 19:23:04 +00001691 Builder.AddPlaceholderChunk("init-statement");
Douglas Gregord8e8a582010-05-25 21:41:55 +00001692 else
Douglas Gregor218937c2011-02-01 19:23:04 +00001693 Builder.AddPlaceholderChunk("init-expression");
1694 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1695 Builder.AddPlaceholderChunk("condition");
1696 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1697 Builder.AddPlaceholderChunk("inc-expression");
1698 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1699 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1700 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1701 Builder.AddPlaceholderChunk("statements");
1702 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1703 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1704 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregord8e8a582010-05-25 21:41:55 +00001705 }
Douglas Gregor01dfea02010-01-10 23:08:15 +00001706
1707 if (S->getContinueParent()) {
1708 // continue ;
Douglas Gregor218937c2011-02-01 19:23:04 +00001709 Builder.AddTypedTextChunk("continue");
1710 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001711 }
1712
1713 if (S->getBreakParent()) {
1714 // break ;
Douglas Gregor218937c2011-02-01 19:23:04 +00001715 Builder.AddTypedTextChunk("break");
1716 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001717 }
1718
1719 // "return expression ;" or "return ;", depending on whether we
1720 // know the function is void or not.
1721 bool isVoid = false;
1722 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext))
1723 isVoid = Function->getResultType()->isVoidType();
1724 else if (ObjCMethodDecl *Method
1725 = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext))
1726 isVoid = Method->getResultType()->isVoidType();
Douglas Gregor9ea9bdb2010-03-01 23:15:13 +00001727 else if (SemaRef.getCurBlock() &&
1728 !SemaRef.getCurBlock()->ReturnType.isNull())
1729 isVoid = SemaRef.getCurBlock()->ReturnType->isVoidType();
Douglas Gregor218937c2011-02-01 19:23:04 +00001730 Builder.AddTypedTextChunk("return");
Douglas Gregor93298002010-02-18 04:06:48 +00001731 if (!isVoid) {
Douglas Gregor218937c2011-02-01 19:23:04 +00001732 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1733 Builder.AddPlaceholderChunk("expression");
Douglas Gregor93298002010-02-18 04:06:48 +00001734 }
Douglas Gregor218937c2011-02-01 19:23:04 +00001735 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001736
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001737 // goto identifier ;
Douglas Gregor218937c2011-02-01 19:23:04 +00001738 Builder.AddTypedTextChunk("goto");
1739 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1740 Builder.AddPlaceholderChunk("label");
1741 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001742
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001743 // Using directives
Douglas Gregor218937c2011-02-01 19:23:04 +00001744 Builder.AddTypedTextChunk("using");
1745 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1746 Builder.AddTextChunk("namespace");
1747 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1748 Builder.AddPlaceholderChunk("identifier");
1749 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001750 }
1751
1752 // Fall through (for statement expressions).
John McCallf312b1e2010-08-26 23:41:50 +00001753 case Sema::PCC_ForInit:
1754 case Sema::PCC_Condition:
David Blaikie4e4d0842012-03-11 07:00:24 +00001755 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
Douglas Gregor01dfea02010-01-10 23:08:15 +00001756 // Fall through: conditions and statements can have expressions.
1757
Douglas Gregor02688102010-09-14 23:59:36 +00001758 case Sema::PCC_ParenthesizedExpression:
David Blaikie4e4d0842012-03-11 07:00:24 +00001759 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +00001760 CCC == Sema::PCC_ParenthesizedExpression) {
1761 // (__bridge <type>)<expression>
1762 Builder.AddTypedTextChunk("__bridge");
1763 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1764 Builder.AddPlaceholderChunk("type");
1765 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1766 Builder.AddPlaceholderChunk("expression");
1767 Results.AddResult(Result(Builder.TakeString()));
1768
1769 // (__bridge_transfer <Objective-C type>)<expression>
1770 Builder.AddTypedTextChunk("__bridge_transfer");
1771 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1772 Builder.AddPlaceholderChunk("Objective-C type");
1773 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1774 Builder.AddPlaceholderChunk("expression");
1775 Results.AddResult(Result(Builder.TakeString()));
1776
1777 // (__bridge_retained <CF type>)<expression>
1778 Builder.AddTypedTextChunk("__bridge_retained");
1779 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1780 Builder.AddPlaceholderChunk("CF type");
1781 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1782 Builder.AddPlaceholderChunk("expression");
1783 Results.AddResult(Result(Builder.TakeString()));
1784 }
1785 // Fall through
1786
John McCallf312b1e2010-08-26 23:41:50 +00001787 case Sema::PCC_Expression: {
David Blaikie4e4d0842012-03-11 07:00:24 +00001788 if (SemaRef.getLangOpts().CPlusPlus) {
Douglas Gregor01dfea02010-01-10 23:08:15 +00001789 // 'this', if we're in a non-static member function.
Douglas Gregor81f3bff2012-02-15 15:34:24 +00001790 addThisCompletion(SemaRef, Results);
Douglas Gregor01dfea02010-01-10 23:08:15 +00001791
Douglas Gregor8ca72082011-10-18 21:20:17 +00001792 // true
1793 Builder.AddResultTypeChunk("bool");
1794 Builder.AddTypedTextChunk("true");
1795 Results.AddResult(Result(Builder.TakeString()));
1796
1797 // false
1798 Builder.AddResultTypeChunk("bool");
1799 Builder.AddTypedTextChunk("false");
1800 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001801
David Blaikie4e4d0842012-03-11 07:00:24 +00001802 if (SemaRef.getLangOpts().RTTI) {
Douglas Gregorec3310a2011-04-12 02:47:21 +00001803 // dynamic_cast < type-id > ( expression )
1804 Builder.AddTypedTextChunk("dynamic_cast");
1805 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1806 Builder.AddPlaceholderChunk("type");
1807 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1808 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1809 Builder.AddPlaceholderChunk("expression");
1810 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1811 Results.AddResult(Result(Builder.TakeString()));
1812 }
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001813
1814 // static_cast < type-id > ( expression )
Douglas Gregor218937c2011-02-01 19:23:04 +00001815 Builder.AddTypedTextChunk("static_cast");
1816 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1817 Builder.AddPlaceholderChunk("type");
1818 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1819 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1820 Builder.AddPlaceholderChunk("expression");
1821 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1822 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001823
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001824 // reinterpret_cast < type-id > ( expression )
Douglas Gregor218937c2011-02-01 19:23:04 +00001825 Builder.AddTypedTextChunk("reinterpret_cast");
1826 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1827 Builder.AddPlaceholderChunk("type");
1828 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1829 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1830 Builder.AddPlaceholderChunk("expression");
1831 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1832 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001833
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001834 // const_cast < type-id > ( expression )
Douglas Gregor218937c2011-02-01 19:23:04 +00001835 Builder.AddTypedTextChunk("const_cast");
1836 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1837 Builder.AddPlaceholderChunk("type");
1838 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1839 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1840 Builder.AddPlaceholderChunk("expression");
1841 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1842 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001843
David Blaikie4e4d0842012-03-11 07:00:24 +00001844 if (SemaRef.getLangOpts().RTTI) {
Douglas Gregorec3310a2011-04-12 02:47:21 +00001845 // typeid ( expression-or-type )
Douglas Gregor8ca72082011-10-18 21:20:17 +00001846 Builder.AddResultTypeChunk("std::type_info");
Douglas Gregorec3310a2011-04-12 02:47:21 +00001847 Builder.AddTypedTextChunk("typeid");
1848 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1849 Builder.AddPlaceholderChunk("expression-or-type");
1850 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1851 Results.AddResult(Result(Builder.TakeString()));
1852 }
1853
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001854 // new T ( ... )
Douglas Gregor218937c2011-02-01 19:23:04 +00001855 Builder.AddTypedTextChunk("new");
1856 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1857 Builder.AddPlaceholderChunk("type");
1858 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1859 Builder.AddPlaceholderChunk("expressions");
1860 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1861 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001862
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001863 // new T [ ] ( ... )
Douglas Gregor218937c2011-02-01 19:23:04 +00001864 Builder.AddTypedTextChunk("new");
1865 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1866 Builder.AddPlaceholderChunk("type");
1867 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
1868 Builder.AddPlaceholderChunk("size");
1869 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
1870 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1871 Builder.AddPlaceholderChunk("expressions");
1872 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1873 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001874
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001875 // delete expression
Douglas Gregor8ca72082011-10-18 21:20:17 +00001876 Builder.AddResultTypeChunk("void");
Douglas Gregor218937c2011-02-01 19:23:04 +00001877 Builder.AddTypedTextChunk("delete");
1878 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1879 Builder.AddPlaceholderChunk("expression");
1880 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001881
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001882 // delete [] expression
Douglas Gregor8ca72082011-10-18 21:20:17 +00001883 Builder.AddResultTypeChunk("void");
Douglas Gregor218937c2011-02-01 19:23:04 +00001884 Builder.AddTypedTextChunk("delete");
1885 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1886 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
1887 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
1888 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1889 Builder.AddPlaceholderChunk("expression");
1890 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001891
David Blaikie4e4d0842012-03-11 07:00:24 +00001892 if (SemaRef.getLangOpts().CXXExceptions) {
Douglas Gregorec3310a2011-04-12 02:47:21 +00001893 // throw expression
Douglas Gregor8ca72082011-10-18 21:20:17 +00001894 Builder.AddResultTypeChunk("void");
Douglas Gregorec3310a2011-04-12 02:47:21 +00001895 Builder.AddTypedTextChunk("throw");
1896 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1897 Builder.AddPlaceholderChunk("expression");
1898 Results.AddResult(Result(Builder.TakeString()));
1899 }
Douglas Gregora50216c2011-10-18 16:29:03 +00001900
Douglas Gregor12e13132010-05-26 22:00:08 +00001901 // FIXME: Rethrow?
Douglas Gregora50216c2011-10-18 16:29:03 +00001902
David Blaikie4e4d0842012-03-11 07:00:24 +00001903 if (SemaRef.getLangOpts().CPlusPlus0x) {
Douglas Gregora50216c2011-10-18 16:29:03 +00001904 // nullptr
Douglas Gregor8ca72082011-10-18 21:20:17 +00001905 Builder.AddResultTypeChunk("std::nullptr_t");
Douglas Gregora50216c2011-10-18 16:29:03 +00001906 Builder.AddTypedTextChunk("nullptr");
1907 Results.AddResult(Result(Builder.TakeString()));
1908
1909 // alignof
Douglas Gregor8ca72082011-10-18 21:20:17 +00001910 Builder.AddResultTypeChunk("size_t");
Douglas Gregora50216c2011-10-18 16:29:03 +00001911 Builder.AddTypedTextChunk("alignof");
1912 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1913 Builder.AddPlaceholderChunk("type");
1914 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1915 Results.AddResult(Result(Builder.TakeString()));
1916
1917 // noexcept
Douglas Gregor8ca72082011-10-18 21:20:17 +00001918 Builder.AddResultTypeChunk("bool");
Douglas Gregora50216c2011-10-18 16:29:03 +00001919 Builder.AddTypedTextChunk("noexcept");
1920 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1921 Builder.AddPlaceholderChunk("expression");
1922 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1923 Results.AddResult(Result(Builder.TakeString()));
1924
1925 // sizeof... expression
Douglas Gregor8ca72082011-10-18 21:20:17 +00001926 Builder.AddResultTypeChunk("size_t");
Douglas Gregora50216c2011-10-18 16:29:03 +00001927 Builder.AddTypedTextChunk("sizeof...");
1928 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1929 Builder.AddPlaceholderChunk("parameter-pack");
1930 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1931 Results.AddResult(Result(Builder.TakeString()));
1932 }
Douglas Gregor01dfea02010-01-10 23:08:15 +00001933 }
1934
David Blaikie4e4d0842012-03-11 07:00:24 +00001935 if (SemaRef.getLangOpts().ObjC1) {
Douglas Gregor01dfea02010-01-10 23:08:15 +00001936 // Add "super", if we're in an Objective-C class with a superclass.
Ted Kremenek681e2562010-05-31 21:43:10 +00001937 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
1938 // The interface can be NULL.
1939 if (ObjCInterfaceDecl *ID = Method->getClassInterface())
Douglas Gregor8ca72082011-10-18 21:20:17 +00001940 if (ID->getSuperClass()) {
1941 std::string SuperType;
1942 SuperType = ID->getSuperClass()->getNameAsString();
1943 if (Method->isInstanceMethod())
1944 SuperType += " *";
1945
1946 Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
1947 Builder.AddTypedTextChunk("super");
1948 Results.AddResult(Result(Builder.TakeString()));
1949 }
Ted Kremenek681e2562010-05-31 21:43:10 +00001950 }
1951
Douglas Gregorbca403c2010-01-13 23:51:12 +00001952 AddObjCExpressionResults(Results, true);
Douglas Gregor01dfea02010-01-10 23:08:15 +00001953 }
1954
Douglas Gregorc8bddde2010-05-28 00:22:41 +00001955 // sizeof expression
Douglas Gregor8ca72082011-10-18 21:20:17 +00001956 Builder.AddResultTypeChunk("size_t");
Douglas Gregor218937c2011-02-01 19:23:04 +00001957 Builder.AddTypedTextChunk("sizeof");
1958 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1959 Builder.AddPlaceholderChunk("expression-or-type");
1960 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1961 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001962 break;
1963 }
Douglas Gregord32b0222010-08-24 01:06:58 +00001964
John McCallf312b1e2010-08-26 23:41:50 +00001965 case Sema::PCC_Type:
Douglas Gregor68e3c2e2011-02-15 20:33:25 +00001966 case Sema::PCC_LocalDeclarationSpecifiers:
Douglas Gregord32b0222010-08-24 01:06:58 +00001967 break;
Douglas Gregor01dfea02010-01-10 23:08:15 +00001968 }
1969
David Blaikie4e4d0842012-03-11 07:00:24 +00001970 if (WantTypesInContext(CCC, SemaRef.getLangOpts()))
1971 AddTypeSpecifierResults(SemaRef.getLangOpts(), Results);
Douglas Gregor01dfea02010-01-10 23:08:15 +00001972
David Blaikie4e4d0842012-03-11 07:00:24 +00001973 if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type)
Douglas Gregora4477812010-01-14 16:01:26 +00001974 Results.AddResult(Result("operator"));
Douglas Gregor01dfea02010-01-10 23:08:15 +00001975}
1976
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00001977/// \brief If the given declaration has an associated type, add it as a result
1978/// type chunk.
1979static void AddResultTypeChunk(ASTContext &Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00001980 const PrintingPolicy &Policy,
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00001981 NamedDecl *ND,
Douglas Gregor218937c2011-02-01 19:23:04 +00001982 CodeCompletionBuilder &Result) {
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00001983 if (!ND)
1984 return;
Douglas Gregor6f942b22010-09-21 16:06:22 +00001985
1986 // Skip constructors and conversion functions, which have their return types
1987 // built into their names.
1988 if (isa<CXXConstructorDecl>(ND) || isa<CXXConversionDecl>(ND))
1989 return;
1990
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00001991 // Determine the type of the declaration (if it has a type).
Douglas Gregor6f942b22010-09-21 16:06:22 +00001992 QualType T;
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00001993 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(ND))
1994 T = Function->getResultType();
1995 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND))
1996 T = Method->getResultType();
1997 else if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND))
1998 T = FunTmpl->getTemplatedDecl()->getResultType();
1999 else if (EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
2000 T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2001 else if (isa<UnresolvedUsingValueDecl>(ND)) {
2002 /* Do nothing: ignore unresolved using declarations*/
John McCallf85e1932011-06-15 23:02:42 +00002003 } else if (ValueDecl *Value = dyn_cast<ValueDecl>(ND)) {
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00002004 T = Value->getType();
John McCallf85e1932011-06-15 23:02:42 +00002005 } else if (ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND))
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00002006 T = Property->getType();
2007
2008 if (T.isNull() || Context.hasSameType(T, Context.DependentTy))
2009 return;
2010
Douglas Gregor8987b232011-09-27 23:30:47 +00002011 Result.AddResultTypeChunk(GetCompletionTypeString(T, Context, Policy,
Douglas Gregora63f6de2011-02-01 21:15:40 +00002012 Result.getAllocator()));
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00002013}
2014
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002015static void MaybeAddSentinel(ASTContext &Context, NamedDecl *FunctionOrMethod,
Douglas Gregor218937c2011-02-01 19:23:04 +00002016 CodeCompletionBuilder &Result) {
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002017 if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>())
2018 if (Sentinel->getSentinel() == 0) {
David Blaikie4e4d0842012-03-11 07:00:24 +00002019 if (Context.getLangOpts().ObjC1 &&
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002020 Context.Idents.get("nil").hasMacroDefinition())
Douglas Gregor218937c2011-02-01 19:23:04 +00002021 Result.AddTextChunk(", nil");
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002022 else if (Context.Idents.get("NULL").hasMacroDefinition())
Douglas Gregor218937c2011-02-01 19:23:04 +00002023 Result.AddTextChunk(", NULL");
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002024 else
Douglas Gregor218937c2011-02-01 19:23:04 +00002025 Result.AddTextChunk(", (void*)0");
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002026 }
2027}
2028
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002029static std::string formatObjCParamQualifiers(unsigned ObjCQuals) {
2030 std::string Result;
2031 if (ObjCQuals & Decl::OBJC_TQ_In)
Douglas Gregor6ef92092011-11-09 02:13:45 +00002032 Result += "in ";
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002033 else if (ObjCQuals & Decl::OBJC_TQ_Inout)
Douglas Gregor6ef92092011-11-09 02:13:45 +00002034 Result += "inout ";
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002035 else if (ObjCQuals & Decl::OBJC_TQ_Out)
Douglas Gregor6ef92092011-11-09 02:13:45 +00002036 Result += "out ";
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002037 if (ObjCQuals & Decl::OBJC_TQ_Bycopy)
Douglas Gregor6ef92092011-11-09 02:13:45 +00002038 Result += "bycopy ";
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002039 else if (ObjCQuals & Decl::OBJC_TQ_Byref)
Douglas Gregor6ef92092011-11-09 02:13:45 +00002040 Result += "byref ";
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002041 if (ObjCQuals & Decl::OBJC_TQ_Oneway)
Douglas Gregor6ef92092011-11-09 02:13:45 +00002042 Result += "oneway ";
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002043 return Result;
2044}
2045
Douglas Gregor83482d12010-08-24 16:15:59 +00002046static std::string FormatFunctionParameter(ASTContext &Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00002047 const PrintingPolicy &Policy,
Douglas Gregoraba48082010-08-29 19:47:46 +00002048 ParmVarDecl *Param,
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002049 bool SuppressName = false,
2050 bool SuppressBlock = false) {
Douglas Gregor83482d12010-08-24 16:15:59 +00002051 bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
2052 if (Param->getType()->isDependentType() ||
2053 !Param->getType()->isBlockPointerType()) {
2054 // The argument for a dependent or non-block parameter is a placeholder
2055 // containing that parameter's type.
2056 std::string Result;
2057
Douglas Gregoraba48082010-08-29 19:47:46 +00002058 if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
Douglas Gregor83482d12010-08-24 16:15:59 +00002059 Result = Param->getIdentifier()->getName();
2060
John McCallf85e1932011-06-15 23:02:42 +00002061 Param->getType().getAsStringInternal(Result, Policy);
Douglas Gregor83482d12010-08-24 16:15:59 +00002062
2063 if (ObjCMethodParam) {
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002064 Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier())
2065 + Result + ")";
Douglas Gregoraba48082010-08-29 19:47:46 +00002066 if (Param->getIdentifier() && !SuppressName)
Douglas Gregor83482d12010-08-24 16:15:59 +00002067 Result += Param->getIdentifier()->getName();
2068 }
2069 return Result;
2070 }
2071
2072 // The argument for a block pointer parameter is a block literal with
2073 // the appropriate type.
Douglas Gregor830072c2011-02-15 22:37:09 +00002074 FunctionTypeLoc *Block = 0;
2075 FunctionProtoTypeLoc *BlockProto = 0;
Douglas Gregor83482d12010-08-24 16:15:59 +00002076 TypeLoc TL;
2077 if (TypeSourceInfo *TSInfo = Param->getTypeSourceInfo()) {
2078 TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
2079 while (true) {
2080 // Look through typedefs.
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002081 if (!SuppressBlock) {
2082 if (TypedefTypeLoc *TypedefTL = dyn_cast<TypedefTypeLoc>(&TL)) {
2083 if (TypeSourceInfo *InnerTSInfo
2084 = TypedefTL->getTypedefNameDecl()->getTypeSourceInfo()) {
2085 TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc();
2086 continue;
2087 }
2088 }
2089
2090 // Look through qualified types
2091 if (QualifiedTypeLoc *QualifiedTL = dyn_cast<QualifiedTypeLoc>(&TL)) {
2092 TL = QualifiedTL->getUnqualifiedLoc();
Douglas Gregor83482d12010-08-24 16:15:59 +00002093 continue;
2094 }
2095 }
2096
Douglas Gregor83482d12010-08-24 16:15:59 +00002097 // Try to get the function prototype behind the block pointer type,
2098 // then we're done.
2099 if (BlockPointerTypeLoc *BlockPtr
2100 = dyn_cast<BlockPointerTypeLoc>(&TL)) {
Abramo Bagnara723df242010-12-14 22:11:44 +00002101 TL = BlockPtr->getPointeeLoc().IgnoreParens();
Douglas Gregor830072c2011-02-15 22:37:09 +00002102 Block = dyn_cast<FunctionTypeLoc>(&TL);
2103 BlockProto = dyn_cast<FunctionProtoTypeLoc>(&TL);
Douglas Gregor83482d12010-08-24 16:15:59 +00002104 }
2105 break;
2106 }
2107 }
2108
2109 if (!Block) {
2110 // We were unable to find a FunctionProtoTypeLoc with parameter names
2111 // for the block; just use the parameter type as a placeholder.
2112 std::string Result;
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002113 if (!ObjCMethodParam && Param->getIdentifier())
2114 Result = Param->getIdentifier()->getName();
2115
John McCallf85e1932011-06-15 23:02:42 +00002116 Param->getType().getUnqualifiedType().getAsStringInternal(Result, Policy);
Douglas Gregor83482d12010-08-24 16:15:59 +00002117
2118 if (ObjCMethodParam) {
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002119 Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier())
2120 + Result + ")";
Douglas Gregor83482d12010-08-24 16:15:59 +00002121 if (Param->getIdentifier())
2122 Result += Param->getIdentifier()->getName();
2123 }
2124
2125 return Result;
2126 }
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002127
Douglas Gregor83482d12010-08-24 16:15:59 +00002128 // We have the function prototype behind the block pointer type, as it was
2129 // written in the source.
Douglas Gregor38276252010-09-08 22:47:51 +00002130 std::string Result;
2131 QualType ResultType = Block->getTypePtr()->getResultType();
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002132 if (!ResultType->isVoidType() || SuppressBlock)
John McCallf85e1932011-06-15 23:02:42 +00002133 ResultType.getAsStringInternal(Result, Policy);
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002134
2135 // Format the parameter list.
2136 std::string Params;
Douglas Gregor830072c2011-02-15 22:37:09 +00002137 if (!BlockProto || Block->getNumArgs() == 0) {
2138 if (BlockProto && BlockProto->getTypePtr()->isVariadic())
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002139 Params = "(...)";
Douglas Gregorc2760bc2010-10-02 23:49:58 +00002140 else
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002141 Params = "(void)";
Douglas Gregor38276252010-09-08 22:47:51 +00002142 } else {
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002143 Params += "(";
Douglas Gregor38276252010-09-08 22:47:51 +00002144 for (unsigned I = 0, N = Block->getNumArgs(); I != N; ++I) {
2145 if (I)
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002146 Params += ", ";
2147 Params += FormatFunctionParameter(Context, Policy, Block->getArg(I),
2148 /*SuppressName=*/false,
2149 /*SuppressBlock=*/true);
Douglas Gregor38276252010-09-08 22:47:51 +00002150
Douglas Gregor830072c2011-02-15 22:37:09 +00002151 if (I == N - 1 && BlockProto->getTypePtr()->isVariadic())
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002152 Params += ", ...";
Douglas Gregor38276252010-09-08 22:47:51 +00002153 }
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002154 Params += ")";
Douglas Gregore17794f2010-08-31 05:13:43 +00002155 }
Douglas Gregor38276252010-09-08 22:47:51 +00002156
Douglas Gregoree1c68a2011-10-18 04:23:19 +00002157 if (SuppressBlock) {
2158 // Format as a parameter.
2159 Result = Result + " (^";
2160 if (Param->getIdentifier())
2161 Result += Param->getIdentifier()->getName();
2162 Result += ")";
2163 Result += Params;
2164 } else {
2165 // Format as a block literal argument.
2166 Result = '^' + Result;
2167 Result += Params;
2168
2169 if (Param->getIdentifier())
2170 Result += Param->getIdentifier()->getName();
2171 }
2172
Douglas Gregor83482d12010-08-24 16:15:59 +00002173 return Result;
2174}
2175
Douglas Gregor86d9a522009-09-21 16:56:56 +00002176/// \brief Add function parameter chunks to the given code completion string.
2177static void AddFunctionParameterChunks(ASTContext &Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00002178 const PrintingPolicy &Policy,
Douglas Gregor86d9a522009-09-21 16:56:56 +00002179 FunctionDecl *Function,
Douglas Gregor218937c2011-02-01 19:23:04 +00002180 CodeCompletionBuilder &Result,
2181 unsigned Start = 0,
2182 bool InOptional = false) {
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002183 typedef CodeCompletionString::Chunk Chunk;
Douglas Gregor218937c2011-02-01 19:23:04 +00002184 bool FirstParameter = true;
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002185
Douglas Gregor218937c2011-02-01 19:23:04 +00002186 for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
Douglas Gregor86d9a522009-09-21 16:56:56 +00002187 ParmVarDecl *Param = Function->getParamDecl(P);
2188
Douglas Gregor218937c2011-02-01 19:23:04 +00002189 if (Param->hasDefaultArg() && !InOptional) {
Douglas Gregor86d9a522009-09-21 16:56:56 +00002190 // When we see an optional default argument, put that argument and
2191 // the remaining default arguments into a new, optional string.
Douglas Gregor218937c2011-02-01 19:23:04 +00002192 CodeCompletionBuilder Opt(Result.getAllocator());
2193 if (!FirstParameter)
2194 Opt.AddChunk(Chunk(CodeCompletionString::CK_Comma));
Douglas Gregor8987b232011-09-27 23:30:47 +00002195 AddFunctionParameterChunks(Context, Policy, Function, Opt, P, true);
Douglas Gregor218937c2011-02-01 19:23:04 +00002196 Result.AddOptionalChunk(Opt.TakeString());
2197 break;
Douglas Gregor86d9a522009-09-21 16:56:56 +00002198 }
2199
Douglas Gregor218937c2011-02-01 19:23:04 +00002200 if (FirstParameter)
2201 FirstParameter = false;
2202 else
2203 Result.AddChunk(Chunk(CodeCompletionString::CK_Comma));
2204
2205 InOptional = false;
Douglas Gregor86d9a522009-09-21 16:56:56 +00002206
2207 // Format the placeholder string.
Douglas Gregor8987b232011-09-27 23:30:47 +00002208 std::string PlaceholderStr = FormatFunctionParameter(Context, Policy,
2209 Param);
Douglas Gregor83482d12010-08-24 16:15:59 +00002210
Douglas Gregore17794f2010-08-31 05:13:43 +00002211 if (Function->isVariadic() && P == N - 1)
2212 PlaceholderStr += ", ...";
2213
Douglas Gregor86d9a522009-09-21 16:56:56 +00002214 // Add the placeholder string.
Douglas Gregordae68752011-02-01 22:57:45 +00002215 Result.AddPlaceholderChunk(
2216 Result.getAllocator().CopyString(PlaceholderStr));
Douglas Gregor86d9a522009-09-21 16:56:56 +00002217 }
Douglas Gregorb3d45252009-09-22 21:42:17 +00002218
2219 if (const FunctionProtoType *Proto
2220 = Function->getType()->getAs<FunctionProtoType>())
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002221 if (Proto->isVariadic()) {
Douglas Gregore17794f2010-08-31 05:13:43 +00002222 if (Proto->getNumArgs() == 0)
Douglas Gregor218937c2011-02-01 19:23:04 +00002223 Result.AddPlaceholderChunk("...");
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002224
Douglas Gregor218937c2011-02-01 19:23:04 +00002225 MaybeAddSentinel(Context, Function, Result);
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002226 }
Douglas Gregor86d9a522009-09-21 16:56:56 +00002227}
2228
2229/// \brief Add template parameter chunks to the given code completion string.
2230static void AddTemplateParameterChunks(ASTContext &Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00002231 const PrintingPolicy &Policy,
Douglas Gregor86d9a522009-09-21 16:56:56 +00002232 TemplateDecl *Template,
Douglas Gregor218937c2011-02-01 19:23:04 +00002233 CodeCompletionBuilder &Result,
2234 unsigned MaxParameters = 0,
2235 unsigned Start = 0,
2236 bool InDefaultArg = false) {
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002237 typedef CodeCompletionString::Chunk Chunk;
Douglas Gregor86d9a522009-09-21 16:56:56 +00002238 bool FirstParameter = true;
2239
2240 TemplateParameterList *Params = Template->getTemplateParameters();
2241 TemplateParameterList::iterator PEnd = Params->end();
2242 if (MaxParameters)
2243 PEnd = Params->begin() + MaxParameters;
Douglas Gregor218937c2011-02-01 19:23:04 +00002244 for (TemplateParameterList::iterator P = Params->begin() + Start;
2245 P != PEnd; ++P) {
Douglas Gregor86d9a522009-09-21 16:56:56 +00002246 bool HasDefaultArg = false;
2247 std::string PlaceholderStr;
2248 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
2249 if (TTP->wasDeclaredWithTypename())
2250 PlaceholderStr = "typename";
2251 else
2252 PlaceholderStr = "class";
2253
2254 if (TTP->getIdentifier()) {
2255 PlaceholderStr += ' ';
2256 PlaceholderStr += TTP->getIdentifier()->getName();
2257 }
2258
2259 HasDefaultArg = TTP->hasDefaultArgument();
2260 } else if (NonTypeTemplateParmDecl *NTTP
Douglas Gregor218937c2011-02-01 19:23:04 +00002261 = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
Douglas Gregor86d9a522009-09-21 16:56:56 +00002262 if (NTTP->getIdentifier())
2263 PlaceholderStr = NTTP->getIdentifier()->getName();
John McCallf85e1932011-06-15 23:02:42 +00002264 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
Douglas Gregor86d9a522009-09-21 16:56:56 +00002265 HasDefaultArg = NTTP->hasDefaultArgument();
2266 } else {
2267 assert(isa<TemplateTemplateParmDecl>(*P));
2268 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
2269
2270 // Since putting the template argument list into the placeholder would
2271 // be very, very long, we just use an abbreviation.
2272 PlaceholderStr = "template<...> class";
2273 if (TTP->getIdentifier()) {
2274 PlaceholderStr += ' ';
2275 PlaceholderStr += TTP->getIdentifier()->getName();
2276 }
2277
2278 HasDefaultArg = TTP->hasDefaultArgument();
2279 }
2280
Douglas Gregor218937c2011-02-01 19:23:04 +00002281 if (HasDefaultArg && !InDefaultArg) {
Douglas Gregor86d9a522009-09-21 16:56:56 +00002282 // When we see an optional default argument, put that argument and
2283 // the remaining default arguments into a new, optional string.
Douglas Gregor218937c2011-02-01 19:23:04 +00002284 CodeCompletionBuilder Opt(Result.getAllocator());
2285 if (!FirstParameter)
2286 Opt.AddChunk(Chunk(CodeCompletionString::CK_Comma));
Douglas Gregor8987b232011-09-27 23:30:47 +00002287 AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
Douglas Gregor218937c2011-02-01 19:23:04 +00002288 P - Params->begin(), true);
2289 Result.AddOptionalChunk(Opt.TakeString());
2290 break;
Douglas Gregor86d9a522009-09-21 16:56:56 +00002291 }
2292
Douglas Gregor218937c2011-02-01 19:23:04 +00002293 InDefaultArg = false;
2294
Douglas Gregor86d9a522009-09-21 16:56:56 +00002295 if (FirstParameter)
2296 FirstParameter = false;
2297 else
Douglas Gregor218937c2011-02-01 19:23:04 +00002298 Result.AddChunk(Chunk(CodeCompletionString::CK_Comma));
Douglas Gregor86d9a522009-09-21 16:56:56 +00002299
2300 // Add the placeholder string.
Douglas Gregordae68752011-02-01 22:57:45 +00002301 Result.AddPlaceholderChunk(
2302 Result.getAllocator().CopyString(PlaceholderStr));
Douglas Gregor86d9a522009-09-21 16:56:56 +00002303 }
2304}
2305
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00002306/// \brief Add a qualifier to the given code-completion string, if the
2307/// provided nested-name-specifier is non-NULL.
Douglas Gregora61a8792009-12-11 18:44:16 +00002308static void
Douglas Gregor218937c2011-02-01 19:23:04 +00002309AddQualifierToCompletionString(CodeCompletionBuilder &Result,
Douglas Gregora61a8792009-12-11 18:44:16 +00002310 NestedNameSpecifier *Qualifier,
2311 bool QualifierIsInformative,
Douglas Gregor8987b232011-09-27 23:30:47 +00002312 ASTContext &Context,
2313 const PrintingPolicy &Policy) {
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00002314 if (!Qualifier)
2315 return;
2316
2317 std::string PrintedNNS;
2318 {
2319 llvm::raw_string_ostream OS(PrintedNNS);
Douglas Gregor8987b232011-09-27 23:30:47 +00002320 Qualifier->print(OS, Policy);
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00002321 }
Douglas Gregor0563c262009-09-22 23:15:58 +00002322 if (QualifierIsInformative)
Douglas Gregordae68752011-02-01 22:57:45 +00002323 Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
Douglas Gregor0563c262009-09-22 23:15:58 +00002324 else
Douglas Gregordae68752011-02-01 22:57:45 +00002325 Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00002326}
2327
Douglas Gregor218937c2011-02-01 19:23:04 +00002328static void
2329AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result,
2330 FunctionDecl *Function) {
Douglas Gregora61a8792009-12-11 18:44:16 +00002331 const FunctionProtoType *Proto
2332 = Function->getType()->getAs<FunctionProtoType>();
2333 if (!Proto || !Proto->getTypeQuals())
2334 return;
2335
Douglas Gregora63f6de2011-02-01 21:15:40 +00002336 // FIXME: Add ref-qualifier!
2337
2338 // Handle single qualifiers without copying
2339 if (Proto->getTypeQuals() == Qualifiers::Const) {
2340 Result.AddInformativeChunk(" const");
2341 return;
2342 }
2343
2344 if (Proto->getTypeQuals() == Qualifiers::Volatile) {
2345 Result.AddInformativeChunk(" volatile");
2346 return;
2347 }
2348
2349 if (Proto->getTypeQuals() == Qualifiers::Restrict) {
2350 Result.AddInformativeChunk(" restrict");
2351 return;
2352 }
2353
2354 // Handle multiple qualifiers.
Douglas Gregora61a8792009-12-11 18:44:16 +00002355 std::string QualsStr;
2356 if (Proto->getTypeQuals() & Qualifiers::Const)
2357 QualsStr += " const";
2358 if (Proto->getTypeQuals() & Qualifiers::Volatile)
2359 QualsStr += " volatile";
2360 if (Proto->getTypeQuals() & Qualifiers::Restrict)
2361 QualsStr += " restrict";
Douglas Gregordae68752011-02-01 22:57:45 +00002362 Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
Douglas Gregora61a8792009-12-11 18:44:16 +00002363}
2364
Douglas Gregor6f942b22010-09-21 16:06:22 +00002365/// \brief Add the name of the given declaration
Douglas Gregor8987b232011-09-27 23:30:47 +00002366static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
2367 NamedDecl *ND, CodeCompletionBuilder &Result) {
Douglas Gregor6f942b22010-09-21 16:06:22 +00002368 typedef CodeCompletionString::Chunk Chunk;
2369
2370 DeclarationName Name = ND->getDeclName();
2371 if (!Name)
2372 return;
2373
2374 switch (Name.getNameKind()) {
Douglas Gregora63f6de2011-02-01 21:15:40 +00002375 case DeclarationName::CXXOperatorName: {
2376 const char *OperatorName = 0;
2377 switch (Name.getCXXOverloadedOperator()) {
2378 case OO_None:
2379 case OO_Conditional:
2380 case NUM_OVERLOADED_OPERATORS:
2381 OperatorName = "operator";
2382 break;
2383
2384#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2385 case OO_##Name: OperatorName = "operator" Spelling; break;
2386#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2387#include "clang/Basic/OperatorKinds.def"
2388
2389 case OO_New: OperatorName = "operator new"; break;
2390 case OO_Delete: OperatorName = "operator delete"; break;
2391 case OO_Array_New: OperatorName = "operator new[]"; break;
2392 case OO_Array_Delete: OperatorName = "operator delete[]"; break;
2393 case OO_Call: OperatorName = "operator()"; break;
2394 case OO_Subscript: OperatorName = "operator[]"; break;
2395 }
2396 Result.AddTypedTextChunk(OperatorName);
2397 break;
2398 }
2399
Douglas Gregor6f942b22010-09-21 16:06:22 +00002400 case DeclarationName::Identifier:
2401 case DeclarationName::CXXConversionFunctionName:
Douglas Gregor6f942b22010-09-21 16:06:22 +00002402 case DeclarationName::CXXDestructorName:
2403 case DeclarationName::CXXLiteralOperatorName:
Douglas Gregordae68752011-02-01 22:57:45 +00002404 Result.AddTypedTextChunk(
2405 Result.getAllocator().CopyString(ND->getNameAsString()));
Douglas Gregor6f942b22010-09-21 16:06:22 +00002406 break;
2407
2408 case DeclarationName::CXXUsingDirective:
2409 case DeclarationName::ObjCZeroArgSelector:
2410 case DeclarationName::ObjCOneArgSelector:
2411 case DeclarationName::ObjCMultiArgSelector:
2412 break;
2413
2414 case DeclarationName::CXXConstructorName: {
2415 CXXRecordDecl *Record = 0;
2416 QualType Ty = Name.getCXXNameType();
2417 if (const RecordType *RecordTy = Ty->getAs<RecordType>())
2418 Record = cast<CXXRecordDecl>(RecordTy->getDecl());
2419 else if (const InjectedClassNameType *InjectedTy
2420 = Ty->getAs<InjectedClassNameType>())
2421 Record = InjectedTy->getDecl();
2422 else {
Douglas Gregordae68752011-02-01 22:57:45 +00002423 Result.AddTypedTextChunk(
2424 Result.getAllocator().CopyString(ND->getNameAsString()));
Douglas Gregor6f942b22010-09-21 16:06:22 +00002425 break;
2426 }
2427
Douglas Gregordae68752011-02-01 22:57:45 +00002428 Result.AddTypedTextChunk(
2429 Result.getAllocator().CopyString(Record->getNameAsString()));
Douglas Gregor6f942b22010-09-21 16:06:22 +00002430 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
Douglas Gregor218937c2011-02-01 19:23:04 +00002431 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftAngle));
Douglas Gregor8987b232011-09-27 23:30:47 +00002432 AddTemplateParameterChunks(Context, Policy, Template, Result);
Douglas Gregor218937c2011-02-01 19:23:04 +00002433 Result.AddChunk(Chunk(CodeCompletionString::CK_RightAngle));
Douglas Gregor6f942b22010-09-21 16:06:22 +00002434 }
2435 break;
2436 }
2437 }
2438}
2439
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002440CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(Sema &S,
2441 CodeCompletionAllocator &Allocator) {
2442 return CreateCodeCompletionString(S.Context, S.PP, Allocator);
2443}
2444
Douglas Gregor86d9a522009-09-21 16:56:56 +00002445/// \brief If possible, create a new code completion string for the given
2446/// result.
2447///
2448/// \returns Either a new, heap-allocated code completion string describing
2449/// how to use this result, or NULL to indicate that the string or name of the
2450/// result is all that is needed.
2451CodeCompletionString *
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002452CodeCompletionResult::CreateCodeCompletionString(ASTContext &Ctx,
2453 Preprocessor &PP,
Douglas Gregordae68752011-02-01 22:57:45 +00002454 CodeCompletionAllocator &Allocator) {
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002455 typedef CodeCompletionString::Chunk Chunk;
Douglas Gregor218937c2011-02-01 19:23:04 +00002456 CodeCompletionBuilder Result(Allocator, Priority, Availability);
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002457
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002458 PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
Douglas Gregor218937c2011-02-01 19:23:04 +00002459 if (Kind == RK_Pattern) {
2460 Pattern->Priority = Priority;
2461 Pattern->Availability = Availability;
2462 return Pattern;
2463 }
Douglas Gregor2b4074f2009-12-01 05:55:20 +00002464
Douglas Gregor2b4074f2009-12-01 05:55:20 +00002465 if (Kind == RK_Keyword) {
Douglas Gregor218937c2011-02-01 19:23:04 +00002466 Result.AddTypedTextChunk(Keyword);
2467 return Result.TakeString();
Douglas Gregor2b4074f2009-12-01 05:55:20 +00002468 }
Douglas Gregor86d9a522009-09-21 16:56:56 +00002469
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002470 if (Kind == RK_Macro) {
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002471 MacroInfo *MI = PP.getMacroInfo(Macro);
Douglas Gregor2b4074f2009-12-01 05:55:20 +00002472 assert(MI && "Not a macro?");
2473
Douglas Gregordae68752011-02-01 22:57:45 +00002474 Result.AddTypedTextChunk(
2475 Result.getAllocator().CopyString(Macro->getName()));
Douglas Gregor2b4074f2009-12-01 05:55:20 +00002476
2477 if (!MI->isFunctionLike())
Douglas Gregor218937c2011-02-01 19:23:04 +00002478 return Result.TakeString();
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002479
2480 // Format a function-like macro with placeholders for the arguments.
Douglas Gregor218937c2011-02-01 19:23:04 +00002481 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftParen));
Douglas Gregore4244702011-07-30 08:17:44 +00002482 MacroInfo::arg_iterator A = MI->arg_begin(), AEnd = MI->arg_end();
Douglas Gregorc8dc1352012-01-21 00:43:38 +00002483
2484 // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
2485 if (MI->isC99Varargs()) {
2486 --AEnd;
2487
2488 if (A == AEnd) {
2489 Result.AddPlaceholderChunk("...");
2490 }
Douglas Gregore4244702011-07-30 08:17:44 +00002491 }
Douglas Gregorc8dc1352012-01-21 00:43:38 +00002492
Douglas Gregore4244702011-07-30 08:17:44 +00002493 for (MacroInfo::arg_iterator A = MI->arg_begin(); A != AEnd; ++A) {
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002494 if (A != MI->arg_begin())
Douglas Gregor218937c2011-02-01 19:23:04 +00002495 Result.AddChunk(Chunk(CodeCompletionString::CK_Comma));
Douglas Gregorc8dc1352012-01-21 00:43:38 +00002496
2497 if (MI->isVariadic() && (A+1) == AEnd) {
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00002498 SmallString<32> Arg = (*A)->getName();
Douglas Gregorc8dc1352012-01-21 00:43:38 +00002499 if (MI->isC99Varargs())
2500 Arg += ", ...";
2501 else
2502 Arg += "...";
Douglas Gregordae68752011-02-01 22:57:45 +00002503 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
Douglas Gregorc8dc1352012-01-21 00:43:38 +00002504 break;
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002505 }
Douglas Gregorc8dc1352012-01-21 00:43:38 +00002506
2507 // Non-variadic macros are simple.
2508 Result.AddPlaceholderChunk(
2509 Result.getAllocator().CopyString((*A)->getName()));
Douglas Gregore4244702011-07-30 08:17:44 +00002510 }
Douglas Gregor218937c2011-02-01 19:23:04 +00002511 Result.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
2512 return Result.TakeString();
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002513 }
2514
Douglas Gregord8e8a582010-05-25 21:41:55 +00002515 assert(Kind == RK_Declaration && "Missed a result kind?");
Douglas Gregor86d9a522009-09-21 16:56:56 +00002516 NamedDecl *ND = Declaration;
2517
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002518 if (StartsNestedNameSpecifier) {
Douglas Gregordae68752011-02-01 22:57:45 +00002519 Result.AddTypedTextChunk(
2520 Result.getAllocator().CopyString(ND->getNameAsString()));
Douglas Gregor218937c2011-02-01 19:23:04 +00002521 Result.AddTextChunk("::");
2522 return Result.TakeString();
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002523 }
Erik Verbruggen6164ea12011-10-14 15:31:08 +00002524
2525 for (Decl::attr_iterator i = ND->attr_begin(); i != ND->attr_end(); ++i) {
2526 if (AnnotateAttr *Attr = dyn_cast_or_null<AnnotateAttr>(*i)) {
2527 Result.AddAnnotation(Result.getAllocator().CopyString(Attr->getAnnotation()));
2528 }
2529 }
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002530
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002531 AddResultTypeChunk(Ctx, Policy, ND, Result);
Douglas Gregorff5ce6e2009-12-18 18:53:37 +00002532
Douglas Gregor86d9a522009-09-21 16:56:56 +00002533 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) {
Douglas Gregor0563c262009-09-22 23:15:58 +00002534 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002535 Ctx, Policy);
2536 AddTypedNameChunk(Ctx, Policy, ND, Result);
Douglas Gregor218937c2011-02-01 19:23:04 +00002537 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftParen));
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002538 AddFunctionParameterChunks(Ctx, Policy, Function, Result);
Douglas Gregor218937c2011-02-01 19:23:04 +00002539 Result.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
Douglas Gregora61a8792009-12-11 18:44:16 +00002540 AddFunctionTypeQualsToCompletionString(Result, Function);
Douglas Gregor218937c2011-02-01 19:23:04 +00002541 return Result.TakeString();
Douglas Gregor86d9a522009-09-21 16:56:56 +00002542 }
2543
2544 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) {
Douglas Gregor0563c262009-09-22 23:15:58 +00002545 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002546 Ctx, Policy);
Douglas Gregor86d9a522009-09-21 16:56:56 +00002547 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002548 AddTypedNameChunk(Ctx, Policy, Function, Result);
Douglas Gregor6f942b22010-09-21 16:06:22 +00002549
Douglas Gregor86d9a522009-09-21 16:56:56 +00002550 // Figure out which template parameters are deduced (or have default
2551 // arguments).
Benjamin Kramer013b3662012-01-30 16:17:39 +00002552 llvm::SmallBitVector Deduced;
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002553 Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
Douglas Gregor86d9a522009-09-21 16:56:56 +00002554 unsigned LastDeducibleArgument;
2555 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
2556 --LastDeducibleArgument) {
2557 if (!Deduced[LastDeducibleArgument - 1]) {
2558 // C++0x: Figure out if the template argument has a default. If so,
2559 // the user doesn't need to type this argument.
2560 // FIXME: We need to abstract template parameters better!
2561 bool HasDefaultArg = false;
2562 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
Douglas Gregor218937c2011-02-01 19:23:04 +00002563 LastDeducibleArgument - 1);
Douglas Gregor86d9a522009-09-21 16:56:56 +00002564 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
2565 HasDefaultArg = TTP->hasDefaultArgument();
2566 else if (NonTypeTemplateParmDecl *NTTP
2567 = dyn_cast<NonTypeTemplateParmDecl>(Param))
2568 HasDefaultArg = NTTP->hasDefaultArgument();
2569 else {
2570 assert(isa<TemplateTemplateParmDecl>(Param));
2571 HasDefaultArg
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002572 = cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
Douglas Gregor86d9a522009-09-21 16:56:56 +00002573 }
2574
2575 if (!HasDefaultArg)
2576 break;
2577 }
2578 }
2579
2580 if (LastDeducibleArgument) {
2581 // Some of the function template arguments cannot be deduced from a
2582 // function call, so we introduce an explicit template argument list
2583 // containing all of the arguments up to the first deducible argument.
Douglas Gregor218937c2011-02-01 19:23:04 +00002584 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftAngle));
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002585 AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
Douglas Gregor86d9a522009-09-21 16:56:56 +00002586 LastDeducibleArgument);
Douglas Gregor218937c2011-02-01 19:23:04 +00002587 Result.AddChunk(Chunk(CodeCompletionString::CK_RightAngle));
Douglas Gregor86d9a522009-09-21 16:56:56 +00002588 }
2589
2590 // Add the function parameters
Douglas Gregor218937c2011-02-01 19:23:04 +00002591 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftParen));
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002592 AddFunctionParameterChunks(Ctx, Policy, Function, Result);
Douglas Gregor218937c2011-02-01 19:23:04 +00002593 Result.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
Douglas Gregora61a8792009-12-11 18:44:16 +00002594 AddFunctionTypeQualsToCompletionString(Result, Function);
Douglas Gregor218937c2011-02-01 19:23:04 +00002595 return Result.TakeString();
Douglas Gregor86d9a522009-09-21 16:56:56 +00002596 }
2597
2598 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(ND)) {
Douglas Gregor0563c262009-09-22 23:15:58 +00002599 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002600 Ctx, Policy);
Douglas Gregordae68752011-02-01 22:57:45 +00002601 Result.AddTypedTextChunk(
2602 Result.getAllocator().CopyString(Template->getNameAsString()));
Douglas Gregor218937c2011-02-01 19:23:04 +00002603 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftAngle));
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002604 AddTemplateParameterChunks(Ctx, Policy, Template, Result);
Douglas Gregor218937c2011-02-01 19:23:04 +00002605 Result.AddChunk(Chunk(CodeCompletionString::CK_RightAngle));
2606 return Result.TakeString();
Douglas Gregor86d9a522009-09-21 16:56:56 +00002607 }
2608
Douglas Gregor9630eb62009-11-17 16:44:22 +00002609 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
Douglas Gregor9630eb62009-11-17 16:44:22 +00002610 Selector Sel = Method->getSelector();
2611 if (Sel.isUnarySelector()) {
Douglas Gregordae68752011-02-01 22:57:45 +00002612 Result.AddTypedTextChunk(Result.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00002613 Sel.getNameForSlot(0)));
Douglas Gregor218937c2011-02-01 19:23:04 +00002614 return Result.TakeString();
Douglas Gregor9630eb62009-11-17 16:44:22 +00002615 }
2616
Douglas Gregor813d8342011-02-18 22:29:55 +00002617 std::string SelName = Sel.getNameForSlot(0).str();
Douglas Gregord3c68542009-11-19 01:08:35 +00002618 SelName += ':';
2619 if (StartParameter == 0)
Douglas Gregordae68752011-02-01 22:57:45 +00002620 Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
Douglas Gregord3c68542009-11-19 01:08:35 +00002621 else {
Douglas Gregordae68752011-02-01 22:57:45 +00002622 Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
Douglas Gregord3c68542009-11-19 01:08:35 +00002623
2624 // If there is only one parameter, and we're past it, add an empty
2625 // typed-text chunk since there is nothing to type.
2626 if (Method->param_size() == 1)
Douglas Gregor218937c2011-02-01 19:23:04 +00002627 Result.AddTypedTextChunk("");
Douglas Gregord3c68542009-11-19 01:08:35 +00002628 }
Douglas Gregor9630eb62009-11-17 16:44:22 +00002629 unsigned Idx = 0;
2630 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
2631 PEnd = Method->param_end();
2632 P != PEnd; (void)++P, ++Idx) {
2633 if (Idx > 0) {
Douglas Gregord3c68542009-11-19 01:08:35 +00002634 std::string Keyword;
2635 if (Idx > StartParameter)
Douglas Gregor218937c2011-02-01 19:23:04 +00002636 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
Douglas Gregor9630eb62009-11-17 16:44:22 +00002637 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
Benjamin Kramera0651c52011-07-26 16:59:25 +00002638 Keyword += II->getName();
Douglas Gregor9630eb62009-11-17 16:44:22 +00002639 Keyword += ":";
Douglas Gregor1f5537a2010-07-08 23:20:03 +00002640 if (Idx < StartParameter || AllParametersAreInformative)
Douglas Gregordae68752011-02-01 22:57:45 +00002641 Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
Douglas Gregorc7b7b7a2010-10-18 21:05:04 +00002642 else
Douglas Gregordae68752011-02-01 22:57:45 +00002643 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
Douglas Gregor9630eb62009-11-17 16:44:22 +00002644 }
Douglas Gregord3c68542009-11-19 01:08:35 +00002645
2646 // If we're before the starting parameter, skip the placeholder.
2647 if (Idx < StartParameter)
2648 continue;
Douglas Gregor9630eb62009-11-17 16:44:22 +00002649
2650 std::string Arg;
Douglas Gregor83482d12010-08-24 16:15:59 +00002651
2652 if ((*P)->getType()->isBlockPointerType() && !DeclaringEntity)
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002653 Arg = FormatFunctionParameter(Ctx, Policy, *P, true);
Douglas Gregor83482d12010-08-24 16:15:59 +00002654 else {
John McCallf85e1932011-06-15 23:02:42 +00002655 (*P)->getType().getAsStringInternal(Arg, Policy);
Douglas Gregor6fa14dd2011-07-30 07:55:26 +00002656 Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier())
2657 + Arg + ")";
Douglas Gregor83482d12010-08-24 16:15:59 +00002658 if (IdentifierInfo *II = (*P)->getIdentifier())
Douglas Gregoraba48082010-08-29 19:47:46 +00002659 if (DeclaringEntity || AllParametersAreInformative)
Benjamin Kramera0651c52011-07-26 16:59:25 +00002660 Arg += II->getName();
Douglas Gregor83482d12010-08-24 16:15:59 +00002661 }
2662
Douglas Gregore17794f2010-08-31 05:13:43 +00002663 if (Method->isVariadic() && (P + 1) == PEnd)
2664 Arg += ", ...";
2665
Douglas Gregor1f5537a2010-07-08 23:20:03 +00002666 if (DeclaringEntity)
Douglas Gregordae68752011-02-01 22:57:45 +00002667 Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
Douglas Gregor1f5537a2010-07-08 23:20:03 +00002668 else if (AllParametersAreInformative)
Douglas Gregordae68752011-02-01 22:57:45 +00002669 Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
Douglas Gregor4ad96852009-11-19 07:41:15 +00002670 else
Douglas Gregordae68752011-02-01 22:57:45 +00002671 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
Douglas Gregor9630eb62009-11-17 16:44:22 +00002672 }
2673
Douglas Gregor2a17af02009-12-23 00:21:46 +00002674 if (Method->isVariadic()) {
Douglas Gregore17794f2010-08-31 05:13:43 +00002675 if (Method->param_size() == 0) {
2676 if (DeclaringEntity)
Douglas Gregor218937c2011-02-01 19:23:04 +00002677 Result.AddTextChunk(", ...");
Douglas Gregore17794f2010-08-31 05:13:43 +00002678 else if (AllParametersAreInformative)
Douglas Gregor218937c2011-02-01 19:23:04 +00002679 Result.AddInformativeChunk(", ...");
Douglas Gregore17794f2010-08-31 05:13:43 +00002680 else
Douglas Gregor218937c2011-02-01 19:23:04 +00002681 Result.AddPlaceholderChunk(", ...");
Douglas Gregore17794f2010-08-31 05:13:43 +00002682 }
Douglas Gregoraaa107a2010-08-23 23:51:41 +00002683
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002684 MaybeAddSentinel(Ctx, Method, Result);
Douglas Gregor2a17af02009-12-23 00:21:46 +00002685 }
2686
Douglas Gregor218937c2011-02-01 19:23:04 +00002687 return Result.TakeString();
Douglas Gregor9630eb62009-11-17 16:44:22 +00002688 }
2689
Douglas Gregor2b4074f2009-12-01 05:55:20 +00002690 if (Qualifier)
Douglas Gregor0563c262009-09-22 23:15:58 +00002691 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
Argyrios Kyrtzidisea8c59a2012-01-17 02:15:51 +00002692 Ctx, Policy);
Douglas Gregor2b4074f2009-12-01 05:55:20 +00002693
Douglas Gregordae68752011-02-01 22:57:45 +00002694 Result.AddTypedTextChunk(
2695 Result.getAllocator().CopyString(ND->getNameAsString()));
Douglas Gregor218937c2011-02-01 19:23:04 +00002696 return Result.TakeString();
Douglas Gregor86d9a522009-09-21 16:56:56 +00002697}
2698
Douglas Gregor86d802e2009-09-23 00:34:09 +00002699CodeCompletionString *
2700CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
2701 unsigned CurrentArg,
Douglas Gregor32be4a52010-10-11 21:37:58 +00002702 Sema &S,
Douglas Gregordae68752011-02-01 22:57:45 +00002703 CodeCompletionAllocator &Allocator) const {
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002704 typedef CodeCompletionString::Chunk Chunk;
Douglas Gregor8987b232011-09-27 23:30:47 +00002705 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
John McCallf85e1932011-06-15 23:02:42 +00002706
Douglas Gregor218937c2011-02-01 19:23:04 +00002707 // FIXME: Set priority, availability appropriately.
2708 CodeCompletionBuilder Result(Allocator, 1, CXAvailability_Available);
Douglas Gregor86d802e2009-09-23 00:34:09 +00002709 FunctionDecl *FDecl = getFunction();
Douglas Gregor8987b232011-09-27 23:30:47 +00002710 AddResultTypeChunk(S.Context, Policy, FDecl, Result);
Douglas Gregor86d802e2009-09-23 00:34:09 +00002711 const FunctionProtoType *Proto
2712 = dyn_cast<FunctionProtoType>(getFunctionType());
2713 if (!FDecl && !Proto) {
2714 // Function without a prototype. Just give the return type and a
2715 // highlighted ellipsis.
2716 const FunctionType *FT = getFunctionType();
Douglas Gregora63f6de2011-02-01 21:15:40 +00002717 Result.AddTextChunk(GetCompletionTypeString(FT->getResultType(),
Douglas Gregor8987b232011-09-27 23:30:47 +00002718 S.Context, Policy,
Douglas Gregora63f6de2011-02-01 21:15:40 +00002719 Result.getAllocator()));
Douglas Gregor218937c2011-02-01 19:23:04 +00002720 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftParen));
2721 Result.AddChunk(Chunk(CodeCompletionString::CK_CurrentParameter, "..."));
2722 Result.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
2723 return Result.TakeString();
Douglas Gregor86d802e2009-09-23 00:34:09 +00002724 }
2725
2726 if (FDecl)
Douglas Gregordae68752011-02-01 22:57:45 +00002727 Result.AddTextChunk(
2728 Result.getAllocator().CopyString(FDecl->getNameAsString()));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002729 else
Douglas Gregor218937c2011-02-01 19:23:04 +00002730 Result.AddTextChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00002731 Result.getAllocator().CopyString(
John McCallf85e1932011-06-15 23:02:42 +00002732 Proto->getResultType().getAsString(Policy)));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002733
Douglas Gregor218937c2011-02-01 19:23:04 +00002734 Result.AddChunk(Chunk(CodeCompletionString::CK_LeftParen));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002735 unsigned NumParams = FDecl? FDecl->getNumParams() : Proto->getNumArgs();
2736 for (unsigned I = 0; I != NumParams; ++I) {
2737 if (I)
Douglas Gregor218937c2011-02-01 19:23:04 +00002738 Result.AddChunk(Chunk(CodeCompletionString::CK_Comma));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002739
2740 std::string ArgString;
2741 QualType ArgType;
2742
2743 if (FDecl) {
2744 ArgString = FDecl->getParamDecl(I)->getNameAsString();
2745 ArgType = FDecl->getParamDecl(I)->getOriginalType();
2746 } else {
2747 ArgType = Proto->getArgType(I);
2748 }
2749
John McCallf85e1932011-06-15 23:02:42 +00002750 ArgType.getAsStringInternal(ArgString, Policy);
Douglas Gregor86d802e2009-09-23 00:34:09 +00002751
2752 if (I == CurrentArg)
Douglas Gregor218937c2011-02-01 19:23:04 +00002753 Result.AddChunk(Chunk(CodeCompletionString::CK_CurrentParameter,
Douglas Gregordae68752011-02-01 22:57:45 +00002754 Result.getAllocator().CopyString(ArgString)));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002755 else
Douglas Gregordae68752011-02-01 22:57:45 +00002756 Result.AddTextChunk(Result.getAllocator().CopyString(ArgString));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002757 }
2758
2759 if (Proto && Proto->isVariadic()) {
Douglas Gregor218937c2011-02-01 19:23:04 +00002760 Result.AddChunk(Chunk(CodeCompletionString::CK_Comma));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002761 if (CurrentArg < NumParams)
Douglas Gregor218937c2011-02-01 19:23:04 +00002762 Result.AddTextChunk("...");
Douglas Gregor86d802e2009-09-23 00:34:09 +00002763 else
Douglas Gregor218937c2011-02-01 19:23:04 +00002764 Result.AddChunk(Chunk(CodeCompletionString::CK_CurrentParameter, "..."));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002765 }
Douglas Gregor218937c2011-02-01 19:23:04 +00002766 Result.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
Douglas Gregor86d802e2009-09-23 00:34:09 +00002767
Douglas Gregor218937c2011-02-01 19:23:04 +00002768 return Result.TakeString();
Douglas Gregor86d802e2009-09-23 00:34:09 +00002769}
2770
Chris Lattner5f9e2722011-07-23 10:55:15 +00002771unsigned clang::getMacroUsagePriority(StringRef MacroName,
Douglas Gregorb05496d2010-09-20 21:11:48 +00002772 const LangOptions &LangOpts,
Douglas Gregor1827e102010-08-16 16:18:59 +00002773 bool PreferredTypeIsPointer) {
2774 unsigned Priority = CCP_Macro;
2775
Douglas Gregorb05496d2010-09-20 21:11:48 +00002776 // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
2777 if (MacroName.equals("nil") || MacroName.equals("NULL") ||
2778 MacroName.equals("Nil")) {
Douglas Gregor1827e102010-08-16 16:18:59 +00002779 Priority = CCP_Constant;
2780 if (PreferredTypeIsPointer)
2781 Priority = Priority / CCF_SimilarTypeMatch;
Douglas Gregorb05496d2010-09-20 21:11:48 +00002782 }
2783 // Treat "YES", "NO", "true", and "false" as constants.
2784 else if (MacroName.equals("YES") || MacroName.equals("NO") ||
2785 MacroName.equals("true") || MacroName.equals("false"))
2786 Priority = CCP_Constant;
2787 // Treat "bool" as a type.
2788 else if (MacroName.equals("bool"))
2789 Priority = CCP_Type + (LangOpts.ObjC1? CCD_bool_in_ObjC : 0);
2790
Douglas Gregor1827e102010-08-16 16:18:59 +00002791
2792 return Priority;
2793}
2794
Douglas Gregore8d7beb2010-09-03 23:30:36 +00002795CXCursorKind clang::getCursorKindForDecl(Decl *D) {
2796 if (!D)
2797 return CXCursor_UnexposedDecl;
2798
2799 switch (D->getKind()) {
2800 case Decl::Enum: return CXCursor_EnumDecl;
2801 case Decl::EnumConstant: return CXCursor_EnumConstantDecl;
2802 case Decl::Field: return CXCursor_FieldDecl;
2803 case Decl::Function:
2804 return CXCursor_FunctionDecl;
2805 case Decl::ObjCCategory: return CXCursor_ObjCCategoryDecl;
2806 case Decl::ObjCCategoryImpl: return CXCursor_ObjCCategoryImplDecl;
Douglas Gregore8d7beb2010-09-03 23:30:36 +00002807 case Decl::ObjCImplementation: return CXCursor_ObjCImplementationDecl;
Douglas Gregor375bb142011-12-27 22:43:10 +00002808
Argyrios Kyrtzidisc15707d2012-01-24 21:39:26 +00002809 case Decl::ObjCInterface: return CXCursor_ObjCInterfaceDecl;
Douglas Gregore8d7beb2010-09-03 23:30:36 +00002810 case Decl::ObjCIvar: return CXCursor_ObjCIvarDecl;
2811 case Decl::ObjCMethod:
2812 return cast<ObjCMethodDecl>(D)->isInstanceMethod()
2813 ? CXCursor_ObjCInstanceMethodDecl : CXCursor_ObjCClassMethodDecl;
2814 case Decl::CXXMethod: return CXCursor_CXXMethod;
2815 case Decl::CXXConstructor: return CXCursor_Constructor;
2816 case Decl::CXXDestructor: return CXCursor_Destructor;
2817 case Decl::CXXConversion: return CXCursor_ConversionFunction;
2818 case Decl::ObjCProperty: return CXCursor_ObjCPropertyDecl;
Argyrios Kyrtzidisc15707d2012-01-24 21:39:26 +00002819 case Decl::ObjCProtocol: return CXCursor_ObjCProtocolDecl;
Douglas Gregore8d7beb2010-09-03 23:30:36 +00002820 case Decl::ParmVar: return CXCursor_ParmDecl;
2821 case Decl::Typedef: return CXCursor_TypedefDecl;
Richard Smith162e1c12011-04-15 14:24:37 +00002822 case Decl::TypeAlias: return CXCursor_TypeAliasDecl;
Douglas Gregore8d7beb2010-09-03 23:30:36 +00002823 case Decl::Var: return CXCursor_VarDecl;
2824 case Decl::Namespace: return CXCursor_Namespace;
2825 case Decl::NamespaceAlias: return CXCursor_NamespaceAlias;
2826 case Decl::TemplateTypeParm: return CXCursor_TemplateTypeParameter;
2827 case Decl::NonTypeTemplateParm:return CXCursor_NonTypeTemplateParameter;
2828 case Decl::TemplateTemplateParm:return CXCursor_TemplateTemplateParameter;
2829 case Decl::FunctionTemplate: return CXCursor_FunctionTemplate;
2830 case Decl::ClassTemplate: return CXCursor_ClassTemplate;
Argyrios Kyrtzidis2dfdb942011-09-30 17:58:23 +00002831 case Decl::AccessSpec: return CXCursor_CXXAccessSpecifier;
Douglas Gregore8d7beb2010-09-03 23:30:36 +00002832 case Decl::ClassTemplatePartialSpecialization:
2833 return CXCursor_ClassTemplatePartialSpecialization;
2834 case Decl::UsingDirective: return CXCursor_UsingDirective;
2835
2836 case Decl::Using:
2837 case Decl::UnresolvedUsingValue:
2838 case Decl::UnresolvedUsingTypename:
2839 return CXCursor_UsingDeclaration;
2840
Douglas Gregor352697a2011-06-03 23:08:58 +00002841 case Decl::ObjCPropertyImpl:
2842 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
2843 case ObjCPropertyImplDecl::Dynamic:
2844 return CXCursor_ObjCDynamicDecl;
2845
2846 case ObjCPropertyImplDecl::Synthesize:
2847 return CXCursor_ObjCSynthesizeDecl;
2848 }
Douglas Gregor352697a2011-06-03 23:08:58 +00002849
Douglas Gregore8d7beb2010-09-03 23:30:36 +00002850 default:
2851 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
2852 switch (TD->getTagKind()) {
2853 case TTK_Struct: return CXCursor_StructDecl;
2854 case TTK_Class: return CXCursor_ClassDecl;
2855 case TTK_Union: return CXCursor_UnionDecl;
2856 case TTK_Enum: return CXCursor_EnumDecl;
2857 }
2858 }
2859 }
2860
2861 return CXCursor_UnexposedDecl;
2862}
2863
Douglas Gregor590c7d52010-07-08 20:55:51 +00002864static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
2865 bool TargetTypeIsPointer = false) {
John McCall0a2c5e22010-08-25 06:19:51 +00002866 typedef CodeCompletionResult Result;
Douglas Gregor590c7d52010-07-08 20:55:51 +00002867
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002868 Results.EnterNewScope();
Douglas Gregorc7b7b7a2010-10-18 21:05:04 +00002869
Douglas Gregor0c8296d2009-11-07 00:00:49 +00002870 for (Preprocessor::macro_iterator M = PP.macro_begin(),
2871 MEnd = PP.macro_end();
Douglas Gregor590c7d52010-07-08 20:55:51 +00002872 M != MEnd; ++M) {
Douglas Gregor1827e102010-08-16 16:18:59 +00002873 Results.AddResult(Result(M->first,
2874 getMacroUsagePriority(M->first->getName(),
David Blaikie4e4d0842012-03-11 07:00:24 +00002875 PP.getLangOpts(),
Douglas Gregor1827e102010-08-16 16:18:59 +00002876 TargetTypeIsPointer)));
Douglas Gregor590c7d52010-07-08 20:55:51 +00002877 }
Douglas Gregorc7b7b7a2010-10-18 21:05:04 +00002878
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002879 Results.ExitScope();
Douglas Gregorc7b7b7a2010-10-18 21:05:04 +00002880
Douglas Gregor3f7c7f42009-10-30 16:50:04 +00002881}
2882
Douglas Gregoraa5f77b2010-08-23 21:54:33 +00002883static void AddPrettyFunctionResults(const LangOptions &LangOpts,
2884 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00002885 typedef CodeCompletionResult Result;
Douglas Gregoraa5f77b2010-08-23 21:54:33 +00002886
2887 Results.EnterNewScope();
Douglas Gregorc7b7b7a2010-10-18 21:05:04 +00002888
Douglas Gregoraa5f77b2010-08-23 21:54:33 +00002889 Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
2890 Results.AddResult(Result("__FUNCTION__", CCP_Constant));
2891 if (LangOpts.C99 || LangOpts.CPlusPlus0x)
2892 Results.AddResult(Result("__func__", CCP_Constant));
2893 Results.ExitScope();
2894}
2895
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00002896static void HandleCodeCompleteResults(Sema *S,
2897 CodeCompleteConsumer *CodeCompleter,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002898 CodeCompletionContext Context,
John McCall0a2c5e22010-08-25 06:19:51 +00002899 CodeCompletionResult *Results,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002900 unsigned NumResults) {
Douglas Gregor86d9a522009-09-21 16:56:56 +00002901 if (CodeCompleter)
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002902 CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
Douglas Gregor86d9a522009-09-21 16:56:56 +00002903}
2904
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002905static enum CodeCompletionContext::Kind mapCodeCompletionContext(Sema &S,
2906 Sema::ParserCompletionContext PCC) {
2907 switch (PCC) {
John McCallf312b1e2010-08-26 23:41:50 +00002908 case Sema::PCC_Namespace:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002909 return CodeCompletionContext::CCC_TopLevel;
2910
John McCallf312b1e2010-08-26 23:41:50 +00002911 case Sema::PCC_Class:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002912 return CodeCompletionContext::CCC_ClassStructUnion;
2913
John McCallf312b1e2010-08-26 23:41:50 +00002914 case Sema::PCC_ObjCInterface:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002915 return CodeCompletionContext::CCC_ObjCInterface;
2916
John McCallf312b1e2010-08-26 23:41:50 +00002917 case Sema::PCC_ObjCImplementation:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002918 return CodeCompletionContext::CCC_ObjCImplementation;
2919
John McCallf312b1e2010-08-26 23:41:50 +00002920 case Sema::PCC_ObjCInstanceVariableList:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002921 return CodeCompletionContext::CCC_ObjCIvarList;
2922
John McCallf312b1e2010-08-26 23:41:50 +00002923 case Sema::PCC_Template:
2924 case Sema::PCC_MemberTemplate:
Douglas Gregor52779fb2010-09-23 23:01:17 +00002925 if (S.CurContext->isFileContext())
2926 return CodeCompletionContext::CCC_TopLevel;
David Blaikie7530c032012-01-17 06:56:22 +00002927 if (S.CurContext->isRecord())
Douglas Gregor52779fb2010-09-23 23:01:17 +00002928 return CodeCompletionContext::CCC_ClassStructUnion;
David Blaikie7530c032012-01-17 06:56:22 +00002929 return CodeCompletionContext::CCC_Other;
Douglas Gregor52779fb2010-09-23 23:01:17 +00002930
John McCallf312b1e2010-08-26 23:41:50 +00002931 case Sema::PCC_RecoveryInFunction:
Douglas Gregor52779fb2010-09-23 23:01:17 +00002932 return CodeCompletionContext::CCC_Recovery;
Douglas Gregora5450a02010-10-18 22:01:46 +00002933
John McCallf312b1e2010-08-26 23:41:50 +00002934 case Sema::PCC_ForInit:
David Blaikie4e4d0842012-03-11 07:00:24 +00002935 if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
2936 S.getLangOpts().ObjC1)
Douglas Gregora5450a02010-10-18 22:01:46 +00002937 return CodeCompletionContext::CCC_ParenthesizedExpression;
2938 else
2939 return CodeCompletionContext::CCC_Expression;
2940
2941 case Sema::PCC_Expression:
John McCallf312b1e2010-08-26 23:41:50 +00002942 case Sema::PCC_Condition:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002943 return CodeCompletionContext::CCC_Expression;
2944
John McCallf312b1e2010-08-26 23:41:50 +00002945 case Sema::PCC_Statement:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002946 return CodeCompletionContext::CCC_Statement;
Douglas Gregor72db1082010-08-24 01:11:00 +00002947
John McCallf312b1e2010-08-26 23:41:50 +00002948 case Sema::PCC_Type:
Douglas Gregor72db1082010-08-24 01:11:00 +00002949 return CodeCompletionContext::CCC_Type;
Douglas Gregor02688102010-09-14 23:59:36 +00002950
2951 case Sema::PCC_ParenthesizedExpression:
2952 return CodeCompletionContext::CCC_ParenthesizedExpression;
Douglas Gregor68e3c2e2011-02-15 20:33:25 +00002953
2954 case Sema::PCC_LocalDeclarationSpecifiers:
2955 return CodeCompletionContext::CCC_Type;
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002956 }
David Blaikie7530c032012-01-17 06:56:22 +00002957
2958 llvm_unreachable("Invalid ParserCompletionContext!");
Douglas Gregore6b1bb62010-08-11 21:23:17 +00002959}
2960
Douglas Gregorf6961522010-08-27 21:18:54 +00002961/// \brief If we're in a C++ virtual member function, add completion results
2962/// that invoke the functions we override, since it's common to invoke the
2963/// overridden function as well as adding new functionality.
2964///
2965/// \param S The semantic analysis object for which we are generating results.
2966///
2967/// \param InContext This context in which the nested-name-specifier preceding
2968/// the code-completion point
2969static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
2970 ResultBuilder &Results) {
2971 // Look through blocks.
2972 DeclContext *CurContext = S.CurContext;
2973 while (isa<BlockDecl>(CurContext))
2974 CurContext = CurContext->getParent();
2975
2976
2977 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
2978 if (!Method || !Method->isVirtual())
2979 return;
2980
2981 // We need to have names for all of the parameters, if we're going to
2982 // generate a forwarding call.
2983 for (CXXMethodDecl::param_iterator P = Method->param_begin(),
2984 PEnd = Method->param_end();
2985 P != PEnd;
2986 ++P) {
2987 if (!(*P)->getDeclName())
2988 return;
2989 }
2990
Douglas Gregor8987b232011-09-27 23:30:47 +00002991 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
Douglas Gregorf6961522010-08-27 21:18:54 +00002992 for (CXXMethodDecl::method_iterator M = Method->begin_overridden_methods(),
2993 MEnd = Method->end_overridden_methods();
2994 M != MEnd; ++M) {
Douglas Gregor218937c2011-02-01 19:23:04 +00002995 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregorf6961522010-08-27 21:18:54 +00002996 CXXMethodDecl *Overridden = const_cast<CXXMethodDecl *>(*M);
2997 if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
2998 continue;
2999
3000 // If we need a nested-name-specifier, add one now.
3001 if (!InContext) {
3002 NestedNameSpecifier *NNS
3003 = getRequiredQualification(S.Context, CurContext,
3004 Overridden->getDeclContext());
3005 if (NNS) {
3006 std::string Str;
3007 llvm::raw_string_ostream OS(Str);
Douglas Gregor8987b232011-09-27 23:30:47 +00003008 NNS->print(OS, Policy);
Douglas Gregordae68752011-02-01 22:57:45 +00003009 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
Douglas Gregorf6961522010-08-27 21:18:54 +00003010 }
3011 } else if (!InContext->Equals(Overridden->getDeclContext()))
3012 continue;
3013
Douglas Gregordae68752011-02-01 22:57:45 +00003014 Builder.AddTypedTextChunk(Results.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00003015 Overridden->getNameAsString()));
3016 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
Douglas Gregorf6961522010-08-27 21:18:54 +00003017 bool FirstParam = true;
3018 for (CXXMethodDecl::param_iterator P = Method->param_begin(),
3019 PEnd = Method->param_end();
3020 P != PEnd; ++P) {
3021 if (FirstParam)
3022 FirstParam = false;
3023 else
Douglas Gregor218937c2011-02-01 19:23:04 +00003024 Builder.AddChunk(CodeCompletionString::CK_Comma);
Douglas Gregorf6961522010-08-27 21:18:54 +00003025
Douglas Gregordae68752011-02-01 22:57:45 +00003026 Builder.AddPlaceholderChunk(Results.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00003027 (*P)->getIdentifier()->getName()));
Douglas Gregorf6961522010-08-27 21:18:54 +00003028 }
Douglas Gregor218937c2011-02-01 19:23:04 +00003029 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3030 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
Douglas Gregorf6961522010-08-27 21:18:54 +00003031 CCP_SuperCompletion,
3032 CXCursor_CXXMethod));
3033 Results.Ignore(Overridden);
3034 }
3035}
3036
Douglas Gregorc5b2e582012-01-29 18:15:03 +00003037void Sema::CodeCompleteModuleImport(SourceLocation ImportLoc,
3038 ModuleIdPath Path) {
3039 typedef CodeCompletionResult Result;
3040 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3041 CodeCompletionContext::CCC_Other);
3042 Results.EnterNewScope();
3043
3044 CodeCompletionAllocator &Allocator = Results.getAllocator();
3045 CodeCompletionBuilder Builder(Allocator);
3046 typedef CodeCompletionResult Result;
3047 if (Path.empty()) {
3048 // Enumerate all top-level modules.
3049 llvm::SmallVector<Module *, 8> Modules;
3050 PP.getHeaderSearchInfo().collectAllModules(Modules);
3051 for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
3052 Builder.AddTypedTextChunk(
3053 Builder.getAllocator().CopyString(Modules[I]->Name));
3054 Results.AddResult(Result(Builder.TakeString(),
3055 CCP_Declaration,
3056 CXCursor_NotImplemented,
3057 Modules[I]->isAvailable()
3058 ? CXAvailability_Available
3059 : CXAvailability_NotAvailable));
3060 }
3061 } else {
3062 // Load the named module.
3063 Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path,
3064 Module::AllVisible,
3065 /*IsInclusionDirective=*/false);
3066 // Enumerate submodules.
3067 if (Mod) {
3068 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
3069 SubEnd = Mod->submodule_end();
3070 Sub != SubEnd; ++Sub) {
3071
3072 Builder.AddTypedTextChunk(
3073 Builder.getAllocator().CopyString((*Sub)->Name));
3074 Results.AddResult(Result(Builder.TakeString(),
3075 CCP_Declaration,
3076 CXCursor_NotImplemented,
3077 (*Sub)->isAvailable()
3078 ? CXAvailability_Available
3079 : CXAvailability_NotAvailable));
3080 }
3081 }
3082 }
3083 Results.ExitScope();
3084 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3085 Results.data(),Results.size());
3086}
3087
Douglas Gregor01dfea02010-01-10 23:08:15 +00003088void Sema::CodeCompleteOrdinaryName(Scope *S,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003089 ParserCompletionContext CompletionContext) {
John McCall0a2c5e22010-08-25 06:19:51 +00003090 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00003091 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00003092 mapCodeCompletionContext(*this, CompletionContext));
Douglas Gregorf6961522010-08-27 21:18:54 +00003093 Results.EnterNewScope();
Douglas Gregorcee9ff12010-09-20 22:39:41 +00003094
Douglas Gregor01dfea02010-01-10 23:08:15 +00003095 // Determine how to filter results, e.g., so that the names of
3096 // values (functions, enumerators, function templates, etc.) are
3097 // only allowed where we can have an expression.
3098 switch (CompletionContext) {
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003099 case PCC_Namespace:
3100 case PCC_Class:
3101 case PCC_ObjCInterface:
3102 case PCC_ObjCImplementation:
3103 case PCC_ObjCInstanceVariableList:
3104 case PCC_Template:
3105 case PCC_MemberTemplate:
Douglas Gregor72db1082010-08-24 01:11:00 +00003106 case PCC_Type:
Douglas Gregor68e3c2e2011-02-15 20:33:25 +00003107 case PCC_LocalDeclarationSpecifiers:
Douglas Gregor01dfea02010-01-10 23:08:15 +00003108 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
3109 break;
3110
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003111 case PCC_Statement:
Douglas Gregor02688102010-09-14 23:59:36 +00003112 case PCC_ParenthesizedExpression:
Douglas Gregoreb0d0142010-08-24 23:58:17 +00003113 case PCC_Expression:
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003114 case PCC_ForInit:
3115 case PCC_Condition:
David Blaikie4e4d0842012-03-11 07:00:24 +00003116 if (WantTypesInContext(CompletionContext, getLangOpts()))
Douglas Gregor4710e5b2010-05-28 00:49:12 +00003117 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3118 else
3119 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
Douglas Gregorf6961522010-08-27 21:18:54 +00003120
David Blaikie4e4d0842012-03-11 07:00:24 +00003121 if (getLangOpts().CPlusPlus)
Douglas Gregorf6961522010-08-27 21:18:54 +00003122 MaybeAddOverrideCalls(*this, /*InContext=*/0, Results);
Douglas Gregor01dfea02010-01-10 23:08:15 +00003123 break;
Douglas Gregordc845342010-05-25 05:58:43 +00003124
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003125 case PCC_RecoveryInFunction:
Douglas Gregordc845342010-05-25 05:58:43 +00003126 // Unfiltered
3127 break;
Douglas Gregor01dfea02010-01-10 23:08:15 +00003128 }
3129
Douglas Gregor3cdee122010-08-26 16:36:48 +00003130 // If we are in a C++ non-static member function, check the qualifiers on
3131 // the member function to filter/prioritize the results list.
3132 if (CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext))
3133 if (CurMethod->isInstance())
3134 Results.setObjectTypeQualifiers(
3135 Qualifiers::fromCVRMask(CurMethod->getTypeQualifiers()));
3136
Douglas Gregor1ca6ae82010-01-14 01:09:38 +00003137 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00003138 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3139 CodeCompleter->includeGlobals());
Douglas Gregor2a7925c2009-12-07 09:54:55 +00003140
Douglas Gregorbca403c2010-01-13 23:51:12 +00003141 AddOrdinaryNameResults(CompletionContext, S, *this, Results);
Douglas Gregor2a7925c2009-12-07 09:54:55 +00003142 Results.ExitScope();
3143
Douglas Gregoraa5f77b2010-08-23 21:54:33 +00003144 switch (CompletionContext) {
Douglas Gregor02688102010-09-14 23:59:36 +00003145 case PCC_ParenthesizedExpression:
Douglas Gregor72db1082010-08-24 01:11:00 +00003146 case PCC_Expression:
3147 case PCC_Statement:
3148 case PCC_RecoveryInFunction:
3149 if (S->getFnParent())
David Blaikie4e4d0842012-03-11 07:00:24 +00003150 AddPrettyFunctionResults(PP.getLangOpts(), Results);
Douglas Gregor72db1082010-08-24 01:11:00 +00003151 break;
3152
3153 case PCC_Namespace:
3154 case PCC_Class:
3155 case PCC_ObjCInterface:
3156 case PCC_ObjCImplementation:
3157 case PCC_ObjCInstanceVariableList:
3158 case PCC_Template:
3159 case PCC_MemberTemplate:
3160 case PCC_ForInit:
3161 case PCC_Condition:
3162 case PCC_Type:
Douglas Gregor68e3c2e2011-02-15 20:33:25 +00003163 case PCC_LocalDeclarationSpecifiers:
Douglas Gregor72db1082010-08-24 01:11:00 +00003164 break;
Douglas Gregoraa5f77b2010-08-23 21:54:33 +00003165 }
3166
Douglas Gregor0c8296d2009-11-07 00:00:49 +00003167 if (CodeCompleter->includeMacros())
Douglas Gregorbca403c2010-01-13 23:51:12 +00003168 AddMacroResults(PP, Results);
Douglas Gregoraa5f77b2010-08-23 21:54:33 +00003169
Douglas Gregorcee9ff12010-09-20 22:39:41 +00003170 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003171 Results.data(),Results.size());
Douglas Gregor791215b2009-09-21 20:51:25 +00003172}
3173
Douglas Gregorc7b6d882010-09-16 15:14:18 +00003174static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
3175 ParsedType Receiver,
3176 IdentifierInfo **SelIdents,
3177 unsigned NumSelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00003178 bool AtArgumentExpression,
Douglas Gregorc7b6d882010-09-16 15:14:18 +00003179 bool IsSuper,
3180 ResultBuilder &Results);
3181
3182void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
3183 bool AllowNonIdentifiers,
3184 bool AllowNestedNameSpecifiers) {
John McCall0a2c5e22010-08-25 06:19:51 +00003185 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00003186 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00003187 AllowNestedNameSpecifiers
3188 ? CodeCompletionContext::CCC_PotentiallyQualifiedName
3189 : CodeCompletionContext::CCC_Name);
Douglas Gregor2ccccb32010-08-23 18:23:48 +00003190 Results.EnterNewScope();
3191
3192 // Type qualifiers can come after names.
3193 Results.AddResult(Result("const"));
3194 Results.AddResult(Result("volatile"));
David Blaikie4e4d0842012-03-11 07:00:24 +00003195 if (getLangOpts().C99)
Douglas Gregor2ccccb32010-08-23 18:23:48 +00003196 Results.AddResult(Result("restrict"));
3197
David Blaikie4e4d0842012-03-11 07:00:24 +00003198 if (getLangOpts().CPlusPlus) {
Douglas Gregor2ccccb32010-08-23 18:23:48 +00003199 if (AllowNonIdentifiers) {
3200 Results.AddResult(Result("operator"));
3201 }
3202
3203 // Add nested-name-specifiers.
3204 if (AllowNestedNameSpecifiers) {
3205 Results.allowNestedNameSpecifiers();
Douglas Gregor52779fb2010-09-23 23:01:17 +00003206 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
Douglas Gregor2ccccb32010-08-23 18:23:48 +00003207 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3208 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
3209 CodeCompleter->includeGlobals());
Douglas Gregor52779fb2010-09-23 23:01:17 +00003210 Results.setFilter(0);
Douglas Gregor2ccccb32010-08-23 18:23:48 +00003211 }
3212 }
3213 Results.ExitScope();
3214
Douglas Gregorc7b6d882010-09-16 15:14:18 +00003215 // If we're in a context where we might have an expression (rather than a
3216 // declaration), and what we've seen so far is an Objective-C type that could
3217 // be a receiver of a class message, this may be a class message send with
3218 // the initial opening bracket '[' missing. Add appropriate completions.
3219 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
3220 DS.getTypeSpecType() == DeclSpec::TST_typename &&
3221 DS.getStorageClassSpecAsWritten() == DeclSpec::SCS_unspecified &&
3222 !DS.isThreadSpecified() && !DS.isExternInLinkageSpec() &&
3223 DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified &&
3224 DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
3225 DS.getTypeQualifiers() == 0 &&
3226 S &&
3227 (S->getFlags() & Scope::DeclScope) != 0 &&
3228 (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope |
3229 Scope::FunctionPrototypeScope |
3230 Scope::AtCatchScope)) == 0) {
3231 ParsedType T = DS.getRepAsType();
3232 if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
Douglas Gregor70c5ac72010-09-20 23:34:21 +00003233 AddClassMessageCompletions(*this, S, T, 0, 0, false, false, Results);
Douglas Gregorc7b6d882010-09-16 15:14:18 +00003234 }
3235
Douglas Gregor4497dd42010-08-24 04:59:56 +00003236 // Note that we intentionally suppress macro results here, since we do not
3237 // encourage using macros to produce the names of entities.
3238
Douglas Gregor52779fb2010-09-23 23:01:17 +00003239 HandleCodeCompleteResults(this, CodeCompleter,
3240 Results.getCompletionContext(),
Douglas Gregor2ccccb32010-08-23 18:23:48 +00003241 Results.data(), Results.size());
3242}
3243
Douglas Gregorfb629412010-08-23 21:17:50 +00003244struct Sema::CodeCompleteExpressionData {
3245 CodeCompleteExpressionData(QualType PreferredType = QualType())
3246 : PreferredType(PreferredType), IntegralConstantExpression(false),
3247 ObjCCollection(false) { }
3248
3249 QualType PreferredType;
3250 bool IntegralConstantExpression;
3251 bool ObjCCollection;
Chris Lattner5f9e2722011-07-23 10:55:15 +00003252 SmallVector<Decl *, 4> IgnoreDecls;
Douglas Gregorfb629412010-08-23 21:17:50 +00003253};
3254
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003255/// \brief Perform code-completion in an expression context when we know what
3256/// type we're looking for.
Douglas Gregorf9578432010-07-28 21:50:18 +00003257///
3258/// \param IntegralConstantExpression Only permit integral constant
3259/// expressions.
Douglas Gregorfb629412010-08-23 21:17:50 +00003260void Sema::CodeCompleteExpression(Scope *S,
3261 const CodeCompleteExpressionData &Data) {
John McCall0a2c5e22010-08-25 06:19:51 +00003262 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00003263 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3264 CodeCompletionContext::CCC_Expression);
Douglas Gregorfb629412010-08-23 21:17:50 +00003265 if (Data.ObjCCollection)
3266 Results.setFilter(&ResultBuilder::IsObjCCollection);
3267 else if (Data.IntegralConstantExpression)
Douglas Gregorf9578432010-07-28 21:50:18 +00003268 Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
David Blaikie4e4d0842012-03-11 07:00:24 +00003269 else if (WantTypesInContext(PCC_Expression, getLangOpts()))
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003270 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3271 else
3272 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
Douglas Gregorfb629412010-08-23 21:17:50 +00003273
3274 if (!Data.PreferredType.isNull())
3275 Results.setPreferredType(Data.PreferredType.getNonReferenceType());
3276
3277 // Ignore any declarations that we were told that we don't care about.
3278 for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
3279 Results.Ignore(Data.IgnoreDecls[I]);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003280
3281 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00003282 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3283 CodeCompleter->includeGlobals());
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003284
3285 Results.EnterNewScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003286 AddOrdinaryNameResults(PCC_Expression, S, *this, Results);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003287 Results.ExitScope();
3288
Douglas Gregor590c7d52010-07-08 20:55:51 +00003289 bool PreferredTypeIsPointer = false;
Douglas Gregorfb629412010-08-23 21:17:50 +00003290 if (!Data.PreferredType.isNull())
3291 PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType()
3292 || Data.PreferredType->isMemberPointerType()
3293 || Data.PreferredType->isBlockPointerType();
Douglas Gregor590c7d52010-07-08 20:55:51 +00003294
Douglas Gregoraa5f77b2010-08-23 21:54:33 +00003295 if (S->getFnParent() &&
3296 !Data.ObjCCollection &&
3297 !Data.IntegralConstantExpression)
David Blaikie4e4d0842012-03-11 07:00:24 +00003298 AddPrettyFunctionResults(PP.getLangOpts(), Results);
Douglas Gregoraa5f77b2010-08-23 21:54:33 +00003299
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003300 if (CodeCompleter->includeMacros())
Douglas Gregor590c7d52010-07-08 20:55:51 +00003301 AddMacroResults(PP, Results, PreferredTypeIsPointer);
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003302 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregorfb629412010-08-23 21:17:50 +00003303 CodeCompletionContext(CodeCompletionContext::CCC_Expression,
3304 Data.PreferredType),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003305 Results.data(),Results.size());
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003306}
3307
Douglas Gregorac5fd842010-09-18 01:28:11 +00003308void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E) {
3309 if (E.isInvalid())
3310 CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction);
David Blaikie4e4d0842012-03-11 07:00:24 +00003311 else if (getLangOpts().ObjC1)
Douglas Gregorac5fd842010-09-18 01:28:11 +00003312 CodeCompleteObjCInstanceMessage(S, E.take(), 0, 0, false);
Douglas Gregor78edf512010-09-15 16:23:04 +00003313}
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003314
Douglas Gregor73449212010-12-09 23:01:55 +00003315/// \brief The set of properties that have already been added, referenced by
3316/// property name.
3317typedef llvm::SmallPtrSet<IdentifierInfo*, 16> AddedPropertiesSet;
3318
Douglas Gregor95ac6552009-11-18 01:29:26 +00003319static void AddObjCProperties(ObjCContainerDecl *Container,
Douglas Gregor322328b2009-11-18 22:32:06 +00003320 bool AllowCategories,
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003321 bool AllowNullaryMethods,
Douglas Gregor95ac6552009-11-18 01:29:26 +00003322 DeclContext *CurContext,
Douglas Gregor73449212010-12-09 23:01:55 +00003323 AddedPropertiesSet &AddedProperties,
Douglas Gregor95ac6552009-11-18 01:29:26 +00003324 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00003325 typedef CodeCompletionResult Result;
Douglas Gregor95ac6552009-11-18 01:29:26 +00003326
3327 // Add properties in this container.
3328 for (ObjCContainerDecl::prop_iterator P = Container->prop_begin(),
3329 PEnd = Container->prop_end();
3330 P != PEnd;
Douglas Gregor73449212010-12-09 23:01:55 +00003331 ++P) {
3332 if (AddedProperties.insert(P->getIdentifier()))
3333 Results.MaybeAddResult(Result(*P, 0), CurContext);
3334 }
Douglas Gregor95ac6552009-11-18 01:29:26 +00003335
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003336 // Add nullary methods
3337 if (AllowNullaryMethods) {
3338 ASTContext &Context = Container->getASTContext();
Douglas Gregor8987b232011-09-27 23:30:47 +00003339 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003340 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(),
3341 MEnd = Container->meth_end();
3342 M != MEnd; ++M) {
3343 if (M->getSelector().isUnarySelector())
3344 if (IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0))
3345 if (AddedProperties.insert(Name)) {
3346 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor8987b232011-09-27 23:30:47 +00003347 AddResultTypeChunk(Context, Policy, *M, Builder);
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003348 Builder.AddTypedTextChunk(
3349 Results.getAllocator().CopyString(Name->getName()));
3350
3351 CXAvailabilityKind Availability = CXAvailability_Available;
3352 switch (M->getAvailability()) {
3353 case AR_Available:
3354 case AR_NotYetIntroduced:
3355 Availability = CXAvailability_Available;
3356 break;
3357
3358 case AR_Deprecated:
3359 Availability = CXAvailability_Deprecated;
3360 break;
3361
3362 case AR_Unavailable:
3363 Availability = CXAvailability_NotAvailable;
3364 break;
3365 }
3366
3367 Results.MaybeAddResult(Result(Builder.TakeString(),
3368 CCP_MemberDeclaration + CCD_MethodAsProperty,
3369 M->isInstanceMethod()
3370 ? CXCursor_ObjCInstanceMethodDecl
3371 : CXCursor_ObjCClassMethodDecl,
3372 Availability),
3373 CurContext);
3374 }
3375 }
3376 }
3377
3378
Douglas Gregor95ac6552009-11-18 01:29:26 +00003379 // Add properties in referenced protocols.
3380 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3381 for (ObjCProtocolDecl::protocol_iterator P = Protocol->protocol_begin(),
3382 PEnd = Protocol->protocol_end();
3383 P != PEnd; ++P)
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003384 AddObjCProperties(*P, AllowCategories, AllowNullaryMethods, CurContext,
3385 AddedProperties, Results);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003386 } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){
Douglas Gregor322328b2009-11-18 22:32:06 +00003387 if (AllowCategories) {
3388 // Look through categories.
3389 for (ObjCCategoryDecl *Category = IFace->getCategoryList();
3390 Category; Category = Category->getNextClassCategory())
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003391 AddObjCProperties(Category, AllowCategories, AllowNullaryMethods,
3392 CurContext, AddedProperties, Results);
Douglas Gregor322328b2009-11-18 22:32:06 +00003393 }
Douglas Gregor95ac6552009-11-18 01:29:26 +00003394
3395 // Look through protocols.
Ted Kremenek53b94412010-09-01 01:21:15 +00003396 for (ObjCInterfaceDecl::all_protocol_iterator
3397 I = IFace->all_referenced_protocol_begin(),
3398 E = IFace->all_referenced_protocol_end(); I != E; ++I)
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003399 AddObjCProperties(*I, AllowCategories, AllowNullaryMethods, CurContext,
3400 AddedProperties, Results);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003401
3402 // Look in the superclass.
3403 if (IFace->getSuperClass())
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003404 AddObjCProperties(IFace->getSuperClass(), AllowCategories,
3405 AllowNullaryMethods, CurContext,
Douglas Gregor73449212010-12-09 23:01:55 +00003406 AddedProperties, Results);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003407 } else if (const ObjCCategoryDecl *Category
3408 = dyn_cast<ObjCCategoryDecl>(Container)) {
3409 // Look through protocols.
Ted Kremenek53b94412010-09-01 01:21:15 +00003410 for (ObjCCategoryDecl::protocol_iterator P = Category->protocol_begin(),
3411 PEnd = Category->protocol_end();
Douglas Gregor95ac6552009-11-18 01:29:26 +00003412 P != PEnd; ++P)
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003413 AddObjCProperties(*P, AllowCategories, AllowNullaryMethods, CurContext,
3414 AddedProperties, Results);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003415 }
3416}
3417
Douglas Gregorf5cd27d2012-01-23 15:59:30 +00003418void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
Douglas Gregor81b747b2009-09-17 21:32:03 +00003419 SourceLocation OpLoc,
3420 bool IsArrow) {
Douglas Gregorf5cd27d2012-01-23 15:59:30 +00003421 if (!Base || !CodeCompleter)
Douglas Gregor81b747b2009-09-17 21:32:03 +00003422 return;
3423
Douglas Gregorf5cd27d2012-01-23 15:59:30 +00003424 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
3425 if (ConvertedBase.isInvalid())
3426 return;
3427 Base = ConvertedBase.get();
3428
John McCall0a2c5e22010-08-25 06:19:51 +00003429 typedef CodeCompletionResult Result;
Douglas Gregor86d9a522009-09-21 16:56:56 +00003430
Douglas Gregor81b747b2009-09-17 21:32:03 +00003431 QualType BaseType = Base->getType();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003432
3433 if (IsArrow) {
3434 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
3435 BaseType = Ptr->getPointeeType();
3436 else if (BaseType->isObjCObjectPointerType())
Douglas Gregor3cdee122010-08-26 16:36:48 +00003437 /*Do nothing*/ ;
Douglas Gregor86d9a522009-09-21 16:56:56 +00003438 else
3439 return;
3440 }
3441
Douglas Gregor3da626b2011-07-07 16:03:39 +00003442 enum CodeCompletionContext::Kind contextKind;
3443
3444 if (IsArrow) {
3445 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess;
3446 }
3447 else {
3448 if (BaseType->isObjCObjectPointerType() ||
3449 BaseType->isObjCObjectOrInterfaceType()) {
3450 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
3451 }
3452 else {
3453 contextKind = CodeCompletionContext::CCC_DotMemberAccess;
3454 }
3455 }
3456
Douglas Gregor218937c2011-02-01 19:23:04 +00003457 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor3da626b2011-07-07 16:03:39 +00003458 CodeCompletionContext(contextKind,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003459 BaseType),
3460 &ResultBuilder::IsMember);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003461 Results.EnterNewScope();
3462 if (const RecordType *Record = BaseType->getAs<RecordType>()) {
Douglas Gregor3cdee122010-08-26 16:36:48 +00003463 // Indicate that we are performing a member access, and the cv-qualifiers
3464 // for the base object type.
3465 Results.setObjectTypeQualifiers(BaseType.getQualifiers());
3466
Douglas Gregor95ac6552009-11-18 01:29:26 +00003467 // Access to a C/C++ class, struct, or union.
Douglas Gregor45bcd432010-01-14 03:21:49 +00003468 Results.allowNestedNameSpecifiers();
Douglas Gregor0cc84042010-01-14 15:47:35 +00003469 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00003470 LookupVisibleDecls(Record->getDecl(), LookupMemberName, Consumer,
3471 CodeCompleter->includeGlobals());
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003472
David Blaikie4e4d0842012-03-11 07:00:24 +00003473 if (getLangOpts().CPlusPlus) {
Douglas Gregor95ac6552009-11-18 01:29:26 +00003474 if (!Results.empty()) {
3475 // The "template" keyword can follow "->" or "." in the grammar.
3476 // However, we only want to suggest the template keyword if something
3477 // is dependent.
3478 bool IsDependent = BaseType->isDependentType();
3479 if (!IsDependent) {
3480 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
3481 if (DeclContext *Ctx = (DeclContext *)DepScope->getEntity()) {
3482 IsDependent = Ctx->isDependentContext();
3483 break;
3484 }
3485 }
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003486
Douglas Gregor95ac6552009-11-18 01:29:26 +00003487 if (IsDependent)
Douglas Gregora4477812010-01-14 16:01:26 +00003488 Results.AddResult(Result("template"));
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003489 }
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003490 }
Douglas Gregor95ac6552009-11-18 01:29:26 +00003491 } else if (!IsArrow && BaseType->getAsObjCInterfacePointerType()) {
3492 // Objective-C property reference.
Douglas Gregor73449212010-12-09 23:01:55 +00003493 AddedPropertiesSet AddedProperties;
Douglas Gregor95ac6552009-11-18 01:29:26 +00003494
3495 // Add property results based on our interface.
3496 const ObjCObjectPointerType *ObjCPtr
3497 = BaseType->getAsObjCInterfacePointerType();
3498 assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003499 AddObjCProperties(ObjCPtr->getInterfaceDecl(), true,
3500 /*AllowNullaryMethods=*/true, CurContext,
Douglas Gregor73449212010-12-09 23:01:55 +00003501 AddedProperties, Results);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003502
3503 // Add properties from the protocols in a qualified interface.
3504 for (ObjCObjectPointerType::qual_iterator I = ObjCPtr->qual_begin(),
3505 E = ObjCPtr->qual_end();
3506 I != E; ++I)
Douglas Gregor4b81cde2011-05-05 15:50:42 +00003507 AddObjCProperties(*I, true, /*AllowNullaryMethods=*/true, CurContext,
3508 AddedProperties, Results);
Douglas Gregor95ac6552009-11-18 01:29:26 +00003509 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
John McCallc12c5bb2010-05-15 11:32:37 +00003510 (!IsArrow && BaseType->isObjCObjectType())) {
Douglas Gregor95ac6552009-11-18 01:29:26 +00003511 // Objective-C instance variable access.
3512 ObjCInterfaceDecl *Class = 0;
3513 if (const ObjCObjectPointerType *ObjCPtr
3514 = BaseType->getAs<ObjCObjectPointerType>())
3515 Class = ObjCPtr->getInterfaceDecl();
3516 else
John McCallc12c5bb2010-05-15 11:32:37 +00003517 Class = BaseType->getAs<ObjCObjectType>()->getInterface();
Douglas Gregor95ac6552009-11-18 01:29:26 +00003518
3519 // Add all ivars from this class and its superclasses.
Douglas Gregor80f4f4c2010-01-14 16:08:12 +00003520 if (Class) {
3521 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3522 Results.setFilter(&ResultBuilder::IsObjCIvar);
Douglas Gregor8071e422010-08-15 06:18:01 +00003523 LookupVisibleDecls(Class, LookupMemberName, Consumer,
3524 CodeCompleter->includeGlobals());
Douglas Gregor95ac6552009-11-18 01:29:26 +00003525 }
Douglas Gregor86d9a522009-09-21 16:56:56 +00003526 }
Douglas Gregor95ac6552009-11-18 01:29:26 +00003527
3528 // FIXME: How do we cope with isa?
3529
3530 Results.ExitScope();
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003531
Daniel Dunbar3a2838d2009-11-13 08:58:20 +00003532 // Hand off the results found for code completion.
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003533 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003534 Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003535 Results.data(),Results.size());
Douglas Gregor81b747b2009-09-17 21:32:03 +00003536}
3537
Douglas Gregor374929f2009-09-18 15:37:17 +00003538void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
3539 if (!CodeCompleter)
3540 return;
3541
John McCall0a2c5e22010-08-25 06:19:51 +00003542 typedef CodeCompletionResult Result;
Douglas Gregor86d9a522009-09-21 16:56:56 +00003543 ResultBuilder::LookupFilter Filter = 0;
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003544 enum CodeCompletionContext::Kind ContextKind
3545 = CodeCompletionContext::CCC_Other;
Douglas Gregor374929f2009-09-18 15:37:17 +00003546 switch ((DeclSpec::TST)TagSpec) {
3547 case DeclSpec::TST_enum:
Douglas Gregor86d9a522009-09-21 16:56:56 +00003548 Filter = &ResultBuilder::IsEnum;
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003549 ContextKind = CodeCompletionContext::CCC_EnumTag;
Douglas Gregor374929f2009-09-18 15:37:17 +00003550 break;
3551
3552 case DeclSpec::TST_union:
Douglas Gregor86d9a522009-09-21 16:56:56 +00003553 Filter = &ResultBuilder::IsUnion;
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003554 ContextKind = CodeCompletionContext::CCC_UnionTag;
Douglas Gregor374929f2009-09-18 15:37:17 +00003555 break;
3556
3557 case DeclSpec::TST_struct:
Douglas Gregor374929f2009-09-18 15:37:17 +00003558 case DeclSpec::TST_class:
Douglas Gregor86d9a522009-09-21 16:56:56 +00003559 Filter = &ResultBuilder::IsClassOrStruct;
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003560 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag;
Douglas Gregor374929f2009-09-18 15:37:17 +00003561 break;
3562
3563 default:
David Blaikieb219cfc2011-09-23 05:06:16 +00003564 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
Douglas Gregor374929f2009-09-18 15:37:17 +00003565 }
Douglas Gregor86d9a522009-09-21 16:56:56 +00003566
Douglas Gregor218937c2011-02-01 19:23:04 +00003567 ResultBuilder Results(*this, CodeCompleter->getAllocator(), ContextKind);
Douglas Gregor5d2fc402010-01-14 03:27:13 +00003568 CodeCompletionDeclConsumer Consumer(Results, CurContext);
John McCall0d6b1642010-04-23 18:46:30 +00003569
3570 // First pass: look for tags.
3571 Results.setFilter(Filter);
Douglas Gregor8071e422010-08-15 06:18:01 +00003572 LookupVisibleDecls(S, LookupTagName, Consumer,
3573 CodeCompleter->includeGlobals());
John McCall0d6b1642010-04-23 18:46:30 +00003574
Douglas Gregor8071e422010-08-15 06:18:01 +00003575 if (CodeCompleter->includeGlobals()) {
3576 // Second pass: look for nested name specifiers.
3577 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
3578 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer);
3579 }
Douglas Gregor86d9a522009-09-21 16:56:56 +00003580
Douglas Gregor52779fb2010-09-23 23:01:17 +00003581 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003582 Results.data(),Results.size());
Douglas Gregor374929f2009-09-18 15:37:17 +00003583}
3584
Douglas Gregor1a480c42010-08-27 17:35:51 +00003585void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) {
Douglas Gregor218937c2011-02-01 19:23:04 +00003586 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3587 CodeCompletionContext::CCC_TypeQualifiers);
Douglas Gregor1a480c42010-08-27 17:35:51 +00003588 Results.EnterNewScope();
3589 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
3590 Results.AddResult("const");
3591 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
3592 Results.AddResult("volatile");
David Blaikie4e4d0842012-03-11 07:00:24 +00003593 if (getLangOpts().C99 &&
Douglas Gregor1a480c42010-08-27 17:35:51 +00003594 !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
3595 Results.AddResult("restrict");
3596 Results.ExitScope();
3597 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003598 Results.getCompletionContext(),
Douglas Gregor1a480c42010-08-27 17:35:51 +00003599 Results.data(), Results.size());
3600}
3601
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003602void Sema::CodeCompleteCase(Scope *S) {
John McCall781472f2010-08-25 08:40:02 +00003603 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003604 return;
John McCalla8e0cd82011-08-06 07:30:58 +00003605
John McCall781472f2010-08-25 08:40:02 +00003606 SwitchStmt *Switch = getCurFunction()->SwitchStack.back();
John McCalla8e0cd82011-08-06 07:30:58 +00003607 QualType type = Switch->getCond()->IgnoreImplicit()->getType();
3608 if (!type->isEnumeralType()) {
3609 CodeCompleteExpressionData Data(type);
Douglas Gregorfb629412010-08-23 21:17:50 +00003610 Data.IntegralConstantExpression = true;
3611 CodeCompleteExpression(S, Data);
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003612 return;
Douglas Gregorf9578432010-07-28 21:50:18 +00003613 }
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003614
3615 // Code-complete the cases of a switch statement over an enumeration type
3616 // by providing the list of
John McCalla8e0cd82011-08-06 07:30:58 +00003617 EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003618
3619 // Determine which enumerators we have already seen in the switch statement.
3620 // FIXME: Ideally, we would also be able to look *past* the code-completion
3621 // token, in case we are code-completing in the middle of the switch and not
3622 // at the end. However, we aren't able to do so at the moment.
3623 llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen;
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00003624 NestedNameSpecifier *Qualifier = 0;
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003625 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
3626 SC = SC->getNextSwitchCase()) {
3627 CaseStmt *Case = dyn_cast<CaseStmt>(SC);
3628 if (!Case)
3629 continue;
3630
3631 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
3632 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal))
3633 if (EnumConstantDecl *Enumerator
3634 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
3635 // We look into the AST of the case statement to determine which
3636 // enumerator was named. Alternatively, we could compute the value of
3637 // the integral constant expression, then compare it against the
3638 // values of each enumerator. However, value-based approach would not
3639 // work as well with C++ templates where enumerators declared within a
3640 // template are type- and value-dependent.
3641 EnumeratorsSeen.insert(Enumerator);
3642
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00003643 // If this is a qualified-id, keep track of the nested-name-specifier
3644 // so that we can reproduce it as part of code completion, e.g.,
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003645 //
3646 // switch (TagD.getKind()) {
3647 // case TagDecl::TK_enum:
3648 // break;
3649 // case XXX
3650 //
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00003651 // At the XXX, our completions are TagDecl::TK_union,
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003652 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
3653 // TK_struct, and TK_class.
Douglas Gregora2813ce2009-10-23 18:54:35 +00003654 Qualifier = DRE->getQualifier();
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003655 }
3656 }
3657
David Blaikie4e4d0842012-03-11 07:00:24 +00003658 if (getLangOpts().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) {
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00003659 // If there are no prior enumerators in C++, check whether we have to
3660 // qualify the names of the enumerators that we suggest, because they
3661 // may not be visible in this scope.
Douglas Gregorb223d8c2012-02-01 05:02:47 +00003662 Qualifier = getRequiredQualification(Context, CurContext, Enum);
Douglas Gregorb9d0ef72009-09-21 19:57:38 +00003663 }
3664
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003665 // Add any enumerators that have not yet been mentioned.
Douglas Gregor218937c2011-02-01 19:23:04 +00003666 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3667 CodeCompletionContext::CCC_Expression);
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003668 Results.EnterNewScope();
3669 for (EnumDecl::enumerator_iterator E = Enum->enumerator_begin(),
3670 EEnd = Enum->enumerator_end();
3671 E != EEnd; ++E) {
3672 if (EnumeratorsSeen.count(*E))
3673 continue;
3674
Douglas Gregor5c722c702011-02-18 23:30:37 +00003675 CodeCompletionResult R(*E, Qualifier);
3676 R.Priority = CCP_EnumInCase;
3677 Results.AddResult(R, CurContext, 0, false);
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003678 }
3679 Results.ExitScope();
Douglas Gregor2f880e42010-04-06 20:02:15 +00003680
Douglas Gregor3da626b2011-07-07 16:03:39 +00003681 //We need to make sure we're setting the right context,
3682 //so only say we include macros if the code completer says we do
3683 enum CodeCompletionContext::Kind kind = CodeCompletionContext::CCC_Other;
3684 if (CodeCompleter->includeMacros()) {
Douglas Gregorbca403c2010-01-13 23:51:12 +00003685 AddMacroResults(PP, Results);
Douglas Gregor3da626b2011-07-07 16:03:39 +00003686 kind = CodeCompletionContext::CCC_OtherWithMacros;
3687 }
3688
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003689 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor3da626b2011-07-07 16:03:39 +00003690 kind,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003691 Results.data(),Results.size());
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003692}
3693
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003694namespace {
3695 struct IsBetterOverloadCandidate {
3696 Sema &S;
John McCall5769d612010-02-08 23:07:23 +00003697 SourceLocation Loc;
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003698
3699 public:
John McCall5769d612010-02-08 23:07:23 +00003700 explicit IsBetterOverloadCandidate(Sema &S, SourceLocation Loc)
3701 : S(S), Loc(Loc) { }
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003702
3703 bool
3704 operator()(const OverloadCandidate &X, const OverloadCandidate &Y) const {
John McCall120d63c2010-08-24 20:38:10 +00003705 return isBetterOverloadCandidate(S, X, Y, Loc);
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003706 }
3707 };
3708}
3709
Ahmed Charles13a140c2012-02-25 11:00:22 +00003710static bool anyNullArguments(llvm::ArrayRef<Expr*> Args) {
3711 if (Args.size() && !Args.data())
Douglas Gregord28dcd72010-05-30 06:10:08 +00003712 return true;
Ahmed Charles13a140c2012-02-25 11:00:22 +00003713
3714 for (unsigned I = 0; I != Args.size(); ++I)
Douglas Gregord28dcd72010-05-30 06:10:08 +00003715 if (!Args[I])
3716 return true;
Ahmed Charles13a140c2012-02-25 11:00:22 +00003717
Douglas Gregord28dcd72010-05-30 06:10:08 +00003718 return false;
3719}
3720
Richard Trieuf81e5a92011-09-09 02:00:50 +00003721void Sema::CodeCompleteCall(Scope *S, Expr *FnIn,
Ahmed Charles13a140c2012-02-25 11:00:22 +00003722 llvm::ArrayRef<Expr *> Args) {
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003723 if (!CodeCompleter)
3724 return;
Douglas Gregoref96eac2009-12-11 19:06:04 +00003725
3726 // When we're code-completing for a call, we fall back to ordinary
3727 // name code-completion whenever we can't produce specific
3728 // results. We may want to revisit this strategy in the future,
3729 // e.g., by merging the two kinds of results.
3730
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003731 Expr *Fn = (Expr *)FnIn;
Douglas Gregoref96eac2009-12-11 19:06:04 +00003732
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003733 // Ignore type-dependent call expressions entirely.
Ahmed Charles13a140c2012-02-25 11:00:22 +00003734 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
3735 Expr::hasAnyTypeDependentArguments(Args)) {
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003736 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003737 return;
Douglas Gregoref96eac2009-12-11 19:06:04 +00003738 }
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003739
John McCall3b4294e2009-12-16 12:17:52 +00003740 // Build an overload candidate set based on the functions we find.
John McCall5769d612010-02-08 23:07:23 +00003741 SourceLocation Loc = Fn->getExprLoc();
3742 OverloadCandidateSet CandidateSet(Loc);
John McCall3b4294e2009-12-16 12:17:52 +00003743
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003744 // FIXME: What if we're calling something that isn't a function declaration?
3745 // FIXME: What if we're calling a pseudo-destructor?
3746 // FIXME: What if we're calling a member function?
3747
Douglas Gregorc0265402010-01-21 15:46:19 +00003748 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate;
Chris Lattner5f9e2722011-07-23 10:55:15 +00003749 SmallVector<ResultCandidate, 8> Results;
Douglas Gregorc0265402010-01-21 15:46:19 +00003750
John McCall3b4294e2009-12-16 12:17:52 +00003751 Expr *NakedFn = Fn->IgnoreParenCasts();
3752 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
Ahmed Charles13a140c2012-02-25 11:00:22 +00003753 AddOverloadedCallCandidates(ULE, Args, CandidateSet,
John McCall3b4294e2009-12-16 12:17:52 +00003754 /*PartialOverloading=*/ true);
3755 else if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(NakedFn)) {
3756 FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
Douglas Gregorc0265402010-01-21 15:46:19 +00003757 if (FDecl) {
David Blaikie4e4d0842012-03-11 07:00:24 +00003758 if (!getLangOpts().CPlusPlus ||
Douglas Gregord28dcd72010-05-30 06:10:08 +00003759 !FDecl->getType()->getAs<FunctionProtoType>())
Douglas Gregorc0265402010-01-21 15:46:19 +00003760 Results.push_back(ResultCandidate(FDecl));
3761 else
John McCall86820f52010-01-26 01:37:31 +00003762 // FIXME: access?
Ahmed Charles13a140c2012-02-25 11:00:22 +00003763 AddOverloadCandidate(FDecl, DeclAccessPair::make(FDecl, AS_none), Args,
3764 CandidateSet, false, /*PartialOverloading*/true);
Douglas Gregorc0265402010-01-21 15:46:19 +00003765 }
John McCall3b4294e2009-12-16 12:17:52 +00003766 }
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003767
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003768 QualType ParamType;
3769
Douglas Gregorc0265402010-01-21 15:46:19 +00003770 if (!CandidateSet.empty()) {
3771 // Sort the overload candidate set by placing the best overloads first.
3772 std::stable_sort(CandidateSet.begin(), CandidateSet.end(),
John McCall5769d612010-02-08 23:07:23 +00003773 IsBetterOverloadCandidate(*this, Loc));
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003774
Douglas Gregorc0265402010-01-21 15:46:19 +00003775 // Add the remaining viable overload candidates as code-completion reslults.
3776 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(),
3777 CandEnd = CandidateSet.end();
3778 Cand != CandEnd; ++Cand) {
3779 if (Cand->Viable)
3780 Results.push_back(ResultCandidate(Cand->Function));
3781 }
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003782
3783 // From the viable candidates, try to determine the type of this parameter.
3784 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
3785 if (const FunctionType *FType = Results[I].getFunctionType())
3786 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FType))
Ahmed Charles13a140c2012-02-25 11:00:22 +00003787 if (Args.size() < Proto->getNumArgs()) {
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003788 if (ParamType.isNull())
Ahmed Charles13a140c2012-02-25 11:00:22 +00003789 ParamType = Proto->getArgType(Args.size());
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003790 else if (!Context.hasSameUnqualifiedType(
3791 ParamType.getNonReferenceType(),
Ahmed Charles13a140c2012-02-25 11:00:22 +00003792 Proto->getArgType(Args.size()).getNonReferenceType())) {
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003793 ParamType = QualType();
3794 break;
3795 }
3796 }
3797 }
3798 } else {
3799 // Try to determine the parameter type from the type of the expression
3800 // being called.
3801 QualType FunctionType = Fn->getType();
3802 if (const PointerType *Ptr = FunctionType->getAs<PointerType>())
3803 FunctionType = Ptr->getPointeeType();
3804 else if (const BlockPointerType *BlockPtr
3805 = FunctionType->getAs<BlockPointerType>())
3806 FunctionType = BlockPtr->getPointeeType();
3807 else if (const MemberPointerType *MemPtr
3808 = FunctionType->getAs<MemberPointerType>())
3809 FunctionType = MemPtr->getPointeeType();
3810
3811 if (const FunctionProtoType *Proto
3812 = FunctionType->getAs<FunctionProtoType>()) {
Ahmed Charles13a140c2012-02-25 11:00:22 +00003813 if (Args.size() < Proto->getNumArgs())
3814 ParamType = Proto->getArgType(Args.size());
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003815 }
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003816 }
Douglas Gregoref96eac2009-12-11 19:06:04 +00003817
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003818 if (ParamType.isNull())
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003819 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003820 else
3821 CodeCompleteExpression(S, ParamType);
3822
Douglas Gregor2e4c7a52010-04-06 20:19:47 +00003823 if (!Results.empty())
Ahmed Charles13a140c2012-02-25 11:00:22 +00003824 CodeCompleter->ProcessOverloadCandidates(*this, Args.size(), Results.data(),
Douglas Gregoref96eac2009-12-11 19:06:04 +00003825 Results.size());
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003826}
3827
John McCalld226f652010-08-21 09:40:31 +00003828void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
3829 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003830 if (!VD) {
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003831 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003832 return;
3833 }
3834
3835 CodeCompleteExpression(S, VD->getType());
3836}
3837
3838void Sema::CodeCompleteReturn(Scope *S) {
3839 QualType ResultType;
3840 if (isa<BlockDecl>(CurContext)) {
3841 if (BlockScopeInfo *BSI = getCurBlock())
3842 ResultType = BSI->ReturnType;
3843 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext))
3844 ResultType = Function->getResultType();
3845 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext))
3846 ResultType = Method->getResultType();
3847
3848 if (ResultType.isNull())
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003849 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003850 else
3851 CodeCompleteExpression(S, ResultType);
3852}
3853
Douglas Gregord2d8be62011-07-30 08:36:53 +00003854void Sema::CodeCompleteAfterIf(Scope *S) {
3855 typedef CodeCompletionResult Result;
3856 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3857 mapCodeCompletionContext(*this, PCC_Statement));
3858 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3859 Results.EnterNewScope();
3860
3861 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3862 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3863 CodeCompleter->includeGlobals());
3864
3865 AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
3866
3867 // "else" block
3868 CodeCompletionBuilder Builder(Results.getAllocator());
3869 Builder.AddTypedTextChunk("else");
Douglas Gregorf11641a2012-02-16 17:49:04 +00003870 if (Results.includeCodePatterns()) {
3871 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3872 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
3873 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3874 Builder.AddPlaceholderChunk("statements");
3875 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3876 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
3877 }
Douglas Gregord2d8be62011-07-30 08:36:53 +00003878 Results.AddResult(Builder.TakeString());
3879
3880 // "else if" block
3881 Builder.AddTypedTextChunk("else");
3882 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3883 Builder.AddTextChunk("if");
3884 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3885 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
David Blaikie4e4d0842012-03-11 07:00:24 +00003886 if (getLangOpts().CPlusPlus)
Douglas Gregord2d8be62011-07-30 08:36:53 +00003887 Builder.AddPlaceholderChunk("condition");
3888 else
3889 Builder.AddPlaceholderChunk("expression");
3890 Builder.AddChunk(CodeCompletionString::CK_RightParen);
Douglas Gregorf11641a2012-02-16 17:49:04 +00003891 if (Results.includeCodePatterns()) {
3892 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3893 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
3894 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3895 Builder.AddPlaceholderChunk("statements");
3896 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3897 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
3898 }
Douglas Gregord2d8be62011-07-30 08:36:53 +00003899 Results.AddResult(Builder.TakeString());
3900
3901 Results.ExitScope();
3902
3903 if (S->getFnParent())
David Blaikie4e4d0842012-03-11 07:00:24 +00003904 AddPrettyFunctionResults(PP.getLangOpts(), Results);
Douglas Gregord2d8be62011-07-30 08:36:53 +00003905
3906 if (CodeCompleter->includeMacros())
3907 AddMacroResults(PP, Results);
3908
3909 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3910 Results.data(),Results.size());
3911}
3912
Richard Trieuf81e5a92011-09-09 02:00:50 +00003913void Sema::CodeCompleteAssignmentRHS(Scope *S, Expr *LHS) {
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003914 if (LHS)
3915 CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType());
3916 else
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003917 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor5ac3bdb2010-05-30 01:49:25 +00003918}
3919
Jeffrey Yasskin9ab14542010-04-08 16:38:48 +00003920void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
Douglas Gregor81b747b2009-09-17 21:32:03 +00003921 bool EnteringContext) {
3922 if (!SS.getScopeRep() || !CodeCompleter)
3923 return;
3924
Douglas Gregor86d9a522009-09-21 16:56:56 +00003925 DeclContext *Ctx = computeDeclContext(SS, EnteringContext);
3926 if (!Ctx)
3927 return;
Douglas Gregord1cd31a2009-12-11 18:28:39 +00003928
3929 // Try to instantiate any non-dependent declaration contexts before
3930 // we look in them.
John McCall77bb1aa2010-05-01 00:40:08 +00003931 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
Douglas Gregord1cd31a2009-12-11 18:28:39 +00003932 return;
3933
Douglas Gregor218937c2011-02-01 19:23:04 +00003934 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3935 CodeCompletionContext::CCC_Name);
Douglas Gregorf6961522010-08-27 21:18:54 +00003936 Results.EnterNewScope();
Douglas Gregor52779fb2010-09-23 23:01:17 +00003937
Douglas Gregor86d9a522009-09-21 16:56:56 +00003938 // The "template" keyword can follow "::" in the grammar, but only
3939 // put it into the grammar if the nested-name-specifier is dependent.
3940 NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep();
3941 if (!Results.empty() && NNS->isDependent())
Douglas Gregora4477812010-01-14 16:01:26 +00003942 Results.AddResult("template");
Douglas Gregorf6961522010-08-27 21:18:54 +00003943
3944 // Add calls to overridden virtual functions, if there are any.
3945 //
3946 // FIXME: This isn't wonderful, because we don't know whether we're actually
3947 // in a context that permits expressions. This is a general issue with
3948 // qualified-id completions.
3949 if (!EnteringContext)
3950 MaybeAddOverrideCalls(*this, Ctx, Results);
3951 Results.ExitScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003952
Douglas Gregorf6961522010-08-27 21:18:54 +00003953 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3954 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer);
3955
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003956 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor430d7a12011-07-25 17:48:11 +00003957 Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003958 Results.data(),Results.size());
Douglas Gregor81b747b2009-09-17 21:32:03 +00003959}
Douglas Gregor49f40bd2009-09-18 19:03:04 +00003960
3961void Sema::CodeCompleteUsing(Scope *S) {
3962 if (!CodeCompleter)
3963 return;
3964
Douglas Gregor218937c2011-02-01 19:23:04 +00003965 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00003966 CodeCompletionContext::CCC_PotentiallyQualifiedName,
3967 &ResultBuilder::IsNestedNameSpecifier);
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003968 Results.EnterNewScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003969
3970 // If we aren't in class scope, we could see the "namespace" keyword.
3971 if (!S->isClassScope())
John McCall0a2c5e22010-08-25 06:19:51 +00003972 Results.AddResult(CodeCompletionResult("namespace"));
Douglas Gregor86d9a522009-09-21 16:56:56 +00003973
3974 // After "using", we can see anything that would start a
3975 // nested-name-specifier.
Douglas Gregor5d2fc402010-01-14 03:27:13 +00003976 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00003977 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3978 CodeCompleter->includeGlobals());
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003979 Results.ExitScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00003980
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003981 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003982 CodeCompletionContext::CCC_PotentiallyQualifiedName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00003983 Results.data(),Results.size());
Douglas Gregor49f40bd2009-09-18 19:03:04 +00003984}
3985
3986void Sema::CodeCompleteUsingDirective(Scope *S) {
3987 if (!CodeCompleter)
3988 return;
3989
Douglas Gregor86d9a522009-09-21 16:56:56 +00003990 // After "using namespace", we expect to see a namespace name or namespace
3991 // alias.
Douglas Gregor218937c2011-02-01 19:23:04 +00003992 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3993 CodeCompletionContext::CCC_Namespace,
Douglas Gregor52779fb2010-09-23 23:01:17 +00003994 &ResultBuilder::IsNamespaceOrAlias);
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003995 Results.EnterNewScope();
Douglas Gregor5d2fc402010-01-14 03:27:13 +00003996 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00003997 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3998 CodeCompleter->includeGlobals());
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00003999 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004000 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor8071e422010-08-15 06:18:01 +00004001 CodeCompletionContext::CCC_Namespace,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004002 Results.data(),Results.size());
Douglas Gregor49f40bd2009-09-18 19:03:04 +00004003}
4004
4005void Sema::CodeCompleteNamespaceDecl(Scope *S) {
4006 if (!CodeCompleter)
4007 return;
4008
Douglas Gregor86d9a522009-09-21 16:56:56 +00004009 DeclContext *Ctx = (DeclContext *)S->getEntity();
4010 if (!S->getParent())
4011 Ctx = Context.getTranslationUnitDecl();
4012
Douglas Gregor52779fb2010-09-23 23:01:17 +00004013 bool SuppressedGlobalResults
4014 = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
4015
Douglas Gregor218937c2011-02-01 19:23:04 +00004016 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00004017 SuppressedGlobalResults
4018 ? CodeCompletionContext::CCC_Namespace
4019 : CodeCompletionContext::CCC_Other,
4020 &ResultBuilder::IsNamespace);
4021
4022 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
Douglas Gregor86d9a522009-09-21 16:56:56 +00004023 // We only want to see those namespaces that have already been defined
4024 // within this scope, because its likely that the user is creating an
4025 // extended namespace declaration. Keep track of the most recent
4026 // definition of each namespace.
4027 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
4028 for (DeclContext::specific_decl_iterator<NamespaceDecl>
4029 NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end());
4030 NS != NSEnd; ++NS)
4031 OrigToLatest[NS->getOriginalNamespace()] = *NS;
4032
4033 // Add the most recent definition (or extended definition) of each
4034 // namespace to the list of results.
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00004035 Results.EnterNewScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00004036 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
4037 NS = OrigToLatest.begin(), NSEnd = OrigToLatest.end();
4038 NS != NSEnd; ++NS)
John McCall0a2c5e22010-08-25 06:19:51 +00004039 Results.AddResult(CodeCompletionResult(NS->second, 0),
Douglas Gregor608300b2010-01-14 16:14:35 +00004040 CurContext, 0, false);
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00004041 Results.ExitScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00004042 }
4043
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004044 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor52779fb2010-09-23 23:01:17 +00004045 Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004046 Results.data(),Results.size());
Douglas Gregor49f40bd2009-09-18 19:03:04 +00004047}
4048
4049void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) {
4050 if (!CodeCompleter)
4051 return;
4052
Douglas Gregor86d9a522009-09-21 16:56:56 +00004053 // After "namespace", we expect to see a namespace or alias.
Douglas Gregor218937c2011-02-01 19:23:04 +00004054 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4055 CodeCompletionContext::CCC_Namespace,
Douglas Gregor52779fb2010-09-23 23:01:17 +00004056 &ResultBuilder::IsNamespaceOrAlias);
Douglas Gregor5d2fc402010-01-14 03:27:13 +00004057 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00004058 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4059 CodeCompleter->includeGlobals());
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004060 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor52779fb2010-09-23 23:01:17 +00004061 Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004062 Results.data(),Results.size());
Douglas Gregor49f40bd2009-09-18 19:03:04 +00004063}
4064
Douglas Gregored8d3222009-09-18 20:05:18 +00004065void Sema::CodeCompleteOperatorName(Scope *S) {
4066 if (!CodeCompleter)
4067 return;
Douglas Gregor86d9a522009-09-21 16:56:56 +00004068
John McCall0a2c5e22010-08-25 06:19:51 +00004069 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004070 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4071 CodeCompletionContext::CCC_Type,
Douglas Gregor52779fb2010-09-23 23:01:17 +00004072 &ResultBuilder::IsType);
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00004073 Results.EnterNewScope();
Douglas Gregored8d3222009-09-18 20:05:18 +00004074
Douglas Gregor86d9a522009-09-21 16:56:56 +00004075 // Add the names of overloadable operators.
4076#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4077 if (std::strcmp(Spelling, "?")) \
Douglas Gregora4477812010-01-14 16:01:26 +00004078 Results.AddResult(Result(Spelling));
Douglas Gregor86d9a522009-09-21 16:56:56 +00004079#include "clang/Basic/OperatorKinds.def"
4080
4081 // Add any type names visible from the current scope
Douglas Gregor45bcd432010-01-14 03:21:49 +00004082 Results.allowNestedNameSpecifiers();
Douglas Gregor5d2fc402010-01-14 03:27:13 +00004083 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor8071e422010-08-15 06:18:01 +00004084 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4085 CodeCompleter->includeGlobals());
Douglas Gregor86d9a522009-09-21 16:56:56 +00004086
4087 // Add any type specifiers
David Blaikie4e4d0842012-03-11 07:00:24 +00004088 AddTypeSpecifierResults(getLangOpts(), Results);
Douglas Gregor8e0a0e42009-09-22 23:31:26 +00004089 Results.ExitScope();
Douglas Gregor86d9a522009-09-21 16:56:56 +00004090
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004091 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor8071e422010-08-15 06:18:01 +00004092 CodeCompletionContext::CCC_Type,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004093 Results.data(),Results.size());
Douglas Gregored8d3222009-09-18 20:05:18 +00004094}
Douglas Gregor49f40bd2009-09-18 19:03:04 +00004095
Douglas Gregor0133f522010-08-28 00:00:50 +00004096void Sema::CodeCompleteConstructorInitializer(Decl *ConstructorD,
Sean Huntcbb67482011-01-08 20:30:50 +00004097 CXXCtorInitializer** Initializers,
Douglas Gregor0133f522010-08-28 00:00:50 +00004098 unsigned NumInitializers) {
Douglas Gregor8987b232011-09-27 23:30:47 +00004099 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
Douglas Gregor0133f522010-08-28 00:00:50 +00004100 CXXConstructorDecl *Constructor
4101 = static_cast<CXXConstructorDecl *>(ConstructorD);
4102 if (!Constructor)
4103 return;
4104
Douglas Gregor218937c2011-02-01 19:23:04 +00004105 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00004106 CodeCompletionContext::CCC_PotentiallyQualifiedName);
Douglas Gregor0133f522010-08-28 00:00:50 +00004107 Results.EnterNewScope();
4108
4109 // Fill in any already-initialized fields or base classes.
4110 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
4111 llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
4112 for (unsigned I = 0; I != NumInitializers; ++I) {
4113 if (Initializers[I]->isBaseInitializer())
4114 InitializedBases.insert(
4115 Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
4116 else
Francois Pichet00eb3f92010-12-04 09:14:42 +00004117 InitializedFields.insert(cast<FieldDecl>(
4118 Initializers[I]->getAnyMember()));
Douglas Gregor0133f522010-08-28 00:00:50 +00004119 }
4120
4121 // Add completions for base classes.
Douglas Gregor218937c2011-02-01 19:23:04 +00004122 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor0c431c82010-08-29 19:27:27 +00004123 bool SawLastInitializer = (NumInitializers == 0);
Douglas Gregor0133f522010-08-28 00:00:50 +00004124 CXXRecordDecl *ClassDecl = Constructor->getParent();
4125 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(),
4126 BaseEnd = ClassDecl->bases_end();
4127 Base != BaseEnd; ++Base) {
Douglas Gregor0c431c82010-08-29 19:27:27 +00004128 if (!InitializedBases.insert(Context.getCanonicalType(Base->getType()))) {
4129 SawLastInitializer
4130 = NumInitializers > 0 &&
4131 Initializers[NumInitializers - 1]->isBaseInitializer() &&
4132 Context.hasSameUnqualifiedType(Base->getType(),
4133 QualType(Initializers[NumInitializers - 1]->getBaseClass(), 0));
Douglas Gregor0133f522010-08-28 00:00:50 +00004134 continue;
Douglas Gregor0c431c82010-08-29 19:27:27 +00004135 }
Douglas Gregor0133f522010-08-28 00:00:50 +00004136
Douglas Gregor218937c2011-02-01 19:23:04 +00004137 Builder.AddTypedTextChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00004138 Results.getAllocator().CopyString(
John McCallf85e1932011-06-15 23:02:42 +00004139 Base->getType().getAsString(Policy)));
Douglas Gregor218937c2011-02-01 19:23:04 +00004140 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4141 Builder.AddPlaceholderChunk("args");
4142 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4143 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
Douglas Gregor0c431c82010-08-29 19:27:27 +00004144 SawLastInitializer? CCP_NextInitializer
4145 : CCP_MemberDeclaration));
4146 SawLastInitializer = false;
Douglas Gregor0133f522010-08-28 00:00:50 +00004147 }
4148
4149 // Add completions for virtual base classes.
4150 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(),
4151 BaseEnd = ClassDecl->vbases_end();
4152 Base != BaseEnd; ++Base) {
Douglas Gregor0c431c82010-08-29 19:27:27 +00004153 if (!InitializedBases.insert(Context.getCanonicalType(Base->getType()))) {
4154 SawLastInitializer
4155 = NumInitializers > 0 &&
4156 Initializers[NumInitializers - 1]->isBaseInitializer() &&
4157 Context.hasSameUnqualifiedType(Base->getType(),
4158 QualType(Initializers[NumInitializers - 1]->getBaseClass(), 0));
Douglas Gregor0133f522010-08-28 00:00:50 +00004159 continue;
Douglas Gregor0c431c82010-08-29 19:27:27 +00004160 }
Douglas Gregor0133f522010-08-28 00:00:50 +00004161
Douglas Gregor218937c2011-02-01 19:23:04 +00004162 Builder.AddTypedTextChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00004163 Builder.getAllocator().CopyString(
John McCallf85e1932011-06-15 23:02:42 +00004164 Base->getType().getAsString(Policy)));
Douglas Gregor218937c2011-02-01 19:23:04 +00004165 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4166 Builder.AddPlaceholderChunk("args");
4167 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4168 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
Douglas Gregor0c431c82010-08-29 19:27:27 +00004169 SawLastInitializer? CCP_NextInitializer
4170 : CCP_MemberDeclaration));
4171 SawLastInitializer = false;
Douglas Gregor0133f522010-08-28 00:00:50 +00004172 }
4173
4174 // Add completions for members.
4175 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
4176 FieldEnd = ClassDecl->field_end();
4177 Field != FieldEnd; ++Field) {
Douglas Gregor0c431c82010-08-29 19:27:27 +00004178 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))) {
4179 SawLastInitializer
4180 = NumInitializers > 0 &&
Francois Pichet00eb3f92010-12-04 09:14:42 +00004181 Initializers[NumInitializers - 1]->isAnyMemberInitializer() &&
4182 Initializers[NumInitializers - 1]->getAnyMember() == *Field;
Douglas Gregor0133f522010-08-28 00:00:50 +00004183 continue;
Douglas Gregor0c431c82010-08-29 19:27:27 +00004184 }
Douglas Gregor0133f522010-08-28 00:00:50 +00004185
4186 if (!Field->getDeclName())
4187 continue;
4188
Douglas Gregordae68752011-02-01 22:57:45 +00004189 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00004190 Field->getIdentifier()->getName()));
4191 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4192 Builder.AddPlaceholderChunk("args");
4193 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4194 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
Douglas Gregor0c431c82010-08-29 19:27:27 +00004195 SawLastInitializer? CCP_NextInitializer
Douglas Gregora67e03f2010-09-09 21:42:20 +00004196 : CCP_MemberDeclaration,
4197 CXCursor_MemberRef));
Douglas Gregor0c431c82010-08-29 19:27:27 +00004198 SawLastInitializer = false;
Douglas Gregor0133f522010-08-28 00:00:50 +00004199 }
4200 Results.ExitScope();
4201
Douglas Gregor52779fb2010-09-23 23:01:17 +00004202 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregor0133f522010-08-28 00:00:50 +00004203 Results.data(), Results.size());
4204}
4205
Douglas Gregor81f3bff2012-02-15 15:34:24 +00004206/// \brief Determine whether this scope denotes a namespace.
4207static bool isNamespaceScope(Scope *S) {
4208 DeclContext *DC = static_cast<DeclContext *>(S->getEntity());
4209 if (!DC)
4210 return false;
4211
4212 return DC->isFileContext();
4213}
4214
4215void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
4216 bool AfterAmpersand) {
4217 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4218 CodeCompletionContext::CCC_Other);
4219 Results.EnterNewScope();
4220
4221 // Note what has already been captured.
4222 llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
4223 bool IncludedThis = false;
4224 for (SmallVectorImpl<LambdaCapture>::iterator C = Intro.Captures.begin(),
4225 CEnd = Intro.Captures.end();
4226 C != CEnd; ++C) {
4227 if (C->Kind == LCK_This) {
4228 IncludedThis = true;
4229 continue;
4230 }
4231
4232 Known.insert(C->Id);
4233 }
4234
4235 // Look for other capturable variables.
4236 for (; S && !isNamespaceScope(S); S = S->getParent()) {
4237 for (Scope::decl_iterator D = S->decl_begin(), DEnd = S->decl_end();
4238 D != DEnd; ++D) {
4239 VarDecl *Var = dyn_cast<VarDecl>(*D);
4240 if (!Var ||
4241 !Var->hasLocalStorage() ||
4242 Var->hasAttr<BlocksAttr>())
4243 continue;
4244
4245 if (Known.insert(Var->getIdentifier()))
4246 Results.AddResult(CodeCompletionResult(Var), CurContext, 0, false);
4247 }
4248 }
4249
4250 // Add 'this', if it would be valid.
4251 if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
4252 addThisCompletion(*this, Results);
4253
4254 Results.ExitScope();
4255
4256 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4257 Results.data(), Results.size());
4258}
4259
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004260// Macro that expands to @Keyword or Keyword, depending on whether NeedAt is
4261// true or false.
4262#define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) NeedAt? "@" #Keyword : #Keyword
Douglas Gregorbca403c2010-01-13 23:51:12 +00004263static void AddObjCImplementationResults(const LangOptions &LangOpts,
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004264 ResultBuilder &Results,
4265 bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004266 typedef CodeCompletionResult Result;
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004267 // Since we have an implementation, we can end it.
Douglas Gregora4477812010-01-14 16:01:26 +00004268 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,end)));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004269
Douglas Gregor218937c2011-02-01 19:23:04 +00004270 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004271 if (LangOpts.ObjC2) {
4272 // @dynamic
Douglas Gregor218937c2011-02-01 19:23:04 +00004273 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,dynamic));
4274 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4275 Builder.AddPlaceholderChunk("property");
4276 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004277
4278 // @synthesize
Douglas Gregor218937c2011-02-01 19:23:04 +00004279 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,synthesize));
4280 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4281 Builder.AddPlaceholderChunk("property");
4282 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004283 }
4284}
4285
Douglas Gregorbca403c2010-01-13 23:51:12 +00004286static void AddObjCInterfaceResults(const LangOptions &LangOpts,
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004287 ResultBuilder &Results,
4288 bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004289 typedef CodeCompletionResult Result;
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004290
4291 // Since we have an interface or protocol, we can end it.
Douglas Gregora4477812010-01-14 16:01:26 +00004292 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,end)));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004293
4294 if (LangOpts.ObjC2) {
4295 // @property
Douglas Gregora4477812010-01-14 16:01:26 +00004296 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,property)));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004297
4298 // @required
Douglas Gregora4477812010-01-14 16:01:26 +00004299 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,required)));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004300
4301 // @optional
Douglas Gregora4477812010-01-14 16:01:26 +00004302 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,optional)));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004303 }
4304}
4305
Douglas Gregorbca403c2010-01-13 23:51:12 +00004306static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004307 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004308 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004309
4310 // @class name ;
Douglas Gregor218937c2011-02-01 19:23:04 +00004311 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,class));
4312 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4313 Builder.AddPlaceholderChunk("name");
4314 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004315
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004316 if (Results.includeCodePatterns()) {
4317 // @interface name
4318 // FIXME: Could introduce the whole pattern, including superclasses and
4319 // such.
Douglas Gregor218937c2011-02-01 19:23:04 +00004320 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,interface));
4321 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4322 Builder.AddPlaceholderChunk("class");
4323 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004324
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004325 // @protocol name
Douglas Gregor218937c2011-02-01 19:23:04 +00004326 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,protocol));
4327 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4328 Builder.AddPlaceholderChunk("protocol");
4329 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004330
4331 // @implementation name
Douglas Gregor218937c2011-02-01 19:23:04 +00004332 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,implementation));
4333 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4334 Builder.AddPlaceholderChunk("class");
4335 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004336 }
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004337
4338 // @compatibility_alias name
Douglas Gregor218937c2011-02-01 19:23:04 +00004339 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,compatibility_alias));
4340 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4341 Builder.AddPlaceholderChunk("alias");
4342 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4343 Builder.AddPlaceholderChunk("class");
4344 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004345}
4346
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004347void Sema::CodeCompleteObjCAtDirective(Scope *S) {
John McCall0a2c5e22010-08-25 06:19:51 +00004348 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004349 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4350 CodeCompletionContext::CCC_Other);
Douglas Gregorc464ae82009-12-07 09:27:33 +00004351 Results.EnterNewScope();
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004352 if (isa<ObjCImplDecl>(CurContext))
David Blaikie4e4d0842012-03-11 07:00:24 +00004353 AddObjCImplementationResults(getLangOpts(), Results, false);
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004354 else if (CurContext->isObjCContainer())
David Blaikie4e4d0842012-03-11 07:00:24 +00004355 AddObjCInterfaceResults(getLangOpts(), Results, false);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004356 else
Douglas Gregorbca403c2010-01-13 23:51:12 +00004357 AddObjCTopLevelResults(Results, false);
Douglas Gregorc464ae82009-12-07 09:27:33 +00004358 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004359 HandleCodeCompleteResults(this, CodeCompleter,
4360 CodeCompletionContext::CCC_Other,
4361 Results.data(),Results.size());
Douglas Gregorc464ae82009-12-07 09:27:33 +00004362}
4363
Douglas Gregorbca403c2010-01-13 23:51:12 +00004364static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004365 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004366 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004367
4368 // @encode ( type-name )
Douglas Gregor8ca72082011-10-18 21:20:17 +00004369 const char *EncodeType = "char[]";
David Blaikie4e4d0842012-03-11 07:00:24 +00004370 if (Results.getSema().getLangOpts().CPlusPlus ||
4371 Results.getSema().getLangOpts().ConstStrings)
Douglas Gregor8ca72082011-10-18 21:20:17 +00004372 EncodeType = " const char[]";
4373 Builder.AddResultTypeChunk(EncodeType);
Douglas Gregor218937c2011-02-01 19:23:04 +00004374 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,encode));
4375 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4376 Builder.AddPlaceholderChunk("type-name");
4377 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4378 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004379
4380 // @protocol ( protocol-name )
Douglas Gregor8ca72082011-10-18 21:20:17 +00004381 Builder.AddResultTypeChunk("Protocol *");
Douglas Gregor218937c2011-02-01 19:23:04 +00004382 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,protocol));
4383 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4384 Builder.AddPlaceholderChunk("protocol-name");
4385 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4386 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004387
4388 // @selector ( selector )
Douglas Gregor8ca72082011-10-18 21:20:17 +00004389 Builder.AddResultTypeChunk("SEL");
Douglas Gregor218937c2011-02-01 19:23:04 +00004390 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,selector));
4391 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4392 Builder.AddPlaceholderChunk("selector");
4393 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4394 Results.AddResult(Result(Builder.TakeString()));
Ted Kremenekebcb57a2012-03-06 20:05:56 +00004395
4396 // @[ objects, ... ]
4397 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,[));
4398 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4399 Builder.AddPlaceholderChunk("objects, ...");
4400 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4401 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
4402 Results.AddResult(Result(Builder.TakeString()));
4403
4404 // @{ key : object, ... }
4405 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,{));
4406 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4407 Builder.AddPlaceholderChunk("key");
4408 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4409 Builder.AddChunk(CodeCompletionString::CK_Colon);
4410 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4411 Builder.AddPlaceholderChunk("object, ...");
4412 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4413 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4414 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004415}
4416
Douglas Gregorbca403c2010-01-13 23:51:12 +00004417static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004418 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004419 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004420
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004421 if (Results.includeCodePatterns()) {
4422 // @try { statements } @catch ( declaration ) { statements } @finally
4423 // { statements }
Douglas Gregor218937c2011-02-01 19:23:04 +00004424 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,try));
4425 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4426 Builder.AddPlaceholderChunk("statements");
4427 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4428 Builder.AddTextChunk("@catch");
4429 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4430 Builder.AddPlaceholderChunk("parameter");
4431 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4432 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4433 Builder.AddPlaceholderChunk("statements");
4434 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4435 Builder.AddTextChunk("@finally");
4436 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4437 Builder.AddPlaceholderChunk("statements");
4438 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4439 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004440 }
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004441
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004442 // @throw
Douglas Gregor218937c2011-02-01 19:23:04 +00004443 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,throw));
4444 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4445 Builder.AddPlaceholderChunk("expression");
4446 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004447
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004448 if (Results.includeCodePatterns()) {
4449 // @synchronized ( expression ) { statements }
Douglas Gregor218937c2011-02-01 19:23:04 +00004450 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,synchronized));
4451 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4452 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4453 Builder.AddPlaceholderChunk("expression");
4454 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4455 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4456 Builder.AddPlaceholderChunk("statements");
4457 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4458 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorc8bddde2010-05-28 00:22:41 +00004459 }
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004460}
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004461
Douglas Gregorbca403c2010-01-13 23:51:12 +00004462static void AddObjCVisibilityResults(const LangOptions &LangOpts,
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004463 ResultBuilder &Results,
4464 bool NeedAt) {
John McCall0a2c5e22010-08-25 06:19:51 +00004465 typedef CodeCompletionResult Result;
Douglas Gregora4477812010-01-14 16:01:26 +00004466 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,private)));
4467 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,protected)));
4468 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,public)));
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004469 if (LangOpts.ObjC2)
Douglas Gregora4477812010-01-14 16:01:26 +00004470 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,package)));
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004471}
4472
4473void Sema::CodeCompleteObjCAtVisibility(Scope *S) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004474 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4475 CodeCompletionContext::CCC_Other);
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004476 Results.EnterNewScope();
David Blaikie4e4d0842012-03-11 07:00:24 +00004477 AddObjCVisibilityResults(getLangOpts(), Results, false);
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004478 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004479 HandleCodeCompleteResults(this, CodeCompleter,
4480 CodeCompletionContext::CCC_Other,
4481 Results.data(),Results.size());
Douglas Gregorc38c3e12010-01-13 21:54:15 +00004482}
4483
4484void Sema::CodeCompleteObjCAtStatement(Scope *S) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004485 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4486 CodeCompletionContext::CCC_Other);
Douglas Gregorb6ac2452010-01-13 21:24:21 +00004487 Results.EnterNewScope();
Douglas Gregorbca403c2010-01-13 23:51:12 +00004488 AddObjCStatementResults(Results, false);
4489 AddObjCExpressionResults(Results, false);
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004490 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004491 HandleCodeCompleteResults(this, CodeCompleter,
4492 CodeCompletionContext::CCC_Other,
4493 Results.data(),Results.size());
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004494}
4495
4496void Sema::CodeCompleteObjCAtExpression(Scope *S) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004497 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4498 CodeCompletionContext::CCC_Other);
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004499 Results.EnterNewScope();
Douglas Gregorbca403c2010-01-13 23:51:12 +00004500 AddObjCExpressionResults(Results, false);
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004501 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004502 HandleCodeCompleteResults(this, CodeCompleter,
4503 CodeCompletionContext::CCC_Other,
4504 Results.data(),Results.size());
Douglas Gregor9a0c85e2009-12-07 09:51:25 +00004505}
4506
Douglas Gregor988358f2009-11-19 00:14:45 +00004507/// \brief Determine whether the addition of the given flag to an Objective-C
4508/// property's attributes will cause a conflict.
4509static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
4510 // Check if we've already added this flag.
4511 if (Attributes & NewFlag)
4512 return true;
4513
4514 Attributes |= NewFlag;
4515
4516 // Check for collisions with "readonly".
4517 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
4518 (Attributes & (ObjCDeclSpec::DQ_PR_readwrite |
4519 ObjCDeclSpec::DQ_PR_assign |
John McCallf85e1932011-06-15 23:02:42 +00004520 ObjCDeclSpec::DQ_PR_unsafe_unretained |
Douglas Gregor988358f2009-11-19 00:14:45 +00004521 ObjCDeclSpec::DQ_PR_copy |
John McCallf85e1932011-06-15 23:02:42 +00004522 ObjCDeclSpec::DQ_PR_retain |
4523 ObjCDeclSpec::DQ_PR_strong)))
Douglas Gregor988358f2009-11-19 00:14:45 +00004524 return true;
4525
John McCallf85e1932011-06-15 23:02:42 +00004526 // Check for more than one of { assign, copy, retain, strong }.
Douglas Gregor988358f2009-11-19 00:14:45 +00004527 unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign |
John McCallf85e1932011-06-15 23:02:42 +00004528 ObjCDeclSpec::DQ_PR_unsafe_unretained |
Douglas Gregor988358f2009-11-19 00:14:45 +00004529 ObjCDeclSpec::DQ_PR_copy |
John McCallf85e1932011-06-15 23:02:42 +00004530 ObjCDeclSpec::DQ_PR_retain|
4531 ObjCDeclSpec::DQ_PR_strong);
Douglas Gregor988358f2009-11-19 00:14:45 +00004532 if (AssignCopyRetMask &&
4533 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
John McCallf85e1932011-06-15 23:02:42 +00004534 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
Douglas Gregor988358f2009-11-19 00:14:45 +00004535 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
John McCallf85e1932011-06-15 23:02:42 +00004536 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
4537 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong)
Douglas Gregor988358f2009-11-19 00:14:45 +00004538 return true;
4539
4540 return false;
4541}
4542
Douglas Gregora93b1082009-11-18 23:08:07 +00004543void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) {
Steve Naroffece8e712009-10-08 21:55:05 +00004544 if (!CodeCompleter)
4545 return;
Douglas Gregord3c68542009-11-19 01:08:35 +00004546
Steve Naroffece8e712009-10-08 21:55:05 +00004547 unsigned Attributes = ODS.getPropertyAttributes();
4548
John McCall0a2c5e22010-08-25 06:19:51 +00004549 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004550 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4551 CodeCompletionContext::CCC_Other);
Steve Naroffece8e712009-10-08 21:55:05 +00004552 Results.EnterNewScope();
Douglas Gregor988358f2009-11-19 00:14:45 +00004553 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly))
John McCall0a2c5e22010-08-25 06:19:51 +00004554 Results.AddResult(CodeCompletionResult("readonly"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004555 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign))
John McCall0a2c5e22010-08-25 06:19:51 +00004556 Results.AddResult(CodeCompletionResult("assign"));
John McCallf85e1932011-06-15 23:02:42 +00004557 if (!ObjCPropertyFlagConflicts(Attributes,
4558 ObjCDeclSpec::DQ_PR_unsafe_unretained))
4559 Results.AddResult(CodeCompletionResult("unsafe_unretained"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004560 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite))
John McCall0a2c5e22010-08-25 06:19:51 +00004561 Results.AddResult(CodeCompletionResult("readwrite"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004562 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain))
John McCall0a2c5e22010-08-25 06:19:51 +00004563 Results.AddResult(CodeCompletionResult("retain"));
John McCallf85e1932011-06-15 23:02:42 +00004564 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_strong))
4565 Results.AddResult(CodeCompletionResult("strong"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004566 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy))
John McCall0a2c5e22010-08-25 06:19:51 +00004567 Results.AddResult(CodeCompletionResult("copy"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004568 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic))
John McCall0a2c5e22010-08-25 06:19:51 +00004569 Results.AddResult(CodeCompletionResult("nonatomic"));
Fariborz Jahanian27f45232011-06-11 17:14:27 +00004570 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_atomic))
4571 Results.AddResult(CodeCompletionResult("atomic"));
Douglas Gregor988358f2009-11-19 00:14:45 +00004572 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004573 CodeCompletionBuilder Setter(Results.getAllocator());
4574 Setter.AddTypedTextChunk("setter");
4575 Setter.AddTextChunk(" = ");
4576 Setter.AddPlaceholderChunk("method");
4577 Results.AddResult(CodeCompletionResult(Setter.TakeString()));
Douglas Gregor54f01612009-11-19 00:01:57 +00004578 }
Douglas Gregor988358f2009-11-19 00:14:45 +00004579 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) {
Douglas Gregor218937c2011-02-01 19:23:04 +00004580 CodeCompletionBuilder Getter(Results.getAllocator());
4581 Getter.AddTypedTextChunk("getter");
4582 Getter.AddTextChunk(" = ");
4583 Getter.AddPlaceholderChunk("method");
4584 Results.AddResult(CodeCompletionResult(Getter.TakeString()));
Douglas Gregor54f01612009-11-19 00:01:57 +00004585 }
Steve Naroffece8e712009-10-08 21:55:05 +00004586 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004587 HandleCodeCompleteResults(this, CodeCompleter,
4588 CodeCompletionContext::CCC_Other,
4589 Results.data(),Results.size());
Steve Naroffece8e712009-10-08 21:55:05 +00004590}
Steve Naroffc4df6d22009-11-07 02:08:14 +00004591
Douglas Gregor4ad96852009-11-19 07:41:15 +00004592/// \brief Descripts the kind of Objective-C method that we want to find
4593/// via code completion.
4594enum ObjCMethodKind {
4595 MK_Any, //< Any kind of method, provided it means other specified criteria.
4596 MK_ZeroArgSelector, //< Zero-argument (unary) selector.
4597 MK_OneArgSelector //< One-argument selector.
4598};
4599
Douglas Gregor458433d2010-08-26 15:07:07 +00004600static bool isAcceptableObjCSelector(Selector Sel,
4601 ObjCMethodKind WantKind,
4602 IdentifierInfo **SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004603 unsigned NumSelIdents,
4604 bool AllowSameLength = true) {
Douglas Gregor458433d2010-08-26 15:07:07 +00004605 if (NumSelIdents > Sel.getNumArgs())
4606 return false;
4607
4608 switch (WantKind) {
4609 case MK_Any: break;
4610 case MK_ZeroArgSelector: return Sel.isUnarySelector();
4611 case MK_OneArgSelector: return Sel.getNumArgs() == 1;
4612 }
4613
Douglas Gregorcf544262010-11-17 21:36:08 +00004614 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
4615 return false;
4616
Douglas Gregor458433d2010-08-26 15:07:07 +00004617 for (unsigned I = 0; I != NumSelIdents; ++I)
4618 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
4619 return false;
4620
4621 return true;
4622}
4623
Douglas Gregor4ad96852009-11-19 07:41:15 +00004624static bool isAcceptableObjCMethod(ObjCMethodDecl *Method,
4625 ObjCMethodKind WantKind,
4626 IdentifierInfo **SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004627 unsigned NumSelIdents,
4628 bool AllowSameLength = true) {
Douglas Gregor458433d2010-08-26 15:07:07 +00004629 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004630 NumSelIdents, AllowSameLength);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004631}
Douglas Gregord36adf52010-09-16 16:06:31 +00004632
4633namespace {
4634 /// \brief A set of selectors, which is used to avoid introducing multiple
4635 /// completions with the same selector into the result set.
4636 typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
4637}
4638
Douglas Gregor36ecb042009-11-17 23:22:23 +00004639/// \brief Add all of the Objective-C methods in the given Objective-C
4640/// container to the set of results.
4641///
4642/// The container will be a class, protocol, category, or implementation of
4643/// any of the above. This mether will recurse to include methods from
4644/// the superclasses of classes along with their categories, protocols, and
4645/// implementations.
4646///
4647/// \param Container the container in which we'll look to find methods.
4648///
4649/// \param WantInstance whether to add instance methods (only); if false, this
4650/// routine will add factory methods (only).
4651///
4652/// \param CurContext the context in which we're performing the lookup that
4653/// finds methods.
4654///
Douglas Gregorcf544262010-11-17 21:36:08 +00004655/// \param AllowSameLength Whether we allow a method to be added to the list
4656/// when it has the same number of parameters as we have selector identifiers.
4657///
Douglas Gregor36ecb042009-11-17 23:22:23 +00004658/// \param Results the structure into which we'll add results.
4659static void AddObjCMethods(ObjCContainerDecl *Container,
4660 bool WantInstanceMethods,
Douglas Gregor4ad96852009-11-19 07:41:15 +00004661 ObjCMethodKind WantKind,
Douglas Gregord3c68542009-11-19 01:08:35 +00004662 IdentifierInfo **SelIdents,
4663 unsigned NumSelIdents,
Douglas Gregor36ecb042009-11-17 23:22:23 +00004664 DeclContext *CurContext,
Douglas Gregord36adf52010-09-16 16:06:31 +00004665 VisitedSelectorSet &Selectors,
Douglas Gregorcf544262010-11-17 21:36:08 +00004666 bool AllowSameLength,
Douglas Gregor408be5a2010-08-25 01:08:01 +00004667 ResultBuilder &Results,
4668 bool InOriginalClass = true) {
John McCall0a2c5e22010-08-25 06:19:51 +00004669 typedef CodeCompletionResult Result;
Douglas Gregor36ecb042009-11-17 23:22:23 +00004670 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(),
4671 MEnd = Container->meth_end();
4672 M != MEnd; ++M) {
Douglas Gregord3c68542009-11-19 01:08:35 +00004673 if ((*M)->isInstanceMethod() == WantInstanceMethods) {
4674 // Check whether the selector identifiers we've been given are a
4675 // subset of the identifiers for this particular method.
Douglas Gregorcf544262010-11-17 21:36:08 +00004676 if (!isAcceptableObjCMethod(*M, WantKind, SelIdents, NumSelIdents,
4677 AllowSameLength))
Douglas Gregord3c68542009-11-19 01:08:35 +00004678 continue;
Douglas Gregor4ad96852009-11-19 07:41:15 +00004679
Douglas Gregord36adf52010-09-16 16:06:31 +00004680 if (!Selectors.insert((*M)->getSelector()))
4681 continue;
4682
Douglas Gregord3c68542009-11-19 01:08:35 +00004683 Result R = Result(*M, 0);
4684 R.StartParameter = NumSelIdents;
Douglas Gregor4ad96852009-11-19 07:41:15 +00004685 R.AllParametersAreInformative = (WantKind != MK_Any);
Douglas Gregor408be5a2010-08-25 01:08:01 +00004686 if (!InOriginalClass)
4687 R.Priority += CCD_InBaseClass;
Douglas Gregord3c68542009-11-19 01:08:35 +00004688 Results.MaybeAddResult(R, CurContext);
4689 }
Douglas Gregor36ecb042009-11-17 23:22:23 +00004690 }
4691
Douglas Gregore396c7b2010-09-16 15:34:59 +00004692 // Visit the protocols of protocols.
4693 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +00004694 if (Protocol->hasDefinition()) {
4695 const ObjCList<ObjCProtocolDecl> &Protocols
4696 = Protocol->getReferencedProtocols();
4697 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
4698 E = Protocols.end();
4699 I != E; ++I)
4700 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
4701 NumSelIdents, CurContext, Selectors, AllowSameLength,
4702 Results, false);
4703 }
Douglas Gregore396c7b2010-09-16 15:34:59 +00004704 }
4705
Douglas Gregor36ecb042009-11-17 23:22:23 +00004706 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
Douglas Gregor2e5c15b2011-12-15 05:27:12 +00004707 if (!IFace || !IFace->hasDefinition())
Douglas Gregor36ecb042009-11-17 23:22:23 +00004708 return;
4709
4710 // Add methods in protocols.
4711 const ObjCList<ObjCProtocolDecl> &Protocols= IFace->getReferencedProtocols();
4712 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
4713 E = Protocols.end();
4714 I != E; ++I)
Douglas Gregor4ad96852009-11-19 07:41:15 +00004715 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, NumSelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004716 CurContext, Selectors, AllowSameLength, Results, false);
Douglas Gregor36ecb042009-11-17 23:22:23 +00004717
4718 // Add methods in categories.
4719 for (ObjCCategoryDecl *CatDecl = IFace->getCategoryList(); CatDecl;
4720 CatDecl = CatDecl->getNextClassCategory()) {
Douglas Gregor4ad96852009-11-19 07:41:15 +00004721 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004722 NumSelIdents, CurContext, Selectors, AllowSameLength,
4723 Results, InOriginalClass);
Douglas Gregor36ecb042009-11-17 23:22:23 +00004724
4725 // Add a categories protocol methods.
4726 const ObjCList<ObjCProtocolDecl> &Protocols
4727 = CatDecl->getReferencedProtocols();
4728 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
4729 E = Protocols.end();
4730 I != E; ++I)
Douglas Gregor4ad96852009-11-19 07:41:15 +00004731 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004732 NumSelIdents, CurContext, Selectors, AllowSameLength,
4733 Results, false);
Douglas Gregor36ecb042009-11-17 23:22:23 +00004734
4735 // Add methods in category implementations.
4736 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
Douglas Gregor4ad96852009-11-19 07:41:15 +00004737 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004738 NumSelIdents, CurContext, Selectors, AllowSameLength,
4739 Results, InOriginalClass);
Douglas Gregor36ecb042009-11-17 23:22:23 +00004740 }
4741
4742 // Add methods in superclass.
4743 if (IFace->getSuperClass())
Douglas Gregor4ad96852009-11-19 07:41:15 +00004744 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
Douglas Gregorcf544262010-11-17 21:36:08 +00004745 SelIdents, NumSelIdents, CurContext, Selectors,
4746 AllowSameLength, Results, false);
Douglas Gregor36ecb042009-11-17 23:22:23 +00004747
4748 // Add methods in our implementation, if any.
4749 if (ObjCImplementationDecl *Impl = IFace->getImplementation())
Douglas Gregor4ad96852009-11-19 07:41:15 +00004750 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00004751 NumSelIdents, CurContext, Selectors, AllowSameLength,
4752 Results, InOriginalClass);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004753}
4754
4755
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004756void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
John McCall0a2c5e22010-08-25 06:19:51 +00004757 typedef CodeCompletionResult Result;
Douglas Gregor4ad96852009-11-19 07:41:15 +00004758
4759 // Try to find the interface where getters might live.
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004760 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004761 if (!Class) {
4762 if (ObjCCategoryDecl *Category
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004763 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
Douglas Gregor4ad96852009-11-19 07:41:15 +00004764 Class = Category->getClassInterface();
4765
4766 if (!Class)
4767 return;
4768 }
4769
4770 // Find all of the potential getters.
Douglas Gregor218937c2011-02-01 19:23:04 +00004771 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4772 CodeCompletionContext::CCC_Other);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004773 Results.EnterNewScope();
4774
Douglas Gregord36adf52010-09-16 16:06:31 +00004775 VisitedSelectorSet Selectors;
4776 AddObjCMethods(Class, true, MK_ZeroArgSelector, 0, 0, CurContext, Selectors,
Douglas Gregorcf544262010-11-17 21:36:08 +00004777 /*AllowSameLength=*/true, Results);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004778 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004779 HandleCodeCompleteResults(this, CodeCompleter,
4780 CodeCompletionContext::CCC_Other,
4781 Results.data(),Results.size());
Douglas Gregor4ad96852009-11-19 07:41:15 +00004782}
4783
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004784void Sema::CodeCompleteObjCPropertySetter(Scope *S) {
John McCall0a2c5e22010-08-25 06:19:51 +00004785 typedef CodeCompletionResult Result;
Douglas Gregor4ad96852009-11-19 07:41:15 +00004786
4787 // Try to find the interface where setters might live.
4788 ObjCInterfaceDecl *Class
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004789 = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004790 if (!Class) {
4791 if (ObjCCategoryDecl *Category
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00004792 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
Douglas Gregor4ad96852009-11-19 07:41:15 +00004793 Class = Category->getClassInterface();
4794
4795 if (!Class)
4796 return;
4797 }
4798
4799 // Find all of the potential getters.
Douglas Gregor218937c2011-02-01 19:23:04 +00004800 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4801 CodeCompletionContext::CCC_Other);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004802 Results.EnterNewScope();
4803
Douglas Gregord36adf52010-09-16 16:06:31 +00004804 VisitedSelectorSet Selectors;
4805 AddObjCMethods(Class, true, MK_OneArgSelector, 0, 0, CurContext,
Douglas Gregorcf544262010-11-17 21:36:08 +00004806 Selectors, /*AllowSameLength=*/true, Results);
Douglas Gregor4ad96852009-11-19 07:41:15 +00004807
4808 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00004809 HandleCodeCompleteResults(this, CodeCompleter,
4810 CodeCompletionContext::CCC_Other,
4811 Results.data(),Results.size());
Douglas Gregor36ecb042009-11-17 23:22:23 +00004812}
4813
Douglas Gregorafc45782011-02-15 22:19:42 +00004814void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
4815 bool IsParameter) {
John McCall0a2c5e22010-08-25 06:19:51 +00004816 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00004817 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4818 CodeCompletionContext::CCC_Type);
Douglas Gregord32b0222010-08-24 01:06:58 +00004819 Results.EnterNewScope();
4820
4821 // Add context-sensitive, Objective-C parameter-passing keywords.
4822 bool AddedInOut = false;
4823 if ((DS.getObjCDeclQualifier() &
4824 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) {
4825 Results.AddResult("in");
4826 Results.AddResult("inout");
4827 AddedInOut = true;
4828 }
4829 if ((DS.getObjCDeclQualifier() &
4830 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) {
4831 Results.AddResult("out");
4832 if (!AddedInOut)
4833 Results.AddResult("inout");
4834 }
4835 if ((DS.getObjCDeclQualifier() &
4836 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref |
4837 ObjCDeclSpec::DQ_Oneway)) == 0) {
4838 Results.AddResult("bycopy");
4839 Results.AddResult("byref");
4840 Results.AddResult("oneway");
4841 }
4842
Douglas Gregorafc45782011-02-15 22:19:42 +00004843 // If we're completing the return type of an Objective-C method and the
4844 // identifier IBAction refers to a macro, provide a completion item for
4845 // an action, e.g.,
4846 // IBAction)<#selector#>:(id)sender
4847 if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
4848 Context.Idents.get("IBAction").hasMacroDefinition()) {
4849 typedef CodeCompletionString::Chunk Chunk;
4850 CodeCompletionBuilder Builder(Results.getAllocator(), CCP_CodePattern,
4851 CXAvailability_Available);
4852 Builder.AddTypedTextChunk("IBAction");
4853 Builder.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
4854 Builder.AddPlaceholderChunk("selector");
4855 Builder.AddChunk(Chunk(CodeCompletionString::CK_Colon));
4856 Builder.AddChunk(Chunk(CodeCompletionString::CK_LeftParen));
4857 Builder.AddTextChunk("id");
4858 Builder.AddChunk(Chunk(CodeCompletionString::CK_RightParen));
4859 Builder.AddTextChunk("sender");
4860 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
4861 }
4862
Douglas Gregord32b0222010-08-24 01:06:58 +00004863 // Add various builtin type names and specifiers.
4864 AddOrdinaryNameResults(PCC_Type, S, *this, Results);
4865 Results.ExitScope();
4866
4867 // Add the various type names
4868 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
4869 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4870 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4871 CodeCompleter->includeGlobals());
4872
4873 if (CodeCompleter->includeMacros())
4874 AddMacroResults(PP, Results);
4875
4876 HandleCodeCompleteResults(this, CodeCompleter,
4877 CodeCompletionContext::CCC_Type,
4878 Results.data(), Results.size());
4879}
4880
Douglas Gregor22f56992010-04-06 19:22:33 +00004881/// \brief When we have an expression with type "id", we may assume
4882/// that it has some more-specific class type based on knowledge of
4883/// common uses of Objective-C. This routine returns that class type,
4884/// or NULL if no better result could be determined.
4885static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
Douglas Gregor78edf512010-09-15 16:23:04 +00004886 ObjCMessageExpr *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
Douglas Gregor22f56992010-04-06 19:22:33 +00004887 if (!Msg)
4888 return 0;
4889
4890 Selector Sel = Msg->getSelector();
4891 if (Sel.isNull())
4892 return 0;
4893
4894 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0);
4895 if (!Id)
4896 return 0;
4897
4898 ObjCMethodDecl *Method = Msg->getMethodDecl();
4899 if (!Method)
4900 return 0;
4901
4902 // Determine the class that we're sending the message to.
Douglas Gregor04badcf2010-04-21 00:45:42 +00004903 ObjCInterfaceDecl *IFace = 0;
4904 switch (Msg->getReceiverKind()) {
4905 case ObjCMessageExpr::Class:
John McCallc12c5bb2010-05-15 11:32:37 +00004906 if (const ObjCObjectType *ObjType
4907 = Msg->getClassReceiver()->getAs<ObjCObjectType>())
4908 IFace = ObjType->getInterface();
Douglas Gregor04badcf2010-04-21 00:45:42 +00004909 break;
4910
4911 case ObjCMessageExpr::Instance: {
4912 QualType T = Msg->getInstanceReceiver()->getType();
4913 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
4914 IFace = Ptr->getInterfaceDecl();
4915 break;
4916 }
4917
4918 case ObjCMessageExpr::SuperInstance:
4919 case ObjCMessageExpr::SuperClass:
4920 break;
Douglas Gregor22f56992010-04-06 19:22:33 +00004921 }
4922
4923 if (!IFace)
4924 return 0;
4925
4926 ObjCInterfaceDecl *Super = IFace->getSuperClass();
4927 if (Method->isInstanceMethod())
4928 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
4929 .Case("retain", IFace)
John McCallf85e1932011-06-15 23:02:42 +00004930 .Case("strong", IFace)
Douglas Gregor22f56992010-04-06 19:22:33 +00004931 .Case("autorelease", IFace)
4932 .Case("copy", IFace)
4933 .Case("copyWithZone", IFace)
4934 .Case("mutableCopy", IFace)
4935 .Case("mutableCopyWithZone", IFace)
4936 .Case("awakeFromCoder", IFace)
4937 .Case("replacementObjectFromCoder", IFace)
4938 .Case("class", IFace)
4939 .Case("classForCoder", IFace)
4940 .Case("superclass", Super)
4941 .Default(0);
4942
4943 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
4944 .Case("new", IFace)
4945 .Case("alloc", IFace)
4946 .Case("allocWithZone", IFace)
4947 .Case("class", IFace)
4948 .Case("superclass", Super)
4949 .Default(0);
4950}
4951
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004952// Add a special completion for a message send to "super", which fills in the
4953// most likely case of forwarding all of our arguments to the superclass
4954// function.
4955///
4956/// \param S The semantic analysis object.
4957///
4958/// \param S NeedSuperKeyword Whether we need to prefix this completion with
4959/// the "super" keyword. Otherwise, we just need to provide the arguments.
4960///
4961/// \param SelIdents The identifiers in the selector that have already been
4962/// provided as arguments for a send to "super".
4963///
4964/// \param NumSelIdents The number of identifiers in \p SelIdents.
4965///
4966/// \param Results The set of results to augment.
4967///
4968/// \returns the Objective-C method declaration that would be invoked by
4969/// this "super" completion. If NULL, no completion was added.
4970static ObjCMethodDecl *AddSuperSendCompletion(Sema &S, bool NeedSuperKeyword,
4971 IdentifierInfo **SelIdents,
4972 unsigned NumSelIdents,
4973 ResultBuilder &Results) {
4974 ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
4975 if (!CurMethod)
4976 return 0;
4977
4978 ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
4979 if (!Class)
4980 return 0;
4981
4982 // Try to find a superclass method with the same selector.
4983 ObjCMethodDecl *SuperMethod = 0;
Douglas Gregor78bcd912011-02-16 00:51:18 +00004984 while ((Class = Class->getSuperClass()) && !SuperMethod) {
4985 // Check in the class
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004986 SuperMethod = Class->getMethod(CurMethod->getSelector(),
4987 CurMethod->isInstanceMethod());
4988
Douglas Gregor78bcd912011-02-16 00:51:18 +00004989 // Check in categories or class extensions.
4990 if (!SuperMethod) {
4991 for (ObjCCategoryDecl *Category = Class->getCategoryList(); Category;
4992 Category = Category->getNextClassCategory())
4993 if ((SuperMethod = Category->getMethod(CurMethod->getSelector(),
4994 CurMethod->isInstanceMethod())))
4995 break;
4996 }
4997 }
4998
Douglas Gregor03d8aec2010-08-27 15:10:57 +00004999 if (!SuperMethod)
5000 return 0;
5001
5002 // Check whether the superclass method has the same signature.
5003 if (CurMethod->param_size() != SuperMethod->param_size() ||
5004 CurMethod->isVariadic() != SuperMethod->isVariadic())
5005 return 0;
5006
5007 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
5008 CurPEnd = CurMethod->param_end(),
5009 SuperP = SuperMethod->param_begin();
5010 CurP != CurPEnd; ++CurP, ++SuperP) {
5011 // Make sure the parameter types are compatible.
5012 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
5013 (*SuperP)->getType()))
5014 return 0;
5015
5016 // Make sure we have a parameter name to forward!
5017 if (!(*CurP)->getIdentifier())
5018 return 0;
5019 }
5020
5021 // We have a superclass method. Now, form the send-to-super completion.
Douglas Gregor218937c2011-02-01 19:23:04 +00005022 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005023
5024 // Give this completion a return type.
Douglas Gregor8987b232011-09-27 23:30:47 +00005025 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod,
5026 Builder);
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005027
5028 // If we need the "super" keyword, add it (plus some spacing).
5029 if (NeedSuperKeyword) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005030 Builder.AddTypedTextChunk("super");
5031 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005032 }
5033
5034 Selector Sel = CurMethod->getSelector();
5035 if (Sel.isUnarySelector()) {
5036 if (NeedSuperKeyword)
Douglas Gregordae68752011-02-01 22:57:45 +00005037 Builder.AddTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00005038 Sel.getNameForSlot(0)));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005039 else
Douglas Gregordae68752011-02-01 22:57:45 +00005040 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00005041 Sel.getNameForSlot(0)));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005042 } else {
5043 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
5044 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
5045 if (I > NumSelIdents)
Douglas Gregor218937c2011-02-01 19:23:04 +00005046 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005047
5048 if (I < NumSelIdents)
Douglas Gregor218937c2011-02-01 19:23:04 +00005049 Builder.AddInformativeChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00005050 Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00005051 Sel.getNameForSlot(I) + ":"));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005052 else if (NeedSuperKeyword || I > NumSelIdents) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005053 Builder.AddTextChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00005054 Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00005055 Sel.getNameForSlot(I) + ":"));
Douglas Gregordae68752011-02-01 22:57:45 +00005056 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00005057 (*CurP)->getIdentifier()->getName()));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005058 } else {
Douglas Gregor218937c2011-02-01 19:23:04 +00005059 Builder.AddTypedTextChunk(
Douglas Gregordae68752011-02-01 22:57:45 +00005060 Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00005061 Sel.getNameForSlot(I) + ":"));
Douglas Gregordae68752011-02-01 22:57:45 +00005062 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00005063 (*CurP)->getIdentifier()->getName()));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005064 }
5065 }
5066 }
5067
Douglas Gregor218937c2011-02-01 19:23:04 +00005068 Results.AddResult(CodeCompletionResult(Builder.TakeString(), CCP_SuperCompletion,
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005069 SuperMethod->isInstanceMethod()
5070 ? CXCursor_ObjCInstanceMethodDecl
5071 : CXCursor_ObjCClassMethodDecl));
5072 return SuperMethod;
5073}
5074
Douglas Gregor8e254cf2010-05-27 23:06:34 +00005075void Sema::CodeCompleteObjCMessageReceiver(Scope *S) {
John McCall0a2c5e22010-08-25 06:19:51 +00005076 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00005077 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5078 CodeCompletionContext::CCC_ObjCMessageReceiver,
David Blaikie4e4d0842012-03-11 07:00:24 +00005079 getLangOpts().CPlusPlus0x
Douglas Gregor81f3bff2012-02-15 15:34:24 +00005080 ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture
5081 : &ResultBuilder::IsObjCMessageReceiver);
Douglas Gregor8e254cf2010-05-27 23:06:34 +00005082
Douglas Gregor8e254cf2010-05-27 23:06:34 +00005083 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5084 Results.EnterNewScope();
Douglas Gregor8071e422010-08-15 06:18:01 +00005085 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5086 CodeCompleter->includeGlobals());
Douglas Gregor8e254cf2010-05-27 23:06:34 +00005087
5088 // If we are in an Objective-C method inside a class that has a superclass,
5089 // add "super" as an option.
5090 if (ObjCMethodDecl *Method = getCurMethodDecl())
5091 if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005092 if (Iface->getSuperClass()) {
Douglas Gregor8e254cf2010-05-27 23:06:34 +00005093 Results.AddResult(Result("super"));
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005094
5095 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, 0, 0, Results);
5096 }
Douglas Gregor8e254cf2010-05-27 23:06:34 +00005097
David Blaikie4e4d0842012-03-11 07:00:24 +00005098 if (getLangOpts().CPlusPlus0x)
Douglas Gregor81f3bff2012-02-15 15:34:24 +00005099 addThisCompletion(*this, Results);
5100
Douglas Gregor8e254cf2010-05-27 23:06:34 +00005101 Results.ExitScope();
5102
5103 if (CodeCompleter->includeMacros())
5104 AddMacroResults(PP, Results);
Douglas Gregorcee9ff12010-09-20 22:39:41 +00005105 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005106 Results.data(), Results.size());
Douglas Gregor8e254cf2010-05-27 23:06:34 +00005107
5108}
5109
Douglas Gregor2725ca82010-04-21 19:57:20 +00005110void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
5111 IdentifierInfo **SelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005112 unsigned NumSelIdents,
5113 bool AtArgumentExpression) {
Douglas Gregor2725ca82010-04-21 19:57:20 +00005114 ObjCInterfaceDecl *CDecl = 0;
5115 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5116 // Figure out which interface we're in.
5117 CDecl = CurMethod->getClassInterface();
5118 if (!CDecl)
5119 return;
5120
5121 // Find the superclass of this class.
5122 CDecl = CDecl->getSuperClass();
5123 if (!CDecl)
5124 return;
5125
5126 if (CurMethod->isInstanceMethod()) {
5127 // We are inside an instance method, which means that the message
5128 // send [super ...] is actually calling an instance method on the
Douglas Gregor6b0656a2010-10-13 21:24:53 +00005129 // current object.
5130 return CodeCompleteObjCInstanceMessage(S, 0,
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005131 SelIdents, NumSelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005132 AtArgumentExpression,
Douglas Gregor6b0656a2010-10-13 21:24:53 +00005133 CDecl);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005134 }
5135
5136 // Fall through to send to the superclass in CDecl.
5137 } else {
5138 // "super" may be the name of a type or variable. Figure out which
5139 // it is.
5140 IdentifierInfo *Super = &Context.Idents.get("super");
5141 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc,
5142 LookupOrdinaryName);
5143 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
5144 // "super" names an interface. Use it.
5145 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
John McCallc12c5bb2010-05-15 11:32:37 +00005146 if (const ObjCObjectType *Iface
5147 = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
5148 CDecl = Iface->getInterface();
Douglas Gregor2725ca82010-04-21 19:57:20 +00005149 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
5150 // "super" names an unresolved type; we can't be more specific.
5151 } else {
5152 // Assume that "super" names some kind of value and parse that way.
5153 CXXScopeSpec SS;
Abramo Bagnarae4b92762012-01-27 09:46:47 +00005154 SourceLocation TemplateKWLoc;
Douglas Gregor2725ca82010-04-21 19:57:20 +00005155 UnqualifiedId id;
5156 id.setIdentifier(Super, SuperLoc);
Abramo Bagnarae4b92762012-01-27 09:46:47 +00005157 ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id,
5158 false, false);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005159 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005160 SelIdents, NumSelIdents,
5161 AtArgumentExpression);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005162 }
5163
5164 // Fall through
5165 }
5166
John McCallb3d87482010-08-24 05:47:05 +00005167 ParsedType Receiver;
Douglas Gregor2725ca82010-04-21 19:57:20 +00005168 if (CDecl)
John McCallb3d87482010-08-24 05:47:05 +00005169 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
Douglas Gregor2725ca82010-04-21 19:57:20 +00005170 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005171 NumSelIdents, AtArgumentExpression,
5172 /*IsSuper=*/true);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005173}
5174
Douglas Gregorb9d77572010-09-21 00:03:25 +00005175/// \brief Given a set of code-completion results for the argument of a message
5176/// send, determine the preferred type (if any) for that argument expression.
5177static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
5178 unsigned NumSelIdents) {
5179 typedef CodeCompletionResult Result;
5180 ASTContext &Context = Results.getSema().Context;
5181
5182 QualType PreferredType;
5183 unsigned BestPriority = CCP_Unlikely * 2;
5184 Result *ResultsData = Results.data();
5185 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
5186 Result &R = ResultsData[I];
5187 if (R.Kind == Result::RK_Declaration &&
5188 isa<ObjCMethodDecl>(R.Declaration)) {
5189 if (R.Priority <= BestPriority) {
5190 ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
5191 if (NumSelIdents <= Method->param_size()) {
5192 QualType MyPreferredType = Method->param_begin()[NumSelIdents - 1]
5193 ->getType();
5194 if (R.Priority < BestPriority || PreferredType.isNull()) {
5195 BestPriority = R.Priority;
5196 PreferredType = MyPreferredType;
5197 } else if (!Context.hasSameUnqualifiedType(PreferredType,
5198 MyPreferredType)) {
5199 PreferredType = QualType();
5200 }
5201 }
5202 }
5203 }
5204 }
5205
5206 return PreferredType;
5207}
5208
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005209static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
5210 ParsedType Receiver,
5211 IdentifierInfo **SelIdents,
5212 unsigned NumSelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005213 bool AtArgumentExpression,
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005214 bool IsSuper,
5215 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00005216 typedef CodeCompletionResult Result;
Douglas Gregor24a069f2009-11-17 17:59:40 +00005217 ObjCInterfaceDecl *CDecl = 0;
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005218
Douglas Gregor24a069f2009-11-17 17:59:40 +00005219 // If the given name refers to an interface type, retrieve the
5220 // corresponding declaration.
Douglas Gregor2725ca82010-04-21 19:57:20 +00005221 if (Receiver) {
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005222 QualType T = SemaRef.GetTypeFromParser(Receiver, 0);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005223 if (!T.isNull())
John McCallc12c5bb2010-05-15 11:32:37 +00005224 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
5225 CDecl = Interface->getInterface();
Douglas Gregor24a069f2009-11-17 17:59:40 +00005226 }
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005227
Douglas Gregor36ecb042009-11-17 23:22:23 +00005228 // Add all of the factory methods in this Objective-C class, its protocols,
5229 // superclasses, categories, implementation, etc.
Steve Naroffc4df6d22009-11-07 02:08:14 +00005230 Results.EnterNewScope();
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005231
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005232 // If this is a send-to-super, try to add the special "super" send
5233 // completion.
5234 if (IsSuper) {
5235 if (ObjCMethodDecl *SuperMethod
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005236 = AddSuperSendCompletion(SemaRef, false, SelIdents, NumSelIdents,
5237 Results))
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005238 Results.Ignore(SuperMethod);
5239 }
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005240
Douglas Gregor265f7492010-08-27 15:29:55 +00005241 // If we're inside an Objective-C method definition, prefer its selector to
5242 // others.
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005243 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
Douglas Gregor265f7492010-08-27 15:29:55 +00005244 Results.setPreferredSelector(CurMethod->getSelector());
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005245
Douglas Gregord36adf52010-09-16 16:06:31 +00005246 VisitedSelectorSet Selectors;
Douglas Gregor13438f92010-04-06 16:40:00 +00005247 if (CDecl)
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005248 AddObjCMethods(CDecl, false, MK_Any, SelIdents, NumSelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00005249 SemaRef.CurContext, Selectors, AtArgumentExpression,
5250 Results);
Douglas Gregor2725ca82010-04-21 19:57:20 +00005251 else {
Douglas Gregor13438f92010-04-06 16:40:00 +00005252 // We're messaging "id" as a type; provide all class/factory methods.
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005253
Douglas Gregor719770d2010-04-06 17:30:22 +00005254 // If we have an external source, load the entire class method
Sebastian Redl3c7f4132010-08-18 23:57:06 +00005255 // pool from the AST file.
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005256 if (SemaRef.ExternalSource) {
5257 for (uint32_t I = 0,
5258 N = SemaRef.ExternalSource->GetNumExternalSelectors();
John McCall76bd1f32010-06-01 09:23:16 +00005259 I != N; ++I) {
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005260 Selector Sel = SemaRef.ExternalSource->GetExternalSelector(I);
5261 if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
Douglas Gregor719770d2010-04-06 17:30:22 +00005262 continue;
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005263
5264 SemaRef.ReadMethodPool(Sel);
Douglas Gregor719770d2010-04-06 17:30:22 +00005265 }
5266 }
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005267
5268 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
5269 MEnd = SemaRef.MethodPool.end();
Sebastian Redldb9d2142010-08-02 23:18:59 +00005270 M != MEnd; ++M) {
5271 for (ObjCMethodList *MethList = &M->second.second;
5272 MethList && MethList->Method;
Douglas Gregor13438f92010-04-06 16:40:00 +00005273 MethList = MethList->Next) {
5274 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents,
5275 NumSelIdents))
5276 continue;
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005277
Douglas Gregor13438f92010-04-06 16:40:00 +00005278 Result R(MethList->Method, 0);
5279 R.StartParameter = NumSelIdents;
5280 R.AllParametersAreInformative = false;
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005281 Results.MaybeAddResult(R, SemaRef.CurContext);
Douglas Gregor13438f92010-04-06 16:40:00 +00005282 }
5283 }
5284 }
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005285
5286 Results.ExitScope();
5287}
Douglas Gregor13438f92010-04-06 16:40:00 +00005288
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005289void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
5290 IdentifierInfo **SelIdents,
5291 unsigned NumSelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005292 bool AtArgumentExpression,
Douglas Gregorc7b6d882010-09-16 15:14:18 +00005293 bool IsSuper) {
Douglas Gregore081a612011-07-21 01:05:26 +00005294
5295 QualType T = this->GetTypeFromParser(Receiver);
5296
Douglas Gregor218937c2011-02-01 19:23:04 +00005297 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregore081a612011-07-21 01:05:26 +00005298 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage,
Douglas Gregor0a47d692011-07-26 15:24:30 +00005299 T, SelIdents, NumSelIdents));
Douglas Gregore081a612011-07-21 01:05:26 +00005300
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005301 AddClassMessageCompletions(*this, S, Receiver, SelIdents, NumSelIdents,
5302 AtArgumentExpression, IsSuper, Results);
Douglas Gregorb9d77572010-09-21 00:03:25 +00005303
5304 // If we're actually at the argument expression (rather than prior to the
5305 // selector), we're actually performing code completion for an expression.
5306 // Determine whether we have a single, best method. If so, we can
5307 // code-complete the expression using the corresponding parameter type as
5308 // our preferred type, improving completion results.
5309 if (AtArgumentExpression) {
5310 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
Douglas Gregore081a612011-07-21 01:05:26 +00005311 NumSelIdents);
Douglas Gregorb9d77572010-09-21 00:03:25 +00005312 if (PreferredType.isNull())
5313 CodeCompleteOrdinaryName(S, PCC_Expression);
5314 else
5315 CodeCompleteExpression(S, PreferredType);
5316 return;
5317 }
5318
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005319 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregore081a612011-07-21 01:05:26 +00005320 Results.getCompletionContext(),
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005321 Results.data(), Results.size());
Steve Naroffc4df6d22009-11-07 02:08:14 +00005322}
5323
Richard Trieuf81e5a92011-09-09 02:00:50 +00005324void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
Douglas Gregord3c68542009-11-19 01:08:35 +00005325 IdentifierInfo **SelIdents,
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005326 unsigned NumSelIdents,
Douglas Gregor70c5ac72010-09-20 23:34:21 +00005327 bool AtArgumentExpression,
Douglas Gregor6b0656a2010-10-13 21:24:53 +00005328 ObjCInterfaceDecl *Super) {
John McCall0a2c5e22010-08-25 06:19:51 +00005329 typedef CodeCompletionResult Result;
Steve Naroffc4df6d22009-11-07 02:08:14 +00005330
5331 Expr *RecExpr = static_cast<Expr *>(Receiver);
Steve Naroffc4df6d22009-11-07 02:08:14 +00005332
Douglas Gregor36ecb042009-11-17 23:22:23 +00005333 // If necessary, apply function/array conversion to the receiver.
5334 // C99 6.7.5.3p[7,8].
John Wiegley429bb272011-04-08 18:41:53 +00005335 if (RecExpr) {
5336 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
5337 if (Conv.isInvalid()) // conversion failed. bail.
5338 return;
5339 RecExpr = Conv.take();
5340 }
Douglas Gregor6b0656a2010-10-13 21:24:53 +00005341 QualType ReceiverType = RecExpr? RecExpr->getType()
5342 : Super? Context.getObjCObjectPointerType(
5343 Context.getObjCInterfaceType(Super))
5344 : Context.getObjCIdType();
Steve Naroffc4df6d22009-11-07 02:08:14 +00005345
Douglas Gregorda892642010-11-08 21:12:30 +00005346 // If we're messaging an expression with type "id" or "Class", check
5347 // whether we know something special about the receiver that allows
5348 // us to assume a more-specific receiver type.
5349 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType())
5350 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
5351 if (ReceiverType->isObjCClassType())
5352 return CodeCompleteObjCClassMessage(S,
5353 ParsedType::make(Context.getObjCInterfaceType(IFace)),
5354 SelIdents, NumSelIdents,
5355 AtArgumentExpression, Super);
5356
5357 ReceiverType = Context.getObjCObjectPointerType(
5358 Context.getObjCInterfaceType(IFace));
5359 }
5360
Douglas Gregor36ecb042009-11-17 23:22:23 +00005361 // Build the set of methods we can see.
Douglas Gregor218937c2011-02-01 19:23:04 +00005362 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregore081a612011-07-21 01:05:26 +00005363 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage,
Douglas Gregor0a47d692011-07-26 15:24:30 +00005364 ReceiverType, SelIdents, NumSelIdents));
Douglas Gregore081a612011-07-21 01:05:26 +00005365
Douglas Gregor36ecb042009-11-17 23:22:23 +00005366 Results.EnterNewScope();
Douglas Gregor22f56992010-04-06 19:22:33 +00005367
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005368 // If this is a send-to-super, try to add the special "super" send
5369 // completion.
Douglas Gregor6b0656a2010-10-13 21:24:53 +00005370 if (Super) {
Douglas Gregor03d8aec2010-08-27 15:10:57 +00005371 if (ObjCMethodDecl *SuperMethod
5372 = AddSuperSendCompletion(*this, false, SelIdents, NumSelIdents,
5373 Results))
5374 Results.Ignore(SuperMethod);
5375 }
5376
Douglas Gregor265f7492010-08-27 15:29:55 +00005377 // If we're inside an Objective-C method definition, prefer its selector to
5378 // others.
5379 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
5380 Results.setPreferredSelector(CurMethod->getSelector());
Douglas Gregor36ecb042009-11-17 23:22:23 +00005381
Douglas Gregord36adf52010-09-16 16:06:31 +00005382 // Keep track of the selectors we've already added.
5383 VisitedSelectorSet Selectors;
5384
Douglas Gregorf74a4192009-11-18 00:06:18 +00005385 // Handle messages to Class. This really isn't a message to an instance
5386 // method, so we treat it the same way we would treat a message send to a
5387 // class method.
5388 if (ReceiverType->isObjCClassType() ||
5389 ReceiverType->isObjCQualifiedClassType()) {
5390 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5391 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
Douglas Gregor4ad96852009-11-19 07:41:15 +00005392 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents, NumSelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00005393 CurContext, Selectors, AtArgumentExpression, Results);
Douglas Gregorf74a4192009-11-18 00:06:18 +00005394 }
5395 }
5396 // Handle messages to a qualified ID ("id<foo>").
5397 else if (const ObjCObjectPointerType *QualID
5398 = ReceiverType->getAsObjCQualifiedIdType()) {
5399 // Search protocols for instance methods.
5400 for (ObjCObjectPointerType::qual_iterator I = QualID->qual_begin(),
5401 E = QualID->qual_end();
5402 I != E; ++I)
Douglas Gregor4ad96852009-11-19 07:41:15 +00005403 AddObjCMethods(*I, true, MK_Any, SelIdents, NumSelIdents, CurContext,
Douglas Gregorcf544262010-11-17 21:36:08 +00005404 Selectors, AtArgumentExpression, Results);
Douglas Gregorf74a4192009-11-18 00:06:18 +00005405 }
5406 // Handle messages to a pointer to interface type.
5407 else if (const ObjCObjectPointerType *IFacePtr
5408 = ReceiverType->getAsObjCInterfacePointerType()) {
5409 // Search the class, its superclasses, etc., for instance methods.
Douglas Gregor4ad96852009-11-19 07:41:15 +00005410 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
Douglas Gregorcf544262010-11-17 21:36:08 +00005411 NumSelIdents, CurContext, Selectors, AtArgumentExpression,
5412 Results);
Douglas Gregorf74a4192009-11-18 00:06:18 +00005413
5414 // Search protocols for instance methods.
5415 for (ObjCObjectPointerType::qual_iterator I = IFacePtr->qual_begin(),
5416 E = IFacePtr->qual_end();
5417 I != E; ++I)
Douglas Gregor4ad96852009-11-19 07:41:15 +00005418 AddObjCMethods(*I, true, MK_Any, SelIdents, NumSelIdents, CurContext,
Douglas Gregorcf544262010-11-17 21:36:08 +00005419 Selectors, AtArgumentExpression, Results);
Douglas Gregorf74a4192009-11-18 00:06:18 +00005420 }
Douglas Gregor13438f92010-04-06 16:40:00 +00005421 // Handle messages to "id".
5422 else if (ReceiverType->isObjCIdType()) {
Douglas Gregor719770d2010-04-06 17:30:22 +00005423 // We're messaging "id", so provide all instance methods we know
5424 // about as code-completion results.
5425
5426 // If we have an external source, load the entire class method
Sebastian Redl3c7f4132010-08-18 23:57:06 +00005427 // pool from the AST file.
Douglas Gregor719770d2010-04-06 17:30:22 +00005428 if (ExternalSource) {
John McCall76bd1f32010-06-01 09:23:16 +00005429 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5430 I != N; ++I) {
5431 Selector Sel = ExternalSource->GetExternalSelector(I);
Sebastian Redldb9d2142010-08-02 23:18:59 +00005432 if (Sel.isNull() || MethodPool.count(Sel))
Douglas Gregor719770d2010-04-06 17:30:22 +00005433 continue;
5434
Sebastian Redldb9d2142010-08-02 23:18:59 +00005435 ReadMethodPool(Sel);
Douglas Gregor719770d2010-04-06 17:30:22 +00005436 }
5437 }
5438
Sebastian Redldb9d2142010-08-02 23:18:59 +00005439 for (GlobalMethodPool::iterator M = MethodPool.begin(),
5440 MEnd = MethodPool.end();
5441 M != MEnd; ++M) {
5442 for (ObjCMethodList *MethList = &M->second.first;
5443 MethList && MethList->Method;
Douglas Gregor13438f92010-04-06 16:40:00 +00005444 MethList = MethList->Next) {
5445 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents,
5446 NumSelIdents))
5447 continue;
Douglas Gregord36adf52010-09-16 16:06:31 +00005448
5449 if (!Selectors.insert(MethList->Method->getSelector()))
5450 continue;
5451
Douglas Gregor13438f92010-04-06 16:40:00 +00005452 Result R(MethList->Method, 0);
5453 R.StartParameter = NumSelIdents;
5454 R.AllParametersAreInformative = false;
5455 Results.MaybeAddResult(R, CurContext);
5456 }
5457 }
5458 }
Steve Naroffc4df6d22009-11-07 02:08:14 +00005459 Results.ExitScope();
Douglas Gregorb9d77572010-09-21 00:03:25 +00005460
5461
5462 // If we're actually at the argument expression (rather than prior to the
5463 // selector), we're actually performing code completion for an expression.
5464 // Determine whether we have a single, best method. If so, we can
5465 // code-complete the expression using the corresponding parameter type as
5466 // our preferred type, improving completion results.
5467 if (AtArgumentExpression) {
5468 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
5469 NumSelIdents);
5470 if (PreferredType.isNull())
5471 CodeCompleteOrdinaryName(S, PCC_Expression);
5472 else
5473 CodeCompleteExpression(S, PreferredType);
5474 return;
5475 }
5476
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005477 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregore081a612011-07-21 01:05:26 +00005478 Results.getCompletionContext(),
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005479 Results.data(),Results.size());
Steve Naroffc4df6d22009-11-07 02:08:14 +00005480}
Douglas Gregor55385fe2009-11-18 04:19:12 +00005481
Douglas Gregorfb629412010-08-23 21:17:50 +00005482void Sema::CodeCompleteObjCForCollection(Scope *S,
5483 DeclGroupPtrTy IterationVar) {
5484 CodeCompleteExpressionData Data;
5485 Data.ObjCCollection = true;
5486
5487 if (IterationVar.getAsOpaquePtr()) {
5488 DeclGroupRef DG = IterationVar.getAsVal<DeclGroupRef>();
5489 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
5490 if (*I)
5491 Data.IgnoreDecls.push_back(*I);
5492 }
5493 }
5494
5495 CodeCompleteExpression(S, Data);
5496}
5497
Douglas Gregor458433d2010-08-26 15:07:07 +00005498void Sema::CodeCompleteObjCSelector(Scope *S, IdentifierInfo **SelIdents,
5499 unsigned NumSelIdents) {
5500 // If we have an external source, load the entire class method
5501 // pool from the AST file.
5502 if (ExternalSource) {
5503 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5504 I != N; ++I) {
5505 Selector Sel = ExternalSource->GetExternalSelector(I);
5506 if (Sel.isNull() || MethodPool.count(Sel))
5507 continue;
5508
5509 ReadMethodPool(Sel);
5510 }
5511 }
5512
Douglas Gregor218937c2011-02-01 19:23:04 +00005513 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5514 CodeCompletionContext::CCC_SelectorName);
Douglas Gregor458433d2010-08-26 15:07:07 +00005515 Results.EnterNewScope();
5516 for (GlobalMethodPool::iterator M = MethodPool.begin(),
5517 MEnd = MethodPool.end();
5518 M != MEnd; ++M) {
5519
5520 Selector Sel = M->first;
5521 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents, NumSelIdents))
5522 continue;
5523
Douglas Gregor218937c2011-02-01 19:23:04 +00005524 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor458433d2010-08-26 15:07:07 +00005525 if (Sel.isUnarySelector()) {
Douglas Gregordae68752011-02-01 22:57:45 +00005526 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00005527 Sel.getNameForSlot(0)));
Douglas Gregor218937c2011-02-01 19:23:04 +00005528 Results.AddResult(Builder.TakeString());
Douglas Gregor458433d2010-08-26 15:07:07 +00005529 continue;
5530 }
5531
Douglas Gregor2d9e21f2010-08-26 16:46:39 +00005532 std::string Accumulator;
Douglas Gregor458433d2010-08-26 15:07:07 +00005533 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
Douglas Gregor2d9e21f2010-08-26 16:46:39 +00005534 if (I == NumSelIdents) {
5535 if (!Accumulator.empty()) {
Douglas Gregordae68752011-02-01 22:57:45 +00005536 Builder.AddInformativeChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00005537 Accumulator));
Douglas Gregor2d9e21f2010-08-26 16:46:39 +00005538 Accumulator.clear();
5539 }
5540 }
5541
Benjamin Kramera0651c52011-07-26 16:59:25 +00005542 Accumulator += Sel.getNameForSlot(I);
Douglas Gregor2d9e21f2010-08-26 16:46:39 +00005543 Accumulator += ':';
Douglas Gregor458433d2010-08-26 15:07:07 +00005544 }
Douglas Gregordae68752011-02-01 22:57:45 +00005545 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( Accumulator));
Douglas Gregor218937c2011-02-01 19:23:04 +00005546 Results.AddResult(Builder.TakeString());
Douglas Gregor458433d2010-08-26 15:07:07 +00005547 }
5548 Results.ExitScope();
5549
5550 HandleCodeCompleteResults(this, CodeCompleter,
5551 CodeCompletionContext::CCC_SelectorName,
5552 Results.data(), Results.size());
5553}
5554
Douglas Gregor55385fe2009-11-18 04:19:12 +00005555/// \brief Add all of the protocol declarations that we find in the given
5556/// (translation unit) context.
5557static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
Douglas Gregor083128f2009-11-18 04:49:41 +00005558 bool OnlyForwardDeclarations,
Douglas Gregor55385fe2009-11-18 04:19:12 +00005559 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00005560 typedef CodeCompletionResult Result;
Douglas Gregor55385fe2009-11-18 04:19:12 +00005561
5562 for (DeclContext::decl_iterator D = Ctx->decls_begin(),
5563 DEnd = Ctx->decls_end();
5564 D != DEnd; ++D) {
5565 // Record any protocols we find.
5566 if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(*D))
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +00005567 if (!OnlyForwardDeclarations || !Proto->hasDefinition())
Douglas Gregor608300b2010-01-14 16:14:35 +00005568 Results.AddResult(Result(Proto, 0), CurContext, 0, false);
Douglas Gregor55385fe2009-11-18 04:19:12 +00005569 }
5570}
5571
5572void Sema::CodeCompleteObjCProtocolReferences(IdentifierLocPair *Protocols,
5573 unsigned NumProtocols) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005574 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5575 CodeCompletionContext::CCC_ObjCProtocolName);
Douglas Gregor55385fe2009-11-18 04:19:12 +00005576
Douglas Gregor70c23352010-12-09 21:44:02 +00005577 if (CodeCompleter && CodeCompleter->includeGlobals()) {
5578 Results.EnterNewScope();
5579
5580 // Tell the result set to ignore all of the protocols we have
5581 // already seen.
5582 // FIXME: This doesn't work when caching code-completion results.
5583 for (unsigned I = 0; I != NumProtocols; ++I)
5584 if (ObjCProtocolDecl *Protocol = LookupProtocol(Protocols[I].first,
5585 Protocols[I].second))
5586 Results.Ignore(Protocol);
Douglas Gregor55385fe2009-11-18 04:19:12 +00005587
Douglas Gregor70c23352010-12-09 21:44:02 +00005588 // Add all protocols.
5589 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
5590 Results);
Douglas Gregor083128f2009-11-18 04:49:41 +00005591
Douglas Gregor70c23352010-12-09 21:44:02 +00005592 Results.ExitScope();
5593 }
5594
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005595 HandleCodeCompleteResults(this, CodeCompleter,
5596 CodeCompletionContext::CCC_ObjCProtocolName,
5597 Results.data(),Results.size());
Douglas Gregor083128f2009-11-18 04:49:41 +00005598}
5599
5600void Sema::CodeCompleteObjCProtocolDecl(Scope *) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005601 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5602 CodeCompletionContext::CCC_ObjCProtocolName);
Douglas Gregor083128f2009-11-18 04:49:41 +00005603
Douglas Gregor70c23352010-12-09 21:44:02 +00005604 if (CodeCompleter && CodeCompleter->includeGlobals()) {
5605 Results.EnterNewScope();
5606
5607 // Add all protocols.
5608 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
5609 Results);
Douglas Gregor55385fe2009-11-18 04:19:12 +00005610
Douglas Gregor70c23352010-12-09 21:44:02 +00005611 Results.ExitScope();
5612 }
5613
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005614 HandleCodeCompleteResults(this, CodeCompleter,
5615 CodeCompletionContext::CCC_ObjCProtocolName,
5616 Results.data(),Results.size());
Douglas Gregor55385fe2009-11-18 04:19:12 +00005617}
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005618
5619/// \brief Add all of the Objective-C interface declarations that we find in
5620/// the given (translation unit) context.
5621static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
5622 bool OnlyForwardDeclarations,
5623 bool OnlyUnimplemented,
5624 ResultBuilder &Results) {
John McCall0a2c5e22010-08-25 06:19:51 +00005625 typedef CodeCompletionResult Result;
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005626
5627 for (DeclContext::decl_iterator D = Ctx->decls_begin(),
5628 DEnd = Ctx->decls_end();
5629 D != DEnd; ++D) {
Douglas Gregordeacbdc2010-08-11 12:19:30 +00005630 // Record any interfaces we find.
5631 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(*D))
Douglas Gregor7723fec2011-12-15 20:29:51 +00005632 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
Douglas Gregordeacbdc2010-08-11 12:19:30 +00005633 (!OnlyUnimplemented || !Class->getImplementation()))
5634 Results.AddResult(Result(Class, 0), CurContext, 0, false);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005635 }
5636}
5637
5638void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005639 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5640 CodeCompletionContext::CCC_Other);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005641 Results.EnterNewScope();
5642
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005643 if (CodeCompleter->includeGlobals()) {
5644 // Add all classes.
5645 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
5646 false, Results);
5647 }
5648
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005649 Results.ExitScope();
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005650
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005651 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005652 CodeCompletionContext::CCC_ObjCInterfaceName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005653 Results.data(),Results.size());
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005654}
5655
Douglas Gregorc83c6872010-04-15 22:33:43 +00005656void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName,
5657 SourceLocation ClassNameLoc) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005658 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005659 CodeCompletionContext::CCC_ObjCInterfaceName);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005660 Results.EnterNewScope();
5661
5662 // Make sure that we ignore the class we're currently defining.
5663 NamedDecl *CurClass
Douglas Gregorc83c6872010-04-15 22:33:43 +00005664 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005665 if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005666 Results.Ignore(CurClass);
5667
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005668 if (CodeCompleter->includeGlobals()) {
5669 // Add all classes.
5670 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
5671 false, Results);
5672 }
5673
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005674 Results.ExitScope();
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005675
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005676 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005677 CodeCompletionContext::CCC_ObjCInterfaceName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005678 Results.data(),Results.size());
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005679}
5680
5681void Sema::CodeCompleteObjCImplementationDecl(Scope *S) {
Douglas Gregor218937c2011-02-01 19:23:04 +00005682 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5683 CodeCompletionContext::CCC_Other);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005684 Results.EnterNewScope();
5685
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005686 if (CodeCompleter->includeGlobals()) {
5687 // Add all unimplemented classes.
5688 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
5689 true, Results);
5690 }
5691
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005692 Results.ExitScope();
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005693
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005694 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor0f91c8c2011-07-30 06:55:39 +00005695 CodeCompletionContext::CCC_ObjCInterfaceName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005696 Results.data(),Results.size());
Douglas Gregor3b49aca2009-11-18 16:26:39 +00005697}
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005698
5699void Sema::CodeCompleteObjCInterfaceCategory(Scope *S,
Douglas Gregorc83c6872010-04-15 22:33:43 +00005700 IdentifierInfo *ClassName,
5701 SourceLocation ClassNameLoc) {
John McCall0a2c5e22010-08-25 06:19:51 +00005702 typedef CodeCompletionResult Result;
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005703
Douglas Gregor218937c2011-02-01 19:23:04 +00005704 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor3da626b2011-07-07 16:03:39 +00005705 CodeCompletionContext::CCC_ObjCCategoryName);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005706
5707 // Ignore any categories we find that have already been implemented by this
5708 // interface.
5709 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
5710 NamedDecl *CurClass
Douglas Gregorc83c6872010-04-15 22:33:43 +00005711 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005712 if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass))
5713 for (ObjCCategoryDecl *Category = Class->getCategoryList(); Category;
5714 Category = Category->getNextClassCategory())
5715 CategoryNames.insert(Category->getIdentifier());
5716
5717 // Add all of the categories we know about.
5718 Results.EnterNewScope();
5719 TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
5720 for (DeclContext::decl_iterator D = TU->decls_begin(),
5721 DEnd = TU->decls_end();
5722 D != DEnd; ++D)
5723 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(*D))
5724 if (CategoryNames.insert(Category->getIdentifier()))
Douglas Gregor608300b2010-01-14 16:14:35 +00005725 Results.AddResult(Result(Category, 0), CurContext, 0, false);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005726 Results.ExitScope();
5727
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005728 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor3da626b2011-07-07 16:03:39 +00005729 CodeCompletionContext::CCC_ObjCCategoryName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005730 Results.data(),Results.size());
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005731}
5732
5733void Sema::CodeCompleteObjCImplementationCategory(Scope *S,
Douglas Gregorc83c6872010-04-15 22:33:43 +00005734 IdentifierInfo *ClassName,
5735 SourceLocation ClassNameLoc) {
John McCall0a2c5e22010-08-25 06:19:51 +00005736 typedef CodeCompletionResult Result;
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005737
5738 // Find the corresponding interface. If we couldn't find the interface, the
5739 // program itself is ill-formed. However, we'll try to be helpful still by
5740 // providing the list of all of the categories we know about.
5741 NamedDecl *CurClass
Douglas Gregorc83c6872010-04-15 22:33:43 +00005742 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005743 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
5744 if (!Class)
Douglas Gregorc83c6872010-04-15 22:33:43 +00005745 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005746
Douglas Gregor218937c2011-02-01 19:23:04 +00005747 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor3da626b2011-07-07 16:03:39 +00005748 CodeCompletionContext::CCC_ObjCCategoryName);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005749
5750 // Add all of the categories that have have corresponding interface
5751 // declarations in this class and any of its superclasses, except for
5752 // already-implemented categories in the class itself.
5753 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
5754 Results.EnterNewScope();
5755 bool IgnoreImplemented = true;
5756 while (Class) {
5757 for (ObjCCategoryDecl *Category = Class->getCategoryList(); Category;
5758 Category = Category->getNextClassCategory())
5759 if ((!IgnoreImplemented || !Category->getImplementation()) &&
5760 CategoryNames.insert(Category->getIdentifier()))
Douglas Gregor608300b2010-01-14 16:14:35 +00005761 Results.AddResult(Result(Category, 0), CurContext, 0, false);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005762
5763 Class = Class->getSuperClass();
5764 IgnoreImplemented = false;
5765 }
5766 Results.ExitScope();
5767
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005768 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor3da626b2011-07-07 16:03:39 +00005769 CodeCompletionContext::CCC_ObjCCategoryName,
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005770 Results.data(),Results.size());
Douglas Gregor33ced0b2009-11-18 19:08:43 +00005771}
Douglas Gregor322328b2009-11-18 22:32:06 +00005772
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00005773void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) {
John McCall0a2c5e22010-08-25 06:19:51 +00005774 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00005775 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5776 CodeCompletionContext::CCC_Other);
Douglas Gregor322328b2009-11-18 22:32:06 +00005777
5778 // Figure out where this @synthesize lives.
5779 ObjCContainerDecl *Container
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00005780 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
Douglas Gregor322328b2009-11-18 22:32:06 +00005781 if (!Container ||
5782 (!isa<ObjCImplementationDecl>(Container) &&
5783 !isa<ObjCCategoryImplDecl>(Container)))
5784 return;
5785
5786 // Ignore any properties that have already been implemented.
5787 for (DeclContext::decl_iterator D = Container->decls_begin(),
5788 DEnd = Container->decls_end();
5789 D != DEnd; ++D)
5790 if (ObjCPropertyImplDecl *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(*D))
5791 Results.Ignore(PropertyImpl->getPropertyDecl());
5792
5793 // Add any properties that we find.
Douglas Gregor73449212010-12-09 23:01:55 +00005794 AddedPropertiesSet AddedProperties;
Douglas Gregor322328b2009-11-18 22:32:06 +00005795 Results.EnterNewScope();
5796 if (ObjCImplementationDecl *ClassImpl
5797 = dyn_cast<ObjCImplementationDecl>(Container))
Douglas Gregor4b81cde2011-05-05 15:50:42 +00005798 AddObjCProperties(ClassImpl->getClassInterface(), false,
5799 /*AllowNullaryMethods=*/false, CurContext,
Douglas Gregor73449212010-12-09 23:01:55 +00005800 AddedProperties, Results);
Douglas Gregor322328b2009-11-18 22:32:06 +00005801 else
5802 AddObjCProperties(cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
Douglas Gregor4b81cde2011-05-05 15:50:42 +00005803 false, /*AllowNullaryMethods=*/false, CurContext,
5804 AddedProperties, Results);
Douglas Gregor322328b2009-11-18 22:32:06 +00005805 Results.ExitScope();
5806
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005807 HandleCodeCompleteResults(this, CodeCompleter,
5808 CodeCompletionContext::CCC_Other,
5809 Results.data(),Results.size());
Douglas Gregor322328b2009-11-18 22:32:06 +00005810}
5811
5812void Sema::CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00005813 IdentifierInfo *PropertyName) {
John McCall0a2c5e22010-08-25 06:19:51 +00005814 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00005815 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5816 CodeCompletionContext::CCC_Other);
Douglas Gregor322328b2009-11-18 22:32:06 +00005817
5818 // Figure out where this @synthesize lives.
5819 ObjCContainerDecl *Container
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00005820 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
Douglas Gregor322328b2009-11-18 22:32:06 +00005821 if (!Container ||
5822 (!isa<ObjCImplementationDecl>(Container) &&
5823 !isa<ObjCCategoryImplDecl>(Container)))
5824 return;
5825
5826 // Figure out which interface we're looking into.
5827 ObjCInterfaceDecl *Class = 0;
5828 if (ObjCImplementationDecl *ClassImpl
5829 = dyn_cast<ObjCImplementationDecl>(Container))
5830 Class = ClassImpl->getClassInterface();
5831 else
5832 Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl()
5833 ->getClassInterface();
5834
Douglas Gregore8426052011-04-18 14:40:46 +00005835 // Determine the type of the property we're synthesizing.
5836 QualType PropertyType = Context.getObjCIdType();
5837 if (Class) {
5838 if (ObjCPropertyDecl *Property
5839 = Class->FindPropertyDeclaration(PropertyName)) {
5840 PropertyType
5841 = Property->getType().getNonReferenceType().getUnqualifiedType();
5842
5843 // Give preference to ivars
5844 Results.setPreferredType(PropertyType);
5845 }
5846 }
5847
Douglas Gregor322328b2009-11-18 22:32:06 +00005848 // Add all of the instance variables in this class and its superclasses.
5849 Results.EnterNewScope();
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005850 bool SawSimilarlyNamedIvar = false;
5851 std::string NameWithPrefix;
5852 NameWithPrefix += '_';
Benjamin Kramera0651c52011-07-26 16:59:25 +00005853 NameWithPrefix += PropertyName->getName();
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005854 std::string NameWithSuffix = PropertyName->getName().str();
5855 NameWithSuffix += '_';
Douglas Gregor322328b2009-11-18 22:32:06 +00005856 for(; Class; Class = Class->getSuperClass()) {
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005857 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
5858 Ivar = Ivar->getNextIvar()) {
Douglas Gregore8426052011-04-18 14:40:46 +00005859 Results.AddResult(Result(Ivar, 0), CurContext, 0, false);
5860
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005861 // Determine whether we've seen an ivar with a name similar to the
5862 // property.
Douglas Gregore8426052011-04-18 14:40:46 +00005863 if ((PropertyName == Ivar->getIdentifier() ||
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005864 NameWithPrefix == Ivar->getName() ||
Douglas Gregore8426052011-04-18 14:40:46 +00005865 NameWithSuffix == Ivar->getName())) {
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005866 SawSimilarlyNamedIvar = true;
Douglas Gregore8426052011-04-18 14:40:46 +00005867
5868 // Reduce the priority of this result by one, to give it a slight
5869 // advantage over other results whose names don't match so closely.
5870 if (Results.size() &&
5871 Results.data()[Results.size() - 1].Kind
5872 == CodeCompletionResult::RK_Declaration &&
5873 Results.data()[Results.size() - 1].Declaration == Ivar)
5874 Results.data()[Results.size() - 1].Priority--;
5875 }
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005876 }
Douglas Gregor322328b2009-11-18 22:32:06 +00005877 }
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005878
5879 if (!SawSimilarlyNamedIvar) {
5880 // Create ivar result _propName, that the user can use to synthesize
Douglas Gregore8426052011-04-18 14:40:46 +00005881 // an ivar of the appropriate type.
5882 unsigned Priority = CCP_MemberDeclaration + 1;
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005883 typedef CodeCompletionResult Result;
5884 CodeCompletionAllocator &Allocator = Results.getAllocator();
5885 CodeCompletionBuilder Builder(Allocator, Priority,CXAvailability_Available);
5886
Douglas Gregor8987b232011-09-27 23:30:47 +00005887 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
Douglas Gregore8426052011-04-18 14:40:46 +00005888 Builder.AddResultTypeChunk(GetCompletionTypeString(PropertyType, Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00005889 Policy, Allocator));
Douglas Gregoraa490cb2011-04-18 14:13:53 +00005890 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
5891 Results.AddResult(Result(Builder.TakeString(), Priority,
5892 CXCursor_ObjCIvarDecl));
5893 }
5894
Douglas Gregor322328b2009-11-18 22:32:06 +00005895 Results.ExitScope();
5896
Douglas Gregore6b1bb62010-08-11 21:23:17 +00005897 HandleCodeCompleteResults(this, CodeCompleter,
5898 CodeCompletionContext::CCC_Other,
5899 Results.data(),Results.size());
Douglas Gregor322328b2009-11-18 22:32:06 +00005900}
Douglas Gregore8f5a172010-04-07 00:21:17 +00005901
Douglas Gregor408be5a2010-08-25 01:08:01 +00005902// Mapping from selectors to the methods that implement that selector, along
5903// with the "in original class" flag.
5904typedef llvm::DenseMap<Selector, std::pair<ObjCMethodDecl *, bool> >
5905 KnownMethodsMap;
Douglas Gregore8f5a172010-04-07 00:21:17 +00005906
5907/// \brief Find all of the methods that reside in the given container
5908/// (and its superclasses, protocols, etc.) that meet the given
5909/// criteria. Insert those methods into the map of known methods,
5910/// indexed by selector so they can be easily found.
5911static void FindImplementableMethods(ASTContext &Context,
5912 ObjCContainerDecl *Container,
5913 bool WantInstanceMethods,
5914 QualType ReturnType,
Douglas Gregor408be5a2010-08-25 01:08:01 +00005915 KnownMethodsMap &KnownMethods,
5916 bool InOriginalClass = true) {
Douglas Gregore8f5a172010-04-07 00:21:17 +00005917 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
5918 // Recurse into protocols.
Douglas Gregor2e5c15b2011-12-15 05:27:12 +00005919 if (!IFace->hasDefinition())
5920 return;
5921
Douglas Gregore8f5a172010-04-07 00:21:17 +00005922 const ObjCList<ObjCProtocolDecl> &Protocols
5923 = IFace->getReferencedProtocols();
5924 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
Douglas Gregorea766182010-10-18 18:21:28 +00005925 E = Protocols.end();
Douglas Gregore8f5a172010-04-07 00:21:17 +00005926 I != E; ++I)
5927 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
Douglas Gregorea766182010-10-18 18:21:28 +00005928 KnownMethods, InOriginalClass);
Douglas Gregore8f5a172010-04-07 00:21:17 +00005929
Douglas Gregorea766182010-10-18 18:21:28 +00005930 // Add methods from any class extensions and categories.
5931 for (const ObjCCategoryDecl *Cat = IFace->getCategoryList(); Cat;
5932 Cat = Cat->getNextClassCategory())
Fariborz Jahanian80aa1cd2010-06-22 23:20:40 +00005933 FindImplementableMethods(Context, const_cast<ObjCCategoryDecl*>(Cat),
5934 WantInstanceMethods, ReturnType,
Douglas Gregorea766182010-10-18 18:21:28 +00005935 KnownMethods, false);
5936
5937 // Visit the superclass.
5938 if (IFace->getSuperClass())
5939 FindImplementableMethods(Context, IFace->getSuperClass(),
5940 WantInstanceMethods, ReturnType,
5941 KnownMethods, false);
Douglas Gregore8f5a172010-04-07 00:21:17 +00005942 }
5943
5944 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
5945 // Recurse into protocols.
5946 const ObjCList<ObjCProtocolDecl> &Protocols
5947 = Category->getReferencedProtocols();
5948 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
Douglas Gregorea766182010-10-18 18:21:28 +00005949 E = Protocols.end();
Douglas Gregore8f5a172010-04-07 00:21:17 +00005950 I != E; ++I)
5951 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
Douglas Gregorea766182010-10-18 18:21:28 +00005952 KnownMethods, InOriginalClass);
5953
5954 // If this category is the original class, jump to the interface.
5955 if (InOriginalClass && Category->getClassInterface())
5956 FindImplementableMethods(Context, Category->getClassInterface(),
5957 WantInstanceMethods, ReturnType, KnownMethods,
5958 false);
Douglas Gregore8f5a172010-04-07 00:21:17 +00005959 }
5960
5961 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
Douglas Gregor5e2a1ff2012-01-01 19:29:29 +00005962 if (Protocol->hasDefinition()) {
5963 // Recurse into protocols.
5964 const ObjCList<ObjCProtocolDecl> &Protocols
5965 = Protocol->getReferencedProtocols();
5966 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5967 E = Protocols.end();
5968 I != E; ++I)
5969 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
5970 KnownMethods, false);
5971 }
Douglas Gregore8f5a172010-04-07 00:21:17 +00005972 }
5973
5974 // Add methods in this container. This operation occurs last because
5975 // we want the methods from this container to override any methods
5976 // we've previously seen with the same selector.
5977 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(),
5978 MEnd = Container->meth_end();
5979 M != MEnd; ++M) {
5980 if ((*M)->isInstanceMethod() == WantInstanceMethods) {
5981 if (!ReturnType.isNull() &&
5982 !Context.hasSameUnqualifiedType(ReturnType, (*M)->getResultType()))
5983 continue;
5984
Douglas Gregor408be5a2010-08-25 01:08:01 +00005985 KnownMethods[(*M)->getSelector()] = std::make_pair(*M, InOriginalClass);
Douglas Gregore8f5a172010-04-07 00:21:17 +00005986 }
5987 }
5988}
5989
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005990/// \brief Add the parenthesized return or parameter type chunk to a code
5991/// completion string.
5992static void AddObjCPassingTypeChunk(QualType Type,
5993 ASTContext &Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00005994 const PrintingPolicy &Policy,
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005995 CodeCompletionBuilder &Builder) {
5996 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
Douglas Gregor8987b232011-09-27 23:30:47 +00005997 Builder.AddTextChunk(GetCompletionTypeString(Type, Context, Policy,
Douglas Gregor577cdfd2011-02-17 00:22:45 +00005998 Builder.getAllocator()));
5999 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6000}
6001
6002/// \brief Determine whether the given class is or inherits from a class by
6003/// the given name.
6004static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class,
Chris Lattner5f9e2722011-07-23 10:55:15 +00006005 StringRef Name) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006006 if (!Class)
6007 return false;
6008
6009 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
6010 return true;
6011
6012 return InheritsFromClassNamed(Class->getSuperClass(), Name);
6013}
6014
6015/// \brief Add code completions for Objective-C Key-Value Coding (KVC) and
6016/// Key-Value Observing (KVO).
6017static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property,
6018 bool IsInstanceMethod,
6019 QualType ReturnType,
6020 ASTContext &Context,
Douglas Gregore74c25c2011-05-04 23:50:46 +00006021 VisitedSelectorSet &KnownSelectors,
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006022 ResultBuilder &Results) {
6023 IdentifierInfo *PropName = Property->getIdentifier();
6024 if (!PropName || PropName->getLength() == 0)
6025 return;
6026
Douglas Gregor8987b232011-09-27 23:30:47 +00006027 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
6028
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006029 // Builder that will create each code completion.
6030 typedef CodeCompletionResult Result;
6031 CodeCompletionAllocator &Allocator = Results.getAllocator();
6032 CodeCompletionBuilder Builder(Allocator);
6033
6034 // The selector table.
6035 SelectorTable &Selectors = Context.Selectors;
6036
6037 // The property name, copied into the code completion allocation region
6038 // on demand.
6039 struct KeyHolder {
6040 CodeCompletionAllocator &Allocator;
Chris Lattner5f9e2722011-07-23 10:55:15 +00006041 StringRef Key;
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006042 const char *CopiedKey;
6043
Chris Lattner5f9e2722011-07-23 10:55:15 +00006044 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006045 : Allocator(Allocator), Key(Key), CopiedKey(0) { }
6046
6047 operator const char *() {
6048 if (CopiedKey)
6049 return CopiedKey;
6050
6051 return CopiedKey = Allocator.CopyString(Key);
6052 }
6053 } Key(Allocator, PropName->getName());
6054
6055 // The uppercased name of the property name.
6056 std::string UpperKey = PropName->getName();
6057 if (!UpperKey.empty())
6058 UpperKey[0] = toupper(UpperKey[0]);
6059
6060 bool ReturnTypeMatchesProperty = ReturnType.isNull() ||
6061 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
6062 Property->getType());
6063 bool ReturnTypeMatchesVoid
6064 = ReturnType.isNull() || ReturnType->isVoidType();
6065
6066 // Add the normal accessor -(type)key.
6067 if (IsInstanceMethod &&
Douglas Gregore74c25c2011-05-04 23:50:46 +00006068 KnownSelectors.insert(Selectors.getNullarySelector(PropName)) &&
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006069 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
6070 if (ReturnType.isNull())
Douglas Gregor8987b232011-09-27 23:30:47 +00006071 AddObjCPassingTypeChunk(Property->getType(), Context, Policy, Builder);
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006072
6073 Builder.AddTypedTextChunk(Key);
6074 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6075 CXCursor_ObjCInstanceMethodDecl));
6076 }
6077
6078 // If we have an integral or boolean property (or the user has provided
6079 // an integral or boolean return type), add the accessor -(type)isKey.
6080 if (IsInstanceMethod &&
6081 ((!ReturnType.isNull() &&
6082 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
6083 (ReturnType.isNull() &&
6084 (Property->getType()->isIntegerType() ||
6085 Property->getType()->isBooleanType())))) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006086 std::string SelectorName = (Twine("is") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006087 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006088 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006089 if (ReturnType.isNull()) {
6090 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6091 Builder.AddTextChunk("BOOL");
6092 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6093 }
6094
6095 Builder.AddTypedTextChunk(
6096 Allocator.CopyString(SelectorId->getName()));
6097 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6098 CXCursor_ObjCInstanceMethodDecl));
6099 }
6100 }
6101
6102 // Add the normal mutator.
6103 if (IsInstanceMethod && ReturnTypeMatchesVoid &&
6104 !Property->getSetterMethodDecl()) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006105 std::string SelectorName = (Twine("set") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006106 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006107 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006108 if (ReturnType.isNull()) {
6109 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6110 Builder.AddTextChunk("void");
6111 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6112 }
6113
6114 Builder.AddTypedTextChunk(
6115 Allocator.CopyString(SelectorId->getName()));
6116 Builder.AddTypedTextChunk(":");
Douglas Gregor8987b232011-09-27 23:30:47 +00006117 AddObjCPassingTypeChunk(Property->getType(), Context, Policy, Builder);
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006118 Builder.AddTextChunk(Key);
6119 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6120 CXCursor_ObjCInstanceMethodDecl));
6121 }
6122 }
6123
6124 // Indexed and unordered accessors
6125 unsigned IndexedGetterPriority = CCP_CodePattern;
6126 unsigned IndexedSetterPriority = CCP_CodePattern;
6127 unsigned UnorderedGetterPriority = CCP_CodePattern;
6128 unsigned UnorderedSetterPriority = CCP_CodePattern;
6129 if (const ObjCObjectPointerType *ObjCPointer
6130 = Property->getType()->getAs<ObjCObjectPointerType>()) {
6131 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
6132 // If this interface type is not provably derived from a known
6133 // collection, penalize the corresponding completions.
6134 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
6135 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6136 if (!InheritsFromClassNamed(IFace, "NSArray"))
6137 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6138 }
6139
6140 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
6141 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6142 if (!InheritsFromClassNamed(IFace, "NSSet"))
6143 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6144 }
6145 }
6146 } else {
6147 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6148 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6149 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6150 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6151 }
6152
6153 // Add -(NSUInteger)countOf<key>
6154 if (IsInstanceMethod &&
6155 (ReturnType.isNull() || ReturnType->isIntegerType())) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006156 std::string SelectorName = (Twine("countOf") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006157 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006158 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006159 if (ReturnType.isNull()) {
6160 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6161 Builder.AddTextChunk("NSUInteger");
6162 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6163 }
6164
6165 Builder.AddTypedTextChunk(
6166 Allocator.CopyString(SelectorId->getName()));
6167 Results.AddResult(Result(Builder.TakeString(),
6168 std::min(IndexedGetterPriority,
6169 UnorderedGetterPriority),
6170 CXCursor_ObjCInstanceMethodDecl));
6171 }
6172 }
6173
6174 // Indexed getters
6175 // Add -(id)objectInKeyAtIndex:(NSUInteger)index
6176 if (IsInstanceMethod &&
6177 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
Douglas Gregor62041592011-02-17 03:19:26 +00006178 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006179 = (Twine("objectIn") + UpperKey + "AtIndex").str();
Douglas Gregor62041592011-02-17 03:19:26 +00006180 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006181 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006182 if (ReturnType.isNull()) {
6183 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6184 Builder.AddTextChunk("id");
6185 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6186 }
6187
6188 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6189 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6190 Builder.AddTextChunk("NSUInteger");
6191 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6192 Builder.AddTextChunk("index");
6193 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6194 CXCursor_ObjCInstanceMethodDecl));
6195 }
6196 }
6197
6198 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
6199 if (IsInstanceMethod &&
6200 (ReturnType.isNull() ||
6201 (ReturnType->isObjCObjectPointerType() &&
6202 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6203 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6204 ->getName() == "NSArray"))) {
Douglas Gregor62041592011-02-17 03:19:26 +00006205 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006206 = (Twine(Property->getName()) + "AtIndexes").str();
Douglas Gregor62041592011-02-17 03:19:26 +00006207 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006208 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006209 if (ReturnType.isNull()) {
6210 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6211 Builder.AddTextChunk("NSArray *");
6212 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6213 }
6214
6215 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6216 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6217 Builder.AddTextChunk("NSIndexSet *");
6218 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6219 Builder.AddTextChunk("indexes");
6220 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6221 CXCursor_ObjCInstanceMethodDecl));
6222 }
6223 }
6224
6225 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
6226 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006227 std::string SelectorName = (Twine("get") + UpperKey).str();
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006228 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor62041592011-02-17 03:19:26 +00006229 &Context.Idents.get(SelectorName),
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006230 &Context.Idents.get("range")
6231 };
6232
Douglas Gregore74c25c2011-05-04 23:50:46 +00006233 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006234 if (ReturnType.isNull()) {
6235 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6236 Builder.AddTextChunk("void");
6237 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6238 }
6239
6240 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6241 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6242 Builder.AddPlaceholderChunk("object-type");
6243 Builder.AddTextChunk(" **");
6244 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6245 Builder.AddTextChunk("buffer");
6246 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6247 Builder.AddTypedTextChunk("range:");
6248 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6249 Builder.AddTextChunk("NSRange");
6250 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6251 Builder.AddTextChunk("inRange");
6252 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6253 CXCursor_ObjCInstanceMethodDecl));
6254 }
6255 }
6256
6257 // Mutable indexed accessors
6258
6259 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
6260 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006261 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006262 IdentifierInfo *SelectorIds[2] = {
6263 &Context.Idents.get("insertObject"),
Douglas Gregor62041592011-02-17 03:19:26 +00006264 &Context.Idents.get(SelectorName)
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006265 };
6266
Douglas Gregore74c25c2011-05-04 23:50:46 +00006267 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006268 if (ReturnType.isNull()) {
6269 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6270 Builder.AddTextChunk("void");
6271 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6272 }
6273
6274 Builder.AddTypedTextChunk("insertObject:");
6275 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6276 Builder.AddPlaceholderChunk("object-type");
6277 Builder.AddTextChunk(" *");
6278 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6279 Builder.AddTextChunk("object");
6280 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6281 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6282 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6283 Builder.AddPlaceholderChunk("NSUInteger");
6284 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6285 Builder.AddTextChunk("index");
6286 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6287 CXCursor_ObjCInstanceMethodDecl));
6288 }
6289 }
6290
6291 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
6292 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006293 std::string SelectorName = (Twine("insert") + UpperKey).str();
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006294 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor62041592011-02-17 03:19:26 +00006295 &Context.Idents.get(SelectorName),
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006296 &Context.Idents.get("atIndexes")
6297 };
6298
Douglas Gregore74c25c2011-05-04 23:50:46 +00006299 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006300 if (ReturnType.isNull()) {
6301 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6302 Builder.AddTextChunk("void");
6303 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6304 }
6305
6306 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6307 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6308 Builder.AddTextChunk("NSArray *");
6309 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6310 Builder.AddTextChunk("array");
6311 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6312 Builder.AddTypedTextChunk("atIndexes:");
6313 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6314 Builder.AddPlaceholderChunk("NSIndexSet *");
6315 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6316 Builder.AddTextChunk("indexes");
6317 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6318 CXCursor_ObjCInstanceMethodDecl));
6319 }
6320 }
6321
6322 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
6323 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006324 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006325 = (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
Douglas Gregor62041592011-02-17 03:19:26 +00006326 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006327 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006328 if (ReturnType.isNull()) {
6329 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6330 Builder.AddTextChunk("void");
6331 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6332 }
6333
6334 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6335 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6336 Builder.AddTextChunk("NSUInteger");
6337 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6338 Builder.AddTextChunk("index");
6339 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6340 CXCursor_ObjCInstanceMethodDecl));
6341 }
6342 }
6343
6344 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
6345 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006346 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006347 = (Twine("remove") + UpperKey + "AtIndexes").str();
Douglas Gregor62041592011-02-17 03:19:26 +00006348 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006349 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006350 if (ReturnType.isNull()) {
6351 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6352 Builder.AddTextChunk("void");
6353 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6354 }
6355
6356 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6357 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6358 Builder.AddTextChunk("NSIndexSet *");
6359 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6360 Builder.AddTextChunk("indexes");
6361 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6362 CXCursor_ObjCInstanceMethodDecl));
6363 }
6364 }
6365
6366 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
6367 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006368 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006369 = (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006370 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor62041592011-02-17 03:19:26 +00006371 &Context.Idents.get(SelectorName),
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006372 &Context.Idents.get("withObject")
6373 };
6374
Douglas Gregore74c25c2011-05-04 23:50:46 +00006375 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006376 if (ReturnType.isNull()) {
6377 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6378 Builder.AddTextChunk("void");
6379 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6380 }
6381
6382 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6383 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6384 Builder.AddPlaceholderChunk("NSUInteger");
6385 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6386 Builder.AddTextChunk("index");
6387 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6388 Builder.AddTypedTextChunk("withObject:");
6389 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6390 Builder.AddTextChunk("id");
6391 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6392 Builder.AddTextChunk("object");
6393 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6394 CXCursor_ObjCInstanceMethodDecl));
6395 }
6396 }
6397
6398 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
6399 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006400 std::string SelectorName1
Chris Lattner5f9e2722011-07-23 10:55:15 +00006401 = (Twine("replace") + UpperKey + "AtIndexes").str();
6402 std::string SelectorName2 = (Twine("with") + UpperKey).str();
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006403 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor62041592011-02-17 03:19:26 +00006404 &Context.Idents.get(SelectorName1),
6405 &Context.Idents.get(SelectorName2)
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006406 };
6407
Douglas Gregore74c25c2011-05-04 23:50:46 +00006408 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006409 if (ReturnType.isNull()) {
6410 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6411 Builder.AddTextChunk("void");
6412 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6413 }
6414
6415 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
6416 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6417 Builder.AddPlaceholderChunk("NSIndexSet *");
6418 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6419 Builder.AddTextChunk("indexes");
6420 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6421 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
6422 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6423 Builder.AddTextChunk("NSArray *");
6424 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6425 Builder.AddTextChunk("array");
6426 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6427 CXCursor_ObjCInstanceMethodDecl));
6428 }
6429 }
6430
6431 // Unordered getters
6432 // - (NSEnumerator *)enumeratorOfKey
6433 if (IsInstanceMethod &&
6434 (ReturnType.isNull() ||
6435 (ReturnType->isObjCObjectPointerType() &&
6436 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6437 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6438 ->getName() == "NSEnumerator"))) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006439 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006440 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006441 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006442 if (ReturnType.isNull()) {
6443 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6444 Builder.AddTextChunk("NSEnumerator *");
6445 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6446 }
6447
6448 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6449 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6450 CXCursor_ObjCInstanceMethodDecl));
6451 }
6452 }
6453
6454 // - (type *)memberOfKey:(type *)object
6455 if (IsInstanceMethod &&
6456 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006457 std::string SelectorName = (Twine("memberOf") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006458 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006459 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006460 if (ReturnType.isNull()) {
6461 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6462 Builder.AddPlaceholderChunk("object-type");
6463 Builder.AddTextChunk(" *");
6464 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6465 }
6466
6467 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6468 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6469 if (ReturnType.isNull()) {
6470 Builder.AddPlaceholderChunk("object-type");
6471 Builder.AddTextChunk(" *");
6472 } else {
6473 Builder.AddTextChunk(GetCompletionTypeString(ReturnType, Context,
Douglas Gregor8987b232011-09-27 23:30:47 +00006474 Policy,
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006475 Builder.getAllocator()));
6476 }
6477 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6478 Builder.AddTextChunk("object");
6479 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6480 CXCursor_ObjCInstanceMethodDecl));
6481 }
6482 }
6483
6484 // Mutable unordered accessors
6485 // - (void)addKeyObject:(type *)object
6486 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006487 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006488 = (Twine("add") + UpperKey + Twine("Object")).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006489 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006490 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006491 if (ReturnType.isNull()) {
6492 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6493 Builder.AddTextChunk("void");
6494 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6495 }
6496
6497 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6498 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6499 Builder.AddPlaceholderChunk("object-type");
6500 Builder.AddTextChunk(" *");
6501 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6502 Builder.AddTextChunk("object");
6503 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6504 CXCursor_ObjCInstanceMethodDecl));
6505 }
6506 }
6507
6508 // - (void)addKey:(NSSet *)objects
6509 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006510 std::string SelectorName = (Twine("add") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006511 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006512 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006513 if (ReturnType.isNull()) {
6514 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6515 Builder.AddTextChunk("void");
6516 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6517 }
6518
6519 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6520 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6521 Builder.AddTextChunk("NSSet *");
6522 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6523 Builder.AddTextChunk("objects");
6524 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6525 CXCursor_ObjCInstanceMethodDecl));
6526 }
6527 }
6528
6529 // - (void)removeKeyObject:(type *)object
6530 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor62041592011-02-17 03:19:26 +00006531 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006532 = (Twine("remove") + UpperKey + Twine("Object")).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006533 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006534 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006535 if (ReturnType.isNull()) {
6536 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6537 Builder.AddTextChunk("void");
6538 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6539 }
6540
6541 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6542 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6543 Builder.AddPlaceholderChunk("object-type");
6544 Builder.AddTextChunk(" *");
6545 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6546 Builder.AddTextChunk("object");
6547 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6548 CXCursor_ObjCInstanceMethodDecl));
6549 }
6550 }
6551
6552 // - (void)removeKey:(NSSet *)objects
6553 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006554 std::string SelectorName = (Twine("remove") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006555 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006556 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006557 if (ReturnType.isNull()) {
6558 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6559 Builder.AddTextChunk("void");
6560 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6561 }
6562
6563 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6564 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6565 Builder.AddTextChunk("NSSet *");
6566 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6567 Builder.AddTextChunk("objects");
6568 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6569 CXCursor_ObjCInstanceMethodDecl));
6570 }
6571 }
6572
6573 // - (void)intersectKey:(NSSet *)objects
6574 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006575 std::string SelectorName = (Twine("intersect") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006576 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006577 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006578 if (ReturnType.isNull()) {
6579 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6580 Builder.AddTextChunk("void");
6581 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6582 }
6583
6584 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6585 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6586 Builder.AddTextChunk("NSSet *");
6587 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6588 Builder.AddTextChunk("objects");
6589 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6590 CXCursor_ObjCInstanceMethodDecl));
6591 }
6592 }
6593
6594 // Key-Value Observing
6595 // + (NSSet *)keyPathsForValuesAffectingKey
6596 if (!IsInstanceMethod &&
6597 (ReturnType.isNull() ||
6598 (ReturnType->isObjCObjectPointerType() &&
6599 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6600 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6601 ->getName() == "NSSet"))) {
Douglas Gregor62041592011-02-17 03:19:26 +00006602 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006603 = (Twine("keyPathsForValuesAffecting") + UpperKey).str();
Douglas Gregor62041592011-02-17 03:19:26 +00006604 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregore74c25c2011-05-04 23:50:46 +00006605 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006606 if (ReturnType.isNull()) {
6607 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6608 Builder.AddTextChunk("NSSet *");
6609 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6610 }
6611
6612 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6613 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
Douglas Gregor3f828d12011-06-02 04:02:27 +00006614 CXCursor_ObjCClassMethodDecl));
6615 }
6616 }
6617
6618 // + (BOOL)automaticallyNotifiesObserversForKey
6619 if (!IsInstanceMethod &&
6620 (ReturnType.isNull() ||
6621 ReturnType->isIntegerType() ||
6622 ReturnType->isBooleanType())) {
6623 std::string SelectorName
Chris Lattner5f9e2722011-07-23 10:55:15 +00006624 = (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
Douglas Gregor3f828d12011-06-02 04:02:27 +00006625 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6626 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
6627 if (ReturnType.isNull()) {
6628 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6629 Builder.AddTextChunk("BOOL");
6630 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6631 }
6632
6633 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6634 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6635 CXCursor_ObjCClassMethodDecl));
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006636 }
6637 }
6638}
6639
Douglas Gregore8f5a172010-04-07 00:21:17 +00006640void Sema::CodeCompleteObjCMethodDecl(Scope *S,
6641 bool IsInstanceMethod,
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00006642 ParsedType ReturnTy) {
Douglas Gregore8f5a172010-04-07 00:21:17 +00006643 // Determine the return type of the method we're declaring, if
6644 // provided.
6645 QualType ReturnType = GetTypeFromParser(ReturnTy);
Fariborz Jahaniana28948f2011-08-22 15:54:49 +00006646 Decl *IDecl = 0;
6647 if (CurContext->isObjCContainer()) {
6648 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
6649 IDecl = cast<Decl>(OCD);
6650 }
Douglas Gregorea766182010-10-18 18:21:28 +00006651 // Determine where we should start searching for methods.
6652 ObjCContainerDecl *SearchDecl = 0;
Douglas Gregore8f5a172010-04-07 00:21:17 +00006653 bool IsInImplementation = false;
John McCalld226f652010-08-21 09:40:31 +00006654 if (Decl *D = IDecl) {
Douglas Gregore8f5a172010-04-07 00:21:17 +00006655 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
6656 SearchDecl = Impl->getClassInterface();
Douglas Gregore8f5a172010-04-07 00:21:17 +00006657 IsInImplementation = true;
6658 } else if (ObjCCategoryImplDecl *CatImpl
Douglas Gregorea766182010-10-18 18:21:28 +00006659 = dyn_cast<ObjCCategoryImplDecl>(D)) {
Douglas Gregore8f5a172010-04-07 00:21:17 +00006660 SearchDecl = CatImpl->getCategoryDecl();
Douglas Gregore8f5a172010-04-07 00:21:17 +00006661 IsInImplementation = true;
Douglas Gregorea766182010-10-18 18:21:28 +00006662 } else
Douglas Gregore8f5a172010-04-07 00:21:17 +00006663 SearchDecl = dyn_cast<ObjCContainerDecl>(D);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006664 }
6665
6666 if (!SearchDecl && S) {
Douglas Gregorea766182010-10-18 18:21:28 +00006667 if (DeclContext *DC = static_cast<DeclContext *>(S->getEntity()))
Douglas Gregore8f5a172010-04-07 00:21:17 +00006668 SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006669 }
6670
Douglas Gregorea766182010-10-18 18:21:28 +00006671 if (!SearchDecl) {
Douglas Gregore6b1bb62010-08-11 21:23:17 +00006672 HandleCodeCompleteResults(this, CodeCompleter,
6673 CodeCompletionContext::CCC_Other,
6674 0, 0);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006675 return;
6676 }
6677
6678 // Find all of the methods that we could declare/implement here.
6679 KnownMethodsMap KnownMethods;
6680 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod,
Douglas Gregorea766182010-10-18 18:21:28 +00006681 ReturnType, KnownMethods);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006682
Douglas Gregore8f5a172010-04-07 00:21:17 +00006683 // Add declarations or definitions for each of the known methods.
John McCall0a2c5e22010-08-25 06:19:51 +00006684 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00006685 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6686 CodeCompletionContext::CCC_Other);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006687 Results.EnterNewScope();
Douglas Gregor8987b232011-09-27 23:30:47 +00006688 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006689 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
6690 MEnd = KnownMethods.end();
6691 M != MEnd; ++M) {
Douglas Gregor408be5a2010-08-25 01:08:01 +00006692 ObjCMethodDecl *Method = M->second.first;
Douglas Gregor218937c2011-02-01 19:23:04 +00006693 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregore8f5a172010-04-07 00:21:17 +00006694
6695 // If the result type was not already provided, add it to the
6696 // pattern as (type).
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006697 if (ReturnType.isNull())
Douglas Gregor8987b232011-09-27 23:30:47 +00006698 AddObjCPassingTypeChunk(Method->getResultType(), Context, Policy,
6699 Builder);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006700
6701 Selector Sel = Method->getSelector();
6702
6703 // Add the first part of the selector to the pattern.
Douglas Gregordae68752011-02-01 22:57:45 +00006704 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor813d8342011-02-18 22:29:55 +00006705 Sel.getNameForSlot(0)));
Douglas Gregore8f5a172010-04-07 00:21:17 +00006706
6707 // Add parameters to the pattern.
6708 unsigned I = 0;
6709 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
6710 PEnd = Method->param_end();
6711 P != PEnd; (void)++P, ++I) {
6712 // Add the part of the selector name.
6713 if (I == 0)
Douglas Gregor218937c2011-02-01 19:23:04 +00006714 Builder.AddTypedTextChunk(":");
Douglas Gregore8f5a172010-04-07 00:21:17 +00006715 else if (I < Sel.getNumArgs()) {
Douglas Gregor218937c2011-02-01 19:23:04 +00006716 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6717 Builder.AddTypedTextChunk(
Douglas Gregor813d8342011-02-18 22:29:55 +00006718 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
Douglas Gregore8f5a172010-04-07 00:21:17 +00006719 } else
6720 break;
6721
6722 // Add the parameter type.
Douglas Gregor8987b232011-09-27 23:30:47 +00006723 AddObjCPassingTypeChunk((*P)->getOriginalType(), Context, Policy,
6724 Builder);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006725
6726 if (IdentifierInfo *Id = (*P)->getIdentifier())
Douglas Gregordae68752011-02-01 22:57:45 +00006727 Builder.AddTextChunk(Builder.getAllocator().CopyString( Id->getName()));
Douglas Gregore8f5a172010-04-07 00:21:17 +00006728 }
6729
6730 if (Method->isVariadic()) {
6731 if (Method->param_size() > 0)
Douglas Gregor218937c2011-02-01 19:23:04 +00006732 Builder.AddChunk(CodeCompletionString::CK_Comma);
6733 Builder.AddTextChunk("...");
Douglas Gregore17794f2010-08-31 05:13:43 +00006734 }
Douglas Gregore8f5a172010-04-07 00:21:17 +00006735
Douglas Gregor447107d2010-05-28 00:57:46 +00006736 if (IsInImplementation && Results.includeCodePatterns()) {
Douglas Gregore8f5a172010-04-07 00:21:17 +00006737 // We will be defining the method here, so add a compound statement.
Douglas Gregor218937c2011-02-01 19:23:04 +00006738 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6739 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
6740 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006741 if (!Method->getResultType()->isVoidType()) {
6742 // If the result type is not void, add a return clause.
Douglas Gregor218937c2011-02-01 19:23:04 +00006743 Builder.AddTextChunk("return");
6744 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6745 Builder.AddPlaceholderChunk("expression");
6746 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006747 } else
Douglas Gregor218937c2011-02-01 19:23:04 +00006748 Builder.AddPlaceholderChunk("statements");
Douglas Gregore8f5a172010-04-07 00:21:17 +00006749
Douglas Gregor218937c2011-02-01 19:23:04 +00006750 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
6751 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
Douglas Gregore8f5a172010-04-07 00:21:17 +00006752 }
6753
Douglas Gregor408be5a2010-08-25 01:08:01 +00006754 unsigned Priority = CCP_CodePattern;
6755 if (!M->second.second)
6756 Priority += CCD_InBaseClass;
6757
Douglas Gregor218937c2011-02-01 19:23:04 +00006758 Results.AddResult(Result(Builder.TakeString(), Priority,
Douglas Gregor16ed9ad2010-08-17 16:06:07 +00006759 Method->isInstanceMethod()
6760 ? CXCursor_ObjCInstanceMethodDecl
6761 : CXCursor_ObjCClassMethodDecl));
Douglas Gregore8f5a172010-04-07 00:21:17 +00006762 }
6763
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006764 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
6765 // the properties in this class and its categories.
David Blaikie4e4d0842012-03-11 07:00:24 +00006766 if (Context.getLangOpts().ObjC2) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00006767 SmallVector<ObjCContainerDecl *, 4> Containers;
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006768 Containers.push_back(SearchDecl);
6769
Douglas Gregore74c25c2011-05-04 23:50:46 +00006770 VisitedSelectorSet KnownSelectors;
6771 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
6772 MEnd = KnownMethods.end();
6773 M != MEnd; ++M)
6774 KnownSelectors.insert(M->first);
6775
6776
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006777 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
6778 if (!IFace)
6779 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
6780 IFace = Category->getClassInterface();
6781
6782 if (IFace) {
6783 for (ObjCCategoryDecl *Category = IFace->getCategoryList(); Category;
6784 Category = Category->getNextClassCategory())
6785 Containers.push_back(Category);
6786 }
6787
6788 for (unsigned I = 0, N = Containers.size(); I != N; ++I) {
6789 for (ObjCContainerDecl::prop_iterator P = Containers[I]->prop_begin(),
6790 PEnd = Containers[I]->prop_end();
6791 P != PEnd; ++P) {
6792 AddObjCKeyValueCompletions(*P, IsInstanceMethod, ReturnType, Context,
Douglas Gregore74c25c2011-05-04 23:50:46 +00006793 KnownSelectors, Results);
Douglas Gregor577cdfd2011-02-17 00:22:45 +00006794 }
6795 }
6796 }
6797
Douglas Gregore8f5a172010-04-07 00:21:17 +00006798 Results.ExitScope();
6799
Douglas Gregore6b1bb62010-08-11 21:23:17 +00006800 HandleCodeCompleteResults(this, CodeCompleter,
6801 CodeCompletionContext::CCC_Other,
6802 Results.data(),Results.size());
Douglas Gregore8f5a172010-04-07 00:21:17 +00006803}
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006804
6805void Sema::CodeCompleteObjCMethodDeclSelector(Scope *S,
6806 bool IsInstanceMethod,
Douglas Gregor40ed9a12010-07-08 23:37:41 +00006807 bool AtParameterName,
John McCallb3d87482010-08-24 05:47:05 +00006808 ParsedType ReturnTy,
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006809 IdentifierInfo **SelIdents,
6810 unsigned NumSelIdents) {
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006811 // If we have an external source, load the entire class method
Sebastian Redl3c7f4132010-08-18 23:57:06 +00006812 // pool from the AST file.
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006813 if (ExternalSource) {
6814 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6815 I != N; ++I) {
6816 Selector Sel = ExternalSource->GetExternalSelector(I);
Sebastian Redldb9d2142010-08-02 23:18:59 +00006817 if (Sel.isNull() || MethodPool.count(Sel))
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006818 continue;
Sebastian Redldb9d2142010-08-02 23:18:59 +00006819
6820 ReadMethodPool(Sel);
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006821 }
6822 }
6823
6824 // Build the set of methods we can see.
John McCall0a2c5e22010-08-25 06:19:51 +00006825 typedef CodeCompletionResult Result;
Douglas Gregor218937c2011-02-01 19:23:04 +00006826 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6827 CodeCompletionContext::CCC_Other);
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006828
6829 if (ReturnTy)
6830 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
Sebastian Redldb9d2142010-08-02 23:18:59 +00006831
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006832 Results.EnterNewScope();
Sebastian Redldb9d2142010-08-02 23:18:59 +00006833 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6834 MEnd = MethodPool.end();
6835 M != MEnd; ++M) {
6836 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first :
6837 &M->second.second;
6838 MethList && MethList->Method;
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006839 MethList = MethList->Next) {
6840 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents,
6841 NumSelIdents))
6842 continue;
6843
Douglas Gregor40ed9a12010-07-08 23:37:41 +00006844 if (AtParameterName) {
6845 // Suggest parameter names we've seen before.
6846 if (NumSelIdents && NumSelIdents <= MethList->Method->param_size()) {
6847 ParmVarDecl *Param = MethList->Method->param_begin()[NumSelIdents-1];
6848 if (Param->getIdentifier()) {
Douglas Gregor218937c2011-02-01 19:23:04 +00006849 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregordae68752011-02-01 22:57:45 +00006850 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00006851 Param->getIdentifier()->getName()));
6852 Results.AddResult(Builder.TakeString());
Douglas Gregor40ed9a12010-07-08 23:37:41 +00006853 }
6854 }
6855
6856 continue;
6857 }
6858
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006859 Result R(MethList->Method, 0);
6860 R.StartParameter = NumSelIdents;
6861 R.AllParametersAreInformative = false;
6862 R.DeclaringEntity = true;
6863 Results.MaybeAddResult(R, CurContext);
6864 }
6865 }
6866
6867 Results.ExitScope();
Douglas Gregore6b1bb62010-08-11 21:23:17 +00006868 HandleCodeCompleteResults(this, CodeCompleter,
6869 CodeCompletionContext::CCC_Other,
6870 Results.data(),Results.size());
Douglas Gregor1f5537a2010-07-08 23:20:03 +00006871}
Douglas Gregor87c08a52010-08-13 22:48:40 +00006872
Douglas Gregorf29c5232010-08-24 22:20:20 +00006873void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
Douglas Gregor218937c2011-02-01 19:23:04 +00006874 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00006875 CodeCompletionContext::CCC_PreprocessorDirective);
Douglas Gregorf44e8542010-08-24 19:08:16 +00006876 Results.EnterNewScope();
6877
6878 // #if <condition>
Douglas Gregor218937c2011-02-01 19:23:04 +00006879 CodeCompletionBuilder Builder(Results.getAllocator());
6880 Builder.AddTypedTextChunk("if");
6881 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6882 Builder.AddPlaceholderChunk("condition");
6883 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006884
6885 // #ifdef <macro>
Douglas Gregor218937c2011-02-01 19:23:04 +00006886 Builder.AddTypedTextChunk("ifdef");
6887 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6888 Builder.AddPlaceholderChunk("macro");
6889 Results.AddResult(Builder.TakeString());
6890
Douglas Gregorf44e8542010-08-24 19:08:16 +00006891 // #ifndef <macro>
Douglas Gregor218937c2011-02-01 19:23:04 +00006892 Builder.AddTypedTextChunk("ifndef");
6893 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6894 Builder.AddPlaceholderChunk("macro");
6895 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006896
6897 if (InConditional) {
6898 // #elif <condition>
Douglas Gregor218937c2011-02-01 19:23:04 +00006899 Builder.AddTypedTextChunk("elif");
6900 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6901 Builder.AddPlaceholderChunk("condition");
6902 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006903
6904 // #else
Douglas Gregor218937c2011-02-01 19:23:04 +00006905 Builder.AddTypedTextChunk("else");
6906 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006907
6908 // #endif
Douglas Gregor218937c2011-02-01 19:23:04 +00006909 Builder.AddTypedTextChunk("endif");
6910 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006911 }
6912
6913 // #include "header"
Douglas Gregor218937c2011-02-01 19:23:04 +00006914 Builder.AddTypedTextChunk("include");
6915 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6916 Builder.AddTextChunk("\"");
6917 Builder.AddPlaceholderChunk("header");
6918 Builder.AddTextChunk("\"");
6919 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006920
6921 // #include <header>
Douglas Gregor218937c2011-02-01 19:23:04 +00006922 Builder.AddTypedTextChunk("include");
6923 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6924 Builder.AddTextChunk("<");
6925 Builder.AddPlaceholderChunk("header");
6926 Builder.AddTextChunk(">");
6927 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006928
6929 // #define <macro>
Douglas Gregor218937c2011-02-01 19:23:04 +00006930 Builder.AddTypedTextChunk("define");
6931 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6932 Builder.AddPlaceholderChunk("macro");
6933 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006934
6935 // #define <macro>(<args>)
Douglas Gregor218937c2011-02-01 19:23:04 +00006936 Builder.AddTypedTextChunk("define");
6937 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6938 Builder.AddPlaceholderChunk("macro");
6939 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6940 Builder.AddPlaceholderChunk("args");
6941 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6942 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006943
6944 // #undef <macro>
Douglas Gregor218937c2011-02-01 19:23:04 +00006945 Builder.AddTypedTextChunk("undef");
6946 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6947 Builder.AddPlaceholderChunk("macro");
6948 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006949
6950 // #line <number>
Douglas Gregor218937c2011-02-01 19:23:04 +00006951 Builder.AddTypedTextChunk("line");
6952 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6953 Builder.AddPlaceholderChunk("number");
6954 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006955
6956 // #line <number> "filename"
Douglas Gregor218937c2011-02-01 19:23:04 +00006957 Builder.AddTypedTextChunk("line");
6958 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6959 Builder.AddPlaceholderChunk("number");
6960 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6961 Builder.AddTextChunk("\"");
6962 Builder.AddPlaceholderChunk("filename");
6963 Builder.AddTextChunk("\"");
6964 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006965
6966 // #error <message>
Douglas Gregor218937c2011-02-01 19:23:04 +00006967 Builder.AddTypedTextChunk("error");
6968 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6969 Builder.AddPlaceholderChunk("message");
6970 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006971
6972 // #pragma <arguments>
Douglas Gregor218937c2011-02-01 19:23:04 +00006973 Builder.AddTypedTextChunk("pragma");
6974 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6975 Builder.AddPlaceholderChunk("arguments");
6976 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006977
David Blaikie4e4d0842012-03-11 07:00:24 +00006978 if (getLangOpts().ObjC1) {
Douglas Gregorf44e8542010-08-24 19:08:16 +00006979 // #import "header"
Douglas Gregor218937c2011-02-01 19:23:04 +00006980 Builder.AddTypedTextChunk("import");
6981 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6982 Builder.AddTextChunk("\"");
6983 Builder.AddPlaceholderChunk("header");
6984 Builder.AddTextChunk("\"");
6985 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006986
6987 // #import <header>
Douglas Gregor218937c2011-02-01 19:23:04 +00006988 Builder.AddTypedTextChunk("import");
6989 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6990 Builder.AddTextChunk("<");
6991 Builder.AddPlaceholderChunk("header");
6992 Builder.AddTextChunk(">");
6993 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00006994 }
6995
6996 // #include_next "header"
Douglas Gregor218937c2011-02-01 19:23:04 +00006997 Builder.AddTypedTextChunk("include_next");
6998 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6999 Builder.AddTextChunk("\"");
7000 Builder.AddPlaceholderChunk("header");
7001 Builder.AddTextChunk("\"");
7002 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00007003
7004 // #include_next <header>
Douglas Gregor218937c2011-02-01 19:23:04 +00007005 Builder.AddTypedTextChunk("include_next");
7006 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7007 Builder.AddTextChunk("<");
7008 Builder.AddPlaceholderChunk("header");
7009 Builder.AddTextChunk(">");
7010 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00007011
7012 // #warning <message>
Douglas Gregor218937c2011-02-01 19:23:04 +00007013 Builder.AddTypedTextChunk("warning");
7014 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7015 Builder.AddPlaceholderChunk("message");
7016 Results.AddResult(Builder.TakeString());
Douglas Gregorf44e8542010-08-24 19:08:16 +00007017
7018 // Note: #ident and #sccs are such crazy anachronisms that we don't provide
7019 // completions for them. And __include_macros is a Clang-internal extension
7020 // that we don't want to encourage anyone to use.
7021
7022 // FIXME: we don't support #assert or #unassert, so don't suggest them.
7023 Results.ExitScope();
7024
Douglas Gregorf44e8542010-08-24 19:08:16 +00007025 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor721f3592010-08-25 18:41:16 +00007026 CodeCompletionContext::CCC_PreprocessorDirective,
Douglas Gregorf44e8542010-08-24 19:08:16 +00007027 Results.data(), Results.size());
7028}
7029
7030void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
Douglas Gregorf29c5232010-08-24 22:20:20 +00007031 CodeCompleteOrdinaryName(S,
John McCallf312b1e2010-08-26 23:41:50 +00007032 S->getFnParent()? Sema::PCC_RecoveryInFunction
7033 : Sema::PCC_Namespace);
Douglas Gregorf44e8542010-08-24 19:08:16 +00007034}
7035
Douglas Gregorf29c5232010-08-24 22:20:20 +00007036void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
Douglas Gregor218937c2011-02-01 19:23:04 +00007037 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00007038 IsDefinition? CodeCompletionContext::CCC_MacroName
7039 : CodeCompletionContext::CCC_MacroNameUse);
Douglas Gregor1fbb4472010-08-24 20:21:13 +00007040 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
7041 // Add just the names of macros, not their arguments.
Douglas Gregor218937c2011-02-01 19:23:04 +00007042 CodeCompletionBuilder Builder(Results.getAllocator());
Douglas Gregor1fbb4472010-08-24 20:21:13 +00007043 Results.EnterNewScope();
7044 for (Preprocessor::macro_iterator M = PP.macro_begin(),
7045 MEnd = PP.macro_end();
7046 M != MEnd; ++M) {
Douglas Gregordae68752011-02-01 22:57:45 +00007047 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregor218937c2011-02-01 19:23:04 +00007048 M->first->getName()));
7049 Results.AddResult(Builder.TakeString());
Douglas Gregor1fbb4472010-08-24 20:21:13 +00007050 }
7051 Results.ExitScope();
7052 } else if (IsDefinition) {
7053 // FIXME: Can we detect when the user just wrote an include guard above?
7054 }
7055
Douglas Gregor52779fb2010-09-23 23:01:17 +00007056 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregor1fbb4472010-08-24 20:21:13 +00007057 Results.data(), Results.size());
7058}
7059
Douglas Gregorf29c5232010-08-24 22:20:20 +00007060void Sema::CodeCompletePreprocessorExpression() {
Douglas Gregor218937c2011-02-01 19:23:04 +00007061 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Douglas Gregor52779fb2010-09-23 23:01:17 +00007062 CodeCompletionContext::CCC_PreprocessorExpression);
Douglas Gregorf29c5232010-08-24 22:20:20 +00007063
7064 if (!CodeCompleter || CodeCompleter->includeMacros())
7065 AddMacroResults(PP, Results);
7066
7067 // defined (<macro>)
7068 Results.EnterNewScope();
Douglas Gregor218937c2011-02-01 19:23:04 +00007069 CodeCompletionBuilder Builder(Results.getAllocator());
7070 Builder.AddTypedTextChunk("defined");
7071 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7072 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7073 Builder.AddPlaceholderChunk("macro");
7074 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7075 Results.AddResult(Builder.TakeString());
Douglas Gregorf29c5232010-08-24 22:20:20 +00007076 Results.ExitScope();
7077
7078 HandleCodeCompleteResults(this, CodeCompleter,
7079 CodeCompletionContext::CCC_PreprocessorExpression,
7080 Results.data(), Results.size());
7081}
7082
7083void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
7084 IdentifierInfo *Macro,
7085 MacroInfo *MacroInfo,
7086 unsigned Argument) {
7087 // FIXME: In the future, we could provide "overload" results, much like we
7088 // do for function calls.
7089
Argyrios Kyrtzidis5c5f03e2011-08-18 19:41:28 +00007090 // Now just ignore this. There will be another code-completion callback
7091 // for the expanded tokens.
Douglas Gregorf29c5232010-08-24 22:20:20 +00007092}
7093
Douglas Gregor55817af2010-08-25 17:04:25 +00007094void Sema::CodeCompleteNaturalLanguage() {
Douglas Gregor55817af2010-08-25 17:04:25 +00007095 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregoraf1c6b52010-08-25 17:10:00 +00007096 CodeCompletionContext::CCC_NaturalLanguage,
Douglas Gregor55817af2010-08-25 17:04:25 +00007097 0, 0);
7098}
7099
Douglas Gregordae68752011-02-01 22:57:45 +00007100void Sema::GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
Chris Lattner5f9e2722011-07-23 10:55:15 +00007101 SmallVectorImpl<CodeCompletionResult> &Results) {
Douglas Gregor218937c2011-02-01 19:23:04 +00007102 ResultBuilder Builder(*this, Allocator, CodeCompletionContext::CCC_Recovery);
Douglas Gregor8071e422010-08-15 06:18:01 +00007103 if (!CodeCompleter || CodeCompleter->includeGlobals()) {
7104 CodeCompletionDeclConsumer Consumer(Builder,
7105 Context.getTranslationUnitDecl());
7106 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
7107 Consumer);
7108 }
Douglas Gregor87c08a52010-08-13 22:48:40 +00007109
7110 if (!CodeCompleter || CodeCompleter->includeMacros())
7111 AddMacroResults(PP, Builder);
7112
7113 Results.clear();
7114 Results.insert(Results.end(),
7115 Builder.data(), Builder.data() + Builder.size());
7116}