blob: 7e34b642ad6af5f0be28e03182656360de519f37 [file] [log] [blame]
Douglas Gregor2436e712009-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 McCall83024632010-08-25 22:03:47 +000013#include "clang/Sema/SemaInternal.h"
John McCallde6836a2010-08-24 07:21:54 +000014#include "clang/AST/DeclObjC.h"
Douglas Gregorf2510672009-09-21 19:57:38 +000015#include "clang/AST/ExprCXX.h"
Douglas Gregor8ce33212009-11-17 17:59:40 +000016#include "clang/AST/ExprObjC.h"
Jordan Rose4938f272013-02-09 10:09:43 +000017#include "clang/Basic/CharInfo.h"
Douglas Gregor07f43572012-01-29 18:15:03 +000018#include "clang/Lex/HeaderSearch.h"
Douglas Gregorf329c7c2009-10-30 16:50:04 +000019#include "clang/Lex/MacroInfo.h"
20#include "clang/Lex/Preprocessor.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000021#include "clang/Sema/CodeCompleteConsumer.h"
22#include "clang/Sema/ExternalSemaSource.h"
23#include "clang/Sema/Lookup.h"
24#include "clang/Sema/Overload.h"
25#include "clang/Sema/Scope.h"
26#include "clang/Sema/ScopeInfo.h"
Douglas Gregor1154e272010-09-16 16:06:31 +000027#include "llvm/ADT/DenseSet.h"
Benjamin Kramere0513cb2012-01-30 16:17:39 +000028#include "llvm/ADT/SmallBitVector.h"
Douglas Gregor3545ff42009-09-21 16:56:56 +000029#include "llvm/ADT/SmallPtrSet.h"
Benjamin Kramer49038022012-02-04 13:45:25 +000030#include "llvm/ADT/SmallString.h"
Douglas Gregore6688e62009-09-28 03:51:44 +000031#include "llvm/ADT/StringExtras.h"
Douglas Gregor9d2ddb22010-04-06 19:22:33 +000032#include "llvm/ADT/StringSwitch.h"
Douglas Gregor67c692c2010-08-26 15:07:07 +000033#include "llvm/ADT/Twine.h"
Douglas Gregor3545ff42009-09-21 16:56:56 +000034#include <list>
35#include <map>
36#include <vector>
Douglas Gregor2436e712009-09-17 21:32:03 +000037
38using namespace clang;
John McCallaab3e412010-08-25 08:40:02 +000039using namespace sema;
Douglas Gregor2436e712009-09-17 21:32:03 +000040
Douglas Gregor3545ff42009-09-21 16:56:56 +000041namespace {
42 /// \brief A container of code-completion results.
43 class ResultBuilder {
44 public:
45 /// \brief The type of a name-lookup filter, which can be provided to the
46 /// name-lookup routines to specify which declarations should be included in
47 /// the result set (when it returns true) and which declarations should be
48 /// filtered out (returns false).
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +000049 typedef bool (ResultBuilder::*LookupFilter)(const NamedDecl *) const;
Douglas Gregor3545ff42009-09-21 16:56:56 +000050
John McCall276321a2010-08-25 06:19:51 +000051 typedef CodeCompletionResult Result;
Douglas Gregor3545ff42009-09-21 16:56:56 +000052
53 private:
54 /// \brief The actual results we have found.
55 std::vector<Result> Results;
56
57 /// \brief A record of all of the declarations we have found and placed
58 /// into the result set, used to ensure that no declaration ever gets into
59 /// the result set twice.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +000060 llvm::SmallPtrSet<const Decl*, 16> AllDeclsFound;
Douglas Gregor3545ff42009-09-21 16:56:56 +000061
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +000062 typedef std::pair<const NamedDecl *, unsigned> DeclIndexPair;
Douglas Gregor05e7ca32009-12-06 20:23:50 +000063
64 /// \brief An entry in the shadow map, which is optimized to store
65 /// a single (declaration, index) mapping (the common case) but
66 /// can also store a list of (declaration, index) mappings.
67 class ShadowMapEntry {
Chris Lattner0e62c1c2011-07-23 10:55:15 +000068 typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector;
Douglas Gregor05e7ca32009-12-06 20:23:50 +000069
70 /// \brief Contains either the solitary NamedDecl * or a vector
71 /// of (declaration, index) pairs.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +000072 llvm::PointerUnion<const NamedDecl *, DeclIndexPairVector*> DeclOrVector;
Douglas Gregor05e7ca32009-12-06 20:23:50 +000073
74 /// \brief When the entry contains a single declaration, this is
75 /// the index associated with that entry.
76 unsigned SingleDeclIndex;
77
78 public:
79 ShadowMapEntry() : DeclOrVector(), SingleDeclIndex(0) { }
80
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +000081 void Add(const NamedDecl *ND, unsigned Index) {
Douglas Gregor05e7ca32009-12-06 20:23:50 +000082 if (DeclOrVector.isNull()) {
83 // 0 - > 1 elements: just set the single element information.
84 DeclOrVector = ND;
85 SingleDeclIndex = Index;
86 return;
87 }
88
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +000089 if (const NamedDecl *PrevND =
90 DeclOrVector.dyn_cast<const NamedDecl *>()) {
Douglas Gregor05e7ca32009-12-06 20:23:50 +000091 // 1 -> 2 elements: create the vector of results and push in the
92 // existing declaration.
93 DeclIndexPairVector *Vec = new DeclIndexPairVector;
94 Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex));
95 DeclOrVector = Vec;
96 }
97
98 // Add the new element to the end of the vector.
99 DeclOrVector.get<DeclIndexPairVector*>()->push_back(
100 DeclIndexPair(ND, Index));
101 }
102
103 void Destroy() {
104 if (DeclIndexPairVector *Vec
105 = DeclOrVector.dyn_cast<DeclIndexPairVector *>()) {
106 delete Vec;
107 DeclOrVector = ((NamedDecl *)0);
108 }
109 }
110
111 // Iteration.
112 class iterator;
113 iterator begin() const;
114 iterator end() const;
115 };
116
Douglas Gregor3545ff42009-09-21 16:56:56 +0000117 /// \brief A mapping from declaration names to the declarations that have
118 /// this name within a particular scope and their index within the list of
119 /// results.
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000120 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
Douglas Gregor3545ff42009-09-21 16:56:56 +0000121
122 /// \brief The semantic analysis object for which results are being
123 /// produced.
124 Sema &SemaRef;
Douglas Gregorb278aaf2011-02-01 19:23:04 +0000125
126 /// \brief The allocator used to allocate new code-completion strings.
Douglas Gregorbcbf46c2011-02-01 22:57:45 +0000127 CodeCompletionAllocator &Allocator;
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000128
129 CodeCompletionTUInfo &CCTUInfo;
Douglas Gregor3545ff42009-09-21 16:56:56 +0000130
131 /// \brief If non-NULL, a filter function used to remove any code-completion
132 /// results that are not desirable.
133 LookupFilter Filter;
Douglas Gregor6ae4c522010-01-14 03:21:49 +0000134
135 /// \brief Whether we should allow declarations as
136 /// nested-name-specifiers that would otherwise be filtered out.
137 bool AllowNestedNameSpecifiers;
138
Douglas Gregor7aa6b222010-05-30 01:49:25 +0000139 /// \brief If set, the type that we would prefer our resulting value
140 /// declarations to have.
141 ///
142 /// Closely matching the preferred type gives a boost to a result's
143 /// priority.
144 CanQualType PreferredType;
145
Douglas Gregor3545ff42009-09-21 16:56:56 +0000146 /// \brief A list of shadow maps, which is used to model name hiding at
147 /// different levels of, e.g., the inheritance hierarchy.
148 std::list<ShadowMap> ShadowMaps;
149
Douglas Gregor9be0ed42010-08-26 16:36:48 +0000150 /// \brief If we're potentially referring to a C++ member function, the set
151 /// of qualifiers applied to the object type.
152 Qualifiers ObjectTypeQualifiers;
153
154 /// \brief Whether the \p ObjectTypeQualifiers field is active.
155 bool HasObjectTypeQualifiers;
156
Douglas Gregorc2cb2e22010-08-27 15:29:55 +0000157 /// \brief The selector that we prefer.
158 Selector PreferredSelector;
159
Douglas Gregor05fcf842010-11-02 20:36:02 +0000160 /// \brief The completion context in which we are gathering results.
Douglas Gregor50832e02010-09-20 22:39:41 +0000161 CodeCompletionContext CompletionContext;
162
James Dennett596e4752012-06-14 03:11:41 +0000163 /// \brief If we are in an instance method definition, the \@implementation
Douglas Gregor05fcf842010-11-02 20:36:02 +0000164 /// object.
165 ObjCImplementationDecl *ObjCImplementation;
Douglas Gregor0a0e2b32013-01-31 04:52:16 +0000166
Douglas Gregor50832e02010-09-20 22:39:41 +0000167 void AdjustResultPriorityForDecl(Result &R);
Douglas Gregor95887f92010-07-08 23:20:03 +0000168
Douglas Gregor0212fd72010-09-21 16:06:22 +0000169 void MaybeAddConstructorResults(Result R);
170
Douglas Gregor3545ff42009-09-21 16:56:56 +0000171 public:
Douglas Gregorbcbf46c2011-02-01 22:57:45 +0000172 explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator,
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000173 CodeCompletionTUInfo &CCTUInfo,
Douglas Gregor0ac41382010-09-23 23:01:17 +0000174 const CodeCompletionContext &CompletionContext,
175 LookupFilter Filter = 0)
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000176 : SemaRef(SemaRef), Allocator(Allocator), CCTUInfo(CCTUInfo),
177 Filter(Filter),
Douglas Gregorb278aaf2011-02-01 19:23:04 +0000178 AllowNestedNameSpecifiers(false), HasObjectTypeQualifiers(false),
Douglas Gregor05fcf842010-11-02 20:36:02 +0000179 CompletionContext(CompletionContext),
180 ObjCImplementation(0)
181 {
182 // If this is an Objective-C instance method definition, dig out the
183 // corresponding implementation.
184 switch (CompletionContext.getKind()) {
185 case CodeCompletionContext::CCC_Expression:
186 case CodeCompletionContext::CCC_ObjCMessageReceiver:
187 case CodeCompletionContext::CCC_ParenthesizedExpression:
188 case CodeCompletionContext::CCC_Statement:
189 case CodeCompletionContext::CCC_Recovery:
190 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl())
191 if (Method->isInstanceMethod())
192 if (ObjCInterfaceDecl *Interface = Method->getClassInterface())
193 ObjCImplementation = Interface->getImplementation();
194 break;
195
196 default:
197 break;
198 }
199 }
Douglas Gregor0a0e2b32013-01-31 04:52:16 +0000200
201 /// \brief Determine the priority for a reference to the given declaration.
202 unsigned getBasePriority(const NamedDecl *D);
203
Douglas Gregorf64acca2010-05-25 21:41:55 +0000204 /// \brief Whether we should include code patterns in the completion
205 /// results.
206 bool includeCodePatterns() const {
207 return SemaRef.CodeCompleter &&
Douglas Gregorac322ec2010-08-27 21:18:54 +0000208 SemaRef.CodeCompleter->includeCodePatterns();
Douglas Gregorf64acca2010-05-25 21:41:55 +0000209 }
210
Douglas Gregor3545ff42009-09-21 16:56:56 +0000211 /// \brief Set the filter used for code-completion results.
212 void setFilter(LookupFilter Filter) {
213 this->Filter = Filter;
214 }
215
Douglas Gregor3545ff42009-09-21 16:56:56 +0000216 Result *data() { return Results.empty()? 0 : &Results.front(); }
217 unsigned size() const { return Results.size(); }
218 bool empty() const { return Results.empty(); }
219
Douglas Gregor7aa6b222010-05-30 01:49:25 +0000220 /// \brief Specify the preferred type.
221 void setPreferredType(QualType T) {
222 PreferredType = SemaRef.Context.getCanonicalType(T);
223 }
224
Douglas Gregor9be0ed42010-08-26 16:36:48 +0000225 /// \brief Set the cv-qualifiers on the object type, for us in filtering
226 /// calls to member functions.
227 ///
228 /// When there are qualifiers in this set, they will be used to filter
229 /// out member functions that aren't available (because there will be a
230 /// cv-qualifier mismatch) or prefer functions with an exact qualifier
231 /// match.
232 void setObjectTypeQualifiers(Qualifiers Quals) {
233 ObjectTypeQualifiers = Quals;
234 HasObjectTypeQualifiers = true;
235 }
236
Douglas Gregorc2cb2e22010-08-27 15:29:55 +0000237 /// \brief Set the preferred selector.
238 ///
239 /// When an Objective-C method declaration result is added, and that
240 /// method's selector matches this preferred selector, we give that method
241 /// a slight priority boost.
242 void setPreferredSelector(Selector Sel) {
243 PreferredSelector = Sel;
244 }
Douglas Gregor05fcf842010-11-02 20:36:02 +0000245
Douglas Gregor50832e02010-09-20 22:39:41 +0000246 /// \brief Retrieve the code-completion context for which results are
247 /// being collected.
248 const CodeCompletionContext &getCompletionContext() const {
249 return CompletionContext;
250 }
251
Douglas Gregor6ae4c522010-01-14 03:21:49 +0000252 /// \brief Specify whether nested-name-specifiers are allowed.
253 void allowNestedNameSpecifiers(bool Allow = true) {
254 AllowNestedNameSpecifiers = Allow;
255 }
256
Douglas Gregor74661272010-09-21 00:03:25 +0000257 /// \brief Return the semantic analysis object for which we are collecting
258 /// code completion results.
259 Sema &getSema() const { return SemaRef; }
260
Douglas Gregorb278aaf2011-02-01 19:23:04 +0000261 /// \brief Retrieve the allocator used to allocate code completion strings.
Douglas Gregorbcbf46c2011-02-01 22:57:45 +0000262 CodeCompletionAllocator &getAllocator() const { return Allocator; }
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +0000263
264 CodeCompletionTUInfo &getCodeCompletionTUInfo() const { return CCTUInfo; }
Douglas Gregorb278aaf2011-02-01 19:23:04 +0000265
Douglas Gregor7c208612010-01-14 00:20:49 +0000266 /// \brief Determine whether the given declaration is at all interesting
267 /// as a code-completion result.
Douglas Gregor6ae4c522010-01-14 03:21:49 +0000268 ///
269 /// \param ND the declaration that we are inspecting.
270 ///
271 /// \param AsNestedNameSpecifier will be set true if this declaration is
272 /// only interesting when it is a nested-name-specifier.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000273 bool isInterestingDecl(const NamedDecl *ND,
274 bool &AsNestedNameSpecifier) const;
Douglas Gregore0717ab2010-01-14 00:41:07 +0000275
276 /// \brief Check whether the result is hidden by the Hiding declaration.
277 ///
278 /// \returns true if the result is hidden and cannot be found, false if
279 /// the hidden result could still be found. When false, \p R may be
280 /// modified to describe how the result can be found (e.g., via extra
281 /// qualification).
282 bool CheckHiddenResult(Result &R, DeclContext *CurContext,
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000283 const NamedDecl *Hiding);
Douglas Gregore0717ab2010-01-14 00:41:07 +0000284
Douglas Gregor3545ff42009-09-21 16:56:56 +0000285 /// \brief Add a new result to this result set (if it isn't already in one
286 /// of the shadow maps), or replace an existing result (for, e.g., a
287 /// redeclaration).
Douglas Gregor2af2f672009-09-21 20:12:40 +0000288 ///
Douglas Gregord8c61782012-02-15 15:34:24 +0000289 /// \param R the result to add (if it is unique).
Douglas Gregor2af2f672009-09-21 20:12:40 +0000290 ///
Douglas Gregord8c61782012-02-15 15:34:24 +0000291 /// \param CurContext the context in which this result will be named.
Douglas Gregor2af2f672009-09-21 20:12:40 +0000292 void MaybeAddResult(Result R, DeclContext *CurContext = 0);
Douglas Gregor3545ff42009-09-21 16:56:56 +0000293
Douglas Gregorc580c522010-01-14 01:09:38 +0000294 /// \brief Add a new result to this result set, where we already know
295 /// the hiding declation (if any).
296 ///
297 /// \param R the result to add (if it is unique).
298 ///
299 /// \param CurContext the context in which this result will be named.
300 ///
301 /// \param Hiding the declaration that hides the result.
Douglas Gregor09bbc652010-01-14 15:47:35 +0000302 ///
303 /// \param InBaseClass whether the result was found in a base
304 /// class of the searched context.
305 void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding,
306 bool InBaseClass);
Douglas Gregorc580c522010-01-14 01:09:38 +0000307
Douglas Gregor78a21012010-01-14 16:01:26 +0000308 /// \brief Add a new non-declaration result to this result set.
309 void AddResult(Result R);
310
Douglas Gregor3545ff42009-09-21 16:56:56 +0000311 /// \brief Enter into a new scope.
312 void EnterNewScope();
313
314 /// \brief Exit from the current scope.
315 void ExitScope();
316
Douglas Gregorbaf69612009-11-18 04:19:12 +0000317 /// \brief Ignore this declaration, if it is seen again.
Dmitri Gribenko6cfb1532013-02-14 13:53:30 +0000318 void Ignore(const Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); }
Douglas Gregorbaf69612009-11-18 04:19:12 +0000319
Douglas Gregor3545ff42009-09-21 16:56:56 +0000320 /// \name Name lookup predicates
321 ///
322 /// These predicates can be passed to the name lookup functions to filter the
323 /// results of name lookup. All of the predicates have the same type, so that
324 ///
325 //@{
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000326 bool IsOrdinaryName(const NamedDecl *ND) const;
327 bool IsOrdinaryNonTypeName(const NamedDecl *ND) const;
328 bool IsIntegralConstantValue(const NamedDecl *ND) const;
329 bool IsOrdinaryNonValueName(const NamedDecl *ND) const;
330 bool IsNestedNameSpecifier(const NamedDecl *ND) const;
331 bool IsEnum(const NamedDecl *ND) const;
332 bool IsClassOrStruct(const NamedDecl *ND) const;
333 bool IsUnion(const NamedDecl *ND) const;
334 bool IsNamespace(const NamedDecl *ND) const;
335 bool IsNamespaceOrAlias(const NamedDecl *ND) const;
336 bool IsType(const NamedDecl *ND) const;
337 bool IsMember(const NamedDecl *ND) const;
338 bool IsObjCIvar(const NamedDecl *ND) const;
339 bool IsObjCMessageReceiver(const NamedDecl *ND) const;
340 bool IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const;
341 bool IsObjCCollection(const NamedDecl *ND) const;
342 bool IsImpossibleToSatisfy(const NamedDecl *ND) const;
Douglas Gregor3545ff42009-09-21 16:56:56 +0000343 //@}
344 };
345}
346
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000347class ResultBuilder::ShadowMapEntry::iterator {
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000348 llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator;
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000349 unsigned SingleDeclIndex;
350
351public:
352 typedef DeclIndexPair value_type;
353 typedef value_type reference;
354 typedef std::ptrdiff_t difference_type;
355 typedef std::input_iterator_tag iterator_category;
356
357 class pointer {
358 DeclIndexPair Value;
359
360 public:
361 pointer(const DeclIndexPair &Value) : Value(Value) { }
362
363 const DeclIndexPair *operator->() const {
364 return &Value;
365 }
366 };
367
368 iterator() : DeclOrIterator((NamedDecl *)0), SingleDeclIndex(0) { }
369
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000370 iterator(const NamedDecl *SingleDecl, unsigned Index)
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000371 : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) { }
372
373 iterator(const DeclIndexPair *Iterator)
374 : DeclOrIterator(Iterator), SingleDeclIndex(0) { }
375
376 iterator &operator++() {
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000377 if (DeclOrIterator.is<const NamedDecl *>()) {
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000378 DeclOrIterator = (NamedDecl *)0;
379 SingleDeclIndex = 0;
380 return *this;
381 }
382
383 const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair*>();
384 ++I;
385 DeclOrIterator = I;
386 return *this;
387 }
388
Chris Lattner9795b392010-09-04 18:12:20 +0000389 /*iterator operator++(int) {
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000390 iterator tmp(*this);
391 ++(*this);
392 return tmp;
Chris Lattner9795b392010-09-04 18:12:20 +0000393 }*/
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000394
395 reference operator*() const {
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000396 if (const NamedDecl *ND = DeclOrIterator.dyn_cast<const NamedDecl *>())
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000397 return reference(ND, SingleDeclIndex);
398
Douglas Gregor94bb5e82009-12-06 21:27:58 +0000399 return *DeclOrIterator.get<const DeclIndexPair*>();
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000400 }
401
402 pointer operator->() const {
403 return pointer(**this);
404 }
405
406 friend bool operator==(const iterator &X, const iterator &Y) {
Douglas Gregor94bb5e82009-12-06 21:27:58 +0000407 return X.DeclOrIterator.getOpaqueValue()
408 == Y.DeclOrIterator.getOpaqueValue() &&
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000409 X.SingleDeclIndex == Y.SingleDeclIndex;
410 }
411
412 friend bool operator!=(const iterator &X, const iterator &Y) {
Douglas Gregor94bb5e82009-12-06 21:27:58 +0000413 return !(X == Y);
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000414 }
415};
416
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000417ResultBuilder::ShadowMapEntry::iterator
418ResultBuilder::ShadowMapEntry::begin() const {
419 if (DeclOrVector.isNull())
420 return iterator();
421
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000422 if (const NamedDecl *ND = DeclOrVector.dyn_cast<const NamedDecl *>())
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000423 return iterator(ND, SingleDeclIndex);
424
425 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin());
426}
427
428ResultBuilder::ShadowMapEntry::iterator
429ResultBuilder::ShadowMapEntry::end() const {
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000430 if (DeclOrVector.is<const NamedDecl *>() || DeclOrVector.isNull())
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000431 return iterator();
432
433 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end());
434}
435
Douglas Gregor2af2f672009-09-21 20:12:40 +0000436/// \brief Compute the qualification required to get from the current context
437/// (\p CurContext) to the target context (\p TargetContext).
438///
439/// \param Context the AST context in which the qualification will be used.
440///
441/// \param CurContext the context where an entity is being named, which is
442/// typically based on the current scope.
443///
444/// \param TargetContext the context in which the named entity actually
445/// resides.
446///
447/// \returns a nested name specifier that refers into the target context, or
448/// NULL if no qualification is needed.
449static NestedNameSpecifier *
450getRequiredQualification(ASTContext &Context,
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000451 const DeclContext *CurContext,
452 const DeclContext *TargetContext) {
453 SmallVector<const DeclContext *, 4> TargetParents;
Douglas Gregor2af2f672009-09-21 20:12:40 +0000454
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000455 for (const DeclContext *CommonAncestor = TargetContext;
Douglas Gregor2af2f672009-09-21 20:12:40 +0000456 CommonAncestor && !CommonAncestor->Encloses(CurContext);
457 CommonAncestor = CommonAncestor->getLookupParent()) {
458 if (CommonAncestor->isTransparentContext() ||
459 CommonAncestor->isFunctionOrMethod())
460 continue;
461
462 TargetParents.push_back(CommonAncestor);
463 }
464
465 NestedNameSpecifier *Result = 0;
466 while (!TargetParents.empty()) {
Robert Wilhelm25284cc2013-08-23 16:11:15 +0000467 const DeclContext *Parent = TargetParents.pop_back_val();
468
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000469 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Parent)) {
Douglas Gregor68762e72010-08-23 21:17:50 +0000470 if (!Namespace->getIdentifier())
471 continue;
472
Douglas Gregor2af2f672009-09-21 20:12:40 +0000473 Result = NestedNameSpecifier::Create(Context, Result, Namespace);
Douglas Gregor68762e72010-08-23 21:17:50 +0000474 }
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000475 else if (const TagDecl *TD = dyn_cast<TagDecl>(Parent))
Douglas Gregor2af2f672009-09-21 20:12:40 +0000476 Result = NestedNameSpecifier::Create(Context, Result,
477 false,
478 Context.getTypeDeclType(TD).getTypePtr());
Douglas Gregor9eb77012009-11-07 00:00:49 +0000479 }
Douglas Gregor2af2f672009-09-21 20:12:40 +0000480 return Result;
481}
482
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000483bool ResultBuilder::isInterestingDecl(const NamedDecl *ND,
Douglas Gregor6ae4c522010-01-14 03:21:49 +0000484 bool &AsNestedNameSpecifier) const {
485 AsNestedNameSpecifier = false;
486
Douglas Gregor7c208612010-01-14 00:20:49 +0000487 ND = ND->getUnderlyingDecl();
488 unsigned IDNS = ND->getIdentifierNamespace();
Douglas Gregor58acf322009-10-09 22:16:47 +0000489
490 // Skip unnamed entities.
Douglas Gregor7c208612010-01-14 00:20:49 +0000491 if (!ND->getDeclName())
492 return false;
Douglas Gregor3545ff42009-09-21 16:56:56 +0000493
494 // Friend declarations and declarations introduced due to friends are never
495 // added as results.
John McCallbbbbe4e2010-03-11 07:50:04 +0000496 if (IDNS & (Decl::IDNS_OrdinaryFriend | Decl::IDNS_TagFriend))
Douglas Gregor7c208612010-01-14 00:20:49 +0000497 return false;
498
Douglas Gregor99fe2ad2009-12-11 17:31:05 +0000499 // Class template (partial) specializations are never added as results.
Douglas Gregor7c208612010-01-14 00:20:49 +0000500 if (isa<ClassTemplateSpecializationDecl>(ND) ||
501 isa<ClassTemplatePartialSpecializationDecl>(ND))
502 return false;
Douglas Gregor3545ff42009-09-21 16:56:56 +0000503
Douglas Gregor99fe2ad2009-12-11 17:31:05 +0000504 // Using declarations themselves are never added as results.
Douglas Gregor7c208612010-01-14 00:20:49 +0000505 if (isa<UsingDecl>(ND))
506 return false;
507
508 // Some declarations have reserved names that we don't want to ever show.
509 if (const IdentifierInfo *Id = ND->getIdentifier()) {
Douglas Gregor3545ff42009-09-21 16:56:56 +0000510 // __va_list_tag is a freak of nature. Find it and skip it.
511 if (Id->isStr("__va_list_tag") || Id->isStr("__builtin_va_list"))
Douglas Gregor7c208612010-01-14 00:20:49 +0000512 return false;
Douglas Gregor3545ff42009-09-21 16:56:56 +0000513
Douglas Gregor58acf322009-10-09 22:16:47 +0000514 // Filter out names reserved for the implementation (C99 7.1.3,
Douglas Gregor9f1570d2010-07-14 17:44:04 +0000515 // C++ [lib.global.names]) if they come from a system header.
Daniel Dunbar2c422dc92009-10-18 20:26:12 +0000516 //
517 // FIXME: Add predicate for this.
Douglas Gregor58acf322009-10-09 22:16:47 +0000518 if (Id->getLength() >= 2) {
Daniel Dunbar2c422dc92009-10-18 20:26:12 +0000519 const char *Name = Id->getNameStart();
Douglas Gregor58acf322009-10-09 22:16:47 +0000520 if (Name[0] == '_' &&
Douglas Gregor9f1570d2010-07-14 17:44:04 +0000521 (Name[1] == '_' || (Name[1] >= 'A' && Name[1] <= 'Z')) &&
522 (ND->getLocation().isInvalid() ||
523 SemaRef.SourceMgr.isInSystemHeader(
524 SemaRef.SourceMgr.getSpellingLoc(ND->getLocation()))))
Douglas Gregor7c208612010-01-14 00:20:49 +0000525 return false;
Douglas Gregor58acf322009-10-09 22:16:47 +0000526 }
Douglas Gregor3545ff42009-09-21 16:56:56 +0000527 }
Douglas Gregor2927c0c2010-11-09 03:59:40 +0000528
Douglas Gregor59cab552010-08-16 23:05:20 +0000529 if (Filter == &ResultBuilder::IsNestedNameSpecifier ||
530 ((isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) &&
531 Filter != &ResultBuilder::IsNamespace &&
Douglas Gregor0ac41382010-09-23 23:01:17 +0000532 Filter != &ResultBuilder::IsNamespaceOrAlias &&
533 Filter != 0))
Douglas Gregor59cab552010-08-16 23:05:20 +0000534 AsNestedNameSpecifier = true;
535
Douglas Gregor3545ff42009-09-21 16:56:56 +0000536 // Filter out any unwanted results.
Douglas Gregor6ae4c522010-01-14 03:21:49 +0000537 if (Filter && !(this->*Filter)(ND)) {
538 // Check whether it is interesting as a nested-name-specifier.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000539 if (AllowNestedNameSpecifiers && SemaRef.getLangOpts().CPlusPlus &&
Douglas Gregor6ae4c522010-01-14 03:21:49 +0000540 IsNestedNameSpecifier(ND) &&
541 (Filter != &ResultBuilder::IsMember ||
542 (isa<CXXRecordDecl>(ND) &&
543 cast<CXXRecordDecl>(ND)->isInjectedClassName()))) {
544 AsNestedNameSpecifier = true;
545 return true;
546 }
547
Douglas Gregor7c208612010-01-14 00:20:49 +0000548 return false;
Douglas Gregor59cab552010-08-16 23:05:20 +0000549 }
Douglas Gregor7c208612010-01-14 00:20:49 +0000550 // ... then it must be interesting!
551 return true;
552}
553
Douglas Gregore0717ab2010-01-14 00:41:07 +0000554bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext,
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000555 const NamedDecl *Hiding) {
Douglas Gregore0717ab2010-01-14 00:41:07 +0000556 // In C, there is no way to refer to a hidden name.
557 // FIXME: This isn't true; we can find a tag name hidden by an ordinary
558 // name if we introduce the tag type.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000559 if (!SemaRef.getLangOpts().CPlusPlus)
Douglas Gregore0717ab2010-01-14 00:41:07 +0000560 return true;
561
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000562 const DeclContext *HiddenCtx =
563 R.Declaration->getDeclContext()->getRedeclContext();
Douglas Gregore0717ab2010-01-14 00:41:07 +0000564
565 // There is no way to qualify a name declared in a function or method.
566 if (HiddenCtx->isFunctionOrMethod())
567 return true;
568
Sebastian Redl50c68252010-08-31 00:36:30 +0000569 if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext())
Douglas Gregore0717ab2010-01-14 00:41:07 +0000570 return true;
571
572 // We can refer to the result with the appropriate qualification. Do it.
573 R.Hidden = true;
574 R.QualifierIsInformative = false;
575
576 if (!R.Qualifier)
577 R.Qualifier = getRequiredQualification(SemaRef.Context,
578 CurContext,
579 R.Declaration->getDeclContext());
580 return false;
581}
582
Douglas Gregor95887f92010-07-08 23:20:03 +0000583/// \brief A simplified classification of types used to determine whether two
584/// types are "similar enough" when adjusting priorities.
Douglas Gregor6e240332010-08-16 16:18:59 +0000585SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) {
Douglas Gregor95887f92010-07-08 23:20:03 +0000586 switch (T->getTypeClass()) {
587 case Type::Builtin:
588 switch (cast<BuiltinType>(T)->getKind()) {
589 case BuiltinType::Void:
590 return STC_Void;
591
592 case BuiltinType::NullPtr:
593 return STC_Pointer;
594
595 case BuiltinType::Overload:
596 case BuiltinType::Dependent:
Douglas Gregor95887f92010-07-08 23:20:03 +0000597 return STC_Other;
598
599 case BuiltinType::ObjCId:
600 case BuiltinType::ObjCClass:
601 case BuiltinType::ObjCSel:
602 return STC_ObjectiveC;
603
604 default:
605 return STC_Arithmetic;
606 }
David Blaikie8a40f702012-01-17 06:56:22 +0000607
Douglas Gregor95887f92010-07-08 23:20:03 +0000608 case Type::Complex:
609 return STC_Arithmetic;
610
611 case Type::Pointer:
612 return STC_Pointer;
613
614 case Type::BlockPointer:
615 return STC_Block;
616
617 case Type::LValueReference:
618 case Type::RValueReference:
619 return getSimplifiedTypeClass(T->getAs<ReferenceType>()->getPointeeType());
620
621 case Type::ConstantArray:
622 case Type::IncompleteArray:
623 case Type::VariableArray:
624 case Type::DependentSizedArray:
625 return STC_Array;
626
627 case Type::DependentSizedExtVector:
628 case Type::Vector:
629 case Type::ExtVector:
630 return STC_Arithmetic;
631
632 case Type::FunctionProto:
633 case Type::FunctionNoProto:
634 return STC_Function;
635
636 case Type::Record:
637 return STC_Record;
638
639 case Type::Enum:
640 return STC_Arithmetic;
641
642 case Type::ObjCObject:
643 case Type::ObjCInterface:
644 case Type::ObjCObjectPointer:
645 return STC_ObjectiveC;
646
647 default:
648 return STC_Other;
649 }
650}
651
652/// \brief Get the type that a given expression will have if this declaration
653/// is used as an expression in its "typical" code-completion form.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000654QualType clang::getDeclUsageType(ASTContext &C, const NamedDecl *ND) {
Douglas Gregor95887f92010-07-08 23:20:03 +0000655 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
656
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000657 if (const TypeDecl *Type = dyn_cast<TypeDecl>(ND))
Douglas Gregor95887f92010-07-08 23:20:03 +0000658 return C.getTypeDeclType(Type);
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000659 if (const ObjCInterfaceDecl *Iface = dyn_cast<ObjCInterfaceDecl>(ND))
Douglas Gregor95887f92010-07-08 23:20:03 +0000660 return C.getObjCInterfaceType(Iface);
661
662 QualType T;
Alp Tokera2794f92014-01-22 07:29:52 +0000663 if (const FunctionDecl *Function = ND->getAsFunction())
Douglas Gregor603d81b2010-07-13 08:18:22 +0000664 T = Function->getCallResultType();
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000665 else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND))
Douglas Gregor603d81b2010-07-13 08:18:22 +0000666 T = Method->getSendResultType();
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000667 else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
Douglas Gregor95887f92010-07-08 23:20:03 +0000668 T = C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext()));
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000669 else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND))
Douglas Gregor95887f92010-07-08 23:20:03 +0000670 T = Property->getType();
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000671 else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND))
Douglas Gregor95887f92010-07-08 23:20:03 +0000672 T = Value->getType();
673 else
674 return QualType();
Douglas Gregoraf670a82011-04-14 20:33:34 +0000675
676 // Dig through references, function pointers, and block pointers to
677 // get down to the likely type of an expression when the entity is
678 // used.
679 do {
680 if (const ReferenceType *Ref = T->getAs<ReferenceType>()) {
681 T = Ref->getPointeeType();
682 continue;
683 }
684
685 if (const PointerType *Pointer = T->getAs<PointerType>()) {
686 if (Pointer->getPointeeType()->isFunctionType()) {
687 T = Pointer->getPointeeType();
688 continue;
689 }
690
691 break;
692 }
693
694 if (const BlockPointerType *Block = T->getAs<BlockPointerType>()) {
695 T = Block->getPointeeType();
696 continue;
697 }
698
699 if (const FunctionType *Function = T->getAs<FunctionType>()) {
Alp Toker314cc812014-01-25 16:55:45 +0000700 T = Function->getReturnType();
Douglas Gregoraf670a82011-04-14 20:33:34 +0000701 continue;
702 }
703
704 break;
705 } while (true);
706
707 return T;
Douglas Gregor95887f92010-07-08 23:20:03 +0000708}
709
Douglas Gregor0a0e2b32013-01-31 04:52:16 +0000710unsigned ResultBuilder::getBasePriority(const NamedDecl *ND) {
711 if (!ND)
712 return CCP_Unlikely;
713
714 // Context-based decisions.
Richard Smith541b38b2013-09-20 01:15:31 +0000715 const DeclContext *LexicalDC = ND->getLexicalDeclContext();
716 if (LexicalDC->isFunctionOrMethod()) {
Douglas Gregor0a0e2b32013-01-31 04:52:16 +0000717 // _cmd is relatively rare
718 if (const ImplicitParamDecl *ImplicitParam =
719 dyn_cast<ImplicitParamDecl>(ND))
720 if (ImplicitParam->getIdentifier() &&
721 ImplicitParam->getIdentifier()->isStr("_cmd"))
722 return CCP_ObjC_cmd;
723
724 return CCP_LocalDeclaration;
725 }
Richard Smith541b38b2013-09-20 01:15:31 +0000726
727 const DeclContext *DC = ND->getDeclContext()->getRedeclContext();
Douglas Gregor0a0e2b32013-01-31 04:52:16 +0000728 if (DC->isRecord() || isa<ObjCContainerDecl>(DC))
729 return CCP_MemberDeclaration;
730
731 // Content-based decisions.
732 if (isa<EnumConstantDecl>(ND))
733 return CCP_Constant;
734
Douglas Gregor52e0de42013-01-31 05:03:46 +0000735 // Use CCP_Type for type declarations unless we're in a statement, Objective-C
736 // message receiver, or parenthesized expression context. There, it's as
737 // likely that the user will want to write a type as other declarations.
738 if ((isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) &&
739 !(CompletionContext.getKind() == CodeCompletionContext::CCC_Statement ||
740 CompletionContext.getKind()
741 == CodeCompletionContext::CCC_ObjCMessageReceiver ||
742 CompletionContext.getKind()
743 == CodeCompletionContext::CCC_ParenthesizedExpression))
Douglas Gregor0a0e2b32013-01-31 04:52:16 +0000744 return CCP_Type;
745
746 return CCP_Declaration;
747}
748
Douglas Gregor50832e02010-09-20 22:39:41 +0000749void ResultBuilder::AdjustResultPriorityForDecl(Result &R) {
750 // If this is an Objective-C method declaration whose selector matches our
751 // preferred selector, give it a priority boost.
752 if (!PreferredSelector.isNull())
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000753 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(R.Declaration))
Douglas Gregor50832e02010-09-20 22:39:41 +0000754 if (PreferredSelector == Method->getSelector())
755 R.Priority += CCD_SelectorMatch;
Douglas Gregor5fb901d2010-09-20 23:11:55 +0000756
Douglas Gregor50832e02010-09-20 22:39:41 +0000757 // If we have a preferred type, adjust the priority for results with exactly-
758 // matching or nearly-matching types.
759 if (!PreferredType.isNull()) {
760 QualType T = getDeclUsageType(SemaRef.Context, R.Declaration);
761 if (!T.isNull()) {
762 CanQualType TC = SemaRef.Context.getCanonicalType(T);
763 // Check for exactly-matching types (modulo qualifiers).
764 if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC))
765 R.Priority /= CCF_ExactTypeMatch;
766 // Check for nearly-matching types, based on classification of each.
767 else if ((getSimplifiedTypeClass(PreferredType)
Douglas Gregor95887f92010-07-08 23:20:03 +0000768 == getSimplifiedTypeClass(TC)) &&
Douglas Gregor50832e02010-09-20 22:39:41 +0000769 !(PreferredType->isEnumeralType() && TC->isEnumeralType()))
770 R.Priority /= CCF_SimilarTypeMatch;
771 }
772 }
Douglas Gregor95887f92010-07-08 23:20:03 +0000773}
774
Douglas Gregor0212fd72010-09-21 16:06:22 +0000775void ResultBuilder::MaybeAddConstructorResults(Result R) {
David Blaikiebbafb8a2012-03-11 07:00:24 +0000776 if (!SemaRef.getLangOpts().CPlusPlus || !R.Declaration ||
Douglas Gregor0212fd72010-09-21 16:06:22 +0000777 !CompletionContext.wantConstructorResults())
778 return;
779
780 ASTContext &Context = SemaRef.Context;
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000781 const NamedDecl *D = R.Declaration;
782 const CXXRecordDecl *Record = 0;
783 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D))
Douglas Gregor0212fd72010-09-21 16:06:22 +0000784 Record = ClassTemplate->getTemplatedDecl();
785 else if ((Record = dyn_cast<CXXRecordDecl>(D))) {
786 // Skip specializations and partial specializations.
787 if (isa<ClassTemplateSpecializationDecl>(Record))
788 return;
789 } else {
790 // There are no constructors here.
791 return;
792 }
793
794 Record = Record->getDefinition();
795 if (!Record)
796 return;
797
798
799 QualType RecordTy = Context.getTypeDeclType(Record);
800 DeclarationName ConstructorName
801 = Context.DeclarationNames.getCXXConstructorName(
802 Context.getCanonicalType(RecordTy));
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000803 DeclContext::lookup_const_result Ctors = Record->lookup(ConstructorName);
804 for (DeclContext::lookup_const_iterator I = Ctors.begin(),
805 E = Ctors.end();
806 I != E; ++I) {
David Blaikieff7d47a2012-12-19 00:45:41 +0000807 R.Declaration = *I;
Douglas Gregor0212fd72010-09-21 16:06:22 +0000808 R.CursorKind = getCursorKindForDecl(R.Declaration);
809 Results.push_back(R);
810 }
811}
812
Douglas Gregor7c208612010-01-14 00:20:49 +0000813void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) {
814 assert(!ShadowMaps.empty() && "Must enter into a results scope");
815
816 if (R.Kind != Result::RK_Declaration) {
817 // For non-declaration results, just add the result.
818 Results.push_back(R);
819 return;
820 }
821
822 // Look through using declarations.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000823 if (const UsingShadowDecl *Using =
824 dyn_cast<UsingShadowDecl>(R.Declaration)) {
Douglas Gregor0a0e2b32013-01-31 04:52:16 +0000825 MaybeAddResult(Result(Using->getTargetDecl(),
826 getBasePriority(Using->getTargetDecl()),
827 R.Qualifier),
828 CurContext);
Douglas Gregor7c208612010-01-14 00:20:49 +0000829 return;
830 }
831
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000832 const Decl *CanonDecl = R.Declaration->getCanonicalDecl();
Douglas Gregor7c208612010-01-14 00:20:49 +0000833 unsigned IDNS = CanonDecl->getIdentifierNamespace();
834
Douglas Gregor6ae4c522010-01-14 03:21:49 +0000835 bool AsNestedNameSpecifier = false;
836 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
Douglas Gregor7c208612010-01-14 00:20:49 +0000837 return;
838
Douglas Gregor0212fd72010-09-21 16:06:22 +0000839 // C++ constructors are never found by name lookup.
840 if (isa<CXXConstructorDecl>(R.Declaration))
841 return;
842
Douglas Gregor3545ff42009-09-21 16:56:56 +0000843 ShadowMap &SMap = ShadowMaps.back();
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000844 ShadowMapEntry::iterator I, IEnd;
845 ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName());
846 if (NamePos != SMap.end()) {
847 I = NamePos->second.begin();
848 IEnd = NamePos->second.end();
849 }
850
851 for (; I != IEnd; ++I) {
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000852 const NamedDecl *ND = I->first;
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000853 unsigned Index = I->second;
Douglas Gregor3545ff42009-09-21 16:56:56 +0000854 if (ND->getCanonicalDecl() == CanonDecl) {
855 // This is a redeclaration. Always pick the newer declaration.
Douglas Gregor3545ff42009-09-21 16:56:56 +0000856 Results[Index].Declaration = R.Declaration;
857
Douglas Gregor3545ff42009-09-21 16:56:56 +0000858 // We're done.
859 return;
860 }
861 }
862
863 // This is a new declaration in this scope. However, check whether this
864 // declaration name is hidden by a similarly-named declaration in an outer
865 // scope.
866 std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end();
867 --SMEnd;
868 for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) {
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000869 ShadowMapEntry::iterator I, IEnd;
870 ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName());
871 if (NamePos != SM->end()) {
872 I = NamePos->second.begin();
873 IEnd = NamePos->second.end();
874 }
875 for (; I != IEnd; ++I) {
Douglas Gregor3545ff42009-09-21 16:56:56 +0000876 // A tag declaration does not hide a non-tag declaration.
John McCalle87beb22010-04-23 18:46:30 +0000877 if (I->first->hasTagIdentifierNamespace() &&
Richard Smith541b38b2013-09-20 01:15:31 +0000878 (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary |
879 Decl::IDNS_LocalExtern | Decl::IDNS_ObjCProtocol)))
Douglas Gregor3545ff42009-09-21 16:56:56 +0000880 continue;
881
882 // Protocols are in distinct namespaces from everything else.
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000883 if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol)
Douglas Gregor3545ff42009-09-21 16:56:56 +0000884 || (IDNS & Decl::IDNS_ObjCProtocol)) &&
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000885 I->first->getIdentifierNamespace() != IDNS)
Douglas Gregor3545ff42009-09-21 16:56:56 +0000886 continue;
887
888 // The newly-added result is hidden by an entry in the shadow map.
Douglas Gregore0717ab2010-01-14 00:41:07 +0000889 if (CheckHiddenResult(R, CurContext, I->first))
Douglas Gregor3545ff42009-09-21 16:56:56 +0000890 return;
Douglas Gregor3545ff42009-09-21 16:56:56 +0000891
892 break;
893 }
894 }
895
896 // Make sure that any given declaration only shows up in the result set once.
897 if (!AllDeclsFound.insert(CanonDecl))
898 return;
Douglas Gregorc2cb2e22010-08-27 15:29:55 +0000899
Douglas Gregore412a5a2009-09-23 22:26:46 +0000900 // If the filter is for nested-name-specifiers, then this result starts a
901 // nested-name-specifier.
Douglas Gregora2db7932010-05-26 22:00:08 +0000902 if (AsNestedNameSpecifier) {
Douglas Gregore412a5a2009-09-23 22:26:46 +0000903 R.StartsNestedNameSpecifier = true;
Douglas Gregora2db7932010-05-26 22:00:08 +0000904 R.Priority = CCP_NestedNameSpecifier;
Douglas Gregor50832e02010-09-20 22:39:41 +0000905 } else
906 AdjustResultPriorityForDecl(R);
Douglas Gregorc2cb2e22010-08-27 15:29:55 +0000907
Douglas Gregor5bf52692009-09-22 23:15:58 +0000908 // If this result is supposed to have an informative qualifier, add one.
Douglas Gregore412a5a2009-09-23 22:26:46 +0000909 if (R.QualifierIsInformative && !R.Qualifier &&
910 !R.StartsNestedNameSpecifier) {
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000911 const DeclContext *Ctx = R.Declaration->getDeclContext();
912 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
Douglas Gregor5bf52692009-09-22 23:15:58 +0000913 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, Namespace);
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000914 else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
Douglas Gregor5bf52692009-09-22 23:15:58 +0000915 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, false,
916 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
917 else
918 R.QualifierIsInformative = false;
919 }
Douglas Gregore412a5a2009-09-23 22:26:46 +0000920
Douglas Gregor3545ff42009-09-21 16:56:56 +0000921 // Insert this result into the set of results and into the current shadow
922 // map.
Douglas Gregor05e7ca32009-12-06 20:23:50 +0000923 SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
Douglas Gregor3545ff42009-09-21 16:56:56 +0000924 Results.push_back(R);
Douglas Gregor0212fd72010-09-21 16:06:22 +0000925
926 if (!AsNestedNameSpecifier)
927 MaybeAddConstructorResults(R);
Douglas Gregor3545ff42009-09-21 16:56:56 +0000928}
929
Douglas Gregorc580c522010-01-14 01:09:38 +0000930void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
Douglas Gregor09bbc652010-01-14 15:47:35 +0000931 NamedDecl *Hiding, bool InBaseClass = false) {
Douglas Gregor78a21012010-01-14 16:01:26 +0000932 if (R.Kind != Result::RK_Declaration) {
933 // For non-declaration results, just add the result.
934 Results.push_back(R);
935 return;
936 }
937
Douglas Gregorc580c522010-01-14 01:09:38 +0000938 // Look through using declarations.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000939 if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
Douglas Gregor0a0e2b32013-01-31 04:52:16 +0000940 AddResult(Result(Using->getTargetDecl(),
941 getBasePriority(Using->getTargetDecl()),
942 R.Qualifier),
943 CurContext, Hiding);
Douglas Gregorc580c522010-01-14 01:09:38 +0000944 return;
945 }
946
Douglas Gregor6ae4c522010-01-14 03:21:49 +0000947 bool AsNestedNameSpecifier = false;
948 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
Douglas Gregorc580c522010-01-14 01:09:38 +0000949 return;
950
Douglas Gregor0212fd72010-09-21 16:06:22 +0000951 // C++ constructors are never found by name lookup.
952 if (isa<CXXConstructorDecl>(R.Declaration))
953 return;
954
Douglas Gregorc580c522010-01-14 01:09:38 +0000955 if (Hiding && CheckHiddenResult(R, CurContext, Hiding))
956 return;
Nick Lewyckyc3921482012-04-03 21:44:08 +0000957
Douglas Gregorc580c522010-01-14 01:09:38 +0000958 // Make sure that any given declaration only shows up in the result set once.
959 if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()))
960 return;
961
962 // If the filter is for nested-name-specifiers, then this result starts a
963 // nested-name-specifier.
Douglas Gregora2db7932010-05-26 22:00:08 +0000964 if (AsNestedNameSpecifier) {
Douglas Gregorc580c522010-01-14 01:09:38 +0000965 R.StartsNestedNameSpecifier = true;
Douglas Gregora2db7932010-05-26 22:00:08 +0000966 R.Priority = CCP_NestedNameSpecifier;
967 }
Douglas Gregor09bbc652010-01-14 15:47:35 +0000968 else if (Filter == &ResultBuilder::IsMember && !R.Qualifier && InBaseClass &&
969 isa<CXXRecordDecl>(R.Declaration->getDeclContext()
Sebastian Redl50c68252010-08-31 00:36:30 +0000970 ->getRedeclContext()))
Douglas Gregor09bbc652010-01-14 15:47:35 +0000971 R.QualifierIsInformative = true;
972
Douglas Gregorc580c522010-01-14 01:09:38 +0000973 // If this result is supposed to have an informative qualifier, add one.
974 if (R.QualifierIsInformative && !R.Qualifier &&
975 !R.StartsNestedNameSpecifier) {
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000976 const DeclContext *Ctx = R.Declaration->getDeclContext();
977 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
Douglas Gregorc580c522010-01-14 01:09:38 +0000978 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, Namespace);
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000979 else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
Douglas Gregorc580c522010-01-14 01:09:38 +0000980 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, false,
Douglas Gregor6ae4c522010-01-14 03:21:49 +0000981 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
Douglas Gregorc580c522010-01-14 01:09:38 +0000982 else
983 R.QualifierIsInformative = false;
984 }
985
Douglas Gregora2db7932010-05-26 22:00:08 +0000986 // Adjust the priority if this result comes from a base class.
987 if (InBaseClass)
988 R.Priority += CCD_InBaseClass;
989
Douglas Gregor50832e02010-09-20 22:39:41 +0000990 AdjustResultPriorityForDecl(R);
Douglas Gregor7aa6b222010-05-30 01:49:25 +0000991
Douglas Gregor9be0ed42010-08-26 16:36:48 +0000992 if (HasObjectTypeQualifiers)
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +0000993 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
Douglas Gregor9be0ed42010-08-26 16:36:48 +0000994 if (Method->isInstance()) {
995 Qualifiers MethodQuals
996 = Qualifiers::fromCVRMask(Method->getTypeQualifiers());
997 if (ObjectTypeQualifiers == MethodQuals)
998 R.Priority += CCD_ObjectQualifierMatch;
999 else if (ObjectTypeQualifiers - MethodQuals) {
1000 // The method cannot be invoked, because doing so would drop
1001 // qualifiers.
1002 return;
1003 }
1004 }
1005
Douglas Gregorc580c522010-01-14 01:09:38 +00001006 // Insert this result into the set of results.
1007 Results.push_back(R);
Douglas Gregor0212fd72010-09-21 16:06:22 +00001008
1009 if (!AsNestedNameSpecifier)
1010 MaybeAddConstructorResults(R);
Douglas Gregorc580c522010-01-14 01:09:38 +00001011}
1012
Douglas Gregor78a21012010-01-14 16:01:26 +00001013void ResultBuilder::AddResult(Result R) {
1014 assert(R.Kind != Result::RK_Declaration &&
1015 "Declaration results need more context");
1016 Results.push_back(R);
1017}
1018
Douglas Gregor3545ff42009-09-21 16:56:56 +00001019/// \brief Enter into a new scope.
1020void ResultBuilder::EnterNewScope() {
1021 ShadowMaps.push_back(ShadowMap());
1022}
1023
1024/// \brief Exit from the current scope.
1025void ResultBuilder::ExitScope() {
Douglas Gregor05e7ca32009-12-06 20:23:50 +00001026 for (ShadowMap::iterator E = ShadowMaps.back().begin(),
1027 EEnd = ShadowMaps.back().end();
1028 E != EEnd;
1029 ++E)
1030 E->second.Destroy();
1031
Douglas Gregor3545ff42009-09-21 16:56:56 +00001032 ShadowMaps.pop_back();
1033}
1034
Douglas Gregor9d64c5e2009-09-21 20:51:25 +00001035/// \brief Determines whether this given declaration will be found by
1036/// ordinary name lookup.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001037bool ResultBuilder::IsOrdinaryName(const NamedDecl *ND) const {
Douglas Gregor70febae2010-05-28 00:49:12 +00001038 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1039
Richard Smith541b38b2013-09-20 01:15:31 +00001040 // If name lookup finds a local extern declaration, then we are in a
1041 // context where it behaves like an ordinary name.
1042 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
David Blaikiebbafb8a2012-03-11 07:00:24 +00001043 if (SemaRef.getLangOpts().CPlusPlus)
Douglas Gregor9858ed52010-06-15 20:26:51 +00001044 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
David Blaikiebbafb8a2012-03-11 07:00:24 +00001045 else if (SemaRef.getLangOpts().ObjC1) {
Douglas Gregor05fcf842010-11-02 20:36:02 +00001046 if (isa<ObjCIvarDecl>(ND))
1047 return true;
Douglas Gregor05fcf842010-11-02 20:36:02 +00001048 }
1049
Douglas Gregor9d64c5e2009-09-21 20:51:25 +00001050 return ND->getIdentifierNamespace() & IDNS;
1051}
1052
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001053/// \brief Determines whether this given declaration will be found by
Douglas Gregor70febae2010-05-28 00:49:12 +00001054/// ordinary name lookup but is not a type name.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001055bool ResultBuilder::IsOrdinaryNonTypeName(const NamedDecl *ND) const {
Douglas Gregor70febae2010-05-28 00:49:12 +00001056 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1057 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND))
1058 return false;
1059
Richard Smith541b38b2013-09-20 01:15:31 +00001060 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
David Blaikiebbafb8a2012-03-11 07:00:24 +00001061 if (SemaRef.getLangOpts().CPlusPlus)
Douglas Gregor9858ed52010-06-15 20:26:51 +00001062 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
David Blaikiebbafb8a2012-03-11 07:00:24 +00001063 else if (SemaRef.getLangOpts().ObjC1) {
Douglas Gregor05fcf842010-11-02 20:36:02 +00001064 if (isa<ObjCIvarDecl>(ND))
1065 return true;
Douglas Gregor05fcf842010-11-02 20:36:02 +00001066 }
1067
Douglas Gregor70febae2010-05-28 00:49:12 +00001068 return ND->getIdentifierNamespace() & IDNS;
1069}
1070
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001071bool ResultBuilder::IsIntegralConstantValue(const NamedDecl *ND) const {
Douglas Gregor85b50632010-07-28 21:50:18 +00001072 if (!IsOrdinaryNonTypeName(ND))
1073 return 0;
1074
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001075 if (const ValueDecl *VD = dyn_cast<ValueDecl>(ND->getUnderlyingDecl()))
Douglas Gregor85b50632010-07-28 21:50:18 +00001076 if (VD->getType()->isIntegralOrEnumerationType())
1077 return true;
1078
1079 return false;
1080}
1081
Douglas Gregor70febae2010-05-28 00:49:12 +00001082/// \brief Determines whether this given declaration will be found by
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001083/// ordinary name lookup.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001084bool ResultBuilder::IsOrdinaryNonValueName(const NamedDecl *ND) const {
Douglas Gregor70febae2010-05-28 00:49:12 +00001085 ND = cast<NamedDecl>(ND->getUnderlyingDecl());
1086
Richard Smith541b38b2013-09-20 01:15:31 +00001087 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
David Blaikiebbafb8a2012-03-11 07:00:24 +00001088 if (SemaRef.getLangOpts().CPlusPlus)
John McCalle87beb22010-04-23 18:46:30 +00001089 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace;
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001090
1091 return (ND->getIdentifierNamespace() & IDNS) &&
Douglas Gregor70febae2010-05-28 00:49:12 +00001092 !isa<ValueDecl>(ND) && !isa<FunctionTemplateDecl>(ND) &&
1093 !isa<ObjCPropertyDecl>(ND);
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001094}
1095
Douglas Gregor3545ff42009-09-21 16:56:56 +00001096/// \brief Determines whether the given declaration is suitable as the
1097/// start of a C++ nested-name-specifier, e.g., a class or namespace.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001098bool ResultBuilder::IsNestedNameSpecifier(const NamedDecl *ND) const {
Douglas Gregor3545ff42009-09-21 16:56:56 +00001099 // Allow us to find class templates, too.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001100 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
Douglas Gregor3545ff42009-09-21 16:56:56 +00001101 ND = ClassTemplate->getTemplatedDecl();
1102
1103 return SemaRef.isAcceptableNestedNameSpecifier(ND);
1104}
1105
1106/// \brief Determines whether the given declaration is an enumeration.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001107bool ResultBuilder::IsEnum(const NamedDecl *ND) const {
Douglas Gregor3545ff42009-09-21 16:56:56 +00001108 return isa<EnumDecl>(ND);
1109}
1110
1111/// \brief Determines whether the given declaration is a class or struct.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001112bool ResultBuilder::IsClassOrStruct(const NamedDecl *ND) const {
Douglas Gregor3545ff42009-09-21 16:56:56 +00001113 // Allow us to find class templates, too.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001114 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
Douglas Gregor3545ff42009-09-21 16:56:56 +00001115 ND = ClassTemplate->getTemplatedDecl();
Joao Matosdc86f942012-08-31 18:45:21 +00001116
1117 // For purposes of this check, interfaces match too.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001118 if (const RecordDecl *RD = dyn_cast<RecordDecl>(ND))
Abramo Bagnara6150c882010-05-11 21:36:43 +00001119 return RD->getTagKind() == TTK_Class ||
Joao Matosdc86f942012-08-31 18:45:21 +00001120 RD->getTagKind() == TTK_Struct ||
1121 RD->getTagKind() == TTK_Interface;
Douglas Gregor3545ff42009-09-21 16:56:56 +00001122
1123 return false;
1124}
1125
1126/// \brief Determines whether the given declaration is a union.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001127bool ResultBuilder::IsUnion(const NamedDecl *ND) const {
Douglas Gregor3545ff42009-09-21 16:56:56 +00001128 // Allow us to find class templates, too.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001129 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
Douglas Gregor3545ff42009-09-21 16:56:56 +00001130 ND = ClassTemplate->getTemplatedDecl();
1131
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001132 if (const RecordDecl *RD = dyn_cast<RecordDecl>(ND))
Abramo Bagnara6150c882010-05-11 21:36:43 +00001133 return RD->getTagKind() == TTK_Union;
Douglas Gregor3545ff42009-09-21 16:56:56 +00001134
1135 return false;
1136}
1137
1138/// \brief Determines whether the given declaration is a namespace.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001139bool ResultBuilder::IsNamespace(const NamedDecl *ND) const {
Douglas Gregor3545ff42009-09-21 16:56:56 +00001140 return isa<NamespaceDecl>(ND);
1141}
1142
1143/// \brief Determines whether the given declaration is a namespace or
1144/// namespace alias.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001145bool ResultBuilder::IsNamespaceOrAlias(const NamedDecl *ND) const {
Douglas Gregor3545ff42009-09-21 16:56:56 +00001146 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND);
1147}
1148
Douglas Gregor99fe2ad2009-12-11 17:31:05 +00001149/// \brief Determines whether the given declaration is a type.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001150bool ResultBuilder::IsType(const NamedDecl *ND) const {
1151 if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(ND))
Douglas Gregor99fa2642010-08-24 01:06:58 +00001152 ND = Using->getTargetDecl();
1153
1154 return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
Douglas Gregor3545ff42009-09-21 16:56:56 +00001155}
1156
Douglas Gregor99fe2ad2009-12-11 17:31:05 +00001157/// \brief Determines which members of a class should be visible via
1158/// "." or "->". Only value declarations, nested name specifiers, and
1159/// using declarations thereof should show up.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001160bool ResultBuilder::IsMember(const NamedDecl *ND) const {
1161 if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(ND))
Douglas Gregor99fe2ad2009-12-11 17:31:05 +00001162 ND = Using->getTargetDecl();
1163
Douglas Gregor70788392009-12-11 18:14:22 +00001164 return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||
1165 isa<ObjCPropertyDecl>(ND);
Douglas Gregore412a5a2009-09-23 22:26:46 +00001166}
1167
Douglas Gregora817a192010-05-27 23:06:34 +00001168static bool isObjCReceiverType(ASTContext &C, QualType T) {
1169 T = C.getCanonicalType(T);
1170 switch (T->getTypeClass()) {
1171 case Type::ObjCObject:
1172 case Type::ObjCInterface:
1173 case Type::ObjCObjectPointer:
1174 return true;
1175
1176 case Type::Builtin:
1177 switch (cast<BuiltinType>(T)->getKind()) {
1178 case BuiltinType::ObjCId:
1179 case BuiltinType::ObjCClass:
1180 case BuiltinType::ObjCSel:
1181 return true;
1182
1183 default:
1184 break;
1185 }
1186 return false;
1187
1188 default:
1189 break;
1190 }
1191
David Blaikiebbafb8a2012-03-11 07:00:24 +00001192 if (!C.getLangOpts().CPlusPlus)
Douglas Gregora817a192010-05-27 23:06:34 +00001193 return false;
1194
1195 // FIXME: We could perform more analysis here to determine whether a
1196 // particular class type has any conversions to Objective-C types. For now,
1197 // just accept all class types.
1198 return T->isDependentType() || T->isRecordType();
1199}
1200
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001201bool ResultBuilder::IsObjCMessageReceiver(const NamedDecl *ND) const {
Douglas Gregora817a192010-05-27 23:06:34 +00001202 QualType T = getDeclUsageType(SemaRef.Context, ND);
1203 if (T.isNull())
1204 return false;
1205
1206 T = SemaRef.Context.getBaseElementType(T);
1207 return isObjCReceiverType(SemaRef.Context, T);
1208}
1209
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001210bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const {
Douglas Gregord8c61782012-02-15 15:34:24 +00001211 if (IsObjCMessageReceiver(ND))
1212 return true;
1213
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001214 const VarDecl *Var = dyn_cast<VarDecl>(ND);
Douglas Gregord8c61782012-02-15 15:34:24 +00001215 if (!Var)
1216 return false;
1217
1218 return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>();
1219}
1220
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001221bool ResultBuilder::IsObjCCollection(const NamedDecl *ND) const {
David Blaikiebbafb8a2012-03-11 07:00:24 +00001222 if ((SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) ||
1223 (!SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND)))
Douglas Gregor68762e72010-08-23 21:17:50 +00001224 return false;
1225
1226 QualType T = getDeclUsageType(SemaRef.Context, ND);
1227 if (T.isNull())
1228 return false;
1229
1230 T = SemaRef.Context.getBaseElementType(T);
1231 return T->isObjCObjectType() || T->isObjCObjectPointerType() ||
1232 T->isObjCIdType() ||
David Blaikiebbafb8a2012-03-11 07:00:24 +00001233 (SemaRef.getLangOpts().CPlusPlus && T->isRecordType());
Douglas Gregor68762e72010-08-23 21:17:50 +00001234}
Douglas Gregora817a192010-05-27 23:06:34 +00001235
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001236bool ResultBuilder::IsImpossibleToSatisfy(const NamedDecl *ND) const {
Douglas Gregor0ac41382010-09-23 23:01:17 +00001237 return false;
1238}
1239
James Dennettf1243872012-06-17 05:33:25 +00001240/// \brief Determines whether the given declaration is an Objective-C
Douglas Gregor2b8162b2010-01-14 16:08:12 +00001241/// instance variable.
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00001242bool ResultBuilder::IsObjCIvar(const NamedDecl *ND) const {
Douglas Gregor2b8162b2010-01-14 16:08:12 +00001243 return isa<ObjCIvarDecl>(ND);
1244}
1245
Douglas Gregorc580c522010-01-14 01:09:38 +00001246namespace {
1247 /// \brief Visible declaration consumer that adds a code-completion result
1248 /// for each visible declaration.
1249 class CodeCompletionDeclConsumer : public VisibleDeclConsumer {
1250 ResultBuilder &Results;
1251 DeclContext *CurContext;
1252
1253 public:
1254 CodeCompletionDeclConsumer(ResultBuilder &Results, DeclContext *CurContext)
1255 : Results(Results), CurContext(CurContext) { }
Craig Toppere14c0f82014-03-12 04:55:44 +00001256
1257 void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
1258 bool InBaseClass) override {
Erik Verbruggen2e657ff2011-10-06 07:27:49 +00001259 bool Accessible = true;
Douglas Gregor03ba1882011-11-03 16:51:37 +00001260 if (Ctx)
1261 Accessible = Results.getSema().IsSimplyAccessible(ND, Ctx);
1262
Douglas Gregor0a0e2b32013-01-31 04:52:16 +00001263 ResultBuilder::Result Result(ND, Results.getBasePriority(ND), 0, false,
1264 Accessible);
Erik Verbruggen2e657ff2011-10-06 07:27:49 +00001265 Results.AddResult(Result, CurContext, Hiding, InBaseClass);
Douglas Gregorc580c522010-01-14 01:09:38 +00001266 }
1267 };
1268}
1269
Douglas Gregor3545ff42009-09-21 16:56:56 +00001270/// \brief Add type specifiers for the current language as keyword results.
Douglas Gregorf98e6a22010-01-13 23:51:12 +00001271static void AddTypeSpecifierResults(const LangOptions &LangOpts,
Douglas Gregor3545ff42009-09-21 16:56:56 +00001272 ResultBuilder &Results) {
John McCall276321a2010-08-25 06:19:51 +00001273 typedef CodeCompletionResult Result;
Douglas Gregora2db7932010-05-26 22:00:08 +00001274 Results.AddResult(Result("short", CCP_Type));
1275 Results.AddResult(Result("long", CCP_Type));
1276 Results.AddResult(Result("signed", CCP_Type));
1277 Results.AddResult(Result("unsigned", CCP_Type));
1278 Results.AddResult(Result("void", CCP_Type));
1279 Results.AddResult(Result("char", CCP_Type));
1280 Results.AddResult(Result("int", CCP_Type));
1281 Results.AddResult(Result("float", CCP_Type));
1282 Results.AddResult(Result("double", CCP_Type));
1283 Results.AddResult(Result("enum", CCP_Type));
1284 Results.AddResult(Result("struct", CCP_Type));
1285 Results.AddResult(Result("union", CCP_Type));
1286 Results.AddResult(Result("const", CCP_Type));
1287 Results.AddResult(Result("volatile", CCP_Type));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001288
Douglas Gregor3545ff42009-09-21 16:56:56 +00001289 if (LangOpts.C99) {
1290 // C99-specific
Douglas Gregora2db7932010-05-26 22:00:08 +00001291 Results.AddResult(Result("_Complex", CCP_Type));
1292 Results.AddResult(Result("_Imaginary", CCP_Type));
1293 Results.AddResult(Result("_Bool", CCP_Type));
1294 Results.AddResult(Result("restrict", CCP_Type));
Douglas Gregor3545ff42009-09-21 16:56:56 +00001295 }
1296
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00001297 CodeCompletionBuilder Builder(Results.getAllocator(),
1298 Results.getCodeCompletionTUInfo());
Douglas Gregor3545ff42009-09-21 16:56:56 +00001299 if (LangOpts.CPlusPlus) {
1300 // C++-specific
Douglas Gregor9dcf58a2010-09-20 21:11:48 +00001301 Results.AddResult(Result("bool", CCP_Type +
1302 (LangOpts.ObjC1? CCD_bool_in_ObjC : 0)));
Douglas Gregora2db7932010-05-26 22:00:08 +00001303 Results.AddResult(Result("class", CCP_Type));
1304 Results.AddResult(Result("wchar_t", CCP_Type));
Douglas Gregor3545ff42009-09-21 16:56:56 +00001305
Douglas Gregorf4c33342010-05-28 00:22:41 +00001306 // typename qualified-id
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001307 Builder.AddTypedTextChunk("typename");
1308 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1309 Builder.AddPlaceholderChunk("qualifier");
1310 Builder.AddTextChunk("::");
1311 Builder.AddPlaceholderChunk("name");
1312 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf64acca2010-05-25 21:41:55 +00001313
Richard Smith2bf7fdb2013-01-02 11:42:31 +00001314 if (LangOpts.CPlusPlus11) {
Douglas Gregora2db7932010-05-26 22:00:08 +00001315 Results.AddResult(Result("auto", CCP_Type));
1316 Results.AddResult(Result("char16_t", CCP_Type));
1317 Results.AddResult(Result("char32_t", CCP_Type));
Douglas Gregorf4c33342010-05-28 00:22:41 +00001318
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001319 Builder.AddTypedTextChunk("decltype");
1320 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1321 Builder.AddPlaceholderChunk("expression");
1322 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1323 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor3545ff42009-09-21 16:56:56 +00001324 }
1325 }
1326
1327 // GNU extensions
1328 if (LangOpts.GNUMode) {
1329 // FIXME: Enable when we actually support decimal floating point.
Douglas Gregor78a21012010-01-14 16:01:26 +00001330 // Results.AddResult(Result("_Decimal32"));
1331 // Results.AddResult(Result("_Decimal64"));
1332 // Results.AddResult(Result("_Decimal128"));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001333
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001334 Builder.AddTypedTextChunk("typeof");
1335 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1336 Builder.AddPlaceholderChunk("expression");
1337 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf4c33342010-05-28 00:22:41 +00001338
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001339 Builder.AddTypedTextChunk("typeof");
1340 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1341 Builder.AddPlaceholderChunk("type");
1342 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1343 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor3545ff42009-09-21 16:56:56 +00001344 }
1345}
1346
John McCallfaf5fb42010-08-26 23:41:50 +00001347static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC,
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001348 const LangOptions &LangOpts,
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001349 ResultBuilder &Results) {
John McCall276321a2010-08-25 06:19:51 +00001350 typedef CodeCompletionResult Result;
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001351 // Note: we don't suggest either "auto" or "register", because both
1352 // are pointless as storage specifiers. Elsewhere, we suggest "auto"
1353 // in C++0x as a type specifier.
Douglas Gregor78a21012010-01-14 16:01:26 +00001354 Results.AddResult(Result("extern"));
1355 Results.AddResult(Result("static"));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001356}
1357
John McCallfaf5fb42010-08-26 23:41:50 +00001358static void AddFunctionSpecifiers(Sema::ParserCompletionContext CCC,
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001359 const LangOptions &LangOpts,
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001360 ResultBuilder &Results) {
John McCall276321a2010-08-25 06:19:51 +00001361 typedef CodeCompletionResult Result;
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001362 switch (CCC) {
John McCallfaf5fb42010-08-26 23:41:50 +00001363 case Sema::PCC_Class:
1364 case Sema::PCC_MemberTemplate:
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001365 if (LangOpts.CPlusPlus) {
Douglas Gregor78a21012010-01-14 16:01:26 +00001366 Results.AddResult(Result("explicit"));
1367 Results.AddResult(Result("friend"));
1368 Results.AddResult(Result("mutable"));
1369 Results.AddResult(Result("virtual"));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001370 }
1371 // Fall through
1372
John McCallfaf5fb42010-08-26 23:41:50 +00001373 case Sema::PCC_ObjCInterface:
1374 case Sema::PCC_ObjCImplementation:
1375 case Sema::PCC_Namespace:
1376 case Sema::PCC_Template:
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001377 if (LangOpts.CPlusPlus || LangOpts.C99)
Douglas Gregor78a21012010-01-14 16:01:26 +00001378 Results.AddResult(Result("inline"));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001379 break;
1380
John McCallfaf5fb42010-08-26 23:41:50 +00001381 case Sema::PCC_ObjCInstanceVariableList:
1382 case Sema::PCC_Expression:
1383 case Sema::PCC_Statement:
1384 case Sema::PCC_ForInit:
1385 case Sema::PCC_Condition:
1386 case Sema::PCC_RecoveryInFunction:
1387 case Sema::PCC_Type:
Douglas Gregor5e35d592010-09-14 23:59:36 +00001388 case Sema::PCC_ParenthesizedExpression:
Douglas Gregor80039242011-02-15 20:33:25 +00001389 case Sema::PCC_LocalDeclarationSpecifiers:
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001390 break;
1391 }
1392}
1393
Douglas Gregorf98e6a22010-01-13 23:51:12 +00001394static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt);
1395static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt);
1396static void AddObjCVisibilityResults(const LangOptions &LangOpts,
Douglas Gregor48d46252010-01-13 21:54:15 +00001397 ResultBuilder &Results,
1398 bool NeedAt);
Douglas Gregorf98e6a22010-01-13 23:51:12 +00001399static void AddObjCImplementationResults(const LangOptions &LangOpts,
Douglas Gregorf1934162010-01-13 21:24:21 +00001400 ResultBuilder &Results,
1401 bool NeedAt);
Douglas Gregorf98e6a22010-01-13 23:51:12 +00001402static void AddObjCInterfaceResults(const LangOptions &LangOpts,
Douglas Gregorf1934162010-01-13 21:24:21 +00001403 ResultBuilder &Results,
1404 bool NeedAt);
Douglas Gregorf98e6a22010-01-13 23:51:12 +00001405static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt);
Douglas Gregorf1934162010-01-13 21:24:21 +00001406
Douglas Gregorf4c33342010-05-28 00:22:41 +00001407static void AddTypedefResult(ResultBuilder &Results) {
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00001408 CodeCompletionBuilder Builder(Results.getAllocator(),
1409 Results.getCodeCompletionTUInfo());
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001410 Builder.AddTypedTextChunk("typedef");
1411 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1412 Builder.AddPlaceholderChunk("type");
1413 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1414 Builder.AddPlaceholderChunk("name");
1415 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
Douglas Gregorf4c33342010-05-28 00:22:41 +00001416}
1417
John McCallfaf5fb42010-08-26 23:41:50 +00001418static bool WantTypesInContext(Sema::ParserCompletionContext CCC,
Douglas Gregor70febae2010-05-28 00:49:12 +00001419 const LangOptions &LangOpts) {
Douglas Gregor70febae2010-05-28 00:49:12 +00001420 switch (CCC) {
John McCallfaf5fb42010-08-26 23:41:50 +00001421 case Sema::PCC_Namespace:
1422 case Sema::PCC_Class:
1423 case Sema::PCC_ObjCInstanceVariableList:
1424 case Sema::PCC_Template:
1425 case Sema::PCC_MemberTemplate:
1426 case Sema::PCC_Statement:
1427 case Sema::PCC_RecoveryInFunction:
1428 case Sema::PCC_Type:
Douglas Gregor5e35d592010-09-14 23:59:36 +00001429 case Sema::PCC_ParenthesizedExpression:
Douglas Gregor80039242011-02-15 20:33:25 +00001430 case Sema::PCC_LocalDeclarationSpecifiers:
Douglas Gregor70febae2010-05-28 00:49:12 +00001431 return true;
1432
John McCallfaf5fb42010-08-26 23:41:50 +00001433 case Sema::PCC_Expression:
1434 case Sema::PCC_Condition:
Douglas Gregor5e35d592010-09-14 23:59:36 +00001435 return LangOpts.CPlusPlus;
1436
1437 case Sema::PCC_ObjCInterface:
1438 case Sema::PCC_ObjCImplementation:
Douglas Gregor70febae2010-05-28 00:49:12 +00001439 return false;
1440
John McCallfaf5fb42010-08-26 23:41:50 +00001441 case Sema::PCC_ForInit:
Douglas Gregor5e35d592010-09-14 23:59:36 +00001442 return LangOpts.CPlusPlus || LangOpts.ObjC1 || LangOpts.C99;
Douglas Gregor70febae2010-05-28 00:49:12 +00001443 }
David Blaikie8a40f702012-01-17 06:56:22 +00001444
1445 llvm_unreachable("Invalid ParserCompletionContext!");
Douglas Gregor70febae2010-05-28 00:49:12 +00001446}
1447
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00001448static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context,
1449 const Preprocessor &PP) {
1450 PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
Douglas Gregore5c79d52011-10-18 21:20:17 +00001451 Policy.AnonymousTagLocations = false;
1452 Policy.SuppressStrongLifetime = true;
Douglas Gregor2e10cf92011-11-03 00:16:13 +00001453 Policy.SuppressUnwrittenScope = true;
Douglas Gregore5c79d52011-10-18 21:20:17 +00001454 return Policy;
1455}
1456
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00001457/// \brief Retrieve a printing policy suitable for code completion.
1458static PrintingPolicy getCompletionPrintingPolicy(Sema &S) {
1459 return getCompletionPrintingPolicy(S.Context, S.PP);
1460}
1461
Douglas Gregore5c79d52011-10-18 21:20:17 +00001462/// \brief Retrieve the string representation of the given type as a string
1463/// that has the appropriate lifetime for code completion.
1464///
1465/// This routine provides a fast path where we provide constant strings for
1466/// common type names.
1467static const char *GetCompletionTypeString(QualType T,
1468 ASTContext &Context,
1469 const PrintingPolicy &Policy,
1470 CodeCompletionAllocator &Allocator) {
1471 if (!T.getLocalQualifiers()) {
1472 // Built-in type names are constant strings.
1473 if (const BuiltinType *BT = dyn_cast<BuiltinType>(T))
Argyrios Kyrtzidisbbff3da2012-05-05 04:20:28 +00001474 return BT->getNameAsCString(Policy);
Douglas Gregore5c79d52011-10-18 21:20:17 +00001475
1476 // Anonymous tag types are constant strings.
1477 if (const TagType *TagT = dyn_cast<TagType>(T))
1478 if (TagDecl *Tag = TagT->getDecl())
John McCall5ea95772013-03-09 00:54:27 +00001479 if (!Tag->hasNameForLinkage()) {
Douglas Gregore5c79d52011-10-18 21:20:17 +00001480 switch (Tag->getTagKind()) {
1481 case TTK_Struct: return "struct <anonymous>";
Joao Matosdc86f942012-08-31 18:45:21 +00001482 case TTK_Interface: return "__interface <anonymous>";
1483 case TTK_Class: return "class <anonymous>";
Douglas Gregore5c79d52011-10-18 21:20:17 +00001484 case TTK_Union: return "union <anonymous>";
1485 case TTK_Enum: return "enum <anonymous>";
1486 }
1487 }
1488 }
1489
1490 // Slow path: format the type as a string.
1491 std::string Result;
1492 T.getAsStringInternal(Result, Policy);
1493 return Allocator.CopyString(Result);
1494}
1495
Douglas Gregord8c61782012-02-15 15:34:24 +00001496/// \brief Add a completion for "this", if we're in a member function.
1497static void addThisCompletion(Sema &S, ResultBuilder &Results) {
1498 QualType ThisTy = S.getCurrentThisType();
1499 if (ThisTy.isNull())
1500 return;
1501
1502 CodeCompletionAllocator &Allocator = Results.getAllocator();
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00001503 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
Douglas Gregord8c61782012-02-15 15:34:24 +00001504 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
1505 Builder.AddResultTypeChunk(GetCompletionTypeString(ThisTy,
1506 S.Context,
1507 Policy,
1508 Allocator));
1509 Builder.AddTypedTextChunk("this");
Joao Matosdc86f942012-08-31 18:45:21 +00001510 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
Douglas Gregord8c61782012-02-15 15:34:24 +00001511}
1512
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001513/// \brief Add language constructs that show up for "ordinary" names.
John McCallfaf5fb42010-08-26 23:41:50 +00001514static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC,
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001515 Scope *S,
1516 Sema &SemaRef,
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001517 ResultBuilder &Results) {
Douglas Gregore5c79d52011-10-18 21:20:17 +00001518 CodeCompletionAllocator &Allocator = Results.getAllocator();
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00001519 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
Douglas Gregore5c79d52011-10-18 21:20:17 +00001520 PrintingPolicy Policy = getCompletionPrintingPolicy(SemaRef);
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001521
John McCall276321a2010-08-25 06:19:51 +00001522 typedef CodeCompletionResult Result;
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001523 switch (CCC) {
John McCallfaf5fb42010-08-26 23:41:50 +00001524 case Sema::PCC_Namespace:
David Blaikiebbafb8a2012-03-11 07:00:24 +00001525 if (SemaRef.getLangOpts().CPlusPlus) {
Douglas Gregorf4c33342010-05-28 00:22:41 +00001526 if (Results.includeCodePatterns()) {
1527 // namespace <identifier> { declarations }
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001528 Builder.AddTypedTextChunk("namespace");
1529 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1530 Builder.AddPlaceholderChunk("identifier");
1531 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1532 Builder.AddPlaceholderChunk("declarations");
1533 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1534 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1535 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf4c33342010-05-28 00:22:41 +00001536 }
1537
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001538 // namespace identifier = identifier ;
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001539 Builder.AddTypedTextChunk("namespace");
1540 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1541 Builder.AddPlaceholderChunk("name");
1542 Builder.AddChunk(CodeCompletionString::CK_Equal);
1543 Builder.AddPlaceholderChunk("namespace");
1544 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001545
1546 // Using directives
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001547 Builder.AddTypedTextChunk("using");
1548 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1549 Builder.AddTextChunk("namespace");
1550 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1551 Builder.AddPlaceholderChunk("identifier");
1552 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001553
1554 // asm(string-literal)
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001555 Builder.AddTypedTextChunk("asm");
1556 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1557 Builder.AddPlaceholderChunk("string-literal");
1558 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1559 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001560
Douglas Gregorf4c33342010-05-28 00:22:41 +00001561 if (Results.includeCodePatterns()) {
1562 // Explicit template instantiation
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001563 Builder.AddTypedTextChunk("template");
1564 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1565 Builder.AddPlaceholderChunk("declaration");
1566 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf4c33342010-05-28 00:22:41 +00001567 }
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001568 }
Douglas Gregorf1934162010-01-13 21:24:21 +00001569
David Blaikiebbafb8a2012-03-11 07:00:24 +00001570 if (SemaRef.getLangOpts().ObjC1)
Douglas Gregorf98e6a22010-01-13 23:51:12 +00001571 AddObjCTopLevelResults(Results, true);
Douglas Gregorf1934162010-01-13 21:24:21 +00001572
Douglas Gregorf4c33342010-05-28 00:22:41 +00001573 AddTypedefResult(Results);
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001574 // Fall through
1575
John McCallfaf5fb42010-08-26 23:41:50 +00001576 case Sema::PCC_Class:
David Blaikiebbafb8a2012-03-11 07:00:24 +00001577 if (SemaRef.getLangOpts().CPlusPlus) {
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001578 // Using declaration
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001579 Builder.AddTypedTextChunk("using");
1580 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1581 Builder.AddPlaceholderChunk("qualifier");
1582 Builder.AddTextChunk("::");
1583 Builder.AddPlaceholderChunk("name");
1584 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001585
Douglas Gregorf4c33342010-05-28 00:22:41 +00001586 // using typename qualifier::name (only in a dependent context)
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001587 if (SemaRef.CurContext->isDependentContext()) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001588 Builder.AddTypedTextChunk("using");
1589 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1590 Builder.AddTextChunk("typename");
1591 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1592 Builder.AddPlaceholderChunk("qualifier");
1593 Builder.AddTextChunk("::");
1594 Builder.AddPlaceholderChunk("name");
1595 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001596 }
1597
John McCallfaf5fb42010-08-26 23:41:50 +00001598 if (CCC == Sema::PCC_Class) {
Douglas Gregorf4c33342010-05-28 00:22:41 +00001599 AddTypedefResult(Results);
1600
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001601 // public:
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001602 Builder.AddTypedTextChunk("public");
Douglas Gregor9489cdf2012-04-10 17:56:28 +00001603 if (Results.includeCodePatterns())
1604 Builder.AddChunk(CodeCompletionString::CK_Colon);
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001605 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001606
1607 // protected:
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001608 Builder.AddTypedTextChunk("protected");
Douglas Gregor9489cdf2012-04-10 17:56:28 +00001609 if (Results.includeCodePatterns())
1610 Builder.AddChunk(CodeCompletionString::CK_Colon);
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001611 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001612
1613 // private:
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001614 Builder.AddTypedTextChunk("private");
Douglas Gregor9489cdf2012-04-10 17:56:28 +00001615 if (Results.includeCodePatterns())
1616 Builder.AddChunk(CodeCompletionString::CK_Colon);
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001617 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001618 }
1619 }
1620 // Fall through
1621
John McCallfaf5fb42010-08-26 23:41:50 +00001622 case Sema::PCC_Template:
1623 case Sema::PCC_MemberTemplate:
David Blaikiebbafb8a2012-03-11 07:00:24 +00001624 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001625 // template < parameters >
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001626 Builder.AddTypedTextChunk("template");
1627 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1628 Builder.AddPlaceholderChunk("parameters");
1629 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1630 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001631 }
1632
David Blaikiebbafb8a2012-03-11 07:00:24 +00001633 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1634 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001635 break;
1636
John McCallfaf5fb42010-08-26 23:41:50 +00001637 case Sema::PCC_ObjCInterface:
David Blaikiebbafb8a2012-03-11 07:00:24 +00001638 AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true);
1639 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1640 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
Douglas Gregorf1934162010-01-13 21:24:21 +00001641 break;
1642
John McCallfaf5fb42010-08-26 23:41:50 +00001643 case Sema::PCC_ObjCImplementation:
David Blaikiebbafb8a2012-03-11 07:00:24 +00001644 AddObjCImplementationResults(SemaRef.getLangOpts(), Results, true);
1645 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1646 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
Douglas Gregorf1934162010-01-13 21:24:21 +00001647 break;
1648
John McCallfaf5fb42010-08-26 23:41:50 +00001649 case Sema::PCC_ObjCInstanceVariableList:
David Blaikiebbafb8a2012-03-11 07:00:24 +00001650 AddObjCVisibilityResults(SemaRef.getLangOpts(), Results, true);
Douglas Gregor48d46252010-01-13 21:54:15 +00001651 break;
1652
John McCallfaf5fb42010-08-26 23:41:50 +00001653 case Sema::PCC_RecoveryInFunction:
1654 case Sema::PCC_Statement: {
Douglas Gregorf4c33342010-05-28 00:22:41 +00001655 AddTypedefResult(Results);
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001656
David Blaikiebbafb8a2012-03-11 07:00:24 +00001657 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() &&
1658 SemaRef.getLangOpts().CXXExceptions) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001659 Builder.AddTypedTextChunk("try");
1660 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1661 Builder.AddPlaceholderChunk("statements");
1662 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1663 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1664 Builder.AddTextChunk("catch");
1665 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1666 Builder.AddPlaceholderChunk("declaration");
1667 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1668 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1669 Builder.AddPlaceholderChunk("statements");
1670 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1671 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1672 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001673 }
David Blaikiebbafb8a2012-03-11 07:00:24 +00001674 if (SemaRef.getLangOpts().ObjC1)
Douglas Gregorf98e6a22010-01-13 23:51:12 +00001675 AddObjCStatementResults(Results, true);
Douglas Gregorf1934162010-01-13 21:24:21 +00001676
Douglas Gregorf64acca2010-05-25 21:41:55 +00001677 if (Results.includeCodePatterns()) {
1678 // if (condition) { statements }
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001679 Builder.AddTypedTextChunk("if");
1680 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
David Blaikiebbafb8a2012-03-11 07:00:24 +00001681 if (SemaRef.getLangOpts().CPlusPlus)
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001682 Builder.AddPlaceholderChunk("condition");
Douglas Gregorf64acca2010-05-25 21:41:55 +00001683 else
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001684 Builder.AddPlaceholderChunk("expression");
1685 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1686 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1687 Builder.AddPlaceholderChunk("statements");
1688 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1689 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1690 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001691
Douglas Gregorf64acca2010-05-25 21:41:55 +00001692 // switch (condition) { }
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001693 Builder.AddTypedTextChunk("switch");
1694 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
David Blaikiebbafb8a2012-03-11 07:00:24 +00001695 if (SemaRef.getLangOpts().CPlusPlus)
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001696 Builder.AddPlaceholderChunk("condition");
Douglas Gregorf64acca2010-05-25 21:41:55 +00001697 else
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001698 Builder.AddPlaceholderChunk("expression");
1699 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1700 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1701 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1702 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1703 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf64acca2010-05-25 21:41:55 +00001704 }
1705
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001706 // Switch-specific statements.
John McCallaab3e412010-08-25 08:40:02 +00001707 if (!SemaRef.getCurFunction()->SwitchStack.empty()) {
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001708 // case expression:
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001709 Builder.AddTypedTextChunk("case");
1710 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1711 Builder.AddPlaceholderChunk("expression");
1712 Builder.AddChunk(CodeCompletionString::CK_Colon);
1713 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001714
1715 // default:
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001716 Builder.AddTypedTextChunk("default");
1717 Builder.AddChunk(CodeCompletionString::CK_Colon);
1718 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001719 }
1720
Douglas Gregorf64acca2010-05-25 21:41:55 +00001721 if (Results.includeCodePatterns()) {
1722 /// while (condition) { statements }
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001723 Builder.AddTypedTextChunk("while");
1724 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
David Blaikiebbafb8a2012-03-11 07:00:24 +00001725 if (SemaRef.getLangOpts().CPlusPlus)
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001726 Builder.AddPlaceholderChunk("condition");
Douglas Gregorf64acca2010-05-25 21:41:55 +00001727 else
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001728 Builder.AddPlaceholderChunk("expression");
1729 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1730 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1731 Builder.AddPlaceholderChunk("statements");
1732 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1733 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1734 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf64acca2010-05-25 21:41:55 +00001735
1736 // do { statements } while ( expression );
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001737 Builder.AddTypedTextChunk("do");
1738 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1739 Builder.AddPlaceholderChunk("statements");
1740 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1741 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1742 Builder.AddTextChunk("while");
1743 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1744 Builder.AddPlaceholderChunk("expression");
1745 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1746 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001747
Douglas Gregorf64acca2010-05-25 21:41:55 +00001748 // for ( for-init-statement ; condition ; expression ) { statements }
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001749 Builder.AddTypedTextChunk("for");
1750 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
David Blaikiebbafb8a2012-03-11 07:00:24 +00001751 if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99)
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001752 Builder.AddPlaceholderChunk("init-statement");
Douglas Gregorf64acca2010-05-25 21:41:55 +00001753 else
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001754 Builder.AddPlaceholderChunk("init-expression");
1755 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1756 Builder.AddPlaceholderChunk("condition");
1757 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1758 Builder.AddPlaceholderChunk("inc-expression");
1759 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1760 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1761 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1762 Builder.AddPlaceholderChunk("statements");
1763 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1764 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1765 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf64acca2010-05-25 21:41:55 +00001766 }
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001767
1768 if (S->getContinueParent()) {
1769 // continue ;
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001770 Builder.AddTypedTextChunk("continue");
1771 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001772 }
1773
1774 if (S->getBreakParent()) {
1775 // break ;
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001776 Builder.AddTypedTextChunk("break");
1777 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001778 }
1779
1780 // "return expression ;" or "return ;", depending on whether we
1781 // know the function is void or not.
1782 bool isVoid = false;
1783 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext))
Alp Toker314cc812014-01-25 16:55:45 +00001784 isVoid = Function->getReturnType()->isVoidType();
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001785 else if (ObjCMethodDecl *Method
1786 = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext))
Alp Toker314cc812014-01-25 16:55:45 +00001787 isVoid = Method->getReturnType()->isVoidType();
Douglas Gregor9a28e842010-03-01 23:15:13 +00001788 else if (SemaRef.getCurBlock() &&
1789 !SemaRef.getCurBlock()->ReturnType.isNull())
1790 isVoid = SemaRef.getCurBlock()->ReturnType->isVoidType();
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001791 Builder.AddTypedTextChunk("return");
Douglas Gregor44272ca2010-02-18 04:06:48 +00001792 if (!isVoid) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001793 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1794 Builder.AddPlaceholderChunk("expression");
Douglas Gregor44272ca2010-02-18 04:06:48 +00001795 }
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001796 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001797
Douglas Gregorf4c33342010-05-28 00:22:41 +00001798 // goto identifier ;
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001799 Builder.AddTypedTextChunk("goto");
1800 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1801 Builder.AddPlaceholderChunk("label");
1802 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001803
Douglas Gregorf4c33342010-05-28 00:22:41 +00001804 // Using directives
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001805 Builder.AddTypedTextChunk("using");
1806 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1807 Builder.AddTextChunk("namespace");
1808 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1809 Builder.AddPlaceholderChunk("identifier");
1810 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001811 }
1812
1813 // Fall through (for statement expressions).
John McCallfaf5fb42010-08-26 23:41:50 +00001814 case Sema::PCC_ForInit:
1815 case Sema::PCC_Condition:
David Blaikiebbafb8a2012-03-11 07:00:24 +00001816 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001817 // Fall through: conditions and statements can have expressions.
1818
Douglas Gregor5e35d592010-09-14 23:59:36 +00001819 case Sema::PCC_ParenthesizedExpression:
David Blaikiebbafb8a2012-03-11 07:00:24 +00001820 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
John McCall31168b02011-06-15 23:02:42 +00001821 CCC == Sema::PCC_ParenthesizedExpression) {
1822 // (__bridge <type>)<expression>
1823 Builder.AddTypedTextChunk("__bridge");
1824 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1825 Builder.AddPlaceholderChunk("type");
1826 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1827 Builder.AddPlaceholderChunk("expression");
1828 Results.AddResult(Result(Builder.TakeString()));
1829
1830 // (__bridge_transfer <Objective-C type>)<expression>
1831 Builder.AddTypedTextChunk("__bridge_transfer");
1832 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1833 Builder.AddPlaceholderChunk("Objective-C type");
1834 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1835 Builder.AddPlaceholderChunk("expression");
1836 Results.AddResult(Result(Builder.TakeString()));
1837
1838 // (__bridge_retained <CF type>)<expression>
1839 Builder.AddTypedTextChunk("__bridge_retained");
1840 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1841 Builder.AddPlaceholderChunk("CF type");
1842 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1843 Builder.AddPlaceholderChunk("expression");
1844 Results.AddResult(Result(Builder.TakeString()));
1845 }
1846 // Fall through
1847
John McCallfaf5fb42010-08-26 23:41:50 +00001848 case Sema::PCC_Expression: {
David Blaikiebbafb8a2012-03-11 07:00:24 +00001849 if (SemaRef.getLangOpts().CPlusPlus) {
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001850 // 'this', if we're in a non-static member function.
Douglas Gregord8c61782012-02-15 15:34:24 +00001851 addThisCompletion(SemaRef, Results);
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001852
Douglas Gregore5c79d52011-10-18 21:20:17 +00001853 // true
1854 Builder.AddResultTypeChunk("bool");
1855 Builder.AddTypedTextChunk("true");
1856 Results.AddResult(Result(Builder.TakeString()));
1857
1858 // false
1859 Builder.AddResultTypeChunk("bool");
1860 Builder.AddTypedTextChunk("false");
1861 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001862
David Blaikiebbafb8a2012-03-11 07:00:24 +00001863 if (SemaRef.getLangOpts().RTTI) {
Douglas Gregorc05f6572011-04-12 02:47:21 +00001864 // dynamic_cast < type-id > ( expression )
1865 Builder.AddTypedTextChunk("dynamic_cast");
1866 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1867 Builder.AddPlaceholderChunk("type");
1868 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1869 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1870 Builder.AddPlaceholderChunk("expression");
1871 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1872 Results.AddResult(Result(Builder.TakeString()));
1873 }
Douglas Gregorf4c33342010-05-28 00:22:41 +00001874
1875 // static_cast < type-id > ( expression )
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001876 Builder.AddTypedTextChunk("static_cast");
1877 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1878 Builder.AddPlaceholderChunk("type");
1879 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1880 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1881 Builder.AddPlaceholderChunk("expression");
1882 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1883 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001884
Douglas Gregorf4c33342010-05-28 00:22:41 +00001885 // reinterpret_cast < type-id > ( expression )
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001886 Builder.AddTypedTextChunk("reinterpret_cast");
1887 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1888 Builder.AddPlaceholderChunk("type");
1889 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1890 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1891 Builder.AddPlaceholderChunk("expression");
1892 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1893 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001894
Douglas Gregorf4c33342010-05-28 00:22:41 +00001895 // const_cast < type-id > ( expression )
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001896 Builder.AddTypedTextChunk("const_cast");
1897 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1898 Builder.AddPlaceholderChunk("type");
1899 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1900 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1901 Builder.AddPlaceholderChunk("expression");
1902 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1903 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001904
David Blaikiebbafb8a2012-03-11 07:00:24 +00001905 if (SemaRef.getLangOpts().RTTI) {
Douglas Gregorc05f6572011-04-12 02:47:21 +00001906 // typeid ( expression-or-type )
Douglas Gregore5c79d52011-10-18 21:20:17 +00001907 Builder.AddResultTypeChunk("std::type_info");
Douglas Gregorc05f6572011-04-12 02:47:21 +00001908 Builder.AddTypedTextChunk("typeid");
1909 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1910 Builder.AddPlaceholderChunk("expression-or-type");
1911 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1912 Results.AddResult(Result(Builder.TakeString()));
1913 }
1914
Douglas Gregorf4c33342010-05-28 00:22:41 +00001915 // new T ( ... )
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001916 Builder.AddTypedTextChunk("new");
1917 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1918 Builder.AddPlaceholderChunk("type");
1919 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1920 Builder.AddPlaceholderChunk("expressions");
1921 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1922 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001923
Douglas Gregorf4c33342010-05-28 00:22:41 +00001924 // new T [ ] ( ... )
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001925 Builder.AddTypedTextChunk("new");
1926 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1927 Builder.AddPlaceholderChunk("type");
1928 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
1929 Builder.AddPlaceholderChunk("size");
1930 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
1931 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1932 Builder.AddPlaceholderChunk("expressions");
1933 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1934 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001935
Douglas Gregorf4c33342010-05-28 00:22:41 +00001936 // delete expression
Douglas Gregore5c79d52011-10-18 21:20:17 +00001937 Builder.AddResultTypeChunk("void");
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001938 Builder.AddTypedTextChunk("delete");
1939 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1940 Builder.AddPlaceholderChunk("expression");
1941 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001942
Douglas Gregorf4c33342010-05-28 00:22:41 +00001943 // delete [] expression
Douglas Gregore5c79d52011-10-18 21:20:17 +00001944 Builder.AddResultTypeChunk("void");
Douglas Gregorb278aaf2011-02-01 19:23:04 +00001945 Builder.AddTypedTextChunk("delete");
1946 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1947 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
1948 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
1949 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1950 Builder.AddPlaceholderChunk("expression");
1951 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001952
David Blaikiebbafb8a2012-03-11 07:00:24 +00001953 if (SemaRef.getLangOpts().CXXExceptions) {
Douglas Gregorc05f6572011-04-12 02:47:21 +00001954 // throw expression
Douglas Gregore5c79d52011-10-18 21:20:17 +00001955 Builder.AddResultTypeChunk("void");
Douglas Gregorc05f6572011-04-12 02:47:21 +00001956 Builder.AddTypedTextChunk("throw");
1957 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1958 Builder.AddPlaceholderChunk("expression");
1959 Results.AddResult(Result(Builder.TakeString()));
1960 }
Douglas Gregor4205fef2011-10-18 16:29:03 +00001961
Douglas Gregora2db7932010-05-26 22:00:08 +00001962 // FIXME: Rethrow?
Douglas Gregor4205fef2011-10-18 16:29:03 +00001963
Richard Smith2bf7fdb2013-01-02 11:42:31 +00001964 if (SemaRef.getLangOpts().CPlusPlus11) {
Douglas Gregor4205fef2011-10-18 16:29:03 +00001965 // nullptr
Douglas Gregore5c79d52011-10-18 21:20:17 +00001966 Builder.AddResultTypeChunk("std::nullptr_t");
Douglas Gregor4205fef2011-10-18 16:29:03 +00001967 Builder.AddTypedTextChunk("nullptr");
1968 Results.AddResult(Result(Builder.TakeString()));
1969
1970 // alignof
Douglas Gregore5c79d52011-10-18 21:20:17 +00001971 Builder.AddResultTypeChunk("size_t");
Douglas Gregor4205fef2011-10-18 16:29:03 +00001972 Builder.AddTypedTextChunk("alignof");
1973 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1974 Builder.AddPlaceholderChunk("type");
1975 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1976 Results.AddResult(Result(Builder.TakeString()));
1977
1978 // noexcept
Douglas Gregore5c79d52011-10-18 21:20:17 +00001979 Builder.AddResultTypeChunk("bool");
Douglas Gregor4205fef2011-10-18 16:29:03 +00001980 Builder.AddTypedTextChunk("noexcept");
1981 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1982 Builder.AddPlaceholderChunk("expression");
1983 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1984 Results.AddResult(Result(Builder.TakeString()));
1985
1986 // sizeof... expression
Douglas Gregore5c79d52011-10-18 21:20:17 +00001987 Builder.AddResultTypeChunk("size_t");
Douglas Gregor4205fef2011-10-18 16:29:03 +00001988 Builder.AddTypedTextChunk("sizeof...");
1989 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1990 Builder.AddPlaceholderChunk("parameter-pack");
1991 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1992 Results.AddResult(Result(Builder.TakeString()));
1993 }
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001994 }
1995
David Blaikiebbafb8a2012-03-11 07:00:24 +00001996 if (SemaRef.getLangOpts().ObjC1) {
Douglas Gregor504a6ae2010-01-10 23:08:15 +00001997 // Add "super", if we're in an Objective-C class with a superclass.
Ted Kremenek305a0a72010-05-31 21:43:10 +00001998 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
1999 // The interface can be NULL.
2000 if (ObjCInterfaceDecl *ID = Method->getClassInterface())
Douglas Gregore5c79d52011-10-18 21:20:17 +00002001 if (ID->getSuperClass()) {
2002 std::string SuperType;
2003 SuperType = ID->getSuperClass()->getNameAsString();
2004 if (Method->isInstanceMethod())
2005 SuperType += " *";
2006
2007 Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
2008 Builder.AddTypedTextChunk("super");
2009 Results.AddResult(Result(Builder.TakeString()));
2010 }
Ted Kremenek305a0a72010-05-31 21:43:10 +00002011 }
2012
Douglas Gregorf98e6a22010-01-13 23:51:12 +00002013 AddObjCExpressionResults(Results, true);
Douglas Gregor504a6ae2010-01-10 23:08:15 +00002014 }
2015
Jordan Rose58d54722012-06-30 21:33:57 +00002016 if (SemaRef.getLangOpts().C11) {
2017 // _Alignof
2018 Builder.AddResultTypeChunk("size_t");
2019 if (SemaRef.getASTContext().Idents.get("alignof").hasMacroDefinition())
2020 Builder.AddTypedTextChunk("alignof");
2021 else
2022 Builder.AddTypedTextChunk("_Alignof");
2023 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2024 Builder.AddPlaceholderChunk("type");
2025 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2026 Results.AddResult(Result(Builder.TakeString()));
2027 }
2028
Douglas Gregorf4c33342010-05-28 00:22:41 +00002029 // sizeof expression
Douglas Gregore5c79d52011-10-18 21:20:17 +00002030 Builder.AddResultTypeChunk("size_t");
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002031 Builder.AddTypedTextChunk("sizeof");
2032 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2033 Builder.AddPlaceholderChunk("expression-or-type");
2034 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2035 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00002036 break;
2037 }
Douglas Gregor99fa2642010-08-24 01:06:58 +00002038
John McCallfaf5fb42010-08-26 23:41:50 +00002039 case Sema::PCC_Type:
Douglas Gregor80039242011-02-15 20:33:25 +00002040 case Sema::PCC_LocalDeclarationSpecifiers:
Douglas Gregor99fa2642010-08-24 01:06:58 +00002041 break;
Douglas Gregor504a6ae2010-01-10 23:08:15 +00002042 }
2043
David Blaikiebbafb8a2012-03-11 07:00:24 +00002044 if (WantTypesInContext(CCC, SemaRef.getLangOpts()))
2045 AddTypeSpecifierResults(SemaRef.getLangOpts(), Results);
Douglas Gregor504a6ae2010-01-10 23:08:15 +00002046
David Blaikiebbafb8a2012-03-11 07:00:24 +00002047 if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type)
Douglas Gregor78a21012010-01-14 16:01:26 +00002048 Results.AddResult(Result("operator"));
Douglas Gregor504a6ae2010-01-10 23:08:15 +00002049}
2050
Douglas Gregorb3fa9192009-12-18 18:53:37 +00002051/// \brief If the given declaration has an associated type, add it as a result
2052/// type chunk.
2053static void AddResultTypeChunk(ASTContext &Context,
Douglas Gregor75acd922011-09-27 23:30:47 +00002054 const PrintingPolicy &Policy,
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002055 const NamedDecl *ND,
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002056 CodeCompletionBuilder &Result) {
Douglas Gregorb3fa9192009-12-18 18:53:37 +00002057 if (!ND)
2058 return;
Douglas Gregor0212fd72010-09-21 16:06:22 +00002059
2060 // Skip constructors and conversion functions, which have their return types
2061 // built into their names.
2062 if (isa<CXXConstructorDecl>(ND) || isa<CXXConversionDecl>(ND))
2063 return;
2064
Douglas Gregorb3fa9192009-12-18 18:53:37 +00002065 // Determine the type of the declaration (if it has a type).
Alp Tokera2794f92014-01-22 07:29:52 +00002066 QualType T;
2067 if (const FunctionDecl *Function = ND->getAsFunction())
Alp Toker314cc812014-01-25 16:55:45 +00002068 T = Function->getReturnType();
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002069 else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND))
Alp Toker314cc812014-01-25 16:55:45 +00002070 T = Method->getReturnType();
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002071 else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
Douglas Gregorb3fa9192009-12-18 18:53:37 +00002072 T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2073 else if (isa<UnresolvedUsingValueDecl>(ND)) {
2074 /* Do nothing: ignore unresolved using declarations*/
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002075 } else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND)) {
Douglas Gregorb3fa9192009-12-18 18:53:37 +00002076 T = Value->getType();
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002077 } else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND))
Douglas Gregorb3fa9192009-12-18 18:53:37 +00002078 T = Property->getType();
2079
2080 if (T.isNull() || Context.hasSameType(T, Context.DependentTy))
2081 return;
2082
Douglas Gregor75acd922011-09-27 23:30:47 +00002083 Result.AddResultTypeChunk(GetCompletionTypeString(T, Context, Policy,
Douglas Gregor304f9b02011-02-01 21:15:40 +00002084 Result.getAllocator()));
Douglas Gregorb3fa9192009-12-18 18:53:37 +00002085}
2086
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002087static void MaybeAddSentinel(ASTContext &Context,
2088 const NamedDecl *FunctionOrMethod,
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002089 CodeCompletionBuilder &Result) {
Douglas Gregordbb71db2010-08-23 23:51:41 +00002090 if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>())
2091 if (Sentinel->getSentinel() == 0) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00002092 if (Context.getLangOpts().ObjC1 &&
Douglas Gregordbb71db2010-08-23 23:51:41 +00002093 Context.Idents.get("nil").hasMacroDefinition())
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002094 Result.AddTextChunk(", nil");
Douglas Gregordbb71db2010-08-23 23:51:41 +00002095 else if (Context.Idents.get("NULL").hasMacroDefinition())
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002096 Result.AddTextChunk(", NULL");
Douglas Gregordbb71db2010-08-23 23:51:41 +00002097 else
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002098 Result.AddTextChunk(", (void*)0");
Douglas Gregordbb71db2010-08-23 23:51:41 +00002099 }
2100}
2101
Douglas Gregor8f08d742011-07-30 07:55:26 +00002102static std::string formatObjCParamQualifiers(unsigned ObjCQuals) {
2103 std::string Result;
2104 if (ObjCQuals & Decl::OBJC_TQ_In)
Douglas Gregor407d1f92011-11-09 02:13:45 +00002105 Result += "in ";
Douglas Gregor8f08d742011-07-30 07:55:26 +00002106 else if (ObjCQuals & Decl::OBJC_TQ_Inout)
Douglas Gregor407d1f92011-11-09 02:13:45 +00002107 Result += "inout ";
Douglas Gregor8f08d742011-07-30 07:55:26 +00002108 else if (ObjCQuals & Decl::OBJC_TQ_Out)
Douglas Gregor407d1f92011-11-09 02:13:45 +00002109 Result += "out ";
Douglas Gregor8f08d742011-07-30 07:55:26 +00002110 if (ObjCQuals & Decl::OBJC_TQ_Bycopy)
Douglas Gregor407d1f92011-11-09 02:13:45 +00002111 Result += "bycopy ";
Douglas Gregor8f08d742011-07-30 07:55:26 +00002112 else if (ObjCQuals & Decl::OBJC_TQ_Byref)
Douglas Gregor407d1f92011-11-09 02:13:45 +00002113 Result += "byref ";
Douglas Gregor8f08d742011-07-30 07:55:26 +00002114 if (ObjCQuals & Decl::OBJC_TQ_Oneway)
Douglas Gregor407d1f92011-11-09 02:13:45 +00002115 Result += "oneway ";
Douglas Gregor8f08d742011-07-30 07:55:26 +00002116 return Result;
2117}
2118
Douglas Gregore90dd002010-08-24 16:15:59 +00002119static std::string FormatFunctionParameter(ASTContext &Context,
Douglas Gregor75acd922011-09-27 23:30:47 +00002120 const PrintingPolicy &Policy,
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002121 const ParmVarDecl *Param,
Douglas Gregord793e7c2011-10-18 04:23:19 +00002122 bool SuppressName = false,
2123 bool SuppressBlock = false) {
Douglas Gregore90dd002010-08-24 16:15:59 +00002124 bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
2125 if (Param->getType()->isDependentType() ||
2126 !Param->getType()->isBlockPointerType()) {
2127 // The argument for a dependent or non-block parameter is a placeholder
2128 // containing that parameter's type.
2129 std::string Result;
2130
Douglas Gregor981a0c42010-08-29 19:47:46 +00002131 if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
Douglas Gregore90dd002010-08-24 16:15:59 +00002132 Result = Param->getIdentifier()->getName();
2133
John McCall31168b02011-06-15 23:02:42 +00002134 Param->getType().getAsStringInternal(Result, Policy);
Douglas Gregore90dd002010-08-24 16:15:59 +00002135
2136 if (ObjCMethodParam) {
Douglas Gregor8f08d742011-07-30 07:55:26 +00002137 Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier())
2138 + Result + ")";
Douglas Gregor981a0c42010-08-29 19:47:46 +00002139 if (Param->getIdentifier() && !SuppressName)
Douglas Gregore90dd002010-08-24 16:15:59 +00002140 Result += Param->getIdentifier()->getName();
2141 }
2142 return Result;
2143 }
2144
2145 // The argument for a block pointer parameter is a block literal with
2146 // the appropriate type.
David Blaikie6adc78e2013-02-18 22:06:02 +00002147 FunctionTypeLoc Block;
2148 FunctionProtoTypeLoc BlockProto;
Douglas Gregore90dd002010-08-24 16:15:59 +00002149 TypeLoc TL;
2150 if (TypeSourceInfo *TSInfo = Param->getTypeSourceInfo()) {
2151 TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
2152 while (true) {
2153 // Look through typedefs.
Douglas Gregord793e7c2011-10-18 04:23:19 +00002154 if (!SuppressBlock) {
David Blaikie6adc78e2013-02-18 22:06:02 +00002155 if (TypedefTypeLoc TypedefTL = TL.getAs<TypedefTypeLoc>()) {
2156 if (TypeSourceInfo *InnerTSInfo =
2157 TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) {
Douglas Gregord793e7c2011-10-18 04:23:19 +00002158 TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc();
2159 continue;
2160 }
2161 }
2162
2163 // Look through qualified types
David Blaikie6adc78e2013-02-18 22:06:02 +00002164 if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) {
2165 TL = QualifiedTL.getUnqualifiedLoc();
Douglas Gregore90dd002010-08-24 16:15:59 +00002166 continue;
2167 }
2168 }
2169
Douglas Gregore90dd002010-08-24 16:15:59 +00002170 // Try to get the function prototype behind the block pointer type,
2171 // then we're done.
David Blaikie6adc78e2013-02-18 22:06:02 +00002172 if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) {
2173 TL = BlockPtr.getPointeeLoc().IgnoreParens();
2174 Block = TL.getAs<FunctionTypeLoc>();
2175 BlockProto = TL.getAs<FunctionProtoTypeLoc>();
Douglas Gregore90dd002010-08-24 16:15:59 +00002176 }
2177 break;
2178 }
2179 }
2180
2181 if (!Block) {
2182 // We were unable to find a FunctionProtoTypeLoc with parameter names
2183 // for the block; just use the parameter type as a placeholder.
2184 std::string Result;
Douglas Gregord793e7c2011-10-18 04:23:19 +00002185 if (!ObjCMethodParam && Param->getIdentifier())
2186 Result = Param->getIdentifier()->getName();
2187
John McCall31168b02011-06-15 23:02:42 +00002188 Param->getType().getUnqualifiedType().getAsStringInternal(Result, Policy);
Douglas Gregore90dd002010-08-24 16:15:59 +00002189
2190 if (ObjCMethodParam) {
Douglas Gregor8f08d742011-07-30 07:55:26 +00002191 Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier())
2192 + Result + ")";
Douglas Gregore90dd002010-08-24 16:15:59 +00002193 if (Param->getIdentifier())
2194 Result += Param->getIdentifier()->getName();
2195 }
2196
2197 return Result;
2198 }
Douglas Gregord793e7c2011-10-18 04:23:19 +00002199
Douglas Gregore90dd002010-08-24 16:15:59 +00002200 // We have the function prototype behind the block pointer type, as it was
2201 // written in the source.
Douglas Gregor67da50e2010-09-08 22:47:51 +00002202 std::string Result;
Alp Toker314cc812014-01-25 16:55:45 +00002203 QualType ResultType = Block.getTypePtr()->getReturnType();
Douglas Gregord793e7c2011-10-18 04:23:19 +00002204 if (!ResultType->isVoidType() || SuppressBlock)
John McCall31168b02011-06-15 23:02:42 +00002205 ResultType.getAsStringInternal(Result, Policy);
Douglas Gregord793e7c2011-10-18 04:23:19 +00002206
2207 // Format the parameter list.
2208 std::string Params;
Alp Tokerb3fd5cf2014-01-21 00:32:38 +00002209 if (!BlockProto || Block.getNumParams() == 0) {
David Blaikie6adc78e2013-02-18 22:06:02 +00002210 if (BlockProto && BlockProto.getTypePtr()->isVariadic())
Douglas Gregord793e7c2011-10-18 04:23:19 +00002211 Params = "(...)";
Douglas Gregoraf25cfa2010-10-02 23:49:58 +00002212 else
Douglas Gregord793e7c2011-10-18 04:23:19 +00002213 Params = "(void)";
Douglas Gregor67da50e2010-09-08 22:47:51 +00002214 } else {
Douglas Gregord793e7c2011-10-18 04:23:19 +00002215 Params += "(";
Alp Tokerb3fd5cf2014-01-21 00:32:38 +00002216 for (unsigned I = 0, N = Block.getNumParams(); I != N; ++I) {
Douglas Gregor67da50e2010-09-08 22:47:51 +00002217 if (I)
Douglas Gregord793e7c2011-10-18 04:23:19 +00002218 Params += ", ";
Alp Tokerb3fd5cf2014-01-21 00:32:38 +00002219 Params += FormatFunctionParameter(Context, Policy, Block.getParam(I),
2220 /*SuppressName=*/false,
Douglas Gregord793e7c2011-10-18 04:23:19 +00002221 /*SuppressBlock=*/true);
Alp Tokerb3fd5cf2014-01-21 00:32:38 +00002222
David Blaikie6adc78e2013-02-18 22:06:02 +00002223 if (I == N - 1 && BlockProto.getTypePtr()->isVariadic())
Douglas Gregord793e7c2011-10-18 04:23:19 +00002224 Params += ", ...";
Douglas Gregor67da50e2010-09-08 22:47:51 +00002225 }
Douglas Gregord793e7c2011-10-18 04:23:19 +00002226 Params += ")";
Douglas Gregor400f5972010-08-31 05:13:43 +00002227 }
Douglas Gregor67da50e2010-09-08 22:47:51 +00002228
Douglas Gregord793e7c2011-10-18 04:23:19 +00002229 if (SuppressBlock) {
2230 // Format as a parameter.
2231 Result = Result + " (^";
2232 if (Param->getIdentifier())
2233 Result += Param->getIdentifier()->getName();
2234 Result += ")";
2235 Result += Params;
2236 } else {
2237 // Format as a block literal argument.
2238 Result = '^' + Result;
2239 Result += Params;
2240
2241 if (Param->getIdentifier())
2242 Result += Param->getIdentifier()->getName();
2243 }
2244
Douglas Gregore90dd002010-08-24 16:15:59 +00002245 return Result;
2246}
2247
Douglas Gregor3545ff42009-09-21 16:56:56 +00002248/// \brief Add function parameter chunks to the given code completion string.
2249static void AddFunctionParameterChunks(ASTContext &Context,
Douglas Gregor75acd922011-09-27 23:30:47 +00002250 const PrintingPolicy &Policy,
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002251 const FunctionDecl *Function,
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002252 CodeCompletionBuilder &Result,
2253 unsigned Start = 0,
2254 bool InOptional = false) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002255 bool FirstParameter = true;
Douglas Gregor9eb77012009-11-07 00:00:49 +00002256
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002257 for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002258 const ParmVarDecl *Param = Function->getParamDecl(P);
Douglas Gregor3545ff42009-09-21 16:56:56 +00002259
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002260 if (Param->hasDefaultArg() && !InOptional) {
Douglas Gregor3545ff42009-09-21 16:56:56 +00002261 // When we see an optional default argument, put that argument and
2262 // the remaining default arguments into a new, optional string.
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00002263 CodeCompletionBuilder Opt(Result.getAllocator(),
2264 Result.getCodeCompletionTUInfo());
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002265 if (!FirstParameter)
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002266 Opt.AddChunk(CodeCompletionString::CK_Comma);
Douglas Gregor75acd922011-09-27 23:30:47 +00002267 AddFunctionParameterChunks(Context, Policy, Function, Opt, P, true);
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002268 Result.AddOptionalChunk(Opt.TakeString());
2269 break;
Douglas Gregor3545ff42009-09-21 16:56:56 +00002270 }
2271
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002272 if (FirstParameter)
2273 FirstParameter = false;
2274 else
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002275 Result.AddChunk(CodeCompletionString::CK_Comma);
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002276
2277 InOptional = false;
Douglas Gregor3545ff42009-09-21 16:56:56 +00002278
2279 // Format the placeholder string.
Douglas Gregor75acd922011-09-27 23:30:47 +00002280 std::string PlaceholderStr = FormatFunctionParameter(Context, Policy,
2281 Param);
Douglas Gregore90dd002010-08-24 16:15:59 +00002282
Douglas Gregor400f5972010-08-31 05:13:43 +00002283 if (Function->isVariadic() && P == N - 1)
2284 PlaceholderStr += ", ...";
2285
Douglas Gregor3545ff42009-09-21 16:56:56 +00002286 // Add the placeholder string.
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002287 Result.AddPlaceholderChunk(
2288 Result.getAllocator().CopyString(PlaceholderStr));
Douglas Gregor3545ff42009-09-21 16:56:56 +00002289 }
Douglas Gregorba449032009-09-22 21:42:17 +00002290
2291 if (const FunctionProtoType *Proto
2292 = Function->getType()->getAs<FunctionProtoType>())
Douglas Gregordbb71db2010-08-23 23:51:41 +00002293 if (Proto->isVariadic()) {
Alp Toker9cacbab2014-01-20 20:26:09 +00002294 if (Proto->getNumParams() == 0)
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002295 Result.AddPlaceholderChunk("...");
Douglas Gregordbb71db2010-08-23 23:51:41 +00002296
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002297 MaybeAddSentinel(Context, Function, Result);
Douglas Gregordbb71db2010-08-23 23:51:41 +00002298 }
Douglas Gregor3545ff42009-09-21 16:56:56 +00002299}
2300
2301/// \brief Add template parameter chunks to the given code completion string.
2302static void AddTemplateParameterChunks(ASTContext &Context,
Douglas Gregor75acd922011-09-27 23:30:47 +00002303 const PrintingPolicy &Policy,
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002304 const TemplateDecl *Template,
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002305 CodeCompletionBuilder &Result,
2306 unsigned MaxParameters = 0,
2307 unsigned Start = 0,
2308 bool InDefaultArg = false) {
Douglas Gregor3545ff42009-09-21 16:56:56 +00002309 bool FirstParameter = true;
2310
2311 TemplateParameterList *Params = Template->getTemplateParameters();
2312 TemplateParameterList::iterator PEnd = Params->end();
2313 if (MaxParameters)
2314 PEnd = Params->begin() + MaxParameters;
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002315 for (TemplateParameterList::iterator P = Params->begin() + Start;
2316 P != PEnd; ++P) {
Douglas Gregor3545ff42009-09-21 16:56:56 +00002317 bool HasDefaultArg = false;
2318 std::string PlaceholderStr;
2319 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
2320 if (TTP->wasDeclaredWithTypename())
2321 PlaceholderStr = "typename";
2322 else
2323 PlaceholderStr = "class";
2324
2325 if (TTP->getIdentifier()) {
2326 PlaceholderStr += ' ';
2327 PlaceholderStr += TTP->getIdentifier()->getName();
2328 }
2329
2330 HasDefaultArg = TTP->hasDefaultArgument();
2331 } else if (NonTypeTemplateParmDecl *NTTP
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002332 = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
Douglas Gregor3545ff42009-09-21 16:56:56 +00002333 if (NTTP->getIdentifier())
2334 PlaceholderStr = NTTP->getIdentifier()->getName();
John McCall31168b02011-06-15 23:02:42 +00002335 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
Douglas Gregor3545ff42009-09-21 16:56:56 +00002336 HasDefaultArg = NTTP->hasDefaultArgument();
2337 } else {
2338 assert(isa<TemplateTemplateParmDecl>(*P));
2339 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
2340
2341 // Since putting the template argument list into the placeholder would
2342 // be very, very long, we just use an abbreviation.
2343 PlaceholderStr = "template<...> class";
2344 if (TTP->getIdentifier()) {
2345 PlaceholderStr += ' ';
2346 PlaceholderStr += TTP->getIdentifier()->getName();
2347 }
2348
2349 HasDefaultArg = TTP->hasDefaultArgument();
2350 }
2351
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002352 if (HasDefaultArg && !InDefaultArg) {
Douglas Gregor3545ff42009-09-21 16:56:56 +00002353 // When we see an optional default argument, put that argument and
2354 // the remaining default arguments into a new, optional string.
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00002355 CodeCompletionBuilder Opt(Result.getAllocator(),
2356 Result.getCodeCompletionTUInfo());
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002357 if (!FirstParameter)
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002358 Opt.AddChunk(CodeCompletionString::CK_Comma);
Douglas Gregor75acd922011-09-27 23:30:47 +00002359 AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002360 P - Params->begin(), true);
2361 Result.AddOptionalChunk(Opt.TakeString());
2362 break;
Douglas Gregor3545ff42009-09-21 16:56:56 +00002363 }
2364
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002365 InDefaultArg = false;
2366
Douglas Gregor3545ff42009-09-21 16:56:56 +00002367 if (FirstParameter)
2368 FirstParameter = false;
2369 else
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002370 Result.AddChunk(CodeCompletionString::CK_Comma);
Douglas Gregor3545ff42009-09-21 16:56:56 +00002371
2372 // Add the placeholder string.
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002373 Result.AddPlaceholderChunk(
2374 Result.getAllocator().CopyString(PlaceholderStr));
Douglas Gregor3545ff42009-09-21 16:56:56 +00002375 }
2376}
2377
Douglas Gregorf2510672009-09-21 19:57:38 +00002378/// \brief Add a qualifier to the given code-completion string, if the
2379/// provided nested-name-specifier is non-NULL.
Douglas Gregor0f622362009-12-11 18:44:16 +00002380static void
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002381AddQualifierToCompletionString(CodeCompletionBuilder &Result,
Douglas Gregor0f622362009-12-11 18:44:16 +00002382 NestedNameSpecifier *Qualifier,
2383 bool QualifierIsInformative,
Douglas Gregor75acd922011-09-27 23:30:47 +00002384 ASTContext &Context,
2385 const PrintingPolicy &Policy) {
Douglas Gregorf2510672009-09-21 19:57:38 +00002386 if (!Qualifier)
2387 return;
2388
2389 std::string PrintedNNS;
2390 {
2391 llvm::raw_string_ostream OS(PrintedNNS);
Douglas Gregor75acd922011-09-27 23:30:47 +00002392 Qualifier->print(OS, Policy);
Douglas Gregorf2510672009-09-21 19:57:38 +00002393 }
Douglas Gregor5bf52692009-09-22 23:15:58 +00002394 if (QualifierIsInformative)
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002395 Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
Douglas Gregor5bf52692009-09-22 23:15:58 +00002396 else
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002397 Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
Douglas Gregorf2510672009-09-21 19:57:38 +00002398}
2399
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002400static void
2401AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result,
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002402 const FunctionDecl *Function) {
Douglas Gregor0f622362009-12-11 18:44:16 +00002403 const FunctionProtoType *Proto
2404 = Function->getType()->getAs<FunctionProtoType>();
2405 if (!Proto || !Proto->getTypeQuals())
2406 return;
2407
Douglas Gregor304f9b02011-02-01 21:15:40 +00002408 // FIXME: Add ref-qualifier!
2409
2410 // Handle single qualifiers without copying
2411 if (Proto->getTypeQuals() == Qualifiers::Const) {
2412 Result.AddInformativeChunk(" const");
2413 return;
2414 }
2415
2416 if (Proto->getTypeQuals() == Qualifiers::Volatile) {
2417 Result.AddInformativeChunk(" volatile");
2418 return;
2419 }
2420
2421 if (Proto->getTypeQuals() == Qualifiers::Restrict) {
2422 Result.AddInformativeChunk(" restrict");
2423 return;
2424 }
2425
2426 // Handle multiple qualifiers.
Douglas Gregor0f622362009-12-11 18:44:16 +00002427 std::string QualsStr;
David Blaikief5697e52012-08-10 00:55:35 +00002428 if (Proto->isConst())
Douglas Gregor0f622362009-12-11 18:44:16 +00002429 QualsStr += " const";
David Blaikief5697e52012-08-10 00:55:35 +00002430 if (Proto->isVolatile())
Douglas Gregor0f622362009-12-11 18:44:16 +00002431 QualsStr += " volatile";
David Blaikief5697e52012-08-10 00:55:35 +00002432 if (Proto->isRestrict())
Douglas Gregor0f622362009-12-11 18:44:16 +00002433 QualsStr += " restrict";
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002434 Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
Douglas Gregor0f622362009-12-11 18:44:16 +00002435}
2436
Douglas Gregor0212fd72010-09-21 16:06:22 +00002437/// \brief Add the name of the given declaration
Douglas Gregor75acd922011-09-27 23:30:47 +00002438static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002439 const NamedDecl *ND,
2440 CodeCompletionBuilder &Result) {
Douglas Gregor0212fd72010-09-21 16:06:22 +00002441 DeclarationName Name = ND->getDeclName();
2442 if (!Name)
2443 return;
2444
2445 switch (Name.getNameKind()) {
Douglas Gregor304f9b02011-02-01 21:15:40 +00002446 case DeclarationName::CXXOperatorName: {
2447 const char *OperatorName = 0;
2448 switch (Name.getCXXOverloadedOperator()) {
2449 case OO_None:
2450 case OO_Conditional:
2451 case NUM_OVERLOADED_OPERATORS:
2452 OperatorName = "operator";
2453 break;
2454
2455#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2456 case OO_##Name: OperatorName = "operator" Spelling; break;
2457#define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2458#include "clang/Basic/OperatorKinds.def"
2459
2460 case OO_New: OperatorName = "operator new"; break;
2461 case OO_Delete: OperatorName = "operator delete"; break;
2462 case OO_Array_New: OperatorName = "operator new[]"; break;
2463 case OO_Array_Delete: OperatorName = "operator delete[]"; break;
2464 case OO_Call: OperatorName = "operator()"; break;
2465 case OO_Subscript: OperatorName = "operator[]"; break;
2466 }
2467 Result.AddTypedTextChunk(OperatorName);
2468 break;
2469 }
2470
Douglas Gregor0212fd72010-09-21 16:06:22 +00002471 case DeclarationName::Identifier:
2472 case DeclarationName::CXXConversionFunctionName:
Douglas Gregor0212fd72010-09-21 16:06:22 +00002473 case DeclarationName::CXXDestructorName:
2474 case DeclarationName::CXXLiteralOperatorName:
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002475 Result.AddTypedTextChunk(
2476 Result.getAllocator().CopyString(ND->getNameAsString()));
Douglas Gregor0212fd72010-09-21 16:06:22 +00002477 break;
2478
2479 case DeclarationName::CXXUsingDirective:
2480 case DeclarationName::ObjCZeroArgSelector:
2481 case DeclarationName::ObjCOneArgSelector:
2482 case DeclarationName::ObjCMultiArgSelector:
2483 break;
2484
2485 case DeclarationName::CXXConstructorName: {
2486 CXXRecordDecl *Record = 0;
2487 QualType Ty = Name.getCXXNameType();
2488 if (const RecordType *RecordTy = Ty->getAs<RecordType>())
2489 Record = cast<CXXRecordDecl>(RecordTy->getDecl());
2490 else if (const InjectedClassNameType *InjectedTy
2491 = Ty->getAs<InjectedClassNameType>())
2492 Record = InjectedTy->getDecl();
2493 else {
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002494 Result.AddTypedTextChunk(
2495 Result.getAllocator().CopyString(ND->getNameAsString()));
Douglas Gregor0212fd72010-09-21 16:06:22 +00002496 break;
2497 }
2498
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002499 Result.AddTypedTextChunk(
2500 Result.getAllocator().CopyString(Record->getNameAsString()));
Douglas Gregor0212fd72010-09-21 16:06:22 +00002501 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002502 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
Douglas Gregor75acd922011-09-27 23:30:47 +00002503 AddTemplateParameterChunks(Context, Policy, Template, Result);
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002504 Result.AddChunk(CodeCompletionString::CK_RightAngle);
Douglas Gregor0212fd72010-09-21 16:06:22 +00002505 }
2506 break;
2507 }
2508 }
2509}
2510
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002511CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(Sema &S,
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00002512 CodeCompletionAllocator &Allocator,
Dmitri Gribenko3292d062012-07-02 17:35:10 +00002513 CodeCompletionTUInfo &CCTUInfo,
2514 bool IncludeBriefComments) {
2515 return CreateCodeCompletionString(S.Context, S.PP, Allocator, CCTUInfo,
2516 IncludeBriefComments);
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002517}
2518
Douglas Gregor3545ff42009-09-21 16:56:56 +00002519/// \brief If possible, create a new code completion string for the given
2520/// result.
2521///
2522/// \returns Either a new, heap-allocated code completion string describing
2523/// how to use this result, or NULL to indicate that the string or name of the
2524/// result is all that is needed.
2525CodeCompletionString *
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002526CodeCompletionResult::CreateCodeCompletionString(ASTContext &Ctx,
2527 Preprocessor &PP,
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00002528 CodeCompletionAllocator &Allocator,
Dmitri Gribenko3292d062012-07-02 17:35:10 +00002529 CodeCompletionTUInfo &CCTUInfo,
2530 bool IncludeBriefComments) {
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00002531 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
Douglas Gregor9eb77012009-11-07 00:00:49 +00002532
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002533 PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002534 if (Kind == RK_Pattern) {
2535 Pattern->Priority = Priority;
2536 Pattern->Availability = Availability;
Douglas Gregor78254c82012-03-27 23:34:16 +00002537
2538 if (Declaration) {
2539 Result.addParentContext(Declaration->getDeclContext());
Douglas Gregor78254c82012-03-27 23:34:16 +00002540 Pattern->ParentName = Result.getParentName();
Fariborz Jahanian1fcf4922013-03-22 17:55:27 +00002541 // Provide code completion comment for self.GetterName where
2542 // GetterName is the getter method for a property with name
2543 // different from the property name (declared via a property
2544 // getter attribute.
2545 const NamedDecl *ND = Declaration;
2546 if (const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(ND))
2547 if (M->isPropertyAccessor())
2548 if (const ObjCPropertyDecl *PDecl = M->findPropertyDecl())
2549 if (PDecl->getGetterName() == M->getSelector() &&
Fariborz Jahanianbe8bc672013-03-23 01:10:45 +00002550 PDecl->getIdentifier() != M->getIdentifier()) {
2551 if (const RawComment *RC =
2552 Ctx.getRawCommentForAnyRedecl(M)) {
Fariborz Jahanian1fcf4922013-03-22 17:55:27 +00002553 Result.addBriefComment(RC->getBriefText(Ctx));
2554 Pattern->BriefComment = Result.getBriefComment();
2555 }
Fariborz Jahanianbe8bc672013-03-23 01:10:45 +00002556 else if (const RawComment *RC =
2557 Ctx.getRawCommentForAnyRedecl(PDecl)) {
2558 Result.addBriefComment(RC->getBriefText(Ctx));
2559 Pattern->BriefComment = Result.getBriefComment();
2560 }
2561 }
Douglas Gregor78254c82012-03-27 23:34:16 +00002562 }
2563
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002564 return Pattern;
2565 }
Douglas Gregorf09935f2009-12-01 05:55:20 +00002566
Douglas Gregorf09935f2009-12-01 05:55:20 +00002567 if (Kind == RK_Keyword) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002568 Result.AddTypedTextChunk(Keyword);
2569 return Result.TakeString();
Douglas Gregorf09935f2009-12-01 05:55:20 +00002570 }
Douglas Gregor3545ff42009-09-21 16:56:56 +00002571
Douglas Gregorf329c7c2009-10-30 16:50:04 +00002572 if (Kind == RK_Macro) {
Argyrios Kyrtzidis09c9e812013-02-20 00:54:57 +00002573 const MacroDirective *MD = PP.getMacroDirectiveHistory(Macro);
2574 assert(MD && "Not a macro?");
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00002575 const MacroInfo *MI = MD->getMacroInfo();
Douglas Gregorf09935f2009-12-01 05:55:20 +00002576
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002577 Result.AddTypedTextChunk(
2578 Result.getAllocator().CopyString(Macro->getName()));
Douglas Gregorf09935f2009-12-01 05:55:20 +00002579
2580 if (!MI->isFunctionLike())
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002581 return Result.TakeString();
Douglas Gregorf329c7c2009-10-30 16:50:04 +00002582
2583 // Format a function-like macro with placeholders for the arguments.
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002584 Result.AddChunk(CodeCompletionString::CK_LeftParen);
Douglas Gregor0c505312011-07-30 08:17:44 +00002585 MacroInfo::arg_iterator A = MI->arg_begin(), AEnd = MI->arg_end();
Douglas Gregor3aa55262012-01-21 00:43:38 +00002586
2587 // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
2588 if (MI->isC99Varargs()) {
2589 --AEnd;
2590
2591 if (A == AEnd) {
2592 Result.AddPlaceholderChunk("...");
2593 }
Douglas Gregor0c505312011-07-30 08:17:44 +00002594 }
Douglas Gregor3aa55262012-01-21 00:43:38 +00002595
Douglas Gregor0c505312011-07-30 08:17:44 +00002596 for (MacroInfo::arg_iterator A = MI->arg_begin(); A != AEnd; ++A) {
Douglas Gregorf329c7c2009-10-30 16:50:04 +00002597 if (A != MI->arg_begin())
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002598 Result.AddChunk(CodeCompletionString::CK_Comma);
Douglas Gregor3aa55262012-01-21 00:43:38 +00002599
2600 if (MI->isVariadic() && (A+1) == AEnd) {
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00002601 SmallString<32> Arg = (*A)->getName();
Douglas Gregor3aa55262012-01-21 00:43:38 +00002602 if (MI->isC99Varargs())
2603 Arg += ", ...";
2604 else
2605 Arg += "...";
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002606 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
Douglas Gregor3aa55262012-01-21 00:43:38 +00002607 break;
Douglas Gregorf329c7c2009-10-30 16:50:04 +00002608 }
Douglas Gregor3aa55262012-01-21 00:43:38 +00002609
2610 // Non-variadic macros are simple.
2611 Result.AddPlaceholderChunk(
2612 Result.getAllocator().CopyString((*A)->getName()));
Douglas Gregor0c505312011-07-30 08:17:44 +00002613 }
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002614 Result.AddChunk(CodeCompletionString::CK_RightParen);
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002615 return Result.TakeString();
Douglas Gregorf329c7c2009-10-30 16:50:04 +00002616 }
2617
Douglas Gregorf64acca2010-05-25 21:41:55 +00002618 assert(Kind == RK_Declaration && "Missed a result kind?");
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002619 const NamedDecl *ND = Declaration;
Douglas Gregor78254c82012-03-27 23:34:16 +00002620 Result.addParentContext(ND->getDeclContext());
Dmitri Gribenko3292d062012-07-02 17:35:10 +00002621
2622 if (IncludeBriefComments) {
2623 // Add documentation comment, if it exists.
Dmitri Gribenkoa43ec182012-08-11 00:51:43 +00002624 if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(ND)) {
Dmitri Gribenko3292d062012-07-02 17:35:10 +00002625 Result.addBriefComment(RC->getBriefText(Ctx));
Fariborz Jahanian15a0b552013-02-28 17:47:14 +00002626 }
2627 else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
2628 if (OMD->isPropertyAccessor())
2629 if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
2630 if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(PDecl))
2631 Result.addBriefComment(RC->getBriefText(Ctx));
Dmitri Gribenko3292d062012-07-02 17:35:10 +00002632 }
2633
Douglas Gregor9eb77012009-11-07 00:00:49 +00002634 if (StartsNestedNameSpecifier) {
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002635 Result.AddTypedTextChunk(
2636 Result.getAllocator().CopyString(ND->getNameAsString()));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002637 Result.AddTextChunk("::");
2638 return Result.TakeString();
Douglas Gregor9eb77012009-11-07 00:00:49 +00002639 }
Erik Verbruggen98ea7f62011-10-14 15:31:08 +00002640
Aaron Ballmanbe22bcb2014-03-10 17:08:28 +00002641 for (const auto *I : ND->specific_attrs<AnnotateAttr>())
2642 Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation()));
Aaron Ballmanb97112e2014-03-08 22:19:01 +00002643
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002644 AddResultTypeChunk(Ctx, Policy, ND, Result);
Douglas Gregorb3fa9192009-12-18 18:53:37 +00002645
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002646 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) {
Douglas Gregor5bf52692009-09-22 23:15:58 +00002647 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002648 Ctx, Policy);
2649 AddTypedNameChunk(Ctx, Policy, ND, Result);
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002650 Result.AddChunk(CodeCompletionString::CK_LeftParen);
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002651 AddFunctionParameterChunks(Ctx, Policy, Function, Result);
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002652 Result.AddChunk(CodeCompletionString::CK_RightParen);
Douglas Gregor0f622362009-12-11 18:44:16 +00002653 AddFunctionTypeQualsToCompletionString(Result, Function);
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002654 return Result.TakeString();
Douglas Gregor3545ff42009-09-21 16:56:56 +00002655 }
2656
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002657 if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) {
Douglas Gregor5bf52692009-09-22 23:15:58 +00002658 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002659 Ctx, Policy);
Douglas Gregor3545ff42009-09-21 16:56:56 +00002660 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002661 AddTypedNameChunk(Ctx, Policy, Function, Result);
Douglas Gregor0212fd72010-09-21 16:06:22 +00002662
Douglas Gregor3545ff42009-09-21 16:56:56 +00002663 // Figure out which template parameters are deduced (or have default
2664 // arguments).
Benjamin Kramere0513cb2012-01-30 16:17:39 +00002665 llvm::SmallBitVector Deduced;
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002666 Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
Douglas Gregor3545ff42009-09-21 16:56:56 +00002667 unsigned LastDeducibleArgument;
2668 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
2669 --LastDeducibleArgument) {
2670 if (!Deduced[LastDeducibleArgument - 1]) {
2671 // C++0x: Figure out if the template argument has a default. If so,
2672 // the user doesn't need to type this argument.
2673 // FIXME: We need to abstract template parameters better!
2674 bool HasDefaultArg = false;
2675 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002676 LastDeducibleArgument - 1);
Douglas Gregor3545ff42009-09-21 16:56:56 +00002677 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
2678 HasDefaultArg = TTP->hasDefaultArgument();
2679 else if (NonTypeTemplateParmDecl *NTTP
2680 = dyn_cast<NonTypeTemplateParmDecl>(Param))
2681 HasDefaultArg = NTTP->hasDefaultArgument();
2682 else {
2683 assert(isa<TemplateTemplateParmDecl>(Param));
2684 HasDefaultArg
Douglas Gregor9eb77012009-11-07 00:00:49 +00002685 = cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
Douglas Gregor3545ff42009-09-21 16:56:56 +00002686 }
2687
2688 if (!HasDefaultArg)
2689 break;
2690 }
2691 }
2692
2693 if (LastDeducibleArgument) {
2694 // Some of the function template arguments cannot be deduced from a
2695 // function call, so we introduce an explicit template argument list
2696 // containing all of the arguments up to the first deducible argument.
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002697 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002698 AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
Douglas Gregor3545ff42009-09-21 16:56:56 +00002699 LastDeducibleArgument);
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002700 Result.AddChunk(CodeCompletionString::CK_RightAngle);
Douglas Gregor3545ff42009-09-21 16:56:56 +00002701 }
2702
2703 // Add the function parameters
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002704 Result.AddChunk(CodeCompletionString::CK_LeftParen);
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002705 AddFunctionParameterChunks(Ctx, Policy, Function, Result);
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002706 Result.AddChunk(CodeCompletionString::CK_RightParen);
Douglas Gregor0f622362009-12-11 18:44:16 +00002707 AddFunctionTypeQualsToCompletionString(Result, Function);
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002708 return Result.TakeString();
Douglas Gregor3545ff42009-09-21 16:56:56 +00002709 }
2710
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002711 if (const TemplateDecl *Template = dyn_cast<TemplateDecl>(ND)) {
Douglas Gregor5bf52692009-09-22 23:15:58 +00002712 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002713 Ctx, Policy);
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002714 Result.AddTypedTextChunk(
2715 Result.getAllocator().CopyString(Template->getNameAsString()));
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002716 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002717 AddTemplateParameterChunks(Ctx, Policy, Template, Result);
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002718 Result.AddChunk(CodeCompletionString::CK_RightAngle);
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002719 return Result.TakeString();
Douglas Gregor3545ff42009-09-21 16:56:56 +00002720 }
2721
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002722 if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
Douglas Gregord3c5d792009-11-17 16:44:22 +00002723 Selector Sel = Method->getSelector();
2724 if (Sel.isUnarySelector()) {
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002725 Result.AddTypedTextChunk(Result.getAllocator().CopyString(
Douglas Gregoraf2a6ae2011-02-18 22:29:55 +00002726 Sel.getNameForSlot(0)));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002727 return Result.TakeString();
Douglas Gregord3c5d792009-11-17 16:44:22 +00002728 }
2729
Douglas Gregoraf2a6ae2011-02-18 22:29:55 +00002730 std::string SelName = Sel.getNameForSlot(0).str();
Douglas Gregor1b605f72009-11-19 01:08:35 +00002731 SelName += ':';
2732 if (StartParameter == 0)
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002733 Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
Douglas Gregor1b605f72009-11-19 01:08:35 +00002734 else {
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002735 Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
Douglas Gregor1b605f72009-11-19 01:08:35 +00002736
2737 // If there is only one parameter, and we're past it, add an empty
2738 // typed-text chunk since there is nothing to type.
2739 if (Method->param_size() == 1)
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002740 Result.AddTypedTextChunk("");
Douglas Gregor1b605f72009-11-19 01:08:35 +00002741 }
Douglas Gregord3c5d792009-11-17 16:44:22 +00002742 unsigned Idx = 0;
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00002743 for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(),
2744 PEnd = Method->param_end();
Douglas Gregord3c5d792009-11-17 16:44:22 +00002745 P != PEnd; (void)++P, ++Idx) {
2746 if (Idx > 0) {
Douglas Gregor1b605f72009-11-19 01:08:35 +00002747 std::string Keyword;
2748 if (Idx > StartParameter)
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002749 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
Douglas Gregord3c5d792009-11-17 16:44:22 +00002750 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
Benjamin Kramer632500c2011-07-26 16:59:25 +00002751 Keyword += II->getName();
Douglas Gregord3c5d792009-11-17 16:44:22 +00002752 Keyword += ":";
Douglas Gregor95887f92010-07-08 23:20:03 +00002753 if (Idx < StartParameter || AllParametersAreInformative)
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002754 Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
Douglas Gregor8e3e8742010-10-18 21:05:04 +00002755 else
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002756 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
Douglas Gregord3c5d792009-11-17 16:44:22 +00002757 }
Douglas Gregor1b605f72009-11-19 01:08:35 +00002758
2759 // If we're before the starting parameter, skip the placeholder.
2760 if (Idx < StartParameter)
2761 continue;
Douglas Gregord3c5d792009-11-17 16:44:22 +00002762
2763 std::string Arg;
Douglas Gregore90dd002010-08-24 16:15:59 +00002764
2765 if ((*P)->getType()->isBlockPointerType() && !DeclaringEntity)
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002766 Arg = FormatFunctionParameter(Ctx, Policy, *P, true);
Douglas Gregore90dd002010-08-24 16:15:59 +00002767 else {
John McCall31168b02011-06-15 23:02:42 +00002768 (*P)->getType().getAsStringInternal(Arg, Policy);
Douglas Gregor8f08d742011-07-30 07:55:26 +00002769 Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier())
2770 + Arg + ")";
Douglas Gregore90dd002010-08-24 16:15:59 +00002771 if (IdentifierInfo *II = (*P)->getIdentifier())
Douglas Gregor981a0c42010-08-29 19:47:46 +00002772 if (DeclaringEntity || AllParametersAreInformative)
Benjamin Kramer632500c2011-07-26 16:59:25 +00002773 Arg += II->getName();
Douglas Gregore90dd002010-08-24 16:15:59 +00002774 }
2775
Douglas Gregor400f5972010-08-31 05:13:43 +00002776 if (Method->isVariadic() && (P + 1) == PEnd)
2777 Arg += ", ...";
2778
Douglas Gregor95887f92010-07-08 23:20:03 +00002779 if (DeclaringEntity)
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002780 Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
Douglas Gregor95887f92010-07-08 23:20:03 +00002781 else if (AllParametersAreInformative)
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002782 Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
Douglas Gregorc8537c52009-11-19 07:41:15 +00002783 else
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002784 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
Douglas Gregord3c5d792009-11-17 16:44:22 +00002785 }
2786
Douglas Gregor04c5f972009-12-23 00:21:46 +00002787 if (Method->isVariadic()) {
Douglas Gregor400f5972010-08-31 05:13:43 +00002788 if (Method->param_size() == 0) {
2789 if (DeclaringEntity)
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002790 Result.AddTextChunk(", ...");
Douglas Gregor400f5972010-08-31 05:13:43 +00002791 else if (AllParametersAreInformative)
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002792 Result.AddInformativeChunk(", ...");
Douglas Gregor400f5972010-08-31 05:13:43 +00002793 else
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002794 Result.AddPlaceholderChunk(", ...");
Douglas Gregor400f5972010-08-31 05:13:43 +00002795 }
Douglas Gregordbb71db2010-08-23 23:51:41 +00002796
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002797 MaybeAddSentinel(Ctx, Method, Result);
Douglas Gregor04c5f972009-12-23 00:21:46 +00002798 }
2799
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002800 return Result.TakeString();
Douglas Gregord3c5d792009-11-17 16:44:22 +00002801 }
2802
Douglas Gregorf09935f2009-12-01 05:55:20 +00002803 if (Qualifier)
Douglas Gregor5bf52692009-09-22 23:15:58 +00002804 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +00002805 Ctx, Policy);
Douglas Gregorf09935f2009-12-01 05:55:20 +00002806
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002807 Result.AddTypedTextChunk(
2808 Result.getAllocator().CopyString(ND->getNameAsString()));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002809 return Result.TakeString();
Douglas Gregor3545ff42009-09-21 16:56:56 +00002810}
2811
Douglas Gregorf0f51982009-09-23 00:34:09 +00002812CodeCompletionString *
2813CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
2814 unsigned CurrentArg,
Douglas Gregor36e3b5c2010-10-11 21:37:58 +00002815 Sema &S,
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00002816 CodeCompletionAllocator &Allocator,
2817 CodeCompletionTUInfo &CCTUInfo) const {
Douglas Gregor75acd922011-09-27 23:30:47 +00002818 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
John McCall31168b02011-06-15 23:02:42 +00002819
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002820 // FIXME: Set priority, availability appropriately.
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00002821 CodeCompletionBuilder Result(Allocator,CCTUInfo, 1, CXAvailability_Available);
Douglas Gregorf0f51982009-09-23 00:34:09 +00002822 FunctionDecl *FDecl = getFunction();
Douglas Gregor75acd922011-09-27 23:30:47 +00002823 AddResultTypeChunk(S.Context, Policy, FDecl, Result);
Douglas Gregorf0f51982009-09-23 00:34:09 +00002824 const FunctionProtoType *Proto
2825 = dyn_cast<FunctionProtoType>(getFunctionType());
2826 if (!FDecl && !Proto) {
2827 // Function without a prototype. Just give the return type and a
2828 // highlighted ellipsis.
2829 const FunctionType *FT = getFunctionType();
Alp Toker314cc812014-01-25 16:55:45 +00002830 Result.AddTextChunk(GetCompletionTypeString(FT->getReturnType(), S.Context,
2831 Policy, Result.getAllocator()));
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002832 Result.AddChunk(CodeCompletionString::CK_LeftParen);
2833 Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
2834 Result.AddChunk(CodeCompletionString::CK_RightParen);
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002835 return Result.TakeString();
Douglas Gregorf0f51982009-09-23 00:34:09 +00002836 }
2837
2838 if (FDecl)
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002839 Result.AddTextChunk(
2840 Result.getAllocator().CopyString(FDecl->getNameAsString()));
Douglas Gregorf0f51982009-09-23 00:34:09 +00002841 else
Alp Toker314cc812014-01-25 16:55:45 +00002842 Result.AddTextChunk(Result.getAllocator().CopyString(
2843 Proto->getReturnType().getAsString(Policy)));
2844
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002845 Result.AddChunk(CodeCompletionString::CK_LeftParen);
Alp Toker9cacbab2014-01-20 20:26:09 +00002846 unsigned NumParams = FDecl ? FDecl->getNumParams() : Proto->getNumParams();
Douglas Gregorf0f51982009-09-23 00:34:09 +00002847 for (unsigned I = 0; I != NumParams; ++I) {
2848 if (I)
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002849 Result.AddChunk(CodeCompletionString::CK_Comma);
Douglas Gregorf0f51982009-09-23 00:34:09 +00002850
2851 std::string ArgString;
2852 QualType ArgType;
2853
2854 if (FDecl) {
2855 ArgString = FDecl->getParamDecl(I)->getNameAsString();
2856 ArgType = FDecl->getParamDecl(I)->getOriginalType();
2857 } else {
Alp Toker9cacbab2014-01-20 20:26:09 +00002858 ArgType = Proto->getParamType(I);
Douglas Gregorf0f51982009-09-23 00:34:09 +00002859 }
2860
John McCall31168b02011-06-15 23:02:42 +00002861 ArgType.getAsStringInternal(ArgString, Policy);
Douglas Gregorf0f51982009-09-23 00:34:09 +00002862
2863 if (I == CurrentArg)
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002864 Result.AddChunk(CodeCompletionString::CK_CurrentParameter,
2865 Result.getAllocator().CopyString(ArgString));
Douglas Gregorf0f51982009-09-23 00:34:09 +00002866 else
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00002867 Result.AddTextChunk(Result.getAllocator().CopyString(ArgString));
Douglas Gregorf0f51982009-09-23 00:34:09 +00002868 }
2869
2870 if (Proto && Proto->isVariadic()) {
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002871 Result.AddChunk(CodeCompletionString::CK_Comma);
Douglas Gregorf0f51982009-09-23 00:34:09 +00002872 if (CurrentArg < NumParams)
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002873 Result.AddTextChunk("...");
Douglas Gregorf0f51982009-09-23 00:34:09 +00002874 else
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002875 Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
Douglas Gregorf0f51982009-09-23 00:34:09 +00002876 }
Benjamin Kramerdb534a42012-03-26 16:57:36 +00002877 Result.AddChunk(CodeCompletionString::CK_RightParen);
Douglas Gregorf0f51982009-09-23 00:34:09 +00002878
Douglas Gregorb278aaf2011-02-01 19:23:04 +00002879 return Result.TakeString();
Douglas Gregorf0f51982009-09-23 00:34:09 +00002880}
2881
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002882unsigned clang::getMacroUsagePriority(StringRef MacroName,
Douglas Gregor9dcf58a2010-09-20 21:11:48 +00002883 const LangOptions &LangOpts,
Douglas Gregor6e240332010-08-16 16:18:59 +00002884 bool PreferredTypeIsPointer) {
2885 unsigned Priority = CCP_Macro;
2886
Douglas Gregor9dcf58a2010-09-20 21:11:48 +00002887 // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
2888 if (MacroName.equals("nil") || MacroName.equals("NULL") ||
2889 MacroName.equals("Nil")) {
Douglas Gregor6e240332010-08-16 16:18:59 +00002890 Priority = CCP_Constant;
2891 if (PreferredTypeIsPointer)
2892 Priority = Priority / CCF_SimilarTypeMatch;
Douglas Gregor9dcf58a2010-09-20 21:11:48 +00002893 }
2894 // Treat "YES", "NO", "true", and "false" as constants.
2895 else if (MacroName.equals("YES") || MacroName.equals("NO") ||
2896 MacroName.equals("true") || MacroName.equals("false"))
2897 Priority = CCP_Constant;
2898 // Treat "bool" as a type.
2899 else if (MacroName.equals("bool"))
2900 Priority = CCP_Type + (LangOpts.ObjC1? CCD_bool_in_ObjC : 0);
2901
Douglas Gregor6e240332010-08-16 16:18:59 +00002902
2903 return Priority;
2904}
2905
Dmitri Gribenkobdc80de2013-01-11 20:32:41 +00002906CXCursorKind clang::getCursorKindForDecl(const Decl *D) {
Douglas Gregor09c0eb12010-09-03 23:30:36 +00002907 if (!D)
2908 return CXCursor_UnexposedDecl;
2909
2910 switch (D->getKind()) {
2911 case Decl::Enum: return CXCursor_EnumDecl;
2912 case Decl::EnumConstant: return CXCursor_EnumConstantDecl;
2913 case Decl::Field: return CXCursor_FieldDecl;
2914 case Decl::Function:
2915 return CXCursor_FunctionDecl;
2916 case Decl::ObjCCategory: return CXCursor_ObjCCategoryDecl;
2917 case Decl::ObjCCategoryImpl: return CXCursor_ObjCCategoryImplDecl;
Douglas Gregor09c0eb12010-09-03 23:30:36 +00002918 case Decl::ObjCImplementation: return CXCursor_ObjCImplementationDecl;
Douglas Gregordeafd0b2011-12-27 22:43:10 +00002919
Argyrios Kyrtzidis3698cef2012-01-24 21:39:26 +00002920 case Decl::ObjCInterface: return CXCursor_ObjCInterfaceDecl;
Douglas Gregor09c0eb12010-09-03 23:30:36 +00002921 case Decl::ObjCIvar: return CXCursor_ObjCIvarDecl;
2922 case Decl::ObjCMethod:
2923 return cast<ObjCMethodDecl>(D)->isInstanceMethod()
2924 ? CXCursor_ObjCInstanceMethodDecl : CXCursor_ObjCClassMethodDecl;
2925 case Decl::CXXMethod: return CXCursor_CXXMethod;
2926 case Decl::CXXConstructor: return CXCursor_Constructor;
2927 case Decl::CXXDestructor: return CXCursor_Destructor;
2928 case Decl::CXXConversion: return CXCursor_ConversionFunction;
2929 case Decl::ObjCProperty: return CXCursor_ObjCPropertyDecl;
Argyrios Kyrtzidis3698cef2012-01-24 21:39:26 +00002930 case Decl::ObjCProtocol: return CXCursor_ObjCProtocolDecl;
Douglas Gregor09c0eb12010-09-03 23:30:36 +00002931 case Decl::ParmVar: return CXCursor_ParmDecl;
2932 case Decl::Typedef: return CXCursor_TypedefDecl;
Richard Smithdda56e42011-04-15 14:24:37 +00002933 case Decl::TypeAlias: return CXCursor_TypeAliasDecl;
Douglas Gregor09c0eb12010-09-03 23:30:36 +00002934 case Decl::Var: return CXCursor_VarDecl;
2935 case Decl::Namespace: return CXCursor_Namespace;
2936 case Decl::NamespaceAlias: return CXCursor_NamespaceAlias;
2937 case Decl::TemplateTypeParm: return CXCursor_TemplateTypeParameter;
2938 case Decl::NonTypeTemplateParm:return CXCursor_NonTypeTemplateParameter;
2939 case Decl::TemplateTemplateParm:return CXCursor_TemplateTemplateParameter;
2940 case Decl::FunctionTemplate: return CXCursor_FunctionTemplate;
2941 case Decl::ClassTemplate: return CXCursor_ClassTemplate;
Argyrios Kyrtzidis12afd702011-09-30 17:58:23 +00002942 case Decl::AccessSpec: return CXCursor_CXXAccessSpecifier;
Douglas Gregor09c0eb12010-09-03 23:30:36 +00002943 case Decl::ClassTemplatePartialSpecialization:
2944 return CXCursor_ClassTemplatePartialSpecialization;
2945 case Decl::UsingDirective: return CXCursor_UsingDirective;
Douglas Gregor3e653b32012-04-30 23:41:16 +00002946 case Decl::TranslationUnit: return CXCursor_TranslationUnit;
Douglas Gregor09c0eb12010-09-03 23:30:36 +00002947
2948 case Decl::Using:
2949 case Decl::UnresolvedUsingValue:
2950 case Decl::UnresolvedUsingTypename:
2951 return CXCursor_UsingDeclaration;
2952
Douglas Gregor4cd65962011-06-03 23:08:58 +00002953 case Decl::ObjCPropertyImpl:
2954 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
2955 case ObjCPropertyImplDecl::Dynamic:
2956 return CXCursor_ObjCDynamicDecl;
2957
2958 case ObjCPropertyImplDecl::Synthesize:
2959 return CXCursor_ObjCSynthesizeDecl;
2960 }
Argyrios Kyrtzidis50e5b1d2012-10-05 00:22:24 +00002961
2962 case Decl::Import:
2963 return CXCursor_ModuleImportDecl;
Douglas Gregor4cd65962011-06-03 23:08:58 +00002964
Douglas Gregor09c0eb12010-09-03 23:30:36 +00002965 default:
Dmitri Gribenkobdc80de2013-01-11 20:32:41 +00002966 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
Douglas Gregor09c0eb12010-09-03 23:30:36 +00002967 switch (TD->getTagKind()) {
Joao Matosdc86f942012-08-31 18:45:21 +00002968 case TTK_Interface: // fall through
Douglas Gregor09c0eb12010-09-03 23:30:36 +00002969 case TTK_Struct: return CXCursor_StructDecl;
2970 case TTK_Class: return CXCursor_ClassDecl;
2971 case TTK_Union: return CXCursor_UnionDecl;
2972 case TTK_Enum: return CXCursor_EnumDecl;
2973 }
2974 }
2975 }
2976
2977 return CXCursor_UnexposedDecl;
2978}
2979
Douglas Gregor55b037b2010-07-08 20:55:51 +00002980static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
Douglas Gregor8cb17462012-10-09 16:01:50 +00002981 bool IncludeUndefined,
Douglas Gregor55b037b2010-07-08 20:55:51 +00002982 bool TargetTypeIsPointer = false) {
John McCall276321a2010-08-25 06:19:51 +00002983 typedef CodeCompletionResult Result;
Douglas Gregor55b037b2010-07-08 20:55:51 +00002984
Douglas Gregorf329c7c2009-10-30 16:50:04 +00002985 Results.EnterNewScope();
Douglas Gregor8e3e8742010-10-18 21:05:04 +00002986
Douglas Gregor9eb77012009-11-07 00:00:49 +00002987 for (Preprocessor::macro_iterator M = PP.macro_begin(),
2988 MEnd = PP.macro_end();
Douglas Gregor55b037b2010-07-08 20:55:51 +00002989 M != MEnd; ++M) {
Argyrios Kyrtzidis9ef53ce2014-04-09 18:21:23 +00002990 if (IncludeUndefined || M->first->hasMacroDefinition()) {
2991 if (MacroInfo *MI = M->second->getMacroInfo())
2992 if (MI->isUsedForHeaderGuard())
2993 continue;
2994
Douglas Gregor8cb17462012-10-09 16:01:50 +00002995 Results.AddResult(Result(M->first,
Douglas Gregor6e240332010-08-16 16:18:59 +00002996 getMacroUsagePriority(M->first->getName(),
David Blaikiebbafb8a2012-03-11 07:00:24 +00002997 PP.getLangOpts(),
Douglas Gregor6e240332010-08-16 16:18:59 +00002998 TargetTypeIsPointer)));
Argyrios Kyrtzidis9ef53ce2014-04-09 18:21:23 +00002999 }
Douglas Gregor55b037b2010-07-08 20:55:51 +00003000 }
Douglas Gregor8e3e8742010-10-18 21:05:04 +00003001
Douglas Gregorf329c7c2009-10-30 16:50:04 +00003002 Results.ExitScope();
Douglas Gregor8e3e8742010-10-18 21:05:04 +00003003
Douglas Gregorf329c7c2009-10-30 16:50:04 +00003004}
3005
Douglas Gregorce0e8562010-08-23 21:54:33 +00003006static void AddPrettyFunctionResults(const LangOptions &LangOpts,
3007 ResultBuilder &Results) {
John McCall276321a2010-08-25 06:19:51 +00003008 typedef CodeCompletionResult Result;
Douglas Gregorce0e8562010-08-23 21:54:33 +00003009
3010 Results.EnterNewScope();
Douglas Gregor8e3e8742010-10-18 21:05:04 +00003011
Douglas Gregorce0e8562010-08-23 21:54:33 +00003012 Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
3013 Results.AddResult(Result("__FUNCTION__", CCP_Constant));
Richard Smith2bf7fdb2013-01-02 11:42:31 +00003014 if (LangOpts.C99 || LangOpts.CPlusPlus11)
Douglas Gregorce0e8562010-08-23 21:54:33 +00003015 Results.AddResult(Result("__func__", CCP_Constant));
3016 Results.ExitScope();
3017}
3018
Daniel Dunbar242ea9a2009-11-13 08:58:20 +00003019static void HandleCodeCompleteResults(Sema *S,
3020 CodeCompleteConsumer *CodeCompleter,
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003021 CodeCompletionContext Context,
John McCall276321a2010-08-25 06:19:51 +00003022 CodeCompletionResult *Results,
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003023 unsigned NumResults) {
Douglas Gregor3545ff42009-09-21 16:56:56 +00003024 if (CodeCompleter)
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003025 CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
Douglas Gregor3545ff42009-09-21 16:56:56 +00003026}
3027
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003028static enum CodeCompletionContext::Kind mapCodeCompletionContext(Sema &S,
3029 Sema::ParserCompletionContext PCC) {
3030 switch (PCC) {
John McCallfaf5fb42010-08-26 23:41:50 +00003031 case Sema::PCC_Namespace:
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003032 return CodeCompletionContext::CCC_TopLevel;
3033
John McCallfaf5fb42010-08-26 23:41:50 +00003034 case Sema::PCC_Class:
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003035 return CodeCompletionContext::CCC_ClassStructUnion;
3036
John McCallfaf5fb42010-08-26 23:41:50 +00003037 case Sema::PCC_ObjCInterface:
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003038 return CodeCompletionContext::CCC_ObjCInterface;
3039
John McCallfaf5fb42010-08-26 23:41:50 +00003040 case Sema::PCC_ObjCImplementation:
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003041 return CodeCompletionContext::CCC_ObjCImplementation;
3042
John McCallfaf5fb42010-08-26 23:41:50 +00003043 case Sema::PCC_ObjCInstanceVariableList:
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003044 return CodeCompletionContext::CCC_ObjCIvarList;
3045
John McCallfaf5fb42010-08-26 23:41:50 +00003046 case Sema::PCC_Template:
3047 case Sema::PCC_MemberTemplate:
Douglas Gregor0ac41382010-09-23 23:01:17 +00003048 if (S.CurContext->isFileContext())
3049 return CodeCompletionContext::CCC_TopLevel;
David Blaikie8a40f702012-01-17 06:56:22 +00003050 if (S.CurContext->isRecord())
Douglas Gregor0ac41382010-09-23 23:01:17 +00003051 return CodeCompletionContext::CCC_ClassStructUnion;
David Blaikie8a40f702012-01-17 06:56:22 +00003052 return CodeCompletionContext::CCC_Other;
Douglas Gregor0ac41382010-09-23 23:01:17 +00003053
John McCallfaf5fb42010-08-26 23:41:50 +00003054 case Sema::PCC_RecoveryInFunction:
Douglas Gregor0ac41382010-09-23 23:01:17 +00003055 return CodeCompletionContext::CCC_Recovery;
Douglas Gregorc769d6e2010-10-18 22:01:46 +00003056
John McCallfaf5fb42010-08-26 23:41:50 +00003057 case Sema::PCC_ForInit:
David Blaikiebbafb8a2012-03-11 07:00:24 +00003058 if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
3059 S.getLangOpts().ObjC1)
Douglas Gregorc769d6e2010-10-18 22:01:46 +00003060 return CodeCompletionContext::CCC_ParenthesizedExpression;
3061 else
3062 return CodeCompletionContext::CCC_Expression;
3063
3064 case Sema::PCC_Expression:
John McCallfaf5fb42010-08-26 23:41:50 +00003065 case Sema::PCC_Condition:
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003066 return CodeCompletionContext::CCC_Expression;
3067
John McCallfaf5fb42010-08-26 23:41:50 +00003068 case Sema::PCC_Statement:
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003069 return CodeCompletionContext::CCC_Statement;
Douglas Gregorf02e5f32010-08-24 01:11:00 +00003070
John McCallfaf5fb42010-08-26 23:41:50 +00003071 case Sema::PCC_Type:
Douglas Gregorf02e5f32010-08-24 01:11:00 +00003072 return CodeCompletionContext::CCC_Type;
Douglas Gregor5e35d592010-09-14 23:59:36 +00003073
3074 case Sema::PCC_ParenthesizedExpression:
3075 return CodeCompletionContext::CCC_ParenthesizedExpression;
Douglas Gregor80039242011-02-15 20:33:25 +00003076
3077 case Sema::PCC_LocalDeclarationSpecifiers:
3078 return CodeCompletionContext::CCC_Type;
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003079 }
David Blaikie8a40f702012-01-17 06:56:22 +00003080
3081 llvm_unreachable("Invalid ParserCompletionContext!");
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003082}
3083
Douglas Gregorac322ec2010-08-27 21:18:54 +00003084/// \brief If we're in a C++ virtual member function, add completion results
3085/// that invoke the functions we override, since it's common to invoke the
3086/// overridden function as well as adding new functionality.
3087///
3088/// \param S The semantic analysis object for which we are generating results.
3089///
3090/// \param InContext This context in which the nested-name-specifier preceding
3091/// the code-completion point
3092static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
3093 ResultBuilder &Results) {
3094 // Look through blocks.
3095 DeclContext *CurContext = S.CurContext;
3096 while (isa<BlockDecl>(CurContext))
3097 CurContext = CurContext->getParent();
3098
3099
3100 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
3101 if (!Method || !Method->isVirtual())
3102 return;
3103
3104 // We need to have names for all of the parameters, if we're going to
3105 // generate a forwarding call.
Aaron Ballman43b68be2014-03-07 17:50:17 +00003106 for (auto P : Method->params())
3107 if (!P->getDeclName())
Douglas Gregorac322ec2010-08-27 21:18:54 +00003108 return;
Douglas Gregorac322ec2010-08-27 21:18:54 +00003109
Douglas Gregor75acd922011-09-27 23:30:47 +00003110 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
Douglas Gregorac322ec2010-08-27 21:18:54 +00003111 for (CXXMethodDecl::method_iterator M = Method->begin_overridden_methods(),
3112 MEnd = Method->end_overridden_methods();
3113 M != MEnd; ++M) {
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00003114 CodeCompletionBuilder Builder(Results.getAllocator(),
3115 Results.getCodeCompletionTUInfo());
Dmitri Gribenko6cfb1532013-02-14 13:53:30 +00003116 const CXXMethodDecl *Overridden = *M;
Douglas Gregorac322ec2010-08-27 21:18:54 +00003117 if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
3118 continue;
3119
3120 // If we need a nested-name-specifier, add one now.
3121 if (!InContext) {
3122 NestedNameSpecifier *NNS
3123 = getRequiredQualification(S.Context, CurContext,
3124 Overridden->getDeclContext());
3125 if (NNS) {
3126 std::string Str;
3127 llvm::raw_string_ostream OS(Str);
Douglas Gregor75acd922011-09-27 23:30:47 +00003128 NNS->print(OS, Policy);
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00003129 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
Douglas Gregorac322ec2010-08-27 21:18:54 +00003130 }
3131 } else if (!InContext->Equals(Overridden->getDeclContext()))
3132 continue;
3133
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00003134 Builder.AddTypedTextChunk(Results.getAllocator().CopyString(
Douglas Gregorb278aaf2011-02-01 19:23:04 +00003135 Overridden->getNameAsString()));
3136 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
Douglas Gregorac322ec2010-08-27 21:18:54 +00003137 bool FirstParam = true;
Aaron Ballman43b68be2014-03-07 17:50:17 +00003138 for (auto P : Method->params()) {
Douglas Gregorac322ec2010-08-27 21:18:54 +00003139 if (FirstParam)
3140 FirstParam = false;
3141 else
Douglas Gregorb278aaf2011-02-01 19:23:04 +00003142 Builder.AddChunk(CodeCompletionString::CK_Comma);
Douglas Gregorac322ec2010-08-27 21:18:54 +00003143
Aaron Ballman43b68be2014-03-07 17:50:17 +00003144 Builder.AddPlaceholderChunk(
3145 Results.getAllocator().CopyString(P->getIdentifier()->getName()));
Douglas Gregorac322ec2010-08-27 21:18:54 +00003146 }
Douglas Gregorb278aaf2011-02-01 19:23:04 +00003147 Builder.AddChunk(CodeCompletionString::CK_RightParen);
3148 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
Douglas Gregorac322ec2010-08-27 21:18:54 +00003149 CCP_SuperCompletion,
Douglas Gregor78254c82012-03-27 23:34:16 +00003150 CXCursor_CXXMethod,
3151 CXAvailability_Available,
3152 Overridden));
Douglas Gregorac322ec2010-08-27 21:18:54 +00003153 Results.Ignore(Overridden);
3154 }
3155}
3156
Douglas Gregor07f43572012-01-29 18:15:03 +00003157void Sema::CodeCompleteModuleImport(SourceLocation ImportLoc,
3158 ModuleIdPath Path) {
3159 typedef CodeCompletionResult Result;
3160 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00003161 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor07f43572012-01-29 18:15:03 +00003162 CodeCompletionContext::CCC_Other);
3163 Results.EnterNewScope();
3164
3165 CodeCompletionAllocator &Allocator = Results.getAllocator();
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00003166 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
Douglas Gregor07f43572012-01-29 18:15:03 +00003167 typedef CodeCompletionResult Result;
3168 if (Path.empty()) {
3169 // Enumerate all top-level modules.
Dmitri Gribenkof8579502013-01-12 19:30:44 +00003170 SmallVector<Module *, 8> Modules;
Douglas Gregor07f43572012-01-29 18:15:03 +00003171 PP.getHeaderSearchInfo().collectAllModules(Modules);
3172 for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
3173 Builder.AddTypedTextChunk(
3174 Builder.getAllocator().CopyString(Modules[I]->Name));
3175 Results.AddResult(Result(Builder.TakeString(),
3176 CCP_Declaration,
Argyrios Kyrtzidis345d05f2013-05-29 18:50:15 +00003177 CXCursor_ModuleImportDecl,
Douglas Gregor07f43572012-01-29 18:15:03 +00003178 Modules[I]->isAvailable()
3179 ? CXAvailability_Available
3180 : CXAvailability_NotAvailable));
3181 }
Daniel Jasper07e6c402013-08-05 20:26:17 +00003182 } else if (getLangOpts().Modules) {
Douglas Gregor07f43572012-01-29 18:15:03 +00003183 // Load the named module.
3184 Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path,
3185 Module::AllVisible,
3186 /*IsInclusionDirective=*/false);
3187 // Enumerate submodules.
3188 if (Mod) {
3189 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
3190 SubEnd = Mod->submodule_end();
3191 Sub != SubEnd; ++Sub) {
3192
3193 Builder.AddTypedTextChunk(
3194 Builder.getAllocator().CopyString((*Sub)->Name));
3195 Results.AddResult(Result(Builder.TakeString(),
3196 CCP_Declaration,
Argyrios Kyrtzidis345d05f2013-05-29 18:50:15 +00003197 CXCursor_ModuleImportDecl,
Douglas Gregor07f43572012-01-29 18:15:03 +00003198 (*Sub)->isAvailable()
3199 ? CXAvailability_Available
3200 : CXAvailability_NotAvailable));
3201 }
3202 }
3203 }
3204 Results.ExitScope();
3205 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3206 Results.data(),Results.size());
3207}
3208
Douglas Gregor504a6ae2010-01-10 23:08:15 +00003209void Sema::CodeCompleteOrdinaryName(Scope *S,
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003210 ParserCompletionContext CompletionContext) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00003211 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00003212 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor0ac41382010-09-23 23:01:17 +00003213 mapCodeCompletionContext(*this, CompletionContext));
Douglas Gregorac322ec2010-08-27 21:18:54 +00003214 Results.EnterNewScope();
Douglas Gregor50832e02010-09-20 22:39:41 +00003215
Douglas Gregor504a6ae2010-01-10 23:08:15 +00003216 // Determine how to filter results, e.g., so that the names of
3217 // values (functions, enumerators, function templates, etc.) are
3218 // only allowed where we can have an expression.
3219 switch (CompletionContext) {
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003220 case PCC_Namespace:
3221 case PCC_Class:
3222 case PCC_ObjCInterface:
3223 case PCC_ObjCImplementation:
3224 case PCC_ObjCInstanceVariableList:
3225 case PCC_Template:
3226 case PCC_MemberTemplate:
Douglas Gregorf02e5f32010-08-24 01:11:00 +00003227 case PCC_Type:
Douglas Gregor80039242011-02-15 20:33:25 +00003228 case PCC_LocalDeclarationSpecifiers:
Douglas Gregor504a6ae2010-01-10 23:08:15 +00003229 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
3230 break;
3231
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003232 case PCC_Statement:
Douglas Gregor5e35d592010-09-14 23:59:36 +00003233 case PCC_ParenthesizedExpression:
Douglas Gregor4d755e82010-08-24 23:58:17 +00003234 case PCC_Expression:
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003235 case PCC_ForInit:
3236 case PCC_Condition:
David Blaikiebbafb8a2012-03-11 07:00:24 +00003237 if (WantTypesInContext(CompletionContext, getLangOpts()))
Douglas Gregor70febae2010-05-28 00:49:12 +00003238 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3239 else
3240 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
Douglas Gregorac322ec2010-08-27 21:18:54 +00003241
David Blaikiebbafb8a2012-03-11 07:00:24 +00003242 if (getLangOpts().CPlusPlus)
Douglas Gregorac322ec2010-08-27 21:18:54 +00003243 MaybeAddOverrideCalls(*this, /*InContext=*/0, Results);
Douglas Gregor504a6ae2010-01-10 23:08:15 +00003244 break;
Douglas Gregor6da3db42010-05-25 05:58:43 +00003245
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003246 case PCC_RecoveryInFunction:
Douglas Gregor6da3db42010-05-25 05:58:43 +00003247 // Unfiltered
3248 break;
Douglas Gregor504a6ae2010-01-10 23:08:15 +00003249 }
3250
Douglas Gregor9be0ed42010-08-26 16:36:48 +00003251 // If we are in a C++ non-static member function, check the qualifiers on
3252 // the member function to filter/prioritize the results list.
3253 if (CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext))
3254 if (CurMethod->isInstance())
3255 Results.setObjectTypeQualifiers(
3256 Qualifiers::fromCVRMask(CurMethod->getTypeQualifiers()));
3257
Douglas Gregorc580c522010-01-14 01:09:38 +00003258 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor39982192010-08-15 06:18:01 +00003259 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3260 CodeCompleter->includeGlobals());
Douglas Gregor92253692009-12-07 09:54:55 +00003261
Douglas Gregorf98e6a22010-01-13 23:51:12 +00003262 AddOrdinaryNameResults(CompletionContext, S, *this, Results);
Douglas Gregor92253692009-12-07 09:54:55 +00003263 Results.ExitScope();
3264
Douglas Gregorce0e8562010-08-23 21:54:33 +00003265 switch (CompletionContext) {
Douglas Gregor5e35d592010-09-14 23:59:36 +00003266 case PCC_ParenthesizedExpression:
Douglas Gregorf02e5f32010-08-24 01:11:00 +00003267 case PCC_Expression:
3268 case PCC_Statement:
3269 case PCC_RecoveryInFunction:
3270 if (S->getFnParent())
David Blaikiebbafb8a2012-03-11 07:00:24 +00003271 AddPrettyFunctionResults(PP.getLangOpts(), Results);
Douglas Gregorf02e5f32010-08-24 01:11:00 +00003272 break;
3273
3274 case PCC_Namespace:
3275 case PCC_Class:
3276 case PCC_ObjCInterface:
3277 case PCC_ObjCImplementation:
3278 case PCC_ObjCInstanceVariableList:
3279 case PCC_Template:
3280 case PCC_MemberTemplate:
3281 case PCC_ForInit:
3282 case PCC_Condition:
3283 case PCC_Type:
Douglas Gregor80039242011-02-15 20:33:25 +00003284 case PCC_LocalDeclarationSpecifiers:
Douglas Gregorf02e5f32010-08-24 01:11:00 +00003285 break;
Douglas Gregorce0e8562010-08-23 21:54:33 +00003286 }
3287
Douglas Gregor9eb77012009-11-07 00:00:49 +00003288 if (CodeCompleter->includeMacros())
Douglas Gregor8cb17462012-10-09 16:01:50 +00003289 AddMacroResults(PP, Results, false);
Douglas Gregorce0e8562010-08-23 21:54:33 +00003290
Douglas Gregor50832e02010-09-20 22:39:41 +00003291 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003292 Results.data(),Results.size());
Douglas Gregor9d64c5e2009-09-21 20:51:25 +00003293}
3294
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00003295static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
3296 ParsedType Receiver,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00003297 ArrayRef<IdentifierInfo *> SelIdents,
Douglas Gregorf86e4da2010-09-20 23:34:21 +00003298 bool AtArgumentExpression,
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00003299 bool IsSuper,
3300 ResultBuilder &Results);
3301
3302void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
3303 bool AllowNonIdentifiers,
3304 bool AllowNestedNameSpecifiers) {
John McCall276321a2010-08-25 06:19:51 +00003305 typedef CodeCompletionResult Result;
Douglas Gregorb278aaf2011-02-01 19:23:04 +00003306 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00003307 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor0ac41382010-09-23 23:01:17 +00003308 AllowNestedNameSpecifiers
3309 ? CodeCompletionContext::CCC_PotentiallyQualifiedName
3310 : CodeCompletionContext::CCC_Name);
Douglas Gregorc49f5b22010-08-23 18:23:48 +00003311 Results.EnterNewScope();
3312
3313 // Type qualifiers can come after names.
3314 Results.AddResult(Result("const"));
3315 Results.AddResult(Result("volatile"));
David Blaikiebbafb8a2012-03-11 07:00:24 +00003316 if (getLangOpts().C99)
Douglas Gregorc49f5b22010-08-23 18:23:48 +00003317 Results.AddResult(Result("restrict"));
3318
David Blaikiebbafb8a2012-03-11 07:00:24 +00003319 if (getLangOpts().CPlusPlus) {
Douglas Gregorc49f5b22010-08-23 18:23:48 +00003320 if (AllowNonIdentifiers) {
3321 Results.AddResult(Result("operator"));
3322 }
3323
3324 // Add nested-name-specifiers.
3325 if (AllowNestedNameSpecifiers) {
3326 Results.allowNestedNameSpecifiers();
Douglas Gregor0ac41382010-09-23 23:01:17 +00003327 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
Douglas Gregorc49f5b22010-08-23 18:23:48 +00003328 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3329 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
3330 CodeCompleter->includeGlobals());
Douglas Gregor0ac41382010-09-23 23:01:17 +00003331 Results.setFilter(0);
Douglas Gregorc49f5b22010-08-23 18:23:48 +00003332 }
3333 }
3334 Results.ExitScope();
3335
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00003336 // If we're in a context where we might have an expression (rather than a
3337 // declaration), and what we've seen so far is an Objective-C type that could
3338 // be a receiver of a class message, this may be a class message send with
3339 // the initial opening bracket '[' missing. Add appropriate completions.
3340 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
Richard Smithb4a9e862013-04-12 22:46:28 +00003341 DS.getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier &&
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00003342 DS.getTypeSpecType() == DeclSpec::TST_typename &&
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00003343 DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified &&
3344 DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
Richard Smithb4a9e862013-04-12 22:46:28 +00003345 !DS.isTypeAltiVecVector() &&
3346 S &&
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00003347 (S->getFlags() & Scope::DeclScope) != 0 &&
3348 (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope |
3349 Scope::FunctionPrototypeScope |
3350 Scope::AtCatchScope)) == 0) {
3351 ParsedType T = DS.getRepAsType();
3352 if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00003353 AddClassMessageCompletions(*this, S, T, None, false, false, Results);
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00003354 }
3355
Douglas Gregor56ccce02010-08-24 04:59:56 +00003356 // Note that we intentionally suppress macro results here, since we do not
3357 // encourage using macros to produce the names of entities.
3358
Douglas Gregor0ac41382010-09-23 23:01:17 +00003359 HandleCodeCompleteResults(this, CodeCompleter,
3360 Results.getCompletionContext(),
Douglas Gregorc49f5b22010-08-23 18:23:48 +00003361 Results.data(), Results.size());
3362}
3363
Douglas Gregor68762e72010-08-23 21:17:50 +00003364struct Sema::CodeCompleteExpressionData {
3365 CodeCompleteExpressionData(QualType PreferredType = QualType())
3366 : PreferredType(PreferredType), IntegralConstantExpression(false),
3367 ObjCCollection(false) { }
3368
3369 QualType PreferredType;
3370 bool IntegralConstantExpression;
3371 bool ObjCCollection;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003372 SmallVector<Decl *, 4> IgnoreDecls;
Douglas Gregor68762e72010-08-23 21:17:50 +00003373};
3374
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003375/// \brief Perform code-completion in an expression context when we know what
3376/// type we're looking for.
Douglas Gregor68762e72010-08-23 21:17:50 +00003377void Sema::CodeCompleteExpression(Scope *S,
3378 const CodeCompleteExpressionData &Data) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00003379 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00003380 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00003381 CodeCompletionContext::CCC_Expression);
Douglas Gregor68762e72010-08-23 21:17:50 +00003382 if (Data.ObjCCollection)
3383 Results.setFilter(&ResultBuilder::IsObjCCollection);
3384 else if (Data.IntegralConstantExpression)
Douglas Gregor85b50632010-07-28 21:50:18 +00003385 Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
David Blaikiebbafb8a2012-03-11 07:00:24 +00003386 else if (WantTypesInContext(PCC_Expression, getLangOpts()))
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003387 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3388 else
3389 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
Douglas Gregor68762e72010-08-23 21:17:50 +00003390
3391 if (!Data.PreferredType.isNull())
3392 Results.setPreferredType(Data.PreferredType.getNonReferenceType());
3393
3394 // Ignore any declarations that we were told that we don't care about.
3395 for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
3396 Results.Ignore(Data.IgnoreDecls[I]);
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003397
3398 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor39982192010-08-15 06:18:01 +00003399 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3400 CodeCompleter->includeGlobals());
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003401
3402 Results.EnterNewScope();
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003403 AddOrdinaryNameResults(PCC_Expression, S, *this, Results);
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003404 Results.ExitScope();
3405
Douglas Gregor55b037b2010-07-08 20:55:51 +00003406 bool PreferredTypeIsPointer = false;
Douglas Gregor68762e72010-08-23 21:17:50 +00003407 if (!Data.PreferredType.isNull())
3408 PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType()
3409 || Data.PreferredType->isMemberPointerType()
3410 || Data.PreferredType->isBlockPointerType();
Douglas Gregor55b037b2010-07-08 20:55:51 +00003411
Douglas Gregorce0e8562010-08-23 21:54:33 +00003412 if (S->getFnParent() &&
3413 !Data.ObjCCollection &&
3414 !Data.IntegralConstantExpression)
David Blaikiebbafb8a2012-03-11 07:00:24 +00003415 AddPrettyFunctionResults(PP.getLangOpts(), Results);
Douglas Gregorce0e8562010-08-23 21:54:33 +00003416
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003417 if (CodeCompleter->includeMacros())
Douglas Gregor8cb17462012-10-09 16:01:50 +00003418 AddMacroResults(PP, Results, false, PreferredTypeIsPointer);
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003419 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor68762e72010-08-23 21:17:50 +00003420 CodeCompletionContext(CodeCompletionContext::CCC_Expression,
3421 Data.PreferredType),
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003422 Results.data(),Results.size());
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003423}
3424
Douglas Gregoreda7e542010-09-18 01:28:11 +00003425void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E) {
3426 if (E.isInvalid())
3427 CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction);
David Blaikiebbafb8a2012-03-11 07:00:24 +00003428 else if (getLangOpts().ObjC1)
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00003429 CodeCompleteObjCInstanceMessage(S, E.take(), None, false);
Douglas Gregored0b69d2010-09-15 16:23:04 +00003430}
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003431
Douglas Gregorb888acf2010-12-09 23:01:55 +00003432/// \brief The set of properties that have already been added, referenced by
3433/// property name.
3434typedef llvm::SmallPtrSet<IdentifierInfo*, 16> AddedPropertiesSet;
3435
Douglas Gregor9b4f3702012-06-12 13:44:08 +00003436/// \brief Retrieve the container definition, if any?
3437static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) {
3438 if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
3439 if (Interface->hasDefinition())
3440 return Interface->getDefinition();
3441
3442 return Interface;
3443 }
3444
3445 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3446 if (Protocol->hasDefinition())
3447 return Protocol->getDefinition();
3448
3449 return Protocol;
3450 }
3451 return Container;
3452}
3453
3454static void AddObjCProperties(ObjCContainerDecl *Container,
Douglas Gregor5d649882009-11-18 22:32:06 +00003455 bool AllowCategories,
Douglas Gregor95147142011-05-05 15:50:42 +00003456 bool AllowNullaryMethods,
Douglas Gregor9291bad2009-11-18 01:29:26 +00003457 DeclContext *CurContext,
Douglas Gregorb888acf2010-12-09 23:01:55 +00003458 AddedPropertiesSet &AddedProperties,
Douglas Gregor9291bad2009-11-18 01:29:26 +00003459 ResultBuilder &Results) {
John McCall276321a2010-08-25 06:19:51 +00003460 typedef CodeCompletionResult Result;
Douglas Gregor9291bad2009-11-18 01:29:26 +00003461
Douglas Gregor9b4f3702012-06-12 13:44:08 +00003462 // Retrieve the definition.
3463 Container = getContainerDef(Container);
3464
Douglas Gregor9291bad2009-11-18 01:29:26 +00003465 // Add properties in this container.
Aaron Ballmand174edf2014-03-13 19:11:50 +00003466 for (const auto *P : Container->properties())
Douglas Gregorb888acf2010-12-09 23:01:55 +00003467 if (AddedProperties.insert(P->getIdentifier()))
Aaron Ballmandc4bea42014-03-13 18:47:37 +00003468 Results.MaybeAddResult(Result(P, Results.getBasePriority(P), 0),
Douglas Gregor0a0e2b32013-01-31 04:52:16 +00003469 CurContext);
Douglas Gregor9291bad2009-11-18 01:29:26 +00003470
Douglas Gregor95147142011-05-05 15:50:42 +00003471 // Add nullary methods
3472 if (AllowNullaryMethods) {
3473 ASTContext &Context = Container->getASTContext();
Douglas Gregor75acd922011-09-27 23:30:47 +00003474 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
Aaron Ballmanaff18c02014-03-13 19:03:34 +00003475 for (auto *M : Container->methods()) {
Douglas Gregor95147142011-05-05 15:50:42 +00003476 if (M->getSelector().isUnarySelector())
3477 if (IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0))
3478 if (AddedProperties.insert(Name)) {
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00003479 CodeCompletionBuilder Builder(Results.getAllocator(),
3480 Results.getCodeCompletionTUInfo());
Aaron Ballmanaff18c02014-03-13 19:03:34 +00003481 AddResultTypeChunk(Context, Policy, M, Builder);
Douglas Gregor95147142011-05-05 15:50:42 +00003482 Builder.AddTypedTextChunk(
3483 Results.getAllocator().CopyString(Name->getName()));
3484
Aaron Ballmanaff18c02014-03-13 19:03:34 +00003485 Results.MaybeAddResult(Result(Builder.TakeString(), M,
Douglas Gregor78254c82012-03-27 23:34:16 +00003486 CCP_MemberDeclaration + CCD_MethodAsProperty),
Douglas Gregor95147142011-05-05 15:50:42 +00003487 CurContext);
3488 }
3489 }
3490 }
3491
3492
Douglas Gregor9291bad2009-11-18 01:29:26 +00003493 // Add properties in referenced protocols.
3494 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
Aaron Ballman0f6e64d2014-03-13 22:58:06 +00003495 for (auto *P : Protocol->protocols())
3496 AddObjCProperties(P, AllowCategories, AllowNullaryMethods, CurContext,
Douglas Gregor95147142011-05-05 15:50:42 +00003497 AddedProperties, Results);
Douglas Gregor9291bad2009-11-18 01:29:26 +00003498 } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){
Douglas Gregor5d649882009-11-18 22:32:06 +00003499 if (AllowCategories) {
3500 // Look through categories.
Aaron Ballman15063e12014-03-13 21:35:02 +00003501 for (auto *Cat : IFace->known_categories())
3502 AddObjCProperties(Cat, AllowCategories, AllowNullaryMethods, CurContext,
3503 AddedProperties, Results);
Douglas Gregor5d649882009-11-18 22:32:06 +00003504 }
Aaron Ballman15063e12014-03-13 21:35:02 +00003505
Douglas Gregor9291bad2009-11-18 01:29:26 +00003506 // Look through protocols.
Aaron Ballmana9f49e32014-03-13 20:55:22 +00003507 for (auto *I : IFace->all_referenced_protocols())
3508 AddObjCProperties(I, AllowCategories, AllowNullaryMethods, CurContext,
Douglas Gregor95147142011-05-05 15:50:42 +00003509 AddedProperties, Results);
Douglas Gregor9291bad2009-11-18 01:29:26 +00003510
3511 // Look in the superclass.
3512 if (IFace->getSuperClass())
Douglas Gregor95147142011-05-05 15:50:42 +00003513 AddObjCProperties(IFace->getSuperClass(), AllowCategories,
3514 AllowNullaryMethods, CurContext,
Douglas Gregorb888acf2010-12-09 23:01:55 +00003515 AddedProperties, Results);
Douglas Gregor9291bad2009-11-18 01:29:26 +00003516 } else if (const ObjCCategoryDecl *Category
3517 = dyn_cast<ObjCCategoryDecl>(Container)) {
3518 // Look through protocols.
Aaron Ballman19a41762014-03-14 12:55:57 +00003519 for (auto *P : Category->protocols())
3520 AddObjCProperties(P, AllowCategories, AllowNullaryMethods, CurContext,
Douglas Gregor95147142011-05-05 15:50:42 +00003521 AddedProperties, Results);
Douglas Gregor9291bad2009-11-18 01:29:26 +00003522 }
3523}
3524
Douglas Gregor1cc88a92012-01-23 15:59:30 +00003525void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
Douglas Gregor2436e712009-09-17 21:32:03 +00003526 SourceLocation OpLoc,
3527 bool IsArrow) {
Douglas Gregor1cc88a92012-01-23 15:59:30 +00003528 if (!Base || !CodeCompleter)
Douglas Gregor2436e712009-09-17 21:32:03 +00003529 return;
3530
Douglas Gregor1cc88a92012-01-23 15:59:30 +00003531 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
3532 if (ConvertedBase.isInvalid())
3533 return;
3534 Base = ConvertedBase.get();
3535
John McCall276321a2010-08-25 06:19:51 +00003536 typedef CodeCompletionResult Result;
Douglas Gregor3545ff42009-09-21 16:56:56 +00003537
Douglas Gregor2436e712009-09-17 21:32:03 +00003538 QualType BaseType = Base->getType();
Douglas Gregor3545ff42009-09-21 16:56:56 +00003539
3540 if (IsArrow) {
3541 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
3542 BaseType = Ptr->getPointeeType();
3543 else if (BaseType->isObjCObjectPointerType())
Douglas Gregor9be0ed42010-08-26 16:36:48 +00003544 /*Do nothing*/ ;
Douglas Gregor3545ff42009-09-21 16:56:56 +00003545 else
3546 return;
3547 }
3548
Douglas Gregor21325842011-07-07 16:03:39 +00003549 enum CodeCompletionContext::Kind contextKind;
3550
3551 if (IsArrow) {
3552 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess;
3553 }
3554 else {
3555 if (BaseType->isObjCObjectPointerType() ||
3556 BaseType->isObjCObjectOrInterfaceType()) {
3557 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
3558 }
3559 else {
3560 contextKind = CodeCompletionContext::CCC_DotMemberAccess;
3561 }
3562 }
3563
Douglas Gregorb278aaf2011-02-01 19:23:04 +00003564 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00003565 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor21325842011-07-07 16:03:39 +00003566 CodeCompletionContext(contextKind,
Douglas Gregor0ac41382010-09-23 23:01:17 +00003567 BaseType),
3568 &ResultBuilder::IsMember);
Douglas Gregor9291bad2009-11-18 01:29:26 +00003569 Results.EnterNewScope();
3570 if (const RecordType *Record = BaseType->getAs<RecordType>()) {
Douglas Gregor9be0ed42010-08-26 16:36:48 +00003571 // Indicate that we are performing a member access, and the cv-qualifiers
3572 // for the base object type.
3573 Results.setObjectTypeQualifiers(BaseType.getQualifiers());
3574
Douglas Gregor9291bad2009-11-18 01:29:26 +00003575 // Access to a C/C++ class, struct, or union.
Douglas Gregor6ae4c522010-01-14 03:21:49 +00003576 Results.allowNestedNameSpecifiers();
Douglas Gregor09bbc652010-01-14 15:47:35 +00003577 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor39982192010-08-15 06:18:01 +00003578 LookupVisibleDecls(Record->getDecl(), LookupMemberName, Consumer,
3579 CodeCompleter->includeGlobals());
Daniel Dunbar242ea9a2009-11-13 08:58:20 +00003580
David Blaikiebbafb8a2012-03-11 07:00:24 +00003581 if (getLangOpts().CPlusPlus) {
Douglas Gregor9291bad2009-11-18 01:29:26 +00003582 if (!Results.empty()) {
3583 // The "template" keyword can follow "->" or "." in the grammar.
3584 // However, we only want to suggest the template keyword if something
3585 // is dependent.
3586 bool IsDependent = BaseType->isDependentType();
3587 if (!IsDependent) {
3588 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
Ted Kremenekc37877d2013-10-08 17:08:03 +00003589 if (DeclContext *Ctx = DepScope->getEntity()) {
Douglas Gregor9291bad2009-11-18 01:29:26 +00003590 IsDependent = Ctx->isDependentContext();
3591 break;
3592 }
3593 }
Daniel Dunbar242ea9a2009-11-13 08:58:20 +00003594
Douglas Gregor9291bad2009-11-18 01:29:26 +00003595 if (IsDependent)
Douglas Gregor78a21012010-01-14 16:01:26 +00003596 Results.AddResult(Result("template"));
Daniel Dunbar242ea9a2009-11-13 08:58:20 +00003597 }
Daniel Dunbar242ea9a2009-11-13 08:58:20 +00003598 }
Douglas Gregor9291bad2009-11-18 01:29:26 +00003599 } else if (!IsArrow && BaseType->getAsObjCInterfacePointerType()) {
3600 // Objective-C property reference.
Douglas Gregorb888acf2010-12-09 23:01:55 +00003601 AddedPropertiesSet AddedProperties;
Douglas Gregor9291bad2009-11-18 01:29:26 +00003602
3603 // Add property results based on our interface.
3604 const ObjCObjectPointerType *ObjCPtr
3605 = BaseType->getAsObjCInterfacePointerType();
3606 assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
Douglas Gregor95147142011-05-05 15:50:42 +00003607 AddObjCProperties(ObjCPtr->getInterfaceDecl(), true,
3608 /*AllowNullaryMethods=*/true, CurContext,
Douglas Gregorb888acf2010-12-09 23:01:55 +00003609 AddedProperties, Results);
Douglas Gregor9291bad2009-11-18 01:29:26 +00003610
3611 // Add properties from the protocols in a qualified interface.
Aaron Ballman83731462014-03-17 16:14:00 +00003612 for (auto *I : ObjCPtr->quals())
3613 AddObjCProperties(I, true, /*AllowNullaryMethods=*/true, CurContext,
Douglas Gregor95147142011-05-05 15:50:42 +00003614 AddedProperties, Results);
Douglas Gregor9291bad2009-11-18 01:29:26 +00003615 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
John McCall8b07ec22010-05-15 11:32:37 +00003616 (!IsArrow && BaseType->isObjCObjectType())) {
Douglas Gregor9291bad2009-11-18 01:29:26 +00003617 // Objective-C instance variable access.
3618 ObjCInterfaceDecl *Class = 0;
3619 if (const ObjCObjectPointerType *ObjCPtr
3620 = BaseType->getAs<ObjCObjectPointerType>())
3621 Class = ObjCPtr->getInterfaceDecl();
3622 else
John McCall8b07ec22010-05-15 11:32:37 +00003623 Class = BaseType->getAs<ObjCObjectType>()->getInterface();
Douglas Gregor9291bad2009-11-18 01:29:26 +00003624
3625 // Add all ivars from this class and its superclasses.
Douglas Gregor2b8162b2010-01-14 16:08:12 +00003626 if (Class) {
3627 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3628 Results.setFilter(&ResultBuilder::IsObjCIvar);
Douglas Gregor39982192010-08-15 06:18:01 +00003629 LookupVisibleDecls(Class, LookupMemberName, Consumer,
3630 CodeCompleter->includeGlobals());
Douglas Gregor9291bad2009-11-18 01:29:26 +00003631 }
Douglas Gregor3545ff42009-09-21 16:56:56 +00003632 }
Douglas Gregor9291bad2009-11-18 01:29:26 +00003633
3634 // FIXME: How do we cope with isa?
3635
3636 Results.ExitScope();
Daniel Dunbar242ea9a2009-11-13 08:58:20 +00003637
Daniel Dunbar242ea9a2009-11-13 08:58:20 +00003638 // Hand off the results found for code completion.
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003639 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor0ac41382010-09-23 23:01:17 +00003640 Results.getCompletionContext(),
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003641 Results.data(),Results.size());
Douglas Gregor2436e712009-09-17 21:32:03 +00003642}
3643
Douglas Gregorf45b0cf2009-09-18 15:37:17 +00003644void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
3645 if (!CodeCompleter)
3646 return;
3647
Douglas Gregor3545ff42009-09-21 16:56:56 +00003648 ResultBuilder::LookupFilter Filter = 0;
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003649 enum CodeCompletionContext::Kind ContextKind
3650 = CodeCompletionContext::CCC_Other;
Douglas Gregorf45b0cf2009-09-18 15:37:17 +00003651 switch ((DeclSpec::TST)TagSpec) {
3652 case DeclSpec::TST_enum:
Douglas Gregor3545ff42009-09-21 16:56:56 +00003653 Filter = &ResultBuilder::IsEnum;
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003654 ContextKind = CodeCompletionContext::CCC_EnumTag;
Douglas Gregorf45b0cf2009-09-18 15:37:17 +00003655 break;
3656
3657 case DeclSpec::TST_union:
Douglas Gregor3545ff42009-09-21 16:56:56 +00003658 Filter = &ResultBuilder::IsUnion;
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003659 ContextKind = CodeCompletionContext::CCC_UnionTag;
Douglas Gregorf45b0cf2009-09-18 15:37:17 +00003660 break;
3661
3662 case DeclSpec::TST_struct:
Douglas Gregorf45b0cf2009-09-18 15:37:17 +00003663 case DeclSpec::TST_class:
Joao Matosdc86f942012-08-31 18:45:21 +00003664 case DeclSpec::TST_interface:
Douglas Gregor3545ff42009-09-21 16:56:56 +00003665 Filter = &ResultBuilder::IsClassOrStruct;
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003666 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag;
Douglas Gregorf45b0cf2009-09-18 15:37:17 +00003667 break;
3668
3669 default:
David Blaikie83d382b2011-09-23 05:06:16 +00003670 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
Douglas Gregorf45b0cf2009-09-18 15:37:17 +00003671 }
Douglas Gregor3545ff42009-09-21 16:56:56 +00003672
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00003673 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3674 CodeCompleter->getCodeCompletionTUInfo(), ContextKind);
Douglas Gregora6e2edc2010-01-14 03:27:13 +00003675 CodeCompletionDeclConsumer Consumer(Results, CurContext);
John McCalle87beb22010-04-23 18:46:30 +00003676
3677 // First pass: look for tags.
3678 Results.setFilter(Filter);
Douglas Gregor39982192010-08-15 06:18:01 +00003679 LookupVisibleDecls(S, LookupTagName, Consumer,
3680 CodeCompleter->includeGlobals());
John McCalle87beb22010-04-23 18:46:30 +00003681
Douglas Gregor39982192010-08-15 06:18:01 +00003682 if (CodeCompleter->includeGlobals()) {
3683 // Second pass: look for nested name specifiers.
3684 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
3685 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer);
3686 }
Douglas Gregor3545ff42009-09-21 16:56:56 +00003687
Douglas Gregor0ac41382010-09-23 23:01:17 +00003688 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003689 Results.data(),Results.size());
Douglas Gregorf45b0cf2009-09-18 15:37:17 +00003690}
3691
Douglas Gregor28c78432010-08-27 17:35:51 +00003692void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00003693 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00003694 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00003695 CodeCompletionContext::CCC_TypeQualifiers);
Douglas Gregor28c78432010-08-27 17:35:51 +00003696 Results.EnterNewScope();
3697 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
3698 Results.AddResult("const");
3699 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
3700 Results.AddResult("volatile");
David Blaikiebbafb8a2012-03-11 07:00:24 +00003701 if (getLangOpts().C99 &&
Douglas Gregor28c78432010-08-27 17:35:51 +00003702 !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
3703 Results.AddResult("restrict");
Richard Smith8e1ac332013-03-28 01:55:44 +00003704 if (getLangOpts().C11 &&
3705 !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic))
3706 Results.AddResult("_Atomic");
Douglas Gregor28c78432010-08-27 17:35:51 +00003707 Results.ExitScope();
3708 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor0ac41382010-09-23 23:01:17 +00003709 Results.getCompletionContext(),
Douglas Gregor28c78432010-08-27 17:35:51 +00003710 Results.data(), Results.size());
3711}
3712
Douglas Gregord328d572009-09-21 18:10:23 +00003713void Sema::CodeCompleteCase(Scope *S) {
John McCallaab3e412010-08-25 08:40:02 +00003714 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
Douglas Gregord328d572009-09-21 18:10:23 +00003715 return;
John McCall5939b162011-08-06 07:30:58 +00003716
John McCallaab3e412010-08-25 08:40:02 +00003717 SwitchStmt *Switch = getCurFunction()->SwitchStack.back();
John McCall5939b162011-08-06 07:30:58 +00003718 QualType type = Switch->getCond()->IgnoreImplicit()->getType();
3719 if (!type->isEnumeralType()) {
3720 CodeCompleteExpressionData Data(type);
Douglas Gregor68762e72010-08-23 21:17:50 +00003721 Data.IntegralConstantExpression = true;
3722 CodeCompleteExpression(S, Data);
Douglas Gregord328d572009-09-21 18:10:23 +00003723 return;
Douglas Gregor85b50632010-07-28 21:50:18 +00003724 }
Douglas Gregord328d572009-09-21 18:10:23 +00003725
3726 // Code-complete the cases of a switch statement over an enumeration type
3727 // by providing the list of
John McCall5939b162011-08-06 07:30:58 +00003728 EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
Douglas Gregor9b4f3702012-06-12 13:44:08 +00003729 if (EnumDecl *Def = Enum->getDefinition())
3730 Enum = Def;
Douglas Gregord328d572009-09-21 18:10:23 +00003731
3732 // Determine which enumerators we have already seen in the switch statement.
3733 // FIXME: Ideally, we would also be able to look *past* the code-completion
3734 // token, in case we are code-completing in the middle of the switch and not
3735 // at the end. However, we aren't able to do so at the moment.
3736 llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen;
Douglas Gregorf2510672009-09-21 19:57:38 +00003737 NestedNameSpecifier *Qualifier = 0;
Douglas Gregord328d572009-09-21 18:10:23 +00003738 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
3739 SC = SC->getNextSwitchCase()) {
3740 CaseStmt *Case = dyn_cast<CaseStmt>(SC);
3741 if (!Case)
3742 continue;
3743
3744 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
3745 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal))
3746 if (EnumConstantDecl *Enumerator
3747 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
3748 // We look into the AST of the case statement to determine which
3749 // enumerator was named. Alternatively, we could compute the value of
3750 // the integral constant expression, then compare it against the
3751 // values of each enumerator. However, value-based approach would not
3752 // work as well with C++ templates where enumerators declared within a
3753 // template are type- and value-dependent.
3754 EnumeratorsSeen.insert(Enumerator);
3755
Douglas Gregorf2510672009-09-21 19:57:38 +00003756 // If this is a qualified-id, keep track of the nested-name-specifier
3757 // so that we can reproduce it as part of code completion, e.g.,
Douglas Gregord328d572009-09-21 18:10:23 +00003758 //
3759 // switch (TagD.getKind()) {
3760 // case TagDecl::TK_enum:
3761 // break;
3762 // case XXX
3763 //
Douglas Gregorf2510672009-09-21 19:57:38 +00003764 // At the XXX, our completions are TagDecl::TK_union,
Douglas Gregord328d572009-09-21 18:10:23 +00003765 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
3766 // TK_struct, and TK_class.
Douglas Gregor4bd90e52009-10-23 18:54:35 +00003767 Qualifier = DRE->getQualifier();
Douglas Gregord328d572009-09-21 18:10:23 +00003768 }
3769 }
3770
David Blaikiebbafb8a2012-03-11 07:00:24 +00003771 if (getLangOpts().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) {
Douglas Gregorf2510672009-09-21 19:57:38 +00003772 // If there are no prior enumerators in C++, check whether we have to
3773 // qualify the names of the enumerators that we suggest, because they
3774 // may not be visible in this scope.
Douglas Gregord3cebdb2012-02-01 05:02:47 +00003775 Qualifier = getRequiredQualification(Context, CurContext, Enum);
Douglas Gregorf2510672009-09-21 19:57:38 +00003776 }
3777
Douglas Gregord328d572009-09-21 18:10:23 +00003778 // Add any enumerators that have not yet been mentioned.
Douglas Gregorb278aaf2011-02-01 19:23:04 +00003779 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00003780 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00003781 CodeCompletionContext::CCC_Expression);
Douglas Gregord328d572009-09-21 18:10:23 +00003782 Results.EnterNewScope();
Aaron Ballman23a6dcb2014-03-08 18:45:14 +00003783 for (auto *E : Enum->enumerators()) {
3784 if (EnumeratorsSeen.count(E))
Douglas Gregord328d572009-09-21 18:10:23 +00003785 continue;
3786
Aaron Ballman23a6dcb2014-03-08 18:45:14 +00003787 CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);
Douglas Gregor3a69eaf2011-02-18 23:30:37 +00003788 Results.AddResult(R, CurContext, 0, false);
Douglas Gregord328d572009-09-21 18:10:23 +00003789 }
3790 Results.ExitScope();
Douglas Gregor285560922010-04-06 20:02:15 +00003791
Douglas Gregor21325842011-07-07 16:03:39 +00003792 //We need to make sure we're setting the right context,
3793 //so only say we include macros if the code completer says we do
3794 enum CodeCompletionContext::Kind kind = CodeCompletionContext::CCC_Other;
3795 if (CodeCompleter->includeMacros()) {
Douglas Gregor8cb17462012-10-09 16:01:50 +00003796 AddMacroResults(PP, Results, false);
Douglas Gregor21325842011-07-07 16:03:39 +00003797 kind = CodeCompletionContext::CCC_OtherWithMacros;
3798 }
3799
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003800 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor21325842011-07-07 16:03:39 +00003801 kind,
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003802 Results.data(),Results.size());
Douglas Gregord328d572009-09-21 18:10:23 +00003803}
3804
Robert Wilhelm16e94b92013-08-09 18:02:13 +00003805static bool anyNullArguments(ArrayRef<Expr *> Args) {
Ahmed Charlesb24b9aa2012-02-25 11:00:22 +00003806 if (Args.size() && !Args.data())
Douglas Gregor6ed3eb82010-05-30 06:10:08 +00003807 return true;
Ahmed Charlesb24b9aa2012-02-25 11:00:22 +00003808
3809 for (unsigned I = 0; I != Args.size(); ++I)
Douglas Gregor6ed3eb82010-05-30 06:10:08 +00003810 if (!Args[I])
3811 return true;
Ahmed Charlesb24b9aa2012-02-25 11:00:22 +00003812
Douglas Gregor6ed3eb82010-05-30 06:10:08 +00003813 return false;
3814}
3815
Robert Wilhelm16e94b92013-08-09 18:02:13 +00003816void Sema::CodeCompleteCall(Scope *S, Expr *FnIn, ArrayRef<Expr *> Args) {
Douglas Gregorcabea402009-09-22 15:41:20 +00003817 if (!CodeCompleter)
3818 return;
Douglas Gregor3ef59522009-12-11 19:06:04 +00003819
3820 // When we're code-completing for a call, we fall back to ordinary
3821 // name code-completion whenever we can't produce specific
3822 // results. We may want to revisit this strategy in the future,
3823 // e.g., by merging the two kinds of results.
3824
Douglas Gregorcabea402009-09-22 15:41:20 +00003825 Expr *Fn = (Expr *)FnIn;
Douglas Gregor3ef59522009-12-11 19:06:04 +00003826
Douglas Gregorcabea402009-09-22 15:41:20 +00003827 // Ignore type-dependent call expressions entirely.
Ahmed Charlesb24b9aa2012-02-25 11:00:22 +00003828 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
3829 Expr::hasAnyTypeDependentArguments(Args)) {
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003830 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregorcabea402009-09-22 15:41:20 +00003831 return;
Douglas Gregor3ef59522009-12-11 19:06:04 +00003832 }
Douglas Gregorcabea402009-09-22 15:41:20 +00003833
John McCall57500772009-12-16 12:17:52 +00003834 // Build an overload candidate set based on the functions we find.
John McCallbc077cf2010-02-08 23:07:23 +00003835 SourceLocation Loc = Fn->getExprLoc();
Richard Smith100b24a2014-04-17 01:52:14 +00003836 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
John McCall57500772009-12-16 12:17:52 +00003837
Douglas Gregorcabea402009-09-22 15:41:20 +00003838 // FIXME: What if we're calling something that isn't a function declaration?
3839 // FIXME: What if we're calling a pseudo-destructor?
3840 // FIXME: What if we're calling a member function?
3841
Douglas Gregorff59f672010-01-21 15:46:19 +00003842 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003843 SmallVector<ResultCandidate, 8> Results;
Douglas Gregorff59f672010-01-21 15:46:19 +00003844
John McCall57500772009-12-16 12:17:52 +00003845 Expr *NakedFn = Fn->IgnoreParenCasts();
3846 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
Ahmed Charlesb24b9aa2012-02-25 11:00:22 +00003847 AddOverloadedCallCandidates(ULE, Args, CandidateSet,
John McCall57500772009-12-16 12:17:52 +00003848 /*PartialOverloading=*/ true);
3849 else if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(NakedFn)) {
3850 FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
Douglas Gregorff59f672010-01-21 15:46:19 +00003851 if (FDecl) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00003852 if (!getLangOpts().CPlusPlus ||
Douglas Gregor6ed3eb82010-05-30 06:10:08 +00003853 !FDecl->getType()->getAs<FunctionProtoType>())
Douglas Gregorff59f672010-01-21 15:46:19 +00003854 Results.push_back(ResultCandidate(FDecl));
3855 else
John McCallb89836b2010-01-26 01:37:31 +00003856 // FIXME: access?
Ahmed Charlesb24b9aa2012-02-25 11:00:22 +00003857 AddOverloadCandidate(FDecl, DeclAccessPair::make(FDecl, AS_none), Args,
3858 CandidateSet, false, /*PartialOverloading*/true);
Douglas Gregorff59f672010-01-21 15:46:19 +00003859 }
John McCall57500772009-12-16 12:17:52 +00003860 }
Douglas Gregorcabea402009-09-22 15:41:20 +00003861
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003862 QualType ParamType;
3863
Douglas Gregorff59f672010-01-21 15:46:19 +00003864 if (!CandidateSet.empty()) {
3865 // Sort the overload candidate set by placing the best overloads first.
Benjamin Kramerbbdd7642014-03-01 14:48:57 +00003866 std::stable_sort(
3867 CandidateSet.begin(), CandidateSet.end(),
3868 [&](const OverloadCandidate &X, const OverloadCandidate &Y) {
3869 return isBetterOverloadCandidate(*this, X, Y, Loc);
3870 });
3871
Douglas Gregorff59f672010-01-21 15:46:19 +00003872 // Add the remaining viable overload candidates as code-completion reslults.
3873 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(),
3874 CandEnd = CandidateSet.end();
3875 Cand != CandEnd; ++Cand) {
3876 if (Cand->Viable)
3877 Results.push_back(ResultCandidate(Cand->Function));
3878 }
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003879
3880 // From the viable candidates, try to determine the type of this parameter.
3881 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
3882 if (const FunctionType *FType = Results[I].getFunctionType())
3883 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FType))
Alp Toker9cacbab2014-01-20 20:26:09 +00003884 if (Args.size() < Proto->getNumParams()) {
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003885 if (ParamType.isNull())
Alp Toker9cacbab2014-01-20 20:26:09 +00003886 ParamType = Proto->getParamType(Args.size());
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003887 else if (!Context.hasSameUnqualifiedType(
Alp Toker9cacbab2014-01-20 20:26:09 +00003888 ParamType.getNonReferenceType(),
3889 Proto->getParamType(Args.size())
3890 .getNonReferenceType())) {
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003891 ParamType = QualType();
3892 break;
3893 }
3894 }
3895 }
3896 } else {
3897 // Try to determine the parameter type from the type of the expression
3898 // being called.
3899 QualType FunctionType = Fn->getType();
3900 if (const PointerType *Ptr = FunctionType->getAs<PointerType>())
3901 FunctionType = Ptr->getPointeeType();
3902 else if (const BlockPointerType *BlockPtr
3903 = FunctionType->getAs<BlockPointerType>())
3904 FunctionType = BlockPtr->getPointeeType();
3905 else if (const MemberPointerType *MemPtr
3906 = FunctionType->getAs<MemberPointerType>())
3907 FunctionType = MemPtr->getPointeeType();
3908
3909 if (const FunctionProtoType *Proto
3910 = FunctionType->getAs<FunctionProtoType>()) {
Alp Toker9cacbab2014-01-20 20:26:09 +00003911 if (Args.size() < Proto->getNumParams())
3912 ParamType = Proto->getParamType(Args.size());
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003913 }
Douglas Gregorcabea402009-09-22 15:41:20 +00003914 }
Douglas Gregor3ef59522009-12-11 19:06:04 +00003915
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003916 if (ParamType.isNull())
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003917 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003918 else
3919 CodeCompleteExpression(S, ParamType);
3920
Douglas Gregorc01890e2010-04-06 20:19:47 +00003921 if (!Results.empty())
Ahmed Charlesb24b9aa2012-02-25 11:00:22 +00003922 CodeCompleter->ProcessOverloadCandidates(*this, Args.size(), Results.data(),
Douglas Gregor3ef59522009-12-11 19:06:04 +00003923 Results.size());
Douglas Gregorcabea402009-09-22 15:41:20 +00003924}
3925
John McCall48871652010-08-21 09:40:31 +00003926void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
3927 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003928 if (!VD) {
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003929 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003930 return;
3931 }
3932
3933 CodeCompleteExpression(S, VD->getType());
3934}
3935
3936void Sema::CodeCompleteReturn(Scope *S) {
3937 QualType ResultType;
3938 if (isa<BlockDecl>(CurContext)) {
3939 if (BlockScopeInfo *BSI = getCurBlock())
3940 ResultType = BSI->ReturnType;
3941 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext))
Alp Toker314cc812014-01-25 16:55:45 +00003942 ResultType = Function->getReturnType();
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003943 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext))
Alp Toker314cc812014-01-25 16:55:45 +00003944 ResultType = Method->getReturnType();
3945
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003946 if (ResultType.isNull())
Douglas Gregor00c37ef2010-08-11 21:23:17 +00003947 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor7aa6b222010-05-30 01:49:25 +00003948 else
3949 CodeCompleteExpression(S, ResultType);
3950}
3951
Douglas Gregor4ecb7202011-07-30 08:36:53 +00003952void Sema::CodeCompleteAfterIf(Scope *S) {
Douglas Gregor4ecb7202011-07-30 08:36:53 +00003953 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00003954 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor4ecb7202011-07-30 08:36:53 +00003955 mapCodeCompletionContext(*this, PCC_Statement));
3956 Results.setFilter(&ResultBuilder::IsOrdinaryName);
3957 Results.EnterNewScope();
3958
3959 CodeCompletionDeclConsumer Consumer(Results, CurContext);
3960 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3961 CodeCompleter->includeGlobals());
3962
3963 AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
3964
3965 // "else" block
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00003966 CodeCompletionBuilder Builder(Results.getAllocator(),
3967 Results.getCodeCompletionTUInfo());
Douglas Gregor4ecb7202011-07-30 08:36:53 +00003968 Builder.AddTypedTextChunk("else");
Douglas Gregor3a5d6c22012-02-16 17:49:04 +00003969 if (Results.includeCodePatterns()) {
3970 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3971 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
3972 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3973 Builder.AddPlaceholderChunk("statements");
3974 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3975 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
3976 }
Douglas Gregor4ecb7202011-07-30 08:36:53 +00003977 Results.AddResult(Builder.TakeString());
3978
3979 // "else if" block
3980 Builder.AddTypedTextChunk("else");
3981 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3982 Builder.AddTextChunk("if");
3983 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3984 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
David Blaikiebbafb8a2012-03-11 07:00:24 +00003985 if (getLangOpts().CPlusPlus)
Douglas Gregor4ecb7202011-07-30 08:36:53 +00003986 Builder.AddPlaceholderChunk("condition");
3987 else
3988 Builder.AddPlaceholderChunk("expression");
3989 Builder.AddChunk(CodeCompletionString::CK_RightParen);
Douglas Gregor3a5d6c22012-02-16 17:49:04 +00003990 if (Results.includeCodePatterns()) {
3991 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3992 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
3993 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3994 Builder.AddPlaceholderChunk("statements");
3995 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
3996 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
3997 }
Douglas Gregor4ecb7202011-07-30 08:36:53 +00003998 Results.AddResult(Builder.TakeString());
3999
4000 Results.ExitScope();
4001
4002 if (S->getFnParent())
David Blaikiebbafb8a2012-03-11 07:00:24 +00004003 AddPrettyFunctionResults(PP.getLangOpts(), Results);
Douglas Gregor4ecb7202011-07-30 08:36:53 +00004004
4005 if (CodeCompleter->includeMacros())
Douglas Gregor8cb17462012-10-09 16:01:50 +00004006 AddMacroResults(PP, Results, false);
Douglas Gregor4ecb7202011-07-30 08:36:53 +00004007
4008 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4009 Results.data(),Results.size());
4010}
4011
Richard Trieu2bd04012011-09-09 02:00:50 +00004012void Sema::CodeCompleteAssignmentRHS(Scope *S, Expr *LHS) {
Douglas Gregor7aa6b222010-05-30 01:49:25 +00004013 if (LHS)
4014 CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType());
4015 else
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004016 CodeCompleteOrdinaryName(S, PCC_Expression);
Douglas Gregor7aa6b222010-05-30 01:49:25 +00004017}
4018
Jeffrey Yasskinc76498d2010-04-08 16:38:48 +00004019void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
Douglas Gregor2436e712009-09-17 21:32:03 +00004020 bool EnteringContext) {
4021 if (!SS.getScopeRep() || !CodeCompleter)
4022 return;
4023
Douglas Gregor3545ff42009-09-21 16:56:56 +00004024 DeclContext *Ctx = computeDeclContext(SS, EnteringContext);
4025 if (!Ctx)
4026 return;
Douglas Gregor800f2f02009-12-11 18:28:39 +00004027
4028 // Try to instantiate any non-dependent declaration contexts before
4029 // we look in them.
John McCall0b66eb32010-05-01 00:40:08 +00004030 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
Douglas Gregor800f2f02009-12-11 18:28:39 +00004031 return;
4032
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004033 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004034 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004035 CodeCompletionContext::CCC_Name);
Douglas Gregorac322ec2010-08-27 21:18:54 +00004036 Results.EnterNewScope();
Douglas Gregor0ac41382010-09-23 23:01:17 +00004037
Douglas Gregor3545ff42009-09-21 16:56:56 +00004038 // The "template" keyword can follow "::" in the grammar, but only
4039 // put it into the grammar if the nested-name-specifier is dependent.
Aaron Ballman4a979672014-01-03 13:56:08 +00004040 NestedNameSpecifier *NNS = SS.getScopeRep();
Douglas Gregor3545ff42009-09-21 16:56:56 +00004041 if (!Results.empty() && NNS->isDependent())
Douglas Gregor78a21012010-01-14 16:01:26 +00004042 Results.AddResult("template");
Douglas Gregorac322ec2010-08-27 21:18:54 +00004043
4044 // Add calls to overridden virtual functions, if there are any.
4045 //
4046 // FIXME: This isn't wonderful, because we don't know whether we're actually
4047 // in a context that permits expressions. This is a general issue with
4048 // qualified-id completions.
4049 if (!EnteringContext)
4050 MaybeAddOverrideCalls(*this, Ctx, Results);
4051 Results.ExitScope();
Douglas Gregor3545ff42009-09-21 16:56:56 +00004052
Douglas Gregorac322ec2010-08-27 21:18:54 +00004053 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4054 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer);
4055
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004056 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregorc1679ec2011-07-25 17:48:11 +00004057 Results.getCompletionContext(),
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004058 Results.data(),Results.size());
Douglas Gregor2436e712009-09-17 21:32:03 +00004059}
Douglas Gregor7e90c6d2009-09-18 19:03:04 +00004060
4061void Sema::CodeCompleteUsing(Scope *S) {
4062 if (!CodeCompleter)
4063 return;
4064
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004065 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004066 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor0ac41382010-09-23 23:01:17 +00004067 CodeCompletionContext::CCC_PotentiallyQualifiedName,
4068 &ResultBuilder::IsNestedNameSpecifier);
Douglas Gregor64b12b52009-09-22 23:31:26 +00004069 Results.EnterNewScope();
Douglas Gregor3545ff42009-09-21 16:56:56 +00004070
4071 // If we aren't in class scope, we could see the "namespace" keyword.
4072 if (!S->isClassScope())
John McCall276321a2010-08-25 06:19:51 +00004073 Results.AddResult(CodeCompletionResult("namespace"));
Douglas Gregor3545ff42009-09-21 16:56:56 +00004074
4075 // After "using", we can see anything that would start a
4076 // nested-name-specifier.
Douglas Gregora6e2edc2010-01-14 03:27:13 +00004077 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor39982192010-08-15 06:18:01 +00004078 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4079 CodeCompleter->includeGlobals());
Douglas Gregor64b12b52009-09-22 23:31:26 +00004080 Results.ExitScope();
Douglas Gregor3545ff42009-09-21 16:56:56 +00004081
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004082 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor0ac41382010-09-23 23:01:17 +00004083 CodeCompletionContext::CCC_PotentiallyQualifiedName,
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004084 Results.data(),Results.size());
Douglas Gregor7e90c6d2009-09-18 19:03:04 +00004085}
4086
4087void Sema::CodeCompleteUsingDirective(Scope *S) {
4088 if (!CodeCompleter)
4089 return;
4090
Douglas Gregor3545ff42009-09-21 16:56:56 +00004091 // After "using namespace", we expect to see a namespace name or namespace
4092 // alias.
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004093 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004094 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004095 CodeCompletionContext::CCC_Namespace,
Douglas Gregor0ac41382010-09-23 23:01:17 +00004096 &ResultBuilder::IsNamespaceOrAlias);
Douglas Gregor64b12b52009-09-22 23:31:26 +00004097 Results.EnterNewScope();
Douglas Gregora6e2edc2010-01-14 03:27:13 +00004098 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor39982192010-08-15 06:18:01 +00004099 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4100 CodeCompleter->includeGlobals());
Douglas Gregor64b12b52009-09-22 23:31:26 +00004101 Results.ExitScope();
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004102 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor39982192010-08-15 06:18:01 +00004103 CodeCompletionContext::CCC_Namespace,
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004104 Results.data(),Results.size());
Douglas Gregor7e90c6d2009-09-18 19:03:04 +00004105}
4106
4107void Sema::CodeCompleteNamespaceDecl(Scope *S) {
4108 if (!CodeCompleter)
4109 return;
4110
Ted Kremenekc37877d2013-10-08 17:08:03 +00004111 DeclContext *Ctx = S->getEntity();
Douglas Gregor3545ff42009-09-21 16:56:56 +00004112 if (!S->getParent())
4113 Ctx = Context.getTranslationUnitDecl();
4114
Douglas Gregor0ac41382010-09-23 23:01:17 +00004115 bool SuppressedGlobalResults
4116 = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
4117
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004118 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004119 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor0ac41382010-09-23 23:01:17 +00004120 SuppressedGlobalResults
4121 ? CodeCompletionContext::CCC_Namespace
4122 : CodeCompletionContext::CCC_Other,
4123 &ResultBuilder::IsNamespace);
4124
4125 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
Douglas Gregor3545ff42009-09-21 16:56:56 +00004126 // We only want to see those namespaces that have already been defined
4127 // within this scope, because its likely that the user is creating an
4128 // extended namespace declaration. Keep track of the most recent
4129 // definition of each namespace.
4130 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
4131 for (DeclContext::specific_decl_iterator<NamespaceDecl>
4132 NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end());
4133 NS != NSEnd; ++NS)
David Blaikie40ed2972012-06-06 20:45:41 +00004134 OrigToLatest[NS->getOriginalNamespace()] = *NS;
Douglas Gregor3545ff42009-09-21 16:56:56 +00004135
4136 // Add the most recent definition (or extended definition) of each
4137 // namespace to the list of results.
Douglas Gregor64b12b52009-09-22 23:31:26 +00004138 Results.EnterNewScope();
Douglas Gregor3545ff42009-09-21 16:56:56 +00004139 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
Douglas Gregor78254c82012-03-27 23:34:16 +00004140 NS = OrigToLatest.begin(),
4141 NSEnd = OrigToLatest.end();
Douglas Gregor3545ff42009-09-21 16:56:56 +00004142 NS != NSEnd; ++NS)
Douglas Gregor0a0e2b32013-01-31 04:52:16 +00004143 Results.AddResult(CodeCompletionResult(
4144 NS->second, Results.getBasePriority(NS->second), 0),
Douglas Gregorfc59ce12010-01-14 16:14:35 +00004145 CurContext, 0, false);
Douglas Gregor64b12b52009-09-22 23:31:26 +00004146 Results.ExitScope();
Douglas Gregor3545ff42009-09-21 16:56:56 +00004147 }
4148
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004149 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor0ac41382010-09-23 23:01:17 +00004150 Results.getCompletionContext(),
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004151 Results.data(),Results.size());
Douglas Gregor7e90c6d2009-09-18 19:03:04 +00004152}
4153
4154void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) {
4155 if (!CodeCompleter)
4156 return;
4157
Douglas Gregor3545ff42009-09-21 16:56:56 +00004158 // After "namespace", we expect to see a namespace or alias.
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004159 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004160 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004161 CodeCompletionContext::CCC_Namespace,
Douglas Gregor0ac41382010-09-23 23:01:17 +00004162 &ResultBuilder::IsNamespaceOrAlias);
Douglas Gregora6e2edc2010-01-14 03:27:13 +00004163 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor39982192010-08-15 06:18:01 +00004164 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4165 CodeCompleter->includeGlobals());
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004166 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor0ac41382010-09-23 23:01:17 +00004167 Results.getCompletionContext(),
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004168 Results.data(),Results.size());
Douglas Gregor7e90c6d2009-09-18 19:03:04 +00004169}
4170
Douglas Gregorc811ede2009-09-18 20:05:18 +00004171void Sema::CodeCompleteOperatorName(Scope *S) {
4172 if (!CodeCompleter)
4173 return;
Douglas Gregor3545ff42009-09-21 16:56:56 +00004174
John McCall276321a2010-08-25 06:19:51 +00004175 typedef CodeCompletionResult Result;
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004176 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004177 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004178 CodeCompletionContext::CCC_Type,
Douglas Gregor0ac41382010-09-23 23:01:17 +00004179 &ResultBuilder::IsType);
Douglas Gregor64b12b52009-09-22 23:31:26 +00004180 Results.EnterNewScope();
Douglas Gregorc811ede2009-09-18 20:05:18 +00004181
Douglas Gregor3545ff42009-09-21 16:56:56 +00004182 // Add the names of overloadable operators.
4183#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4184 if (std::strcmp(Spelling, "?")) \
Douglas Gregor78a21012010-01-14 16:01:26 +00004185 Results.AddResult(Result(Spelling));
Douglas Gregor3545ff42009-09-21 16:56:56 +00004186#include "clang/Basic/OperatorKinds.def"
4187
4188 // Add any type names visible from the current scope
Douglas Gregor6ae4c522010-01-14 03:21:49 +00004189 Results.allowNestedNameSpecifiers();
Douglas Gregora6e2edc2010-01-14 03:27:13 +00004190 CodeCompletionDeclConsumer Consumer(Results, CurContext);
Douglas Gregor39982192010-08-15 06:18:01 +00004191 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4192 CodeCompleter->includeGlobals());
Douglas Gregor3545ff42009-09-21 16:56:56 +00004193
4194 // Add any type specifiers
David Blaikiebbafb8a2012-03-11 07:00:24 +00004195 AddTypeSpecifierResults(getLangOpts(), Results);
Douglas Gregor64b12b52009-09-22 23:31:26 +00004196 Results.ExitScope();
Douglas Gregor3545ff42009-09-21 16:56:56 +00004197
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004198 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor39982192010-08-15 06:18:01 +00004199 CodeCompletionContext::CCC_Type,
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004200 Results.data(),Results.size());
Douglas Gregorc811ede2009-09-18 20:05:18 +00004201}
Douglas Gregor7e90c6d2009-09-18 19:03:04 +00004202
Dmitri Gribenko27cb3dd02013-06-23 22:58:02 +00004203void Sema::CodeCompleteConstructorInitializer(
4204 Decl *ConstructorD,
4205 ArrayRef <CXXCtorInitializer *> Initializers) {
Douglas Gregor75acd922011-09-27 23:30:47 +00004206 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
Douglas Gregoreaeeca92010-08-28 00:00:50 +00004207 CXXConstructorDecl *Constructor
4208 = static_cast<CXXConstructorDecl *>(ConstructorD);
4209 if (!Constructor)
4210 return;
4211
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004212 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004213 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor0ac41382010-09-23 23:01:17 +00004214 CodeCompletionContext::CCC_PotentiallyQualifiedName);
Douglas Gregoreaeeca92010-08-28 00:00:50 +00004215 Results.EnterNewScope();
4216
4217 // Fill in any already-initialized fields or base classes.
4218 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
4219 llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
Dmitri Gribenko27cb3dd02013-06-23 22:58:02 +00004220 for (unsigned I = 0, E = Initializers.size(); I != E; ++I) {
Douglas Gregoreaeeca92010-08-28 00:00:50 +00004221 if (Initializers[I]->isBaseInitializer())
4222 InitializedBases.insert(
4223 Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
4224 else
Francois Pichetd583da02010-12-04 09:14:42 +00004225 InitializedFields.insert(cast<FieldDecl>(
4226 Initializers[I]->getAnyMember()));
Douglas Gregoreaeeca92010-08-28 00:00:50 +00004227 }
4228
4229 // Add completions for base classes.
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004230 CodeCompletionBuilder Builder(Results.getAllocator(),
4231 Results.getCodeCompletionTUInfo());
Dmitri Gribenko27cb3dd02013-06-23 22:58:02 +00004232 bool SawLastInitializer = Initializers.empty();
Douglas Gregoreaeeca92010-08-28 00:00:50 +00004233 CXXRecordDecl *ClassDecl = Constructor->getParent();
Aaron Ballman574705e2014-03-13 15:41:46 +00004234 for (const auto &Base : ClassDecl->bases()) {
4235 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))) {
Douglas Gregor99129ef2010-08-29 19:27:27 +00004236 SawLastInitializer
Dmitri Gribenko27cb3dd02013-06-23 22:58:02 +00004237 = !Initializers.empty() &&
4238 Initializers.back()->isBaseInitializer() &&
Aaron Ballman574705e2014-03-13 15:41:46 +00004239 Context.hasSameUnqualifiedType(Base.getType(),
Dmitri Gribenko27cb3dd02013-06-23 22:58:02 +00004240 QualType(Initializers.back()->getBaseClass(), 0));
Douglas Gregoreaeeca92010-08-28 00:00:50 +00004241 continue;
Douglas Gregor99129ef2010-08-29 19:27:27 +00004242 }
Douglas Gregoreaeeca92010-08-28 00:00:50 +00004243
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004244 Builder.AddTypedTextChunk(
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00004245 Results.getAllocator().CopyString(
Aaron Ballman574705e2014-03-13 15:41:46 +00004246 Base.getType().getAsString(Policy)));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004247 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4248 Builder.AddPlaceholderChunk("args");
4249 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4250 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
Douglas Gregor99129ef2010-08-29 19:27:27 +00004251 SawLastInitializer? CCP_NextInitializer
4252 : CCP_MemberDeclaration));
4253 SawLastInitializer = false;
Douglas Gregoreaeeca92010-08-28 00:00:50 +00004254 }
4255
4256 // Add completions for virtual base classes.
Aaron Ballman445a9392014-03-13 16:15:17 +00004257 for (const auto &Base : ClassDecl->vbases()) {
4258 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))) {
Douglas Gregor99129ef2010-08-29 19:27:27 +00004259 SawLastInitializer
Dmitri Gribenko27cb3dd02013-06-23 22:58:02 +00004260 = !Initializers.empty() &&
4261 Initializers.back()->isBaseInitializer() &&
Aaron Ballman445a9392014-03-13 16:15:17 +00004262 Context.hasSameUnqualifiedType(Base.getType(),
Dmitri Gribenko27cb3dd02013-06-23 22:58:02 +00004263 QualType(Initializers.back()->getBaseClass(), 0));
Douglas Gregoreaeeca92010-08-28 00:00:50 +00004264 continue;
Douglas Gregor99129ef2010-08-29 19:27:27 +00004265 }
Douglas Gregoreaeeca92010-08-28 00:00:50 +00004266
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004267 Builder.AddTypedTextChunk(
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00004268 Builder.getAllocator().CopyString(
Aaron Ballman445a9392014-03-13 16:15:17 +00004269 Base.getType().getAsString(Policy)));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004270 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4271 Builder.AddPlaceholderChunk("args");
4272 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4273 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
Douglas Gregor99129ef2010-08-29 19:27:27 +00004274 SawLastInitializer? CCP_NextInitializer
4275 : CCP_MemberDeclaration));
4276 SawLastInitializer = false;
Douglas Gregoreaeeca92010-08-28 00:00:50 +00004277 }
4278
4279 // Add completions for members.
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00004280 for (auto *Field : ClassDecl->fields()) {
Douglas Gregor99129ef2010-08-29 19:27:27 +00004281 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))) {
4282 SawLastInitializer
Dmitri Gribenko27cb3dd02013-06-23 22:58:02 +00004283 = !Initializers.empty() &&
4284 Initializers.back()->isAnyMemberInitializer() &&
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00004285 Initializers.back()->getAnyMember() == Field;
Douglas Gregoreaeeca92010-08-28 00:00:50 +00004286 continue;
Douglas Gregor99129ef2010-08-29 19:27:27 +00004287 }
Douglas Gregoreaeeca92010-08-28 00:00:50 +00004288
4289 if (!Field->getDeclName())
4290 continue;
4291
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00004292 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004293 Field->getIdentifier()->getName()));
4294 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4295 Builder.AddPlaceholderChunk("args");
4296 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4297 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
Douglas Gregor99129ef2010-08-29 19:27:27 +00004298 SawLastInitializer? CCP_NextInitializer
Douglas Gregorf3af3112010-09-09 21:42:20 +00004299 : CCP_MemberDeclaration,
Douglas Gregor78254c82012-03-27 23:34:16 +00004300 CXCursor_MemberRef,
4301 CXAvailability_Available,
Aaron Ballmane8a8bae2014-03-08 20:12:42 +00004302 Field));
Douglas Gregor99129ef2010-08-29 19:27:27 +00004303 SawLastInitializer = false;
Douglas Gregoreaeeca92010-08-28 00:00:50 +00004304 }
4305 Results.ExitScope();
4306
Douglas Gregor0ac41382010-09-23 23:01:17 +00004307 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregoreaeeca92010-08-28 00:00:50 +00004308 Results.data(), Results.size());
4309}
4310
Douglas Gregord8c61782012-02-15 15:34:24 +00004311/// \brief Determine whether this scope denotes a namespace.
4312static bool isNamespaceScope(Scope *S) {
Ted Kremenekc37877d2013-10-08 17:08:03 +00004313 DeclContext *DC = S->getEntity();
Douglas Gregord8c61782012-02-15 15:34:24 +00004314 if (!DC)
4315 return false;
4316
4317 return DC->isFileContext();
4318}
4319
4320void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
4321 bool AfterAmpersand) {
4322 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004323 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregord8c61782012-02-15 15:34:24 +00004324 CodeCompletionContext::CCC_Other);
4325 Results.EnterNewScope();
4326
4327 // Note what has already been captured.
4328 llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
4329 bool IncludedThis = false;
Benjamin Kramerf3ca26982014-05-10 16:31:55 +00004330 for (const auto &C : Intro.Captures) {
4331 if (C.Kind == LCK_This) {
Douglas Gregord8c61782012-02-15 15:34:24 +00004332 IncludedThis = true;
4333 continue;
4334 }
4335
Benjamin Kramerf3ca26982014-05-10 16:31:55 +00004336 Known.insert(C.Id);
Douglas Gregord8c61782012-02-15 15:34:24 +00004337 }
4338
4339 // Look for other capturable variables.
4340 for (; S && !isNamespaceScope(S); S = S->getParent()) {
Aaron Ballman35c54952014-03-17 16:55:25 +00004341 for (const auto *D : S->decls()) {
4342 const auto *Var = dyn_cast<VarDecl>(D);
Douglas Gregord8c61782012-02-15 15:34:24 +00004343 if (!Var ||
4344 !Var->hasLocalStorage() ||
4345 Var->hasAttr<BlocksAttr>())
4346 continue;
4347
4348 if (Known.insert(Var->getIdentifier()))
Douglas Gregor0a0e2b32013-01-31 04:52:16 +00004349 Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration),
4350 CurContext, 0, false);
Douglas Gregord8c61782012-02-15 15:34:24 +00004351 }
4352 }
4353
4354 // Add 'this', if it would be valid.
4355 if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
4356 addThisCompletion(*this, Results);
4357
4358 Results.ExitScope();
4359
4360 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4361 Results.data(), Results.size());
4362}
4363
James Dennett596e4752012-06-14 03:11:41 +00004364/// Macro that optionally prepends an "@" to the string literal passed in via
4365/// Keyword, depending on whether NeedAt is true or false.
4366#define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) ((NeedAt)? "@" Keyword : Keyword)
4367
Douglas Gregorf98e6a22010-01-13 23:51:12 +00004368static void AddObjCImplementationResults(const LangOptions &LangOpts,
Douglas Gregorf1934162010-01-13 21:24:21 +00004369 ResultBuilder &Results,
4370 bool NeedAt) {
John McCall276321a2010-08-25 06:19:51 +00004371 typedef CodeCompletionResult Result;
Douglas Gregorf1934162010-01-13 21:24:21 +00004372 // Since we have an implementation, we can end it.
James Dennett596e4752012-06-14 03:11:41 +00004373 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
Douglas Gregorf1934162010-01-13 21:24:21 +00004374
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004375 CodeCompletionBuilder Builder(Results.getAllocator(),
4376 Results.getCodeCompletionTUInfo());
Douglas Gregorf1934162010-01-13 21:24:21 +00004377 if (LangOpts.ObjC2) {
4378 // @dynamic
James Dennett596e4752012-06-14 03:11:41 +00004379 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"dynamic"));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004380 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4381 Builder.AddPlaceholderChunk("property");
4382 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf1934162010-01-13 21:24:21 +00004383
4384 // @synthesize
James Dennett596e4752012-06-14 03:11:41 +00004385 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synthesize"));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004386 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4387 Builder.AddPlaceholderChunk("property");
4388 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf1934162010-01-13 21:24:21 +00004389 }
4390}
4391
Douglas Gregorf98e6a22010-01-13 23:51:12 +00004392static void AddObjCInterfaceResults(const LangOptions &LangOpts,
Douglas Gregorf1934162010-01-13 21:24:21 +00004393 ResultBuilder &Results,
4394 bool NeedAt) {
John McCall276321a2010-08-25 06:19:51 +00004395 typedef CodeCompletionResult Result;
Douglas Gregorf1934162010-01-13 21:24:21 +00004396
4397 // Since we have an interface or protocol, we can end it.
James Dennett596e4752012-06-14 03:11:41 +00004398 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
Douglas Gregorf1934162010-01-13 21:24:21 +00004399
4400 if (LangOpts.ObjC2) {
4401 // @property
James Dennett596e4752012-06-14 03:11:41 +00004402 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"property")));
Douglas Gregorf1934162010-01-13 21:24:21 +00004403
4404 // @required
James Dennett596e4752012-06-14 03:11:41 +00004405 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"required")));
Douglas Gregorf1934162010-01-13 21:24:21 +00004406
4407 // @optional
James Dennett596e4752012-06-14 03:11:41 +00004408 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"optional")));
Douglas Gregorf1934162010-01-13 21:24:21 +00004409 }
4410}
4411
Douglas Gregorf98e6a22010-01-13 23:51:12 +00004412static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
John McCall276321a2010-08-25 06:19:51 +00004413 typedef CodeCompletionResult Result;
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004414 CodeCompletionBuilder Builder(Results.getAllocator(),
4415 Results.getCodeCompletionTUInfo());
Douglas Gregorf1934162010-01-13 21:24:21 +00004416
4417 // @class name ;
James Dennett596e4752012-06-14 03:11:41 +00004418 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"class"));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004419 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4420 Builder.AddPlaceholderChunk("name");
4421 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf1934162010-01-13 21:24:21 +00004422
Douglas Gregorf4c33342010-05-28 00:22:41 +00004423 if (Results.includeCodePatterns()) {
4424 // @interface name
4425 // FIXME: Could introduce the whole pattern, including superclasses and
4426 // such.
James Dennett596e4752012-06-14 03:11:41 +00004427 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"interface"));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004428 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4429 Builder.AddPlaceholderChunk("class");
4430 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf1934162010-01-13 21:24:21 +00004431
Douglas Gregorf4c33342010-05-28 00:22:41 +00004432 // @protocol name
James Dennett596e4752012-06-14 03:11:41 +00004433 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004434 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4435 Builder.AddPlaceholderChunk("protocol");
4436 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf4c33342010-05-28 00:22:41 +00004437
4438 // @implementation name
James Dennett596e4752012-06-14 03:11:41 +00004439 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"implementation"));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004440 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4441 Builder.AddPlaceholderChunk("class");
4442 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf4c33342010-05-28 00:22:41 +00004443 }
Douglas Gregorf1934162010-01-13 21:24:21 +00004444
4445 // @compatibility_alias name
James Dennett596e4752012-06-14 03:11:41 +00004446 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"compatibility_alias"));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004447 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4448 Builder.AddPlaceholderChunk("alias");
4449 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4450 Builder.AddPlaceholderChunk("class");
4451 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregor61e36812013-03-07 23:26:24 +00004452
4453 if (Results.getSema().getLangOpts().Modules) {
4454 // @import name
4455 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import"));
4456 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4457 Builder.AddPlaceholderChunk("module");
4458 Results.AddResult(Result(Builder.TakeString()));
4459 }
Douglas Gregorf1934162010-01-13 21:24:21 +00004460}
4461
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00004462void Sema::CodeCompleteObjCAtDirective(Scope *S) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004463 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004464 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004465 CodeCompletionContext::CCC_Other);
Douglas Gregorf48706c2009-12-07 09:27:33 +00004466 Results.EnterNewScope();
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00004467 if (isa<ObjCImplDecl>(CurContext))
David Blaikiebbafb8a2012-03-11 07:00:24 +00004468 AddObjCImplementationResults(getLangOpts(), Results, false);
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00004469 else if (CurContext->isObjCContainer())
David Blaikiebbafb8a2012-03-11 07:00:24 +00004470 AddObjCInterfaceResults(getLangOpts(), Results, false);
Douglas Gregorf1934162010-01-13 21:24:21 +00004471 else
Douglas Gregorf98e6a22010-01-13 23:51:12 +00004472 AddObjCTopLevelResults(Results, false);
Douglas Gregorf48706c2009-12-07 09:27:33 +00004473 Results.ExitScope();
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004474 HandleCodeCompleteResults(this, CodeCompleter,
4475 CodeCompletionContext::CCC_Other,
4476 Results.data(),Results.size());
Douglas Gregorf48706c2009-12-07 09:27:33 +00004477}
4478
Douglas Gregorf98e6a22010-01-13 23:51:12 +00004479static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
John McCall276321a2010-08-25 06:19:51 +00004480 typedef CodeCompletionResult Result;
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004481 CodeCompletionBuilder Builder(Results.getAllocator(),
4482 Results.getCodeCompletionTUInfo());
Douglas Gregorbc7c5e42009-12-07 09:51:25 +00004483
4484 // @encode ( type-name )
Douglas Gregore5c79d52011-10-18 21:20:17 +00004485 const char *EncodeType = "char[]";
David Blaikiebbafb8a2012-03-11 07:00:24 +00004486 if (Results.getSema().getLangOpts().CPlusPlus ||
4487 Results.getSema().getLangOpts().ConstStrings)
Jordan Rose9da05852012-06-15 18:19:56 +00004488 EncodeType = "const char[]";
Douglas Gregore5c79d52011-10-18 21:20:17 +00004489 Builder.AddResultTypeChunk(EncodeType);
James Dennett596e4752012-06-14 03:11:41 +00004490 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"encode"));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004491 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4492 Builder.AddPlaceholderChunk("type-name");
4493 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4494 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorbc7c5e42009-12-07 09:51:25 +00004495
4496 // @protocol ( protocol-name )
Douglas Gregore5c79d52011-10-18 21:20:17 +00004497 Builder.AddResultTypeChunk("Protocol *");
James Dennett596e4752012-06-14 03:11:41 +00004498 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004499 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4500 Builder.AddPlaceholderChunk("protocol-name");
4501 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4502 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorbc7c5e42009-12-07 09:51:25 +00004503
4504 // @selector ( selector )
Douglas Gregore5c79d52011-10-18 21:20:17 +00004505 Builder.AddResultTypeChunk("SEL");
James Dennett596e4752012-06-14 03:11:41 +00004506 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"selector"));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004507 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4508 Builder.AddPlaceholderChunk("selector");
4509 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4510 Results.AddResult(Result(Builder.TakeString()));
Jordan Rose9da05852012-06-15 18:19:56 +00004511
4512 // @"string"
4513 Builder.AddResultTypeChunk("NSString *");
4514 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"\""));
4515 Builder.AddPlaceholderChunk("string");
4516 Builder.AddTextChunk("\"");
4517 Results.AddResult(Result(Builder.TakeString()));
4518
Douglas Gregor951de302012-07-17 23:24:47 +00004519 // @[objects, ...]
Jordan Rose9da05852012-06-15 18:19:56 +00004520 Builder.AddResultTypeChunk("NSArray *");
James Dennett596e4752012-06-14 03:11:41 +00004521 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"["));
Ted Kremeneke65b0862012-03-06 20:05:56 +00004522 Builder.AddPlaceholderChunk("objects, ...");
Ted Kremeneke65b0862012-03-06 20:05:56 +00004523 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
4524 Results.AddResult(Result(Builder.TakeString()));
4525
Douglas Gregor951de302012-07-17 23:24:47 +00004526 // @{key : object, ...}
Jordan Rose9da05852012-06-15 18:19:56 +00004527 Builder.AddResultTypeChunk("NSDictionary *");
James Dennett596e4752012-06-14 03:11:41 +00004528 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"{"));
Ted Kremeneke65b0862012-03-06 20:05:56 +00004529 Builder.AddPlaceholderChunk("key");
Ted Kremeneke65b0862012-03-06 20:05:56 +00004530 Builder.AddChunk(CodeCompletionString::CK_Colon);
4531 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4532 Builder.AddPlaceholderChunk("object, ...");
Ted Kremeneke65b0862012-03-06 20:05:56 +00004533 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4534 Results.AddResult(Result(Builder.TakeString()));
Jordan Rose9da05852012-06-15 18:19:56 +00004535
Douglas Gregor951de302012-07-17 23:24:47 +00004536 // @(expression)
Jordan Rose9da05852012-06-15 18:19:56 +00004537 Builder.AddResultTypeChunk("id");
4538 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "("));
Jordan Rose9da05852012-06-15 18:19:56 +00004539 Builder.AddPlaceholderChunk("expression");
Jordan Rose9da05852012-06-15 18:19:56 +00004540 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4541 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorbc7c5e42009-12-07 09:51:25 +00004542}
4543
Douglas Gregorf98e6a22010-01-13 23:51:12 +00004544static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
John McCall276321a2010-08-25 06:19:51 +00004545 typedef CodeCompletionResult Result;
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004546 CodeCompletionBuilder Builder(Results.getAllocator(),
4547 Results.getCodeCompletionTUInfo());
Douglas Gregorf1934162010-01-13 21:24:21 +00004548
Douglas Gregorf4c33342010-05-28 00:22:41 +00004549 if (Results.includeCodePatterns()) {
4550 // @try { statements } @catch ( declaration ) { statements } @finally
4551 // { statements }
James Dennett596e4752012-06-14 03:11:41 +00004552 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"try"));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004553 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4554 Builder.AddPlaceholderChunk("statements");
4555 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4556 Builder.AddTextChunk("@catch");
4557 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4558 Builder.AddPlaceholderChunk("parameter");
4559 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4560 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4561 Builder.AddPlaceholderChunk("statements");
4562 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4563 Builder.AddTextChunk("@finally");
4564 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4565 Builder.AddPlaceholderChunk("statements");
4566 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4567 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf4c33342010-05-28 00:22:41 +00004568 }
Douglas Gregorf1934162010-01-13 21:24:21 +00004569
Douglas Gregorbc7c5e42009-12-07 09:51:25 +00004570 // @throw
James Dennett596e4752012-06-14 03:11:41 +00004571 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"throw"));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004572 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4573 Builder.AddPlaceholderChunk("expression");
4574 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf1934162010-01-13 21:24:21 +00004575
Douglas Gregorf4c33342010-05-28 00:22:41 +00004576 if (Results.includeCodePatterns()) {
4577 // @synchronized ( expression ) { statements }
James Dennett596e4752012-06-14 03:11:41 +00004578 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synchronized"));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004579 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4580 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4581 Builder.AddPlaceholderChunk("expression");
4582 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4583 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4584 Builder.AddPlaceholderChunk("statements");
4585 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4586 Results.AddResult(Result(Builder.TakeString()));
Douglas Gregorf4c33342010-05-28 00:22:41 +00004587 }
Douglas Gregorf1934162010-01-13 21:24:21 +00004588}
Douglas Gregorbc7c5e42009-12-07 09:51:25 +00004589
Douglas Gregorf98e6a22010-01-13 23:51:12 +00004590static void AddObjCVisibilityResults(const LangOptions &LangOpts,
Douglas Gregor48d46252010-01-13 21:54:15 +00004591 ResultBuilder &Results,
4592 bool NeedAt) {
John McCall276321a2010-08-25 06:19:51 +00004593 typedef CodeCompletionResult Result;
James Dennett596e4752012-06-14 03:11:41 +00004594 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"private")));
4595 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"protected")));
4596 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"public")));
Douglas Gregor48d46252010-01-13 21:54:15 +00004597 if (LangOpts.ObjC2)
James Dennett596e4752012-06-14 03:11:41 +00004598 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"package")));
Douglas Gregor48d46252010-01-13 21:54:15 +00004599}
4600
4601void Sema::CodeCompleteObjCAtVisibility(Scope *S) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004602 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004603 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004604 CodeCompletionContext::CCC_Other);
Douglas Gregor48d46252010-01-13 21:54:15 +00004605 Results.EnterNewScope();
David Blaikiebbafb8a2012-03-11 07:00:24 +00004606 AddObjCVisibilityResults(getLangOpts(), Results, false);
Douglas Gregor48d46252010-01-13 21:54:15 +00004607 Results.ExitScope();
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004608 HandleCodeCompleteResults(this, CodeCompleter,
4609 CodeCompletionContext::CCC_Other,
4610 Results.data(),Results.size());
Douglas Gregor48d46252010-01-13 21:54:15 +00004611}
4612
4613void Sema::CodeCompleteObjCAtStatement(Scope *S) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004614 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004615 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004616 CodeCompletionContext::CCC_Other);
Douglas Gregorf1934162010-01-13 21:24:21 +00004617 Results.EnterNewScope();
Douglas Gregorf98e6a22010-01-13 23:51:12 +00004618 AddObjCStatementResults(Results, false);
4619 AddObjCExpressionResults(Results, false);
Douglas Gregorbc7c5e42009-12-07 09:51:25 +00004620 Results.ExitScope();
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004621 HandleCodeCompleteResults(this, CodeCompleter,
4622 CodeCompletionContext::CCC_Other,
4623 Results.data(),Results.size());
Douglas Gregorbc7c5e42009-12-07 09:51:25 +00004624}
4625
4626void Sema::CodeCompleteObjCAtExpression(Scope *S) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004627 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004628 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004629 CodeCompletionContext::CCC_Other);
Douglas Gregorbc7c5e42009-12-07 09:51:25 +00004630 Results.EnterNewScope();
Douglas Gregorf98e6a22010-01-13 23:51:12 +00004631 AddObjCExpressionResults(Results, false);
Douglas Gregorbc7c5e42009-12-07 09:51:25 +00004632 Results.ExitScope();
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004633 HandleCodeCompleteResults(this, CodeCompleter,
4634 CodeCompletionContext::CCC_Other,
4635 Results.data(),Results.size());
Douglas Gregorbc7c5e42009-12-07 09:51:25 +00004636}
4637
Douglas Gregore6078da2009-11-19 00:14:45 +00004638/// \brief Determine whether the addition of the given flag to an Objective-C
4639/// property's attributes will cause a conflict.
Bill Wendling44426052012-12-20 19:22:21 +00004640static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
Douglas Gregore6078da2009-11-19 00:14:45 +00004641 // Check if we've already added this flag.
Bill Wendling44426052012-12-20 19:22:21 +00004642 if (Attributes & NewFlag)
Douglas Gregore6078da2009-11-19 00:14:45 +00004643 return true;
4644
Bill Wendling44426052012-12-20 19:22:21 +00004645 Attributes |= NewFlag;
Douglas Gregore6078da2009-11-19 00:14:45 +00004646
4647 // Check for collisions with "readonly".
Bill Wendling44426052012-12-20 19:22:21 +00004648 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
4649 (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
Douglas Gregore6078da2009-11-19 00:14:45 +00004650 return true;
4651
Jordan Rose53cb2f32012-08-20 20:01:13 +00004652 // Check for more than one of { assign, copy, retain, strong, weak }.
Bill Wendling44426052012-12-20 19:22:21 +00004653 unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign |
John McCall31168b02011-06-15 23:02:42 +00004654 ObjCDeclSpec::DQ_PR_unsafe_unretained |
Douglas Gregore6078da2009-11-19 00:14:45 +00004655 ObjCDeclSpec::DQ_PR_copy |
Jordan Rose53cb2f32012-08-20 20:01:13 +00004656 ObjCDeclSpec::DQ_PR_retain |
4657 ObjCDeclSpec::DQ_PR_strong |
4658 ObjCDeclSpec::DQ_PR_weak);
Douglas Gregore6078da2009-11-19 00:14:45 +00004659 if (AssignCopyRetMask &&
4660 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
John McCall31168b02011-06-15 23:02:42 +00004661 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
Douglas Gregore6078da2009-11-19 00:14:45 +00004662 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
John McCall31168b02011-06-15 23:02:42 +00004663 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
Jordan Rose53cb2f32012-08-20 20:01:13 +00004664 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong &&
4665 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_weak)
Douglas Gregore6078da2009-11-19 00:14:45 +00004666 return true;
4667
4668 return false;
4669}
4670
Douglas Gregor36029f42009-11-18 23:08:07 +00004671void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) {
Steve Naroff936354c2009-10-08 21:55:05 +00004672 if (!CodeCompleter)
4673 return;
Douglas Gregor1b605f72009-11-19 01:08:35 +00004674
Bill Wendling44426052012-12-20 19:22:21 +00004675 unsigned Attributes = ODS.getPropertyAttributes();
Steve Naroff936354c2009-10-08 21:55:05 +00004676
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004677 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004678 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004679 CodeCompletionContext::CCC_Other);
Steve Naroff936354c2009-10-08 21:55:05 +00004680 Results.EnterNewScope();
Bill Wendling44426052012-12-20 19:22:21 +00004681 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly))
John McCall276321a2010-08-25 06:19:51 +00004682 Results.AddResult(CodeCompletionResult("readonly"));
Bill Wendling44426052012-12-20 19:22:21 +00004683 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign))
John McCall276321a2010-08-25 06:19:51 +00004684 Results.AddResult(CodeCompletionResult("assign"));
Bill Wendling44426052012-12-20 19:22:21 +00004685 if (!ObjCPropertyFlagConflicts(Attributes,
John McCall31168b02011-06-15 23:02:42 +00004686 ObjCDeclSpec::DQ_PR_unsafe_unretained))
4687 Results.AddResult(CodeCompletionResult("unsafe_unretained"));
Bill Wendling44426052012-12-20 19:22:21 +00004688 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite))
John McCall276321a2010-08-25 06:19:51 +00004689 Results.AddResult(CodeCompletionResult("readwrite"));
Bill Wendling44426052012-12-20 19:22:21 +00004690 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain))
John McCall276321a2010-08-25 06:19:51 +00004691 Results.AddResult(CodeCompletionResult("retain"));
Bill Wendling44426052012-12-20 19:22:21 +00004692 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_strong))
John McCall31168b02011-06-15 23:02:42 +00004693 Results.AddResult(CodeCompletionResult("strong"));
Bill Wendling44426052012-12-20 19:22:21 +00004694 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy))
John McCall276321a2010-08-25 06:19:51 +00004695 Results.AddResult(CodeCompletionResult("copy"));
Bill Wendling44426052012-12-20 19:22:21 +00004696 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic))
John McCall276321a2010-08-25 06:19:51 +00004697 Results.AddResult(CodeCompletionResult("nonatomic"));
Bill Wendling44426052012-12-20 19:22:21 +00004698 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_atomic))
Fariborz Jahanian1c2d29e2011-06-11 17:14:27 +00004699 Results.AddResult(CodeCompletionResult("atomic"));
Jordan Rose53cb2f32012-08-20 20:01:13 +00004700
4701 // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
John McCall3deb1ad2012-08-21 02:47:43 +00004702 if (getLangOpts().ObjCARCWeak || getLangOpts().getGC() != LangOptions::NonGC)
Bill Wendling44426052012-12-20 19:22:21 +00004703 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_weak))
Jordan Rose53cb2f32012-08-20 20:01:13 +00004704 Results.AddResult(CodeCompletionResult("weak"));
4705
Bill Wendling44426052012-12-20 19:22:21 +00004706 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) {
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004707 CodeCompletionBuilder Setter(Results.getAllocator(),
4708 Results.getCodeCompletionTUInfo());
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004709 Setter.AddTypedTextChunk("setter");
Argyrios Kyrtzidis7bbb8812014-02-20 07:55:15 +00004710 Setter.AddTextChunk("=");
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004711 Setter.AddPlaceholderChunk("method");
4712 Results.AddResult(CodeCompletionResult(Setter.TakeString()));
Douglas Gregor45f83ee2009-11-19 00:01:57 +00004713 }
Bill Wendling44426052012-12-20 19:22:21 +00004714 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) {
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004715 CodeCompletionBuilder Getter(Results.getAllocator(),
4716 Results.getCodeCompletionTUInfo());
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004717 Getter.AddTypedTextChunk("getter");
Argyrios Kyrtzidis7bbb8812014-02-20 07:55:15 +00004718 Getter.AddTextChunk("=");
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004719 Getter.AddPlaceholderChunk("method");
4720 Results.AddResult(CodeCompletionResult(Getter.TakeString()));
Douglas Gregor45f83ee2009-11-19 00:01:57 +00004721 }
Steve Naroff936354c2009-10-08 21:55:05 +00004722 Results.ExitScope();
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004723 HandleCodeCompleteResults(this, CodeCompleter,
4724 CodeCompletionContext::CCC_Other,
4725 Results.data(),Results.size());
Steve Naroff936354c2009-10-08 21:55:05 +00004726}
Steve Naroffeae65032009-11-07 02:08:14 +00004727
James Dennettf1243872012-06-17 05:33:25 +00004728/// \brief Describes the kind of Objective-C method that we want to find
Douglas Gregorc8537c52009-11-19 07:41:15 +00004729/// via code completion.
4730enum ObjCMethodKind {
Dmitri Gribenko4280e5c2012-06-08 23:13:42 +00004731 MK_Any, ///< Any kind of method, provided it means other specified criteria.
4732 MK_ZeroArgSelector, ///< Zero-argument (unary) selector.
4733 MK_OneArgSelector ///< One-argument selector.
Douglas Gregorc8537c52009-11-19 07:41:15 +00004734};
4735
Douglas Gregor67c692c2010-08-26 15:07:07 +00004736static bool isAcceptableObjCSelector(Selector Sel,
4737 ObjCMethodKind WantKind,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00004738 ArrayRef<IdentifierInfo *> SelIdents,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00004739 bool AllowSameLength = true) {
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00004740 unsigned NumSelIdents = SelIdents.size();
Douglas Gregor67c692c2010-08-26 15:07:07 +00004741 if (NumSelIdents > Sel.getNumArgs())
4742 return false;
4743
4744 switch (WantKind) {
4745 case MK_Any: break;
4746 case MK_ZeroArgSelector: return Sel.isUnarySelector();
4747 case MK_OneArgSelector: return Sel.getNumArgs() == 1;
4748 }
4749
Douglas Gregorb4a7c032010-11-17 21:36:08 +00004750 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
4751 return false;
4752
Douglas Gregor67c692c2010-08-26 15:07:07 +00004753 for (unsigned I = 0; I != NumSelIdents; ++I)
4754 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
4755 return false;
4756
4757 return true;
4758}
4759
Douglas Gregorc8537c52009-11-19 07:41:15 +00004760static bool isAcceptableObjCMethod(ObjCMethodDecl *Method,
4761 ObjCMethodKind WantKind,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00004762 ArrayRef<IdentifierInfo *> SelIdents,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00004763 bool AllowSameLength = true) {
Douglas Gregor67c692c2010-08-26 15:07:07 +00004764 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00004765 AllowSameLength);
Douglas Gregorc8537c52009-11-19 07:41:15 +00004766}
Douglas Gregor1154e272010-09-16 16:06:31 +00004767
4768namespace {
4769 /// \brief A set of selectors, which is used to avoid introducing multiple
4770 /// completions with the same selector into the result set.
4771 typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
4772}
4773
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00004774/// \brief Add all of the Objective-C methods in the given Objective-C
4775/// container to the set of results.
4776///
4777/// The container will be a class, protocol, category, or implementation of
4778/// any of the above. This mether will recurse to include methods from
4779/// the superclasses of classes along with their categories, protocols, and
4780/// implementations.
4781///
4782/// \param Container the container in which we'll look to find methods.
4783///
James Dennett596e4752012-06-14 03:11:41 +00004784/// \param WantInstanceMethods Whether to add instance methods (only); if
4785/// false, this routine will add factory methods (only).
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00004786///
4787/// \param CurContext the context in which we're performing the lookup that
4788/// finds methods.
4789///
Douglas Gregorb4a7c032010-11-17 21:36:08 +00004790/// \param AllowSameLength Whether we allow a method to be added to the list
4791/// when it has the same number of parameters as we have selector identifiers.
4792///
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00004793/// \param Results the structure into which we'll add results.
4794static void AddObjCMethods(ObjCContainerDecl *Container,
4795 bool WantInstanceMethods,
Douglas Gregorc8537c52009-11-19 07:41:15 +00004796 ObjCMethodKind WantKind,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00004797 ArrayRef<IdentifierInfo *> SelIdents,
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00004798 DeclContext *CurContext,
Douglas Gregor1154e272010-09-16 16:06:31 +00004799 VisitedSelectorSet &Selectors,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00004800 bool AllowSameLength,
Douglas Gregor416b5752010-08-25 01:08:01 +00004801 ResultBuilder &Results,
4802 bool InOriginalClass = true) {
John McCall276321a2010-08-25 06:19:51 +00004803 typedef CodeCompletionResult Result;
Douglas Gregor9b4f3702012-06-12 13:44:08 +00004804 Container = getContainerDef(Container);
Douglas Gregor41778c32013-01-30 06:58:39 +00004805 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
4806 bool isRootClass = IFace && !IFace->getSuperClass();
Aaron Ballmanaff18c02014-03-13 19:03:34 +00004807 for (auto *M : Container->methods()) {
Douglas Gregor41778c32013-01-30 06:58:39 +00004808 // The instance methods on the root class can be messaged via the
4809 // metaclass.
4810 if (M->isInstanceMethod() == WantInstanceMethods ||
4811 (isRootClass && !WantInstanceMethods)) {
Douglas Gregor1b605f72009-11-19 01:08:35 +00004812 // Check whether the selector identifiers we've been given are a
4813 // subset of the identifiers for this particular method.
Aaron Ballmanaff18c02014-03-13 19:03:34 +00004814 if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength))
Douglas Gregor1b605f72009-11-19 01:08:35 +00004815 continue;
Douglas Gregorc8537c52009-11-19 07:41:15 +00004816
David Blaikie2d7c57e2012-04-30 02:36:29 +00004817 if (!Selectors.insert(M->getSelector()))
Douglas Gregor1154e272010-09-16 16:06:31 +00004818 continue;
4819
Aaron Ballmanaff18c02014-03-13 19:03:34 +00004820 Result R = Result(M, Results.getBasePriority(M), 0);
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00004821 R.StartParameter = SelIdents.size();
Douglas Gregorc8537c52009-11-19 07:41:15 +00004822 R.AllParametersAreInformative = (WantKind != MK_Any);
Douglas Gregor416b5752010-08-25 01:08:01 +00004823 if (!InOriginalClass)
4824 R.Priority += CCD_InBaseClass;
Douglas Gregor1b605f72009-11-19 01:08:35 +00004825 Results.MaybeAddResult(R, CurContext);
4826 }
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00004827 }
4828
Douglas Gregorf37c9492010-09-16 15:34:59 +00004829 // Visit the protocols of protocols.
4830 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
Douglas Gregore6e48b12012-01-01 19:29:29 +00004831 if (Protocol->hasDefinition()) {
4832 const ObjCList<ObjCProtocolDecl> &Protocols
4833 = Protocol->getReferencedProtocols();
4834 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
4835 E = Protocols.end();
4836 I != E; ++I)
4837 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00004838 CurContext, Selectors, AllowSameLength, Results, false);
Douglas Gregore6e48b12012-01-01 19:29:29 +00004839 }
Douglas Gregorf37c9492010-09-16 15:34:59 +00004840 }
4841
Douglas Gregorc0ac7d62011-12-15 05:27:12 +00004842 if (!IFace || !IFace->hasDefinition())
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00004843 return;
4844
4845 // Add methods in protocols.
Aaron Ballmana49c5062014-03-13 20:29:09 +00004846 for (auto *I : IFace->protocols())
4847 AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00004848 CurContext, Selectors, AllowSameLength, Results, false);
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00004849
4850 // Add methods in categories.
Aaron Ballman15063e12014-03-13 21:35:02 +00004851 for (auto *CatDecl : IFace->known_categories()) {
Douglas Gregor048fbfa2013-01-16 23:00:23 +00004852 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00004853 CurContext, Selectors, AllowSameLength,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00004854 Results, InOriginalClass);
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00004855
4856 // Add a categories protocol methods.
4857 const ObjCList<ObjCProtocolDecl> &Protocols
4858 = CatDecl->getReferencedProtocols();
4859 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
4860 E = Protocols.end();
4861 I != E; ++I)
Douglas Gregorc8537c52009-11-19 07:41:15 +00004862 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00004863 CurContext, Selectors, AllowSameLength,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00004864 Results, false);
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00004865
4866 // Add methods in category implementations.
4867 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
Douglas Gregorc8537c52009-11-19 07:41:15 +00004868 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00004869 CurContext, Selectors, AllowSameLength,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00004870 Results, InOriginalClass);
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00004871 }
4872
4873 // Add methods in superclass.
4874 if (IFace->getSuperClass())
Douglas Gregorc8537c52009-11-19 07:41:15 +00004875 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00004876 SelIdents, CurContext, Selectors,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00004877 AllowSameLength, Results, false);
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00004878
4879 // Add methods in our implementation, if any.
4880 if (ObjCImplementationDecl *Impl = IFace->getImplementation())
Douglas Gregorc8537c52009-11-19 07:41:15 +00004881 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00004882 CurContext, Selectors, AllowSameLength,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00004883 Results, InOriginalClass);
Douglas Gregorc8537c52009-11-19 07:41:15 +00004884}
4885
4886
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00004887void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
Douglas Gregorc8537c52009-11-19 07:41:15 +00004888 // Try to find the interface where getters might live.
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00004889 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
Douglas Gregorc8537c52009-11-19 07:41:15 +00004890 if (!Class) {
4891 if (ObjCCategoryDecl *Category
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00004892 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
Douglas Gregorc8537c52009-11-19 07:41:15 +00004893 Class = Category->getClassInterface();
4894
4895 if (!Class)
4896 return;
4897 }
4898
4899 // Find all of the potential getters.
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004900 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004901 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004902 CodeCompletionContext::CCC_Other);
Douglas Gregorc8537c52009-11-19 07:41:15 +00004903 Results.EnterNewScope();
4904
Douglas Gregor1154e272010-09-16 16:06:31 +00004905 VisitedSelectorSet Selectors;
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00004906 AddObjCMethods(Class, true, MK_ZeroArgSelector, None, CurContext, Selectors,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00004907 /*AllowSameLength=*/true, Results);
Douglas Gregorc8537c52009-11-19 07:41:15 +00004908 Results.ExitScope();
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004909 HandleCodeCompleteResults(this, CodeCompleter,
4910 CodeCompletionContext::CCC_Other,
4911 Results.data(),Results.size());
Douglas Gregorc8537c52009-11-19 07:41:15 +00004912}
4913
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00004914void Sema::CodeCompleteObjCPropertySetter(Scope *S) {
Douglas Gregorc8537c52009-11-19 07:41:15 +00004915 // Try to find the interface where setters might live.
4916 ObjCInterfaceDecl *Class
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00004917 = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
Douglas Gregorc8537c52009-11-19 07:41:15 +00004918 if (!Class) {
4919 if (ObjCCategoryDecl *Category
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00004920 = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
Douglas Gregorc8537c52009-11-19 07:41:15 +00004921 Class = Category->getClassInterface();
4922
4923 if (!Class)
4924 return;
4925 }
4926
4927 // Find all of the potential getters.
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004928 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004929 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004930 CodeCompletionContext::CCC_Other);
Douglas Gregorc8537c52009-11-19 07:41:15 +00004931 Results.EnterNewScope();
4932
Douglas Gregor1154e272010-09-16 16:06:31 +00004933 VisitedSelectorSet Selectors;
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00004934 AddObjCMethods(Class, true, MK_OneArgSelector, None, CurContext,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00004935 Selectors, /*AllowSameLength=*/true, Results);
Douglas Gregorc8537c52009-11-19 07:41:15 +00004936
4937 Results.ExitScope();
Douglas Gregor00c37ef2010-08-11 21:23:17 +00004938 HandleCodeCompleteResults(this, CodeCompleter,
4939 CodeCompletionContext::CCC_Other,
4940 Results.data(),Results.size());
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00004941}
4942
Douglas Gregorf34a6f02011-02-15 22:19:42 +00004943void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
4944 bool IsParameter) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004945 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004946 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00004947 CodeCompletionContext::CCC_Type);
Douglas Gregor99fa2642010-08-24 01:06:58 +00004948 Results.EnterNewScope();
4949
4950 // Add context-sensitive, Objective-C parameter-passing keywords.
4951 bool AddedInOut = false;
4952 if ((DS.getObjCDeclQualifier() &
4953 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) {
4954 Results.AddResult("in");
4955 Results.AddResult("inout");
4956 AddedInOut = true;
4957 }
4958 if ((DS.getObjCDeclQualifier() &
4959 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) {
4960 Results.AddResult("out");
4961 if (!AddedInOut)
4962 Results.AddResult("inout");
4963 }
4964 if ((DS.getObjCDeclQualifier() &
4965 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref |
4966 ObjCDeclSpec::DQ_Oneway)) == 0) {
4967 Results.AddResult("bycopy");
4968 Results.AddResult("byref");
4969 Results.AddResult("oneway");
4970 }
4971
Douglas Gregorf34a6f02011-02-15 22:19:42 +00004972 // If we're completing the return type of an Objective-C method and the
4973 // identifier IBAction refers to a macro, provide a completion item for
4974 // an action, e.g.,
4975 // IBAction)<#selector#>:(id)sender
4976 if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
4977 Context.Idents.get("IBAction").hasMacroDefinition()) {
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00004978 CodeCompletionBuilder Builder(Results.getAllocator(),
4979 Results.getCodeCompletionTUInfo(),
4980 CCP_CodePattern, CXAvailability_Available);
Douglas Gregorf34a6f02011-02-15 22:19:42 +00004981 Builder.AddTypedTextChunk("IBAction");
Benjamin Kramerdb534a42012-03-26 16:57:36 +00004982 Builder.AddChunk(CodeCompletionString::CK_RightParen);
Douglas Gregorf34a6f02011-02-15 22:19:42 +00004983 Builder.AddPlaceholderChunk("selector");
Benjamin Kramerdb534a42012-03-26 16:57:36 +00004984 Builder.AddChunk(CodeCompletionString::CK_Colon);
4985 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
Douglas Gregorf34a6f02011-02-15 22:19:42 +00004986 Builder.AddTextChunk("id");
Benjamin Kramerdb534a42012-03-26 16:57:36 +00004987 Builder.AddChunk(CodeCompletionString::CK_RightParen);
Douglas Gregorf34a6f02011-02-15 22:19:42 +00004988 Builder.AddTextChunk("sender");
4989 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
4990 }
Douglas Gregored1f5972013-01-30 07:11:43 +00004991
4992 // If we're completing the return type, provide 'instancetype'.
4993 if (!IsParameter) {
4994 Results.AddResult(CodeCompletionResult("instancetype"));
4995 }
Douglas Gregorf34a6f02011-02-15 22:19:42 +00004996
Douglas Gregor99fa2642010-08-24 01:06:58 +00004997 // Add various builtin type names and specifiers.
4998 AddOrdinaryNameResults(PCC_Type, S, *this, Results);
4999 Results.ExitScope();
5000
5001 // Add the various type names
5002 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
5003 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5004 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5005 CodeCompleter->includeGlobals());
5006
5007 if (CodeCompleter->includeMacros())
Douglas Gregor8cb17462012-10-09 16:01:50 +00005008 AddMacroResults(PP, Results, false);
Douglas Gregor99fa2642010-08-24 01:06:58 +00005009
5010 HandleCodeCompleteResults(this, CodeCompleter,
5011 CodeCompletionContext::CCC_Type,
5012 Results.data(), Results.size());
5013}
5014
Douglas Gregor9d2ddb22010-04-06 19:22:33 +00005015/// \brief When we have an expression with type "id", we may assume
5016/// that it has some more-specific class type based on knowledge of
5017/// common uses of Objective-C. This routine returns that class type,
5018/// or NULL if no better result could be determined.
5019static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
Douglas Gregored0b69d2010-09-15 16:23:04 +00005020 ObjCMessageExpr *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
Douglas Gregor9d2ddb22010-04-06 19:22:33 +00005021 if (!Msg)
5022 return 0;
5023
5024 Selector Sel = Msg->getSelector();
5025 if (Sel.isNull())
5026 return 0;
5027
5028 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0);
5029 if (!Id)
5030 return 0;
5031
5032 ObjCMethodDecl *Method = Msg->getMethodDecl();
5033 if (!Method)
5034 return 0;
5035
5036 // Determine the class that we're sending the message to.
Douglas Gregor9a129192010-04-21 00:45:42 +00005037 ObjCInterfaceDecl *IFace = 0;
5038 switch (Msg->getReceiverKind()) {
5039 case ObjCMessageExpr::Class:
John McCall8b07ec22010-05-15 11:32:37 +00005040 if (const ObjCObjectType *ObjType
5041 = Msg->getClassReceiver()->getAs<ObjCObjectType>())
5042 IFace = ObjType->getInterface();
Douglas Gregor9a129192010-04-21 00:45:42 +00005043 break;
5044
5045 case ObjCMessageExpr::Instance: {
5046 QualType T = Msg->getInstanceReceiver()->getType();
5047 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
5048 IFace = Ptr->getInterfaceDecl();
5049 break;
5050 }
5051
5052 case ObjCMessageExpr::SuperInstance:
5053 case ObjCMessageExpr::SuperClass:
5054 break;
Douglas Gregor9d2ddb22010-04-06 19:22:33 +00005055 }
5056
5057 if (!IFace)
5058 return 0;
5059
5060 ObjCInterfaceDecl *Super = IFace->getSuperClass();
5061 if (Method->isInstanceMethod())
5062 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5063 .Case("retain", IFace)
John McCall31168b02011-06-15 23:02:42 +00005064 .Case("strong", IFace)
Douglas Gregor9d2ddb22010-04-06 19:22:33 +00005065 .Case("autorelease", IFace)
5066 .Case("copy", IFace)
5067 .Case("copyWithZone", IFace)
5068 .Case("mutableCopy", IFace)
5069 .Case("mutableCopyWithZone", IFace)
5070 .Case("awakeFromCoder", IFace)
5071 .Case("replacementObjectFromCoder", IFace)
5072 .Case("class", IFace)
5073 .Case("classForCoder", IFace)
5074 .Case("superclass", Super)
5075 .Default(0);
5076
5077 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5078 .Case("new", IFace)
5079 .Case("alloc", IFace)
5080 .Case("allocWithZone", IFace)
5081 .Case("class", IFace)
5082 .Case("superclass", Super)
5083 .Default(0);
5084}
5085
Douglas Gregor6fc04132010-08-27 15:10:57 +00005086// Add a special completion for a message send to "super", which fills in the
5087// most likely case of forwarding all of our arguments to the superclass
5088// function.
5089///
5090/// \param S The semantic analysis object.
5091///
Dmitri Gribenkoadba9be2012-08-23 17:58:28 +00005092/// \param NeedSuperKeyword Whether we need to prefix this completion with
Douglas Gregor6fc04132010-08-27 15:10:57 +00005093/// the "super" keyword. Otherwise, we just need to provide the arguments.
5094///
5095/// \param SelIdents The identifiers in the selector that have already been
5096/// provided as arguments for a send to "super".
5097///
Douglas Gregor6fc04132010-08-27 15:10:57 +00005098/// \param Results The set of results to augment.
5099///
5100/// \returns the Objective-C method declaration that would be invoked by
5101/// this "super" completion. If NULL, no completion was added.
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005102static ObjCMethodDecl *AddSuperSendCompletion(
5103 Sema &S, bool NeedSuperKeyword,
5104 ArrayRef<IdentifierInfo *> SelIdents,
5105 ResultBuilder &Results) {
Douglas Gregor6fc04132010-08-27 15:10:57 +00005106 ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
5107 if (!CurMethod)
5108 return 0;
5109
5110 ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
5111 if (!Class)
5112 return 0;
5113
5114 // Try to find a superclass method with the same selector.
5115 ObjCMethodDecl *SuperMethod = 0;
Douglas Gregorb5f1e462011-02-16 00:51:18 +00005116 while ((Class = Class->getSuperClass()) && !SuperMethod) {
5117 // Check in the class
Douglas Gregor6fc04132010-08-27 15:10:57 +00005118 SuperMethod = Class->getMethod(CurMethod->getSelector(),
5119 CurMethod->isInstanceMethod());
5120
Douglas Gregorb5f1e462011-02-16 00:51:18 +00005121 // Check in categories or class extensions.
5122 if (!SuperMethod) {
Aaron Ballman15063e12014-03-13 21:35:02 +00005123 for (const auto *Cat : Class->known_categories()) {
Douglas Gregor048fbfa2013-01-16 23:00:23 +00005124 if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(),
Douglas Gregorb5f1e462011-02-16 00:51:18 +00005125 CurMethod->isInstanceMethod())))
5126 break;
Douglas Gregor048fbfa2013-01-16 23:00:23 +00005127 }
Douglas Gregorb5f1e462011-02-16 00:51:18 +00005128 }
5129 }
5130
Douglas Gregor6fc04132010-08-27 15:10:57 +00005131 if (!SuperMethod)
5132 return 0;
5133
5134 // Check whether the superclass method has the same signature.
5135 if (CurMethod->param_size() != SuperMethod->param_size() ||
5136 CurMethod->isVariadic() != SuperMethod->isVariadic())
5137 return 0;
5138
5139 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
5140 CurPEnd = CurMethod->param_end(),
5141 SuperP = SuperMethod->param_begin();
5142 CurP != CurPEnd; ++CurP, ++SuperP) {
5143 // Make sure the parameter types are compatible.
5144 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
5145 (*SuperP)->getType()))
5146 return 0;
5147
5148 // Make sure we have a parameter name to forward!
5149 if (!(*CurP)->getIdentifier())
5150 return 0;
5151 }
5152
5153 // We have a superclass method. Now, form the send-to-super completion.
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00005154 CodeCompletionBuilder Builder(Results.getAllocator(),
5155 Results.getCodeCompletionTUInfo());
Douglas Gregor6fc04132010-08-27 15:10:57 +00005156
5157 // Give this completion a return type.
Douglas Gregor75acd922011-09-27 23:30:47 +00005158 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod,
5159 Builder);
Douglas Gregor6fc04132010-08-27 15:10:57 +00005160
5161 // If we need the "super" keyword, add it (plus some spacing).
5162 if (NeedSuperKeyword) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005163 Builder.AddTypedTextChunk("super");
5164 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
Douglas Gregor6fc04132010-08-27 15:10:57 +00005165 }
5166
5167 Selector Sel = CurMethod->getSelector();
5168 if (Sel.isUnarySelector()) {
5169 if (NeedSuperKeyword)
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00005170 Builder.AddTextChunk(Builder.getAllocator().CopyString(
Douglas Gregoraf2a6ae2011-02-18 22:29:55 +00005171 Sel.getNameForSlot(0)));
Douglas Gregor6fc04132010-08-27 15:10:57 +00005172 else
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00005173 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregoraf2a6ae2011-02-18 22:29:55 +00005174 Sel.getNameForSlot(0)));
Douglas Gregor6fc04132010-08-27 15:10:57 +00005175 } else {
5176 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
5177 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005178 if (I > SelIdents.size())
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005179 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
Douglas Gregor6fc04132010-08-27 15:10:57 +00005180
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005181 if (I < SelIdents.size())
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005182 Builder.AddInformativeChunk(
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00005183 Builder.getAllocator().CopyString(
Douglas Gregoraf2a6ae2011-02-18 22:29:55 +00005184 Sel.getNameForSlot(I) + ":"));
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005185 else if (NeedSuperKeyword || I > SelIdents.size()) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005186 Builder.AddTextChunk(
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00005187 Builder.getAllocator().CopyString(
Douglas Gregoraf2a6ae2011-02-18 22:29:55 +00005188 Sel.getNameForSlot(I) + ":"));
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00005189 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005190 (*CurP)->getIdentifier()->getName()));
Douglas Gregor6fc04132010-08-27 15:10:57 +00005191 } else {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005192 Builder.AddTypedTextChunk(
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00005193 Builder.getAllocator().CopyString(
Douglas Gregoraf2a6ae2011-02-18 22:29:55 +00005194 Sel.getNameForSlot(I) + ":"));
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00005195 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005196 (*CurP)->getIdentifier()->getName()));
Douglas Gregor6fc04132010-08-27 15:10:57 +00005197 }
5198 }
5199 }
5200
Douglas Gregor78254c82012-03-27 23:34:16 +00005201 Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod,
5202 CCP_SuperCompletion));
Douglas Gregor6fc04132010-08-27 15:10:57 +00005203 return SuperMethod;
5204}
5205
Douglas Gregora817a192010-05-27 23:06:34 +00005206void Sema::CodeCompleteObjCMessageReceiver(Scope *S) {
John McCall276321a2010-08-25 06:19:51 +00005207 typedef CodeCompletionResult Result;
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005208 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00005209 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005210 CodeCompletionContext::CCC_ObjCMessageReceiver,
Richard Smith2bf7fdb2013-01-02 11:42:31 +00005211 getLangOpts().CPlusPlus11
Douglas Gregord8c61782012-02-15 15:34:24 +00005212 ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture
5213 : &ResultBuilder::IsObjCMessageReceiver);
Douglas Gregora817a192010-05-27 23:06:34 +00005214
Douglas Gregora817a192010-05-27 23:06:34 +00005215 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5216 Results.EnterNewScope();
Douglas Gregor39982192010-08-15 06:18:01 +00005217 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5218 CodeCompleter->includeGlobals());
Douglas Gregora817a192010-05-27 23:06:34 +00005219
5220 // If we are in an Objective-C method inside a class that has a superclass,
5221 // add "super" as an option.
5222 if (ObjCMethodDecl *Method = getCurMethodDecl())
5223 if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
Douglas Gregor6fc04132010-08-27 15:10:57 +00005224 if (Iface->getSuperClass()) {
Douglas Gregora817a192010-05-27 23:06:34 +00005225 Results.AddResult(Result("super"));
Douglas Gregor6fc04132010-08-27 15:10:57 +00005226
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005227 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, None, Results);
Douglas Gregor6fc04132010-08-27 15:10:57 +00005228 }
Douglas Gregora817a192010-05-27 23:06:34 +00005229
Richard Smith2bf7fdb2013-01-02 11:42:31 +00005230 if (getLangOpts().CPlusPlus11)
Douglas Gregord8c61782012-02-15 15:34:24 +00005231 addThisCompletion(*this, Results);
5232
Douglas Gregora817a192010-05-27 23:06:34 +00005233 Results.ExitScope();
5234
5235 if (CodeCompleter->includeMacros())
Douglas Gregor8cb17462012-10-09 16:01:50 +00005236 AddMacroResults(PP, Results, false);
Douglas Gregor50832e02010-09-20 22:39:41 +00005237 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005238 Results.data(), Results.size());
Douglas Gregora817a192010-05-27 23:06:34 +00005239
5240}
5241
Douglas Gregor0c78ad92010-04-21 19:57:20 +00005242void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005243 ArrayRef<IdentifierInfo *> SelIdents,
Douglas Gregorf86e4da2010-09-20 23:34:21 +00005244 bool AtArgumentExpression) {
Douglas Gregor0c78ad92010-04-21 19:57:20 +00005245 ObjCInterfaceDecl *CDecl = 0;
5246 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5247 // Figure out which interface we're in.
5248 CDecl = CurMethod->getClassInterface();
5249 if (!CDecl)
5250 return;
5251
5252 // Find the superclass of this class.
5253 CDecl = CDecl->getSuperClass();
5254 if (!CDecl)
5255 return;
5256
5257 if (CurMethod->isInstanceMethod()) {
5258 // We are inside an instance method, which means that the message
5259 // send [super ...] is actually calling an instance method on the
Douglas Gregor392a84b2010-10-13 21:24:53 +00005260 // current object.
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005261 return CodeCompleteObjCInstanceMessage(S, 0, SelIdents,
Douglas Gregorf86e4da2010-09-20 23:34:21 +00005262 AtArgumentExpression,
Douglas Gregor392a84b2010-10-13 21:24:53 +00005263 CDecl);
Douglas Gregor0c78ad92010-04-21 19:57:20 +00005264 }
5265
5266 // Fall through to send to the superclass in CDecl.
5267 } else {
5268 // "super" may be the name of a type or variable. Figure out which
5269 // it is.
Argyrios Kyrtzidis3e56dd42013-03-14 22:56:43 +00005270 IdentifierInfo *Super = getSuperIdentifier();
Douglas Gregor0c78ad92010-04-21 19:57:20 +00005271 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc,
5272 LookupOrdinaryName);
5273 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
5274 // "super" names an interface. Use it.
5275 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
John McCall8b07ec22010-05-15 11:32:37 +00005276 if (const ObjCObjectType *Iface
5277 = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
5278 CDecl = Iface->getInterface();
Douglas Gregor0c78ad92010-04-21 19:57:20 +00005279 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
5280 // "super" names an unresolved type; we can't be more specific.
5281 } else {
5282 // Assume that "super" names some kind of value and parse that way.
5283 CXXScopeSpec SS;
Abramo Bagnara7945c982012-01-27 09:46:47 +00005284 SourceLocation TemplateKWLoc;
Douglas Gregor0c78ad92010-04-21 19:57:20 +00005285 UnqualifiedId id;
5286 id.setIdentifier(Super, SuperLoc);
Abramo Bagnara7945c982012-01-27 09:46:47 +00005287 ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id,
5288 false, false);
Douglas Gregor0c78ad92010-04-21 19:57:20 +00005289 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005290 SelIdents,
Douglas Gregorf86e4da2010-09-20 23:34:21 +00005291 AtArgumentExpression);
Douglas Gregor0c78ad92010-04-21 19:57:20 +00005292 }
5293
5294 // Fall through
5295 }
5296
John McCallba7bf592010-08-24 05:47:05 +00005297 ParsedType Receiver;
Douglas Gregor0c78ad92010-04-21 19:57:20 +00005298 if (CDecl)
John McCallba7bf592010-08-24 05:47:05 +00005299 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
Douglas Gregor0c78ad92010-04-21 19:57:20 +00005300 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005301 AtArgumentExpression,
Douglas Gregorf86e4da2010-09-20 23:34:21 +00005302 /*IsSuper=*/true);
Douglas Gregor0c78ad92010-04-21 19:57:20 +00005303}
5304
Douglas Gregor74661272010-09-21 00:03:25 +00005305/// \brief Given a set of code-completion results for the argument of a message
5306/// send, determine the preferred type (if any) for that argument expression.
5307static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
5308 unsigned NumSelIdents) {
5309 typedef CodeCompletionResult Result;
5310 ASTContext &Context = Results.getSema().Context;
5311
5312 QualType PreferredType;
5313 unsigned BestPriority = CCP_Unlikely * 2;
5314 Result *ResultsData = Results.data();
5315 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
5316 Result &R = ResultsData[I];
5317 if (R.Kind == Result::RK_Declaration &&
5318 isa<ObjCMethodDecl>(R.Declaration)) {
5319 if (R.Priority <= BestPriority) {
Dmitri Gribenkofe0483d2013-01-23 17:21:11 +00005320 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
Douglas Gregor74661272010-09-21 00:03:25 +00005321 if (NumSelIdents <= Method->param_size()) {
5322 QualType MyPreferredType = Method->param_begin()[NumSelIdents - 1]
5323 ->getType();
5324 if (R.Priority < BestPriority || PreferredType.isNull()) {
5325 BestPriority = R.Priority;
5326 PreferredType = MyPreferredType;
5327 } else if (!Context.hasSameUnqualifiedType(PreferredType,
5328 MyPreferredType)) {
5329 PreferredType = QualType();
5330 }
5331 }
5332 }
5333 }
5334 }
5335
5336 return PreferredType;
5337}
5338
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005339static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
5340 ParsedType Receiver,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005341 ArrayRef<IdentifierInfo *> SelIdents,
Douglas Gregorf86e4da2010-09-20 23:34:21 +00005342 bool AtArgumentExpression,
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005343 bool IsSuper,
5344 ResultBuilder &Results) {
John McCall276321a2010-08-25 06:19:51 +00005345 typedef CodeCompletionResult Result;
Douglas Gregor8ce33212009-11-17 17:59:40 +00005346 ObjCInterfaceDecl *CDecl = 0;
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005347
Douglas Gregor8ce33212009-11-17 17:59:40 +00005348 // If the given name refers to an interface type, retrieve the
5349 // corresponding declaration.
Douglas Gregor0c78ad92010-04-21 19:57:20 +00005350 if (Receiver) {
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005351 QualType T = SemaRef.GetTypeFromParser(Receiver, 0);
Douglas Gregor0c78ad92010-04-21 19:57:20 +00005352 if (!T.isNull())
John McCall8b07ec22010-05-15 11:32:37 +00005353 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
5354 CDecl = Interface->getInterface();
Douglas Gregor8ce33212009-11-17 17:59:40 +00005355 }
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005356
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00005357 // Add all of the factory methods in this Objective-C class, its protocols,
5358 // superclasses, categories, implementation, etc.
Steve Naroffeae65032009-11-07 02:08:14 +00005359 Results.EnterNewScope();
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005360
Douglas Gregor6fc04132010-08-27 15:10:57 +00005361 // If this is a send-to-super, try to add the special "super" send
5362 // completion.
5363 if (IsSuper) {
5364 if (ObjCMethodDecl *SuperMethod
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005365 = AddSuperSendCompletion(SemaRef, false, SelIdents, Results))
Douglas Gregor6fc04132010-08-27 15:10:57 +00005366 Results.Ignore(SuperMethod);
5367 }
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005368
Douglas Gregorc2cb2e22010-08-27 15:29:55 +00005369 // If we're inside an Objective-C method definition, prefer its selector to
5370 // others.
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005371 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
Douglas Gregorc2cb2e22010-08-27 15:29:55 +00005372 Results.setPreferredSelector(CurMethod->getSelector());
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005373
Douglas Gregor1154e272010-09-16 16:06:31 +00005374 VisitedSelectorSet Selectors;
Douglas Gregor6285f752010-04-06 16:40:00 +00005375 if (CDecl)
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005376 AddObjCMethods(CDecl, false, MK_Any, SelIdents,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00005377 SemaRef.CurContext, Selectors, AtArgumentExpression,
5378 Results);
Douglas Gregor0c78ad92010-04-21 19:57:20 +00005379 else {
Douglas Gregor6285f752010-04-06 16:40:00 +00005380 // We're messaging "id" as a type; provide all class/factory methods.
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005381
Douglas Gregord720daf2010-04-06 17:30:22 +00005382 // If we have an external source, load the entire class method
Sebastian Redld44cd6a2010-08-18 23:57:06 +00005383 // pool from the AST file.
Axel Naumanndd433f02012-10-18 19:05:02 +00005384 if (SemaRef.getExternalSource()) {
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005385 for (uint32_t I = 0,
Axel Naumanndd433f02012-10-18 19:05:02 +00005386 N = SemaRef.getExternalSource()->GetNumExternalSelectors();
John McCall75b960e2010-06-01 09:23:16 +00005387 I != N; ++I) {
Axel Naumanndd433f02012-10-18 19:05:02 +00005388 Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I);
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005389 if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
Douglas Gregord720daf2010-04-06 17:30:22 +00005390 continue;
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005391
5392 SemaRef.ReadMethodPool(Sel);
Douglas Gregord720daf2010-04-06 17:30:22 +00005393 }
5394 }
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005395
5396 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
5397 MEnd = SemaRef.MethodPool.end();
Sebastian Redl75d8a322010-08-02 23:18:59 +00005398 M != MEnd; ++M) {
5399 for (ObjCMethodList *MethList = &M->second.second;
5400 MethList && MethList->Method;
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00005401 MethList = MethList->getNext()) {
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005402 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents))
Douglas Gregor6285f752010-04-06 16:40:00 +00005403 continue;
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005404
Douglas Gregor0a0e2b32013-01-31 04:52:16 +00005405 Result R(MethList->Method, Results.getBasePriority(MethList->Method),0);
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005406 R.StartParameter = SelIdents.size();
Douglas Gregor6285f752010-04-06 16:40:00 +00005407 R.AllParametersAreInformative = false;
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005408 Results.MaybeAddResult(R, SemaRef.CurContext);
Douglas Gregor6285f752010-04-06 16:40:00 +00005409 }
5410 }
5411 }
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005412
5413 Results.ExitScope();
5414}
Douglas Gregor6285f752010-04-06 16:40:00 +00005415
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005416void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005417 ArrayRef<IdentifierInfo *> SelIdents,
Douglas Gregorf86e4da2010-09-20 23:34:21 +00005418 bool AtArgumentExpression,
Douglas Gregorbfcea8b2010-09-16 15:14:18 +00005419 bool IsSuper) {
Douglas Gregor63745d52011-07-21 01:05:26 +00005420
5421 QualType T = this->GetTypeFromParser(Receiver);
5422
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005423 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00005424 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor63745d52011-07-21 01:05:26 +00005425 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005426 T, SelIdents));
Douglas Gregor63745d52011-07-21 01:05:26 +00005427
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005428 AddClassMessageCompletions(*this, S, Receiver, SelIdents,
Douglas Gregorf86e4da2010-09-20 23:34:21 +00005429 AtArgumentExpression, IsSuper, Results);
Douglas Gregor74661272010-09-21 00:03:25 +00005430
5431 // If we're actually at the argument expression (rather than prior to the
5432 // selector), we're actually performing code completion for an expression.
5433 // Determine whether we have a single, best method. If so, we can
5434 // code-complete the expression using the corresponding parameter type as
5435 // our preferred type, improving completion results.
5436 if (AtArgumentExpression) {
5437 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005438 SelIdents.size());
Douglas Gregor74661272010-09-21 00:03:25 +00005439 if (PreferredType.isNull())
5440 CodeCompleteOrdinaryName(S, PCC_Expression);
5441 else
5442 CodeCompleteExpression(S, PreferredType);
5443 return;
5444 }
5445
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005446 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor63745d52011-07-21 01:05:26 +00005447 Results.getCompletionContext(),
Douglas Gregor6fc04132010-08-27 15:10:57 +00005448 Results.data(), Results.size());
Steve Naroffeae65032009-11-07 02:08:14 +00005449}
5450
Richard Trieu2bd04012011-09-09 02:00:50 +00005451void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005452 ArrayRef<IdentifierInfo *> SelIdents,
Douglas Gregorf86e4da2010-09-20 23:34:21 +00005453 bool AtArgumentExpression,
Douglas Gregor392a84b2010-10-13 21:24:53 +00005454 ObjCInterfaceDecl *Super) {
John McCall276321a2010-08-25 06:19:51 +00005455 typedef CodeCompletionResult Result;
Steve Naroffeae65032009-11-07 02:08:14 +00005456
5457 Expr *RecExpr = static_cast<Expr *>(Receiver);
Steve Naroffeae65032009-11-07 02:08:14 +00005458
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00005459 // If necessary, apply function/array conversion to the receiver.
5460 // C99 6.7.5.3p[7,8].
John Wiegley01296292011-04-08 18:41:53 +00005461 if (RecExpr) {
5462 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
5463 if (Conv.isInvalid()) // conversion failed. bail.
5464 return;
5465 RecExpr = Conv.take();
5466 }
Douglas Gregor392a84b2010-10-13 21:24:53 +00005467 QualType ReceiverType = RecExpr? RecExpr->getType()
5468 : Super? Context.getObjCObjectPointerType(
5469 Context.getObjCInterfaceType(Super))
5470 : Context.getObjCIdType();
Steve Naroffeae65032009-11-07 02:08:14 +00005471
Douglas Gregordc520b02010-11-08 21:12:30 +00005472 // If we're messaging an expression with type "id" or "Class", check
5473 // whether we know something special about the receiver that allows
5474 // us to assume a more-specific receiver type.
Anders Carlsson382ba412014-02-28 19:07:22 +00005475 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) {
Douglas Gregordc520b02010-11-08 21:12:30 +00005476 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
5477 if (ReceiverType->isObjCClassType())
5478 return CodeCompleteObjCClassMessage(S,
5479 ParsedType::make(Context.getObjCInterfaceType(IFace)),
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005480 SelIdents,
Douglas Gregordc520b02010-11-08 21:12:30 +00005481 AtArgumentExpression, Super);
5482
5483 ReceiverType = Context.getObjCObjectPointerType(
5484 Context.getObjCInterfaceType(IFace));
5485 }
Anders Carlsson382ba412014-02-28 19:07:22 +00005486 } else if (RecExpr && getLangOpts().CPlusPlus) {
5487 ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr);
5488 if (Conv.isUsable()) {
5489 RecExpr = Conv.take();
5490 ReceiverType = RecExpr->getType();
5491 }
5492 }
Douglas Gregordc520b02010-11-08 21:12:30 +00005493
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00005494 // Build the set of methods we can see.
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005495 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00005496 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor63745d52011-07-21 01:05:26 +00005497 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005498 ReceiverType, SelIdents));
Douglas Gregor63745d52011-07-21 01:05:26 +00005499
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00005500 Results.EnterNewScope();
Douglas Gregor9d2ddb22010-04-06 19:22:33 +00005501
Douglas Gregor6fc04132010-08-27 15:10:57 +00005502 // If this is a send-to-super, try to add the special "super" send
5503 // completion.
Douglas Gregor392a84b2010-10-13 21:24:53 +00005504 if (Super) {
Douglas Gregor6fc04132010-08-27 15:10:57 +00005505 if (ObjCMethodDecl *SuperMethod
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005506 = AddSuperSendCompletion(*this, false, SelIdents, Results))
Douglas Gregor6fc04132010-08-27 15:10:57 +00005507 Results.Ignore(SuperMethod);
5508 }
5509
Douglas Gregorc2cb2e22010-08-27 15:29:55 +00005510 // If we're inside an Objective-C method definition, prefer its selector to
5511 // others.
5512 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
5513 Results.setPreferredSelector(CurMethod->getSelector());
Douglas Gregorbab2b3c2009-11-17 23:22:23 +00005514
Douglas Gregor1154e272010-09-16 16:06:31 +00005515 // Keep track of the selectors we've already added.
5516 VisitedSelectorSet Selectors;
5517
Douglas Gregora3329fa2009-11-18 00:06:18 +00005518 // Handle messages to Class. This really isn't a message to an instance
5519 // method, so we treat it the same way we would treat a message send to a
5520 // class method.
5521 if (ReceiverType->isObjCClassType() ||
5522 ReceiverType->isObjCQualifiedClassType()) {
5523 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5524 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005525 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00005526 CurContext, Selectors, AtArgumentExpression, Results);
Douglas Gregora3329fa2009-11-18 00:06:18 +00005527 }
5528 }
5529 // Handle messages to a qualified ID ("id<foo>").
5530 else if (const ObjCObjectPointerType *QualID
5531 = ReceiverType->getAsObjCQualifiedIdType()) {
5532 // Search protocols for instance methods.
Aaron Ballman83731462014-03-17 16:14:00 +00005533 for (auto *I : QualID->quals())
5534 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00005535 Selectors, AtArgumentExpression, Results);
Douglas Gregora3329fa2009-11-18 00:06:18 +00005536 }
5537 // Handle messages to a pointer to interface type.
5538 else if (const ObjCObjectPointerType *IFacePtr
5539 = ReceiverType->getAsObjCInterfacePointerType()) {
5540 // Search the class, its superclasses, etc., for instance methods.
Douglas Gregorc8537c52009-11-19 07:41:15 +00005541 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005542 CurContext, Selectors, AtArgumentExpression,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00005543 Results);
Douglas Gregora3329fa2009-11-18 00:06:18 +00005544
5545 // Search protocols for instance methods.
Aaron Ballman83731462014-03-17 16:14:00 +00005546 for (auto *I : IFacePtr->quals())
5547 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
Douglas Gregorb4a7c032010-11-17 21:36:08 +00005548 Selectors, AtArgumentExpression, Results);
Douglas Gregora3329fa2009-11-18 00:06:18 +00005549 }
Douglas Gregor6285f752010-04-06 16:40:00 +00005550 // Handle messages to "id".
5551 else if (ReceiverType->isObjCIdType()) {
Douglas Gregord720daf2010-04-06 17:30:22 +00005552 // We're messaging "id", so provide all instance methods we know
5553 // about as code-completion results.
5554
5555 // If we have an external source, load the entire class method
Sebastian Redld44cd6a2010-08-18 23:57:06 +00005556 // pool from the AST file.
Douglas Gregord720daf2010-04-06 17:30:22 +00005557 if (ExternalSource) {
John McCall75b960e2010-06-01 09:23:16 +00005558 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5559 I != N; ++I) {
5560 Selector Sel = ExternalSource->GetExternalSelector(I);
Sebastian Redl75d8a322010-08-02 23:18:59 +00005561 if (Sel.isNull() || MethodPool.count(Sel))
Douglas Gregord720daf2010-04-06 17:30:22 +00005562 continue;
5563
Sebastian Redl75d8a322010-08-02 23:18:59 +00005564 ReadMethodPool(Sel);
Douglas Gregord720daf2010-04-06 17:30:22 +00005565 }
5566 }
5567
Sebastian Redl75d8a322010-08-02 23:18:59 +00005568 for (GlobalMethodPool::iterator M = MethodPool.begin(),
5569 MEnd = MethodPool.end();
5570 M != MEnd; ++M) {
5571 for (ObjCMethodList *MethList = &M->second.first;
5572 MethList && MethList->Method;
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00005573 MethList = MethList->getNext()) {
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005574 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents))
Douglas Gregor6285f752010-04-06 16:40:00 +00005575 continue;
Douglas Gregor1154e272010-09-16 16:06:31 +00005576
5577 if (!Selectors.insert(MethList->Method->getSelector()))
5578 continue;
5579
Douglas Gregor0a0e2b32013-01-31 04:52:16 +00005580 Result R(MethList->Method, Results.getBasePriority(MethList->Method),0);
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005581 R.StartParameter = SelIdents.size();
Douglas Gregor6285f752010-04-06 16:40:00 +00005582 R.AllParametersAreInformative = false;
5583 Results.MaybeAddResult(R, CurContext);
5584 }
5585 }
5586 }
Steve Naroffeae65032009-11-07 02:08:14 +00005587 Results.ExitScope();
Douglas Gregor74661272010-09-21 00:03:25 +00005588
5589
5590 // If we're actually at the argument expression (rather than prior to the
5591 // selector), we're actually performing code completion for an expression.
5592 // Determine whether we have a single, best method. If so, we can
5593 // code-complete the expression using the corresponding parameter type as
5594 // our preferred type, improving completion results.
5595 if (AtArgumentExpression) {
5596 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005597 SelIdents.size());
Douglas Gregor74661272010-09-21 00:03:25 +00005598 if (PreferredType.isNull())
5599 CodeCompleteOrdinaryName(S, PCC_Expression);
5600 else
5601 CodeCompleteExpression(S, PreferredType);
5602 return;
5603 }
5604
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005605 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor63745d52011-07-21 01:05:26 +00005606 Results.getCompletionContext(),
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005607 Results.data(),Results.size());
Steve Naroffeae65032009-11-07 02:08:14 +00005608}
Douglas Gregorbaf69612009-11-18 04:19:12 +00005609
Douglas Gregor68762e72010-08-23 21:17:50 +00005610void Sema::CodeCompleteObjCForCollection(Scope *S,
5611 DeclGroupPtrTy IterationVar) {
5612 CodeCompleteExpressionData Data;
5613 Data.ObjCCollection = true;
5614
5615 if (IterationVar.getAsOpaquePtr()) {
Serge Pavlov9ddb76e2013-08-27 13:15:56 +00005616 DeclGroupRef DG = IterationVar.get();
Douglas Gregor68762e72010-08-23 21:17:50 +00005617 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
5618 if (*I)
5619 Data.IgnoreDecls.push_back(*I);
5620 }
5621 }
5622
5623 CodeCompleteExpression(S, Data);
5624}
5625
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005626void Sema::CodeCompleteObjCSelector(Scope *S,
5627 ArrayRef<IdentifierInfo *> SelIdents) {
Douglas Gregor67c692c2010-08-26 15:07:07 +00005628 // If we have an external source, load the entire class method
5629 // pool from the AST file.
5630 if (ExternalSource) {
5631 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5632 I != N; ++I) {
5633 Selector Sel = ExternalSource->GetExternalSelector(I);
5634 if (Sel.isNull() || MethodPool.count(Sel))
5635 continue;
5636
5637 ReadMethodPool(Sel);
5638 }
5639 }
5640
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005641 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00005642 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005643 CodeCompletionContext::CCC_SelectorName);
Douglas Gregor67c692c2010-08-26 15:07:07 +00005644 Results.EnterNewScope();
5645 for (GlobalMethodPool::iterator M = MethodPool.begin(),
5646 MEnd = MethodPool.end();
5647 M != MEnd; ++M) {
5648
5649 Selector Sel = M->first;
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005650 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents))
Douglas Gregor67c692c2010-08-26 15:07:07 +00005651 continue;
5652
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00005653 CodeCompletionBuilder Builder(Results.getAllocator(),
5654 Results.getCodeCompletionTUInfo());
Douglas Gregor67c692c2010-08-26 15:07:07 +00005655 if (Sel.isUnarySelector()) {
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00005656 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregoraf2a6ae2011-02-18 22:29:55 +00005657 Sel.getNameForSlot(0)));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005658 Results.AddResult(Builder.TakeString());
Douglas Gregor67c692c2010-08-26 15:07:07 +00005659 continue;
5660 }
5661
Douglas Gregor9ac1ad12010-08-26 16:46:39 +00005662 std::string Accumulator;
Douglas Gregor67c692c2010-08-26 15:07:07 +00005663 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00005664 if (I == SelIdents.size()) {
Douglas Gregor9ac1ad12010-08-26 16:46:39 +00005665 if (!Accumulator.empty()) {
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00005666 Builder.AddInformativeChunk(Builder.getAllocator().CopyString(
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005667 Accumulator));
Douglas Gregor9ac1ad12010-08-26 16:46:39 +00005668 Accumulator.clear();
5669 }
5670 }
5671
Benjamin Kramer632500c2011-07-26 16:59:25 +00005672 Accumulator += Sel.getNameForSlot(I);
Douglas Gregor9ac1ad12010-08-26 16:46:39 +00005673 Accumulator += ':';
Douglas Gregor67c692c2010-08-26 15:07:07 +00005674 }
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00005675 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( Accumulator));
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005676 Results.AddResult(Builder.TakeString());
Douglas Gregor67c692c2010-08-26 15:07:07 +00005677 }
5678 Results.ExitScope();
5679
5680 HandleCodeCompleteResults(this, CodeCompleter,
5681 CodeCompletionContext::CCC_SelectorName,
5682 Results.data(), Results.size());
5683}
5684
Douglas Gregorbaf69612009-11-18 04:19:12 +00005685/// \brief Add all of the protocol declarations that we find in the given
5686/// (translation unit) context.
5687static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
Douglas Gregor5b4671c2009-11-18 04:49:41 +00005688 bool OnlyForwardDeclarations,
Douglas Gregorbaf69612009-11-18 04:19:12 +00005689 ResultBuilder &Results) {
John McCall276321a2010-08-25 06:19:51 +00005690 typedef CodeCompletionResult Result;
Douglas Gregorbaf69612009-11-18 04:19:12 +00005691
Aaron Ballman629afae2014-03-07 19:56:05 +00005692 for (const auto *D : Ctx->decls()) {
Douglas Gregorbaf69612009-11-18 04:19:12 +00005693 // Record any protocols we find.
Aaron Ballman629afae2014-03-07 19:56:05 +00005694 if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(D))
Douglas Gregore6e48b12012-01-01 19:29:29 +00005695 if (!OnlyForwardDeclarations || !Proto->hasDefinition())
Douglas Gregor0a0e2b32013-01-31 04:52:16 +00005696 Results.AddResult(Result(Proto, Results.getBasePriority(Proto), 0),
5697 CurContext, 0, false);
Douglas Gregorbaf69612009-11-18 04:19:12 +00005698 }
5699}
5700
5701void Sema::CodeCompleteObjCProtocolReferences(IdentifierLocPair *Protocols,
5702 unsigned NumProtocols) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005703 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00005704 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005705 CodeCompletionContext::CCC_ObjCProtocolName);
Douglas Gregorbaf69612009-11-18 04:19:12 +00005706
Douglas Gregora3b23b02010-12-09 21:44:02 +00005707 if (CodeCompleter && CodeCompleter->includeGlobals()) {
5708 Results.EnterNewScope();
5709
5710 // Tell the result set to ignore all of the protocols we have
5711 // already seen.
5712 // FIXME: This doesn't work when caching code-completion results.
5713 for (unsigned I = 0; I != NumProtocols; ++I)
5714 if (ObjCProtocolDecl *Protocol = LookupProtocol(Protocols[I].first,
5715 Protocols[I].second))
5716 Results.Ignore(Protocol);
Douglas Gregorbaf69612009-11-18 04:19:12 +00005717
Douglas Gregora3b23b02010-12-09 21:44:02 +00005718 // Add all protocols.
5719 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
5720 Results);
Douglas Gregor5b4671c2009-11-18 04:49:41 +00005721
Douglas Gregora3b23b02010-12-09 21:44:02 +00005722 Results.ExitScope();
5723 }
5724
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005725 HandleCodeCompleteResults(this, CodeCompleter,
5726 CodeCompletionContext::CCC_ObjCProtocolName,
5727 Results.data(),Results.size());
Douglas Gregor5b4671c2009-11-18 04:49:41 +00005728}
5729
5730void Sema::CodeCompleteObjCProtocolDecl(Scope *) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005731 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00005732 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005733 CodeCompletionContext::CCC_ObjCProtocolName);
Douglas Gregor5b4671c2009-11-18 04:49:41 +00005734
Douglas Gregora3b23b02010-12-09 21:44:02 +00005735 if (CodeCompleter && CodeCompleter->includeGlobals()) {
5736 Results.EnterNewScope();
5737
5738 // Add all protocols.
5739 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
5740 Results);
Douglas Gregorbaf69612009-11-18 04:19:12 +00005741
Douglas Gregora3b23b02010-12-09 21:44:02 +00005742 Results.ExitScope();
5743 }
5744
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005745 HandleCodeCompleteResults(this, CodeCompleter,
5746 CodeCompletionContext::CCC_ObjCProtocolName,
5747 Results.data(),Results.size());
Douglas Gregorbaf69612009-11-18 04:19:12 +00005748}
Douglas Gregor49c22a72009-11-18 16:26:39 +00005749
5750/// \brief Add all of the Objective-C interface declarations that we find in
5751/// the given (translation unit) context.
5752static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
5753 bool OnlyForwardDeclarations,
5754 bool OnlyUnimplemented,
5755 ResultBuilder &Results) {
John McCall276321a2010-08-25 06:19:51 +00005756 typedef CodeCompletionResult Result;
Douglas Gregor49c22a72009-11-18 16:26:39 +00005757
Aaron Ballman629afae2014-03-07 19:56:05 +00005758 for (const auto *D : Ctx->decls()) {
Douglas Gregor1c283312010-08-11 12:19:30 +00005759 // Record any interfaces we find.
Aaron Ballman629afae2014-03-07 19:56:05 +00005760 if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(D))
Douglas Gregordc9166c2011-12-15 20:29:51 +00005761 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
Douglas Gregor1c283312010-08-11 12:19:30 +00005762 (!OnlyUnimplemented || !Class->getImplementation()))
Douglas Gregor0a0e2b32013-01-31 04:52:16 +00005763 Results.AddResult(Result(Class, Results.getBasePriority(Class), 0),
5764 CurContext, 0, false);
Douglas Gregor49c22a72009-11-18 16:26:39 +00005765 }
5766}
5767
5768void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005769 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00005770 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005771 CodeCompletionContext::CCC_Other);
Douglas Gregor49c22a72009-11-18 16:26:39 +00005772 Results.EnterNewScope();
5773
Douglas Gregor2c595ad2011-07-30 06:55:39 +00005774 if (CodeCompleter->includeGlobals()) {
5775 // Add all classes.
5776 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
5777 false, Results);
5778 }
5779
Douglas Gregor49c22a72009-11-18 16:26:39 +00005780 Results.ExitScope();
Douglas Gregor2c595ad2011-07-30 06:55:39 +00005781
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005782 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor2c595ad2011-07-30 06:55:39 +00005783 CodeCompletionContext::CCC_ObjCInterfaceName,
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005784 Results.data(),Results.size());
Douglas Gregor49c22a72009-11-18 16:26:39 +00005785}
5786
Douglas Gregorb2ccf012010-04-15 22:33:43 +00005787void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName,
5788 SourceLocation ClassNameLoc) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005789 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00005790 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor2c595ad2011-07-30 06:55:39 +00005791 CodeCompletionContext::CCC_ObjCInterfaceName);
Douglas Gregor49c22a72009-11-18 16:26:39 +00005792 Results.EnterNewScope();
5793
5794 // Make sure that we ignore the class we're currently defining.
5795 NamedDecl *CurClass
Douglas Gregorb2ccf012010-04-15 22:33:43 +00005796 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
Douglas Gregor5d34fd32009-11-18 19:08:43 +00005797 if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
Douglas Gregor49c22a72009-11-18 16:26:39 +00005798 Results.Ignore(CurClass);
5799
Douglas Gregor2c595ad2011-07-30 06:55:39 +00005800 if (CodeCompleter->includeGlobals()) {
5801 // Add all classes.
5802 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
5803 false, Results);
5804 }
5805
Douglas Gregor49c22a72009-11-18 16:26:39 +00005806 Results.ExitScope();
Douglas Gregor2c595ad2011-07-30 06:55:39 +00005807
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005808 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor2c595ad2011-07-30 06:55:39 +00005809 CodeCompletionContext::CCC_ObjCInterfaceName,
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005810 Results.data(),Results.size());
Douglas Gregor49c22a72009-11-18 16:26:39 +00005811}
5812
5813void Sema::CodeCompleteObjCImplementationDecl(Scope *S) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005814 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00005815 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005816 CodeCompletionContext::CCC_Other);
Douglas Gregor49c22a72009-11-18 16:26:39 +00005817 Results.EnterNewScope();
5818
Douglas Gregor2c595ad2011-07-30 06:55:39 +00005819 if (CodeCompleter->includeGlobals()) {
5820 // Add all unimplemented classes.
5821 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
5822 true, Results);
5823 }
5824
Douglas Gregor49c22a72009-11-18 16:26:39 +00005825 Results.ExitScope();
Douglas Gregor2c595ad2011-07-30 06:55:39 +00005826
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005827 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor2c595ad2011-07-30 06:55:39 +00005828 CodeCompletionContext::CCC_ObjCInterfaceName,
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005829 Results.data(),Results.size());
Douglas Gregor49c22a72009-11-18 16:26:39 +00005830}
Douglas Gregor5d34fd32009-11-18 19:08:43 +00005831
5832void Sema::CodeCompleteObjCInterfaceCategory(Scope *S,
Douglas Gregorb2ccf012010-04-15 22:33:43 +00005833 IdentifierInfo *ClassName,
5834 SourceLocation ClassNameLoc) {
John McCall276321a2010-08-25 06:19:51 +00005835 typedef CodeCompletionResult Result;
Douglas Gregor5d34fd32009-11-18 19:08:43 +00005836
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005837 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00005838 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor21325842011-07-07 16:03:39 +00005839 CodeCompletionContext::CCC_ObjCCategoryName);
Douglas Gregor5d34fd32009-11-18 19:08:43 +00005840
5841 // Ignore any categories we find that have already been implemented by this
5842 // interface.
5843 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
5844 NamedDecl *CurClass
Douglas Gregorb2ccf012010-04-15 22:33:43 +00005845 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
Douglas Gregor048fbfa2013-01-16 23:00:23 +00005846 if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)){
Aaron Ballman3fe486a2014-03-13 21:23:55 +00005847 for (const auto *Cat : Class->visible_categories())
Douglas Gregor048fbfa2013-01-16 23:00:23 +00005848 CategoryNames.insert(Cat->getIdentifier());
Douglas Gregor048fbfa2013-01-16 23:00:23 +00005849 }
5850
Douglas Gregor5d34fd32009-11-18 19:08:43 +00005851 // Add all of the categories we know about.
5852 Results.EnterNewScope();
5853 TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
Aaron Ballman629afae2014-03-07 19:56:05 +00005854 for (const auto *D : TU->decls())
5855 if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D))
Douglas Gregor5d34fd32009-11-18 19:08:43 +00005856 if (CategoryNames.insert(Category->getIdentifier()))
Douglas Gregor0a0e2b32013-01-31 04:52:16 +00005857 Results.AddResult(Result(Category, Results.getBasePriority(Category),0),
5858 CurContext, 0, false);
Douglas Gregor5d34fd32009-11-18 19:08:43 +00005859 Results.ExitScope();
5860
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005861 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor21325842011-07-07 16:03:39 +00005862 CodeCompletionContext::CCC_ObjCCategoryName,
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005863 Results.data(),Results.size());
Douglas Gregor5d34fd32009-11-18 19:08:43 +00005864}
5865
5866void Sema::CodeCompleteObjCImplementationCategory(Scope *S,
Douglas Gregorb2ccf012010-04-15 22:33:43 +00005867 IdentifierInfo *ClassName,
5868 SourceLocation ClassNameLoc) {
John McCall276321a2010-08-25 06:19:51 +00005869 typedef CodeCompletionResult Result;
Douglas Gregor5d34fd32009-11-18 19:08:43 +00005870
5871 // Find the corresponding interface. If we couldn't find the interface, the
5872 // program itself is ill-formed. However, we'll try to be helpful still by
5873 // providing the list of all of the categories we know about.
5874 NamedDecl *CurClass
Douglas Gregorb2ccf012010-04-15 22:33:43 +00005875 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
Douglas Gregor5d34fd32009-11-18 19:08:43 +00005876 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
5877 if (!Class)
Douglas Gregorb2ccf012010-04-15 22:33:43 +00005878 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
Douglas Gregor5d34fd32009-11-18 19:08:43 +00005879
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005880 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00005881 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor21325842011-07-07 16:03:39 +00005882 CodeCompletionContext::CCC_ObjCCategoryName);
Douglas Gregor5d34fd32009-11-18 19:08:43 +00005883
5884 // Add all of the categories that have have corresponding interface
5885 // declarations in this class and any of its superclasses, except for
5886 // already-implemented categories in the class itself.
5887 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
5888 Results.EnterNewScope();
5889 bool IgnoreImplemented = true;
5890 while (Class) {
Aaron Ballman3fe486a2014-03-13 21:23:55 +00005891 for (const auto *Cat : Class->visible_categories()) {
Douglas Gregor048fbfa2013-01-16 23:00:23 +00005892 if ((!IgnoreImplemented || !Cat->getImplementation()) &&
5893 CategoryNames.insert(Cat->getIdentifier()))
Aaron Ballman3fe486a2014-03-13 21:23:55 +00005894 Results.AddResult(Result(Cat, Results.getBasePriority(Cat), 0),
Douglas Gregor0a0e2b32013-01-31 04:52:16 +00005895 CurContext, 0, false);
Douglas Gregor048fbfa2013-01-16 23:00:23 +00005896 }
Douglas Gregor5d34fd32009-11-18 19:08:43 +00005897
5898 Class = Class->getSuperClass();
5899 IgnoreImplemented = false;
5900 }
5901 Results.ExitScope();
5902
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005903 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor21325842011-07-07 16:03:39 +00005904 CodeCompletionContext::CCC_ObjCCategoryName,
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005905 Results.data(),Results.size());
Douglas Gregor5d34fd32009-11-18 19:08:43 +00005906}
Douglas Gregor5d649882009-11-18 22:32:06 +00005907
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00005908void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005909 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00005910 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005911 CodeCompletionContext::CCC_Other);
Douglas Gregor5d649882009-11-18 22:32:06 +00005912
5913 // Figure out where this @synthesize lives.
5914 ObjCContainerDecl *Container
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00005915 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
Douglas Gregor5d649882009-11-18 22:32:06 +00005916 if (!Container ||
5917 (!isa<ObjCImplementationDecl>(Container) &&
5918 !isa<ObjCCategoryImplDecl>(Container)))
5919 return;
5920
5921 // Ignore any properties that have already been implemented.
Douglas Gregor9b4f3702012-06-12 13:44:08 +00005922 Container = getContainerDef(Container);
Aaron Ballman629afae2014-03-07 19:56:05 +00005923 for (const auto *D : Container->decls())
5924 if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D))
Douglas Gregor5d649882009-11-18 22:32:06 +00005925 Results.Ignore(PropertyImpl->getPropertyDecl());
5926
5927 // Add any properties that we find.
Douglas Gregorb888acf2010-12-09 23:01:55 +00005928 AddedPropertiesSet AddedProperties;
Douglas Gregor5d649882009-11-18 22:32:06 +00005929 Results.EnterNewScope();
5930 if (ObjCImplementationDecl *ClassImpl
5931 = dyn_cast<ObjCImplementationDecl>(Container))
Douglas Gregor95147142011-05-05 15:50:42 +00005932 AddObjCProperties(ClassImpl->getClassInterface(), false,
5933 /*AllowNullaryMethods=*/false, CurContext,
Douglas Gregorb888acf2010-12-09 23:01:55 +00005934 AddedProperties, Results);
Douglas Gregor5d649882009-11-18 22:32:06 +00005935 else
5936 AddObjCProperties(cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
Douglas Gregor95147142011-05-05 15:50:42 +00005937 false, /*AllowNullaryMethods=*/false, CurContext,
5938 AddedProperties, Results);
Douglas Gregor5d649882009-11-18 22:32:06 +00005939 Results.ExitScope();
5940
Douglas Gregor00c37ef2010-08-11 21:23:17 +00005941 HandleCodeCompleteResults(this, CodeCompleter,
5942 CodeCompletionContext::CCC_Other,
5943 Results.data(),Results.size());
Douglas Gregor5d649882009-11-18 22:32:06 +00005944}
5945
5946void Sema::CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00005947 IdentifierInfo *PropertyName) {
John McCall276321a2010-08-25 06:19:51 +00005948 typedef CodeCompletionResult Result;
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005949 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00005950 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00005951 CodeCompletionContext::CCC_Other);
Douglas Gregor5d649882009-11-18 22:32:06 +00005952
5953 // Figure out where this @synthesize lives.
5954 ObjCContainerDecl *Container
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00005955 = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
Douglas Gregor5d649882009-11-18 22:32:06 +00005956 if (!Container ||
5957 (!isa<ObjCImplementationDecl>(Container) &&
5958 !isa<ObjCCategoryImplDecl>(Container)))
5959 return;
5960
5961 // Figure out which interface we're looking into.
5962 ObjCInterfaceDecl *Class = 0;
5963 if (ObjCImplementationDecl *ClassImpl
5964 = dyn_cast<ObjCImplementationDecl>(Container))
5965 Class = ClassImpl->getClassInterface();
5966 else
5967 Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl()
5968 ->getClassInterface();
5969
Douglas Gregor6c7a9ee2011-04-18 14:40:46 +00005970 // Determine the type of the property we're synthesizing.
5971 QualType PropertyType = Context.getObjCIdType();
5972 if (Class) {
5973 if (ObjCPropertyDecl *Property
5974 = Class->FindPropertyDeclaration(PropertyName)) {
5975 PropertyType
5976 = Property->getType().getNonReferenceType().getUnqualifiedType();
5977
5978 // Give preference to ivars
5979 Results.setPreferredType(PropertyType);
5980 }
5981 }
5982
Douglas Gregor5d649882009-11-18 22:32:06 +00005983 // Add all of the instance variables in this class and its superclasses.
5984 Results.EnterNewScope();
Douglas Gregor331faa02011-04-18 14:13:53 +00005985 bool SawSimilarlyNamedIvar = false;
5986 std::string NameWithPrefix;
5987 NameWithPrefix += '_';
Benjamin Kramer632500c2011-07-26 16:59:25 +00005988 NameWithPrefix += PropertyName->getName();
Douglas Gregor331faa02011-04-18 14:13:53 +00005989 std::string NameWithSuffix = PropertyName->getName().str();
5990 NameWithSuffix += '_';
Douglas Gregor5d649882009-11-18 22:32:06 +00005991 for(; Class; Class = Class->getSuperClass()) {
Douglas Gregor331faa02011-04-18 14:13:53 +00005992 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
5993 Ivar = Ivar->getNextIvar()) {
Douglas Gregor0a0e2b32013-01-31 04:52:16 +00005994 Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), 0),
5995 CurContext, 0, false);
Douglas Gregor6c7a9ee2011-04-18 14:40:46 +00005996
Douglas Gregor331faa02011-04-18 14:13:53 +00005997 // Determine whether we've seen an ivar with a name similar to the
5998 // property.
Douglas Gregor6c7a9ee2011-04-18 14:40:46 +00005999 if ((PropertyName == Ivar->getIdentifier() ||
Douglas Gregor331faa02011-04-18 14:13:53 +00006000 NameWithPrefix == Ivar->getName() ||
Douglas Gregor6c7a9ee2011-04-18 14:40:46 +00006001 NameWithSuffix == Ivar->getName())) {
Douglas Gregor331faa02011-04-18 14:13:53 +00006002 SawSimilarlyNamedIvar = true;
Douglas Gregor6c7a9ee2011-04-18 14:40:46 +00006003
6004 // Reduce the priority of this result by one, to give it a slight
6005 // advantage over other results whose names don't match so closely.
6006 if (Results.size() &&
6007 Results.data()[Results.size() - 1].Kind
6008 == CodeCompletionResult::RK_Declaration &&
6009 Results.data()[Results.size() - 1].Declaration == Ivar)
6010 Results.data()[Results.size() - 1].Priority--;
6011 }
Douglas Gregor331faa02011-04-18 14:13:53 +00006012 }
Douglas Gregor5d649882009-11-18 22:32:06 +00006013 }
Douglas Gregor331faa02011-04-18 14:13:53 +00006014
6015 if (!SawSimilarlyNamedIvar) {
6016 // Create ivar result _propName, that the user can use to synthesize
Douglas Gregor6c7a9ee2011-04-18 14:40:46 +00006017 // an ivar of the appropriate type.
6018 unsigned Priority = CCP_MemberDeclaration + 1;
Douglas Gregor331faa02011-04-18 14:13:53 +00006019 typedef CodeCompletionResult Result;
6020 CodeCompletionAllocator &Allocator = Results.getAllocator();
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00006021 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(),
6022 Priority,CXAvailability_Available);
Douglas Gregor331faa02011-04-18 14:13:53 +00006023
Douglas Gregor75acd922011-09-27 23:30:47 +00006024 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
Douglas Gregor6c7a9ee2011-04-18 14:40:46 +00006025 Builder.AddResultTypeChunk(GetCompletionTypeString(PropertyType, Context,
Douglas Gregor75acd922011-09-27 23:30:47 +00006026 Policy, Allocator));
Douglas Gregor331faa02011-04-18 14:13:53 +00006027 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
6028 Results.AddResult(Result(Builder.TakeString(), Priority,
6029 CXCursor_ObjCIvarDecl));
6030 }
6031
Douglas Gregor5d649882009-11-18 22:32:06 +00006032 Results.ExitScope();
6033
Douglas Gregor00c37ef2010-08-11 21:23:17 +00006034 HandleCodeCompleteResults(this, CodeCompleter,
6035 CodeCompletionContext::CCC_Other,
6036 Results.data(),Results.size());
Douglas Gregor5d649882009-11-18 22:32:06 +00006037}
Douglas Gregor636a61e2010-04-07 00:21:17 +00006038
Douglas Gregor416b5752010-08-25 01:08:01 +00006039// Mapping from selectors to the methods that implement that selector, along
6040// with the "in original class" flag.
Benjamin Kramereb8c4462013-06-29 17:52:13 +00006041typedef llvm::DenseMap<
6042 Selector, llvm::PointerIntPair<ObjCMethodDecl *, 1, bool> > KnownMethodsMap;
Douglas Gregor636a61e2010-04-07 00:21:17 +00006043
6044/// \brief Find all of the methods that reside in the given container
6045/// (and its superclasses, protocols, etc.) that meet the given
6046/// criteria. Insert those methods into the map of known methods,
6047/// indexed by selector so they can be easily found.
6048static void FindImplementableMethods(ASTContext &Context,
6049 ObjCContainerDecl *Container,
6050 bool WantInstanceMethods,
6051 QualType ReturnType,
Douglas Gregor416b5752010-08-25 01:08:01 +00006052 KnownMethodsMap &KnownMethods,
6053 bool InOriginalClass = true) {
Douglas Gregor636a61e2010-04-07 00:21:17 +00006054 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
Douglas Gregor9b4f3702012-06-12 13:44:08 +00006055 // Make sure we have a definition; that's what we'll walk.
Douglas Gregorc0ac7d62011-12-15 05:27:12 +00006056 if (!IFace->hasDefinition())
6057 return;
Douglas Gregor9b4f3702012-06-12 13:44:08 +00006058
6059 IFace = IFace->getDefinition();
6060 Container = IFace;
Douglas Gregorc0ac7d62011-12-15 05:27:12 +00006061
Douglas Gregor636a61e2010-04-07 00:21:17 +00006062 const ObjCList<ObjCProtocolDecl> &Protocols
6063 = IFace->getReferencedProtocols();
6064 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
Douglas Gregor1b035bb2010-10-18 18:21:28 +00006065 E = Protocols.end();
Douglas Gregor636a61e2010-04-07 00:21:17 +00006066 I != E; ++I)
6067 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
Douglas Gregor1b035bb2010-10-18 18:21:28 +00006068 KnownMethods, InOriginalClass);
Douglas Gregor636a61e2010-04-07 00:21:17 +00006069
Douglas Gregor1b035bb2010-10-18 18:21:28 +00006070 // Add methods from any class extensions and categories.
Aaron Ballman3fe486a2014-03-13 21:23:55 +00006071 for (auto *Cat : IFace->visible_categories()) {
6072 FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType,
Douglas Gregor1b035bb2010-10-18 18:21:28 +00006073 KnownMethods, false);
Douglas Gregor048fbfa2013-01-16 23:00:23 +00006074 }
6075
Douglas Gregor1b035bb2010-10-18 18:21:28 +00006076 // Visit the superclass.
6077 if (IFace->getSuperClass())
6078 FindImplementableMethods(Context, IFace->getSuperClass(),
6079 WantInstanceMethods, ReturnType,
6080 KnownMethods, false);
Douglas Gregor636a61e2010-04-07 00:21:17 +00006081 }
6082
6083 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
6084 // Recurse into protocols.
6085 const ObjCList<ObjCProtocolDecl> &Protocols
6086 = Category->getReferencedProtocols();
6087 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
Douglas Gregor1b035bb2010-10-18 18:21:28 +00006088 E = Protocols.end();
Douglas Gregor636a61e2010-04-07 00:21:17 +00006089 I != E; ++I)
6090 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
Douglas Gregor1b035bb2010-10-18 18:21:28 +00006091 KnownMethods, InOriginalClass);
6092
6093 // If this category is the original class, jump to the interface.
6094 if (InOriginalClass && Category->getClassInterface())
6095 FindImplementableMethods(Context, Category->getClassInterface(),
6096 WantInstanceMethods, ReturnType, KnownMethods,
6097 false);
Douglas Gregor636a61e2010-04-07 00:21:17 +00006098 }
6099
6100 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
Douglas Gregor9b4f3702012-06-12 13:44:08 +00006101 // Make sure we have a definition; that's what we'll walk.
6102 if (!Protocol->hasDefinition())
6103 return;
6104 Protocol = Protocol->getDefinition();
6105 Container = Protocol;
6106
6107 // Recurse into protocols.
6108 const ObjCList<ObjCProtocolDecl> &Protocols
6109 = Protocol->getReferencedProtocols();
6110 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6111 E = Protocols.end();
6112 I != E; ++I)
6113 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6114 KnownMethods, false);
Douglas Gregor636a61e2010-04-07 00:21:17 +00006115 }
6116
6117 // Add methods in this container. This operation occurs last because
6118 // we want the methods from this container to override any methods
6119 // we've previously seen with the same selector.
Aaron Ballmanaff18c02014-03-13 19:03:34 +00006120 for (auto *M : Container->methods()) {
David Blaikie2d7c57e2012-04-30 02:36:29 +00006121 if (M->isInstanceMethod() == WantInstanceMethods) {
Douglas Gregor636a61e2010-04-07 00:21:17 +00006122 if (!ReturnType.isNull() &&
Alp Toker314cc812014-01-25 16:55:45 +00006123 !Context.hasSameUnqualifiedType(ReturnType, M->getReturnType()))
Douglas Gregor636a61e2010-04-07 00:21:17 +00006124 continue;
6125
Benjamin Kramereb8c4462013-06-29 17:52:13 +00006126 KnownMethods[M->getSelector()] =
Aaron Ballmanaff18c02014-03-13 19:03:34 +00006127 KnownMethodsMap::mapped_type(M, InOriginalClass);
Douglas Gregor636a61e2010-04-07 00:21:17 +00006128 }
6129 }
6130}
6131
Douglas Gregor669a25a2011-02-17 00:22:45 +00006132/// \brief Add the parenthesized return or parameter type chunk to a code
6133/// completion string.
6134static void AddObjCPassingTypeChunk(QualType Type,
Douglas Gregor29979142012-04-10 18:35:07 +00006135 unsigned ObjCDeclQuals,
Douglas Gregor669a25a2011-02-17 00:22:45 +00006136 ASTContext &Context,
Douglas Gregor75acd922011-09-27 23:30:47 +00006137 const PrintingPolicy &Policy,
Douglas Gregor669a25a2011-02-17 00:22:45 +00006138 CodeCompletionBuilder &Builder) {
6139 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
Douglas Gregor29979142012-04-10 18:35:07 +00006140 std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals);
6141 if (!Quals.empty())
6142 Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals));
Douglas Gregor75acd922011-09-27 23:30:47 +00006143 Builder.AddTextChunk(GetCompletionTypeString(Type, Context, Policy,
Douglas Gregor669a25a2011-02-17 00:22:45 +00006144 Builder.getAllocator()));
6145 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6146}
6147
6148/// \brief Determine whether the given class is or inherits from a class by
6149/// the given name.
6150static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006151 StringRef Name) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006152 if (!Class)
6153 return false;
6154
6155 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
6156 return true;
6157
6158 return InheritsFromClassNamed(Class->getSuperClass(), Name);
6159}
6160
6161/// \brief Add code completions for Objective-C Key-Value Coding (KVC) and
6162/// Key-Value Observing (KVO).
6163static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property,
6164 bool IsInstanceMethod,
6165 QualType ReturnType,
6166 ASTContext &Context,
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006167 VisitedSelectorSet &KnownSelectors,
Douglas Gregor669a25a2011-02-17 00:22:45 +00006168 ResultBuilder &Results) {
6169 IdentifierInfo *PropName = Property->getIdentifier();
6170 if (!PropName || PropName->getLength() == 0)
6171 return;
6172
Douglas Gregor75acd922011-09-27 23:30:47 +00006173 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
6174
Douglas Gregor669a25a2011-02-17 00:22:45 +00006175 // Builder that will create each code completion.
6176 typedef CodeCompletionResult Result;
6177 CodeCompletionAllocator &Allocator = Results.getAllocator();
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00006178 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
Douglas Gregor669a25a2011-02-17 00:22:45 +00006179
6180 // The selector table.
6181 SelectorTable &Selectors = Context.Selectors;
6182
6183 // The property name, copied into the code completion allocation region
6184 // on demand.
6185 struct KeyHolder {
6186 CodeCompletionAllocator &Allocator;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006187 StringRef Key;
Douglas Gregor669a25a2011-02-17 00:22:45 +00006188 const char *CopiedKey;
6189
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006190 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
Douglas Gregor669a25a2011-02-17 00:22:45 +00006191 : Allocator(Allocator), Key(Key), CopiedKey(0) { }
6192
6193 operator const char *() {
6194 if (CopiedKey)
6195 return CopiedKey;
6196
6197 return CopiedKey = Allocator.CopyString(Key);
6198 }
6199 } Key(Allocator, PropName->getName());
6200
6201 // The uppercased name of the property name.
6202 std::string UpperKey = PropName->getName();
6203 if (!UpperKey.empty())
Jordan Rose4938f272013-02-09 10:09:43 +00006204 UpperKey[0] = toUppercase(UpperKey[0]);
Douglas Gregor669a25a2011-02-17 00:22:45 +00006205
6206 bool ReturnTypeMatchesProperty = ReturnType.isNull() ||
6207 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
6208 Property->getType());
6209 bool ReturnTypeMatchesVoid
6210 = ReturnType.isNull() || ReturnType->isVoidType();
6211
6212 // Add the normal accessor -(type)key.
6213 if (IsInstanceMethod &&
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006214 KnownSelectors.insert(Selectors.getNullarySelector(PropName)) &&
Douglas Gregor669a25a2011-02-17 00:22:45 +00006215 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
6216 if (ReturnType.isNull())
Douglas Gregor29979142012-04-10 18:35:07 +00006217 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6218 Context, Policy, Builder);
Douglas Gregor669a25a2011-02-17 00:22:45 +00006219
6220 Builder.AddTypedTextChunk(Key);
6221 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6222 CXCursor_ObjCInstanceMethodDecl));
6223 }
6224
6225 // If we have an integral or boolean property (or the user has provided
6226 // an integral or boolean return type), add the accessor -(type)isKey.
6227 if (IsInstanceMethod &&
6228 ((!ReturnType.isNull() &&
6229 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
6230 (ReturnType.isNull() &&
6231 (Property->getType()->isIntegerType() ||
6232 Property->getType()->isBooleanType())))) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006233 std::string SelectorName = (Twine("is") + UpperKey).str();
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006234 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006235 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006236 if (ReturnType.isNull()) {
6237 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6238 Builder.AddTextChunk("BOOL");
6239 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6240 }
6241
6242 Builder.AddTypedTextChunk(
6243 Allocator.CopyString(SelectorId->getName()));
6244 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6245 CXCursor_ObjCInstanceMethodDecl));
6246 }
6247 }
6248
6249 // Add the normal mutator.
6250 if (IsInstanceMethod && ReturnTypeMatchesVoid &&
6251 !Property->getSetterMethodDecl()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006252 std::string SelectorName = (Twine("set") + UpperKey).str();
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006253 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006254 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006255 if (ReturnType.isNull()) {
6256 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6257 Builder.AddTextChunk("void");
6258 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6259 }
6260
6261 Builder.AddTypedTextChunk(
6262 Allocator.CopyString(SelectorId->getName()));
6263 Builder.AddTypedTextChunk(":");
Douglas Gregor29979142012-04-10 18:35:07 +00006264 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6265 Context, Policy, Builder);
Douglas Gregor669a25a2011-02-17 00:22:45 +00006266 Builder.AddTextChunk(Key);
6267 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6268 CXCursor_ObjCInstanceMethodDecl));
6269 }
6270 }
6271
6272 // Indexed and unordered accessors
6273 unsigned IndexedGetterPriority = CCP_CodePattern;
6274 unsigned IndexedSetterPriority = CCP_CodePattern;
6275 unsigned UnorderedGetterPriority = CCP_CodePattern;
6276 unsigned UnorderedSetterPriority = CCP_CodePattern;
6277 if (const ObjCObjectPointerType *ObjCPointer
6278 = Property->getType()->getAs<ObjCObjectPointerType>()) {
6279 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
6280 // If this interface type is not provably derived from a known
6281 // collection, penalize the corresponding completions.
6282 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
6283 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6284 if (!InheritsFromClassNamed(IFace, "NSArray"))
6285 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6286 }
6287
6288 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
6289 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6290 if (!InheritsFromClassNamed(IFace, "NSSet"))
6291 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6292 }
6293 }
6294 } else {
6295 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6296 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6297 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6298 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6299 }
6300
6301 // Add -(NSUInteger)countOf<key>
6302 if (IsInstanceMethod &&
6303 (ReturnType.isNull() || ReturnType->isIntegerType())) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006304 std::string SelectorName = (Twine("countOf") + UpperKey).str();
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006305 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006306 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006307 if (ReturnType.isNull()) {
6308 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6309 Builder.AddTextChunk("NSUInteger");
6310 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6311 }
6312
6313 Builder.AddTypedTextChunk(
6314 Allocator.CopyString(SelectorId->getName()));
6315 Results.AddResult(Result(Builder.TakeString(),
6316 std::min(IndexedGetterPriority,
6317 UnorderedGetterPriority),
6318 CXCursor_ObjCInstanceMethodDecl));
6319 }
6320 }
6321
6322 // Indexed getters
6323 // Add -(id)objectInKeyAtIndex:(NSUInteger)index
6324 if (IsInstanceMethod &&
6325 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006326 std::string SelectorName
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006327 = (Twine("objectIn") + UpperKey + "AtIndex").str();
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006328 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006329 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006330 if (ReturnType.isNull()) {
6331 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6332 Builder.AddTextChunk("id");
6333 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6334 }
6335
6336 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6337 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6338 Builder.AddTextChunk("NSUInteger");
6339 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6340 Builder.AddTextChunk("index");
6341 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6342 CXCursor_ObjCInstanceMethodDecl));
6343 }
6344 }
6345
6346 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
6347 if (IsInstanceMethod &&
6348 (ReturnType.isNull() ||
6349 (ReturnType->isObjCObjectPointerType() &&
6350 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6351 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6352 ->getName() == "NSArray"))) {
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006353 std::string SelectorName
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006354 = (Twine(Property->getName()) + "AtIndexes").str();
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006355 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006356 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006357 if (ReturnType.isNull()) {
6358 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6359 Builder.AddTextChunk("NSArray *");
6360 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6361 }
6362
6363 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6364 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6365 Builder.AddTextChunk("NSIndexSet *");
6366 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6367 Builder.AddTextChunk("indexes");
6368 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6369 CXCursor_ObjCInstanceMethodDecl));
6370 }
6371 }
6372
6373 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
6374 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006375 std::string SelectorName = (Twine("get") + UpperKey).str();
Douglas Gregor669a25a2011-02-17 00:22:45 +00006376 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006377 &Context.Idents.get(SelectorName),
Douglas Gregor669a25a2011-02-17 00:22:45 +00006378 &Context.Idents.get("range")
6379 };
6380
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006381 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006382 if (ReturnType.isNull()) {
6383 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6384 Builder.AddTextChunk("void");
6385 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6386 }
6387
6388 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6389 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6390 Builder.AddPlaceholderChunk("object-type");
6391 Builder.AddTextChunk(" **");
6392 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6393 Builder.AddTextChunk("buffer");
6394 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6395 Builder.AddTypedTextChunk("range:");
6396 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6397 Builder.AddTextChunk("NSRange");
6398 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6399 Builder.AddTextChunk("inRange");
6400 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6401 CXCursor_ObjCInstanceMethodDecl));
6402 }
6403 }
6404
6405 // Mutable indexed accessors
6406
6407 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
6408 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006409 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
Douglas Gregor669a25a2011-02-17 00:22:45 +00006410 IdentifierInfo *SelectorIds[2] = {
6411 &Context.Idents.get("insertObject"),
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006412 &Context.Idents.get(SelectorName)
Douglas Gregor669a25a2011-02-17 00:22:45 +00006413 };
6414
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006415 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006416 if (ReturnType.isNull()) {
6417 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6418 Builder.AddTextChunk("void");
6419 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6420 }
6421
6422 Builder.AddTypedTextChunk("insertObject:");
6423 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6424 Builder.AddPlaceholderChunk("object-type");
6425 Builder.AddTextChunk(" *");
6426 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6427 Builder.AddTextChunk("object");
6428 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6429 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6430 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6431 Builder.AddPlaceholderChunk("NSUInteger");
6432 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6433 Builder.AddTextChunk("index");
6434 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6435 CXCursor_ObjCInstanceMethodDecl));
6436 }
6437 }
6438
6439 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
6440 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006441 std::string SelectorName = (Twine("insert") + UpperKey).str();
Douglas Gregor669a25a2011-02-17 00:22:45 +00006442 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006443 &Context.Idents.get(SelectorName),
Douglas Gregor669a25a2011-02-17 00:22:45 +00006444 &Context.Idents.get("atIndexes")
6445 };
6446
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006447 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006448 if (ReturnType.isNull()) {
6449 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6450 Builder.AddTextChunk("void");
6451 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6452 }
6453
6454 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6455 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6456 Builder.AddTextChunk("NSArray *");
6457 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6458 Builder.AddTextChunk("array");
6459 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6460 Builder.AddTypedTextChunk("atIndexes:");
6461 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6462 Builder.AddPlaceholderChunk("NSIndexSet *");
6463 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6464 Builder.AddTextChunk("indexes");
6465 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6466 CXCursor_ObjCInstanceMethodDecl));
6467 }
6468 }
6469
6470 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
6471 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006472 std::string SelectorName
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006473 = (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006474 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006475 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006476 if (ReturnType.isNull()) {
6477 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6478 Builder.AddTextChunk("void");
6479 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6480 }
6481
6482 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6483 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6484 Builder.AddTextChunk("NSUInteger");
6485 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6486 Builder.AddTextChunk("index");
6487 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6488 CXCursor_ObjCInstanceMethodDecl));
6489 }
6490 }
6491
6492 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
6493 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006494 std::string SelectorName
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006495 = (Twine("remove") + UpperKey + "AtIndexes").str();
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006496 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006497 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006498 if (ReturnType.isNull()) {
6499 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6500 Builder.AddTextChunk("void");
6501 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6502 }
6503
6504 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6505 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6506 Builder.AddTextChunk("NSIndexSet *");
6507 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6508 Builder.AddTextChunk("indexes");
6509 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6510 CXCursor_ObjCInstanceMethodDecl));
6511 }
6512 }
6513
6514 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
6515 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006516 std::string SelectorName
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006517 = (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
Douglas Gregor669a25a2011-02-17 00:22:45 +00006518 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006519 &Context.Idents.get(SelectorName),
Douglas Gregor669a25a2011-02-17 00:22:45 +00006520 &Context.Idents.get("withObject")
6521 };
6522
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006523 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006524 if (ReturnType.isNull()) {
6525 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6526 Builder.AddTextChunk("void");
6527 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6528 }
6529
6530 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6531 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6532 Builder.AddPlaceholderChunk("NSUInteger");
6533 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6534 Builder.AddTextChunk("index");
6535 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6536 Builder.AddTypedTextChunk("withObject:");
6537 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6538 Builder.AddTextChunk("id");
6539 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6540 Builder.AddTextChunk("object");
6541 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6542 CXCursor_ObjCInstanceMethodDecl));
6543 }
6544 }
6545
6546 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
6547 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006548 std::string SelectorName1
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006549 = (Twine("replace") + UpperKey + "AtIndexes").str();
6550 std::string SelectorName2 = (Twine("with") + UpperKey).str();
Douglas Gregor669a25a2011-02-17 00:22:45 +00006551 IdentifierInfo *SelectorIds[2] = {
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006552 &Context.Idents.get(SelectorName1),
6553 &Context.Idents.get(SelectorName2)
Douglas Gregor669a25a2011-02-17 00:22:45 +00006554 };
6555
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006556 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds))) {
Douglas Gregor669a25a2011-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(SelectorName1 + ":"));
6564 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6565 Builder.AddPlaceholderChunk("NSIndexSet *");
6566 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6567 Builder.AddTextChunk("indexes");
6568 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6569 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
6570 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6571 Builder.AddTextChunk("NSArray *");
6572 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6573 Builder.AddTextChunk("array");
6574 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6575 CXCursor_ObjCInstanceMethodDecl));
6576 }
6577 }
6578
6579 // Unordered getters
6580 // - (NSEnumerator *)enumeratorOfKey
6581 if (IsInstanceMethod &&
6582 (ReturnType.isNull() ||
6583 (ReturnType->isObjCObjectPointerType() &&
6584 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6585 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6586 ->getName() == "NSEnumerator"))) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006587 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006588 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006589 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006590 if (ReturnType.isNull()) {
6591 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6592 Builder.AddTextChunk("NSEnumerator *");
6593 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6594 }
6595
6596 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6597 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6598 CXCursor_ObjCInstanceMethodDecl));
6599 }
6600 }
6601
6602 // - (type *)memberOfKey:(type *)object
6603 if (IsInstanceMethod &&
6604 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006605 std::string SelectorName = (Twine("memberOf") + UpperKey).str();
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006606 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006607 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006608 if (ReturnType.isNull()) {
6609 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6610 Builder.AddPlaceholderChunk("object-type");
6611 Builder.AddTextChunk(" *");
6612 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6613 }
6614
6615 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6616 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6617 if (ReturnType.isNull()) {
6618 Builder.AddPlaceholderChunk("object-type");
6619 Builder.AddTextChunk(" *");
6620 } else {
6621 Builder.AddTextChunk(GetCompletionTypeString(ReturnType, Context,
Douglas Gregor75acd922011-09-27 23:30:47 +00006622 Policy,
Douglas Gregor669a25a2011-02-17 00:22:45 +00006623 Builder.getAllocator()));
6624 }
6625 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6626 Builder.AddTextChunk("object");
6627 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6628 CXCursor_ObjCInstanceMethodDecl));
6629 }
6630 }
6631
6632 // Mutable unordered accessors
6633 // - (void)addKeyObject:(type *)object
6634 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006635 std::string SelectorName
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006636 = (Twine("add") + UpperKey + Twine("Object")).str();
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006637 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006638 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006639 if (ReturnType.isNull()) {
6640 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6641 Builder.AddTextChunk("void");
6642 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6643 }
6644
6645 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6646 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6647 Builder.AddPlaceholderChunk("object-type");
6648 Builder.AddTextChunk(" *");
6649 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6650 Builder.AddTextChunk("object");
6651 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6652 CXCursor_ObjCInstanceMethodDecl));
6653 }
6654 }
6655
6656 // - (void)addKey:(NSSet *)objects
6657 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006658 std::string SelectorName = (Twine("add") + UpperKey).str();
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006659 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006660 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006661 if (ReturnType.isNull()) {
6662 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6663 Builder.AddTextChunk("void");
6664 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6665 }
6666
6667 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6668 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6669 Builder.AddTextChunk("NSSet *");
6670 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6671 Builder.AddTextChunk("objects");
6672 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6673 CXCursor_ObjCInstanceMethodDecl));
6674 }
6675 }
6676
6677 // - (void)removeKeyObject:(type *)object
6678 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006679 std::string SelectorName
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006680 = (Twine("remove") + UpperKey + Twine("Object")).str();
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006681 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006682 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006683 if (ReturnType.isNull()) {
6684 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6685 Builder.AddTextChunk("void");
6686 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6687 }
6688
6689 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6690 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6691 Builder.AddPlaceholderChunk("object-type");
6692 Builder.AddTextChunk(" *");
6693 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6694 Builder.AddTextChunk("object");
6695 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6696 CXCursor_ObjCInstanceMethodDecl));
6697 }
6698 }
6699
6700 // - (void)removeKey:(NSSet *)objects
6701 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006702 std::string SelectorName = (Twine("remove") + UpperKey).str();
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006703 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006704 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006705 if (ReturnType.isNull()) {
6706 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6707 Builder.AddTextChunk("void");
6708 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6709 }
6710
6711 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6712 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6713 Builder.AddTextChunk("NSSet *");
6714 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6715 Builder.AddTextChunk("objects");
6716 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6717 CXCursor_ObjCInstanceMethodDecl));
6718 }
6719 }
6720
6721 // - (void)intersectKey:(NSSet *)objects
6722 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006723 std::string SelectorName = (Twine("intersect") + UpperKey).str();
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006724 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006725 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006726 if (ReturnType.isNull()) {
6727 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6728 Builder.AddTextChunk("void");
6729 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6730 }
6731
6732 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6733 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6734 Builder.AddTextChunk("NSSet *");
6735 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6736 Builder.AddTextChunk("objects");
6737 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6738 CXCursor_ObjCInstanceMethodDecl));
6739 }
6740 }
6741
6742 // Key-Value Observing
6743 // + (NSSet *)keyPathsForValuesAffectingKey
6744 if (!IsInstanceMethod &&
6745 (ReturnType.isNull() ||
6746 (ReturnType->isObjCObjectPointerType() &&
6747 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6748 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6749 ->getName() == "NSSet"))) {
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006750 std::string SelectorName
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006751 = (Twine("keyPathsForValuesAffecting") + UpperKey).str();
Douglas Gregor0e5d72f2011-02-17 03:19:26 +00006752 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006753 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
Douglas Gregor669a25a2011-02-17 00:22:45 +00006754 if (ReturnType.isNull()) {
6755 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6756 Builder.AddTextChunk("NSSet *");
6757 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6758 }
6759
6760 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6761 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
Douglas Gregor857bcda2011-06-02 04:02:27 +00006762 CXCursor_ObjCClassMethodDecl));
6763 }
6764 }
6765
6766 // + (BOOL)automaticallyNotifiesObserversForKey
6767 if (!IsInstanceMethod &&
6768 (ReturnType.isNull() ||
6769 ReturnType->isIntegerType() ||
6770 ReturnType->isBooleanType())) {
6771 std::string SelectorName
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006772 = (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
Douglas Gregor857bcda2011-06-02 04:02:27 +00006773 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6774 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))) {
6775 if (ReturnType.isNull()) {
6776 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6777 Builder.AddTextChunk("BOOL");
6778 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6779 }
6780
6781 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6782 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6783 CXCursor_ObjCClassMethodDecl));
Douglas Gregor669a25a2011-02-17 00:22:45 +00006784 }
6785 }
6786}
6787
Douglas Gregor636a61e2010-04-07 00:21:17 +00006788void Sema::CodeCompleteObjCMethodDecl(Scope *S,
6789 bool IsInstanceMethod,
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00006790 ParsedType ReturnTy) {
Douglas Gregor636a61e2010-04-07 00:21:17 +00006791 // Determine the return type of the method we're declaring, if
6792 // provided.
6793 QualType ReturnType = GetTypeFromParser(ReturnTy);
Fariborz Jahanian8d382dc2011-08-22 15:54:49 +00006794 Decl *IDecl = 0;
6795 if (CurContext->isObjCContainer()) {
6796 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
6797 IDecl = cast<Decl>(OCD);
6798 }
Douglas Gregor1b035bb2010-10-18 18:21:28 +00006799 // Determine where we should start searching for methods.
6800 ObjCContainerDecl *SearchDecl = 0;
Douglas Gregor636a61e2010-04-07 00:21:17 +00006801 bool IsInImplementation = false;
John McCall48871652010-08-21 09:40:31 +00006802 if (Decl *D = IDecl) {
Douglas Gregor636a61e2010-04-07 00:21:17 +00006803 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
6804 SearchDecl = Impl->getClassInterface();
Douglas Gregor636a61e2010-04-07 00:21:17 +00006805 IsInImplementation = true;
6806 } else if (ObjCCategoryImplDecl *CatImpl
Douglas Gregor1b035bb2010-10-18 18:21:28 +00006807 = dyn_cast<ObjCCategoryImplDecl>(D)) {
Douglas Gregor636a61e2010-04-07 00:21:17 +00006808 SearchDecl = CatImpl->getCategoryDecl();
Douglas Gregor636a61e2010-04-07 00:21:17 +00006809 IsInImplementation = true;
Douglas Gregor1b035bb2010-10-18 18:21:28 +00006810 } else
Douglas Gregor636a61e2010-04-07 00:21:17 +00006811 SearchDecl = dyn_cast<ObjCContainerDecl>(D);
Douglas Gregor636a61e2010-04-07 00:21:17 +00006812 }
6813
6814 if (!SearchDecl && S) {
Ted Kremenekc37877d2013-10-08 17:08:03 +00006815 if (DeclContext *DC = S->getEntity())
Douglas Gregor636a61e2010-04-07 00:21:17 +00006816 SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
Douglas Gregor636a61e2010-04-07 00:21:17 +00006817 }
6818
Douglas Gregor1b035bb2010-10-18 18:21:28 +00006819 if (!SearchDecl) {
Douglas Gregor00c37ef2010-08-11 21:23:17 +00006820 HandleCodeCompleteResults(this, CodeCompleter,
6821 CodeCompletionContext::CCC_Other,
6822 0, 0);
Douglas Gregor636a61e2010-04-07 00:21:17 +00006823 return;
6824 }
6825
6826 // Find all of the methods that we could declare/implement here.
6827 KnownMethodsMap KnownMethods;
6828 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod,
Douglas Gregor1b035bb2010-10-18 18:21:28 +00006829 ReturnType, KnownMethods);
Douglas Gregor636a61e2010-04-07 00:21:17 +00006830
Douglas Gregor636a61e2010-04-07 00:21:17 +00006831 // Add declarations or definitions for each of the known methods.
John McCall276321a2010-08-25 06:19:51 +00006832 typedef CodeCompletionResult Result;
Douglas Gregorb278aaf2011-02-01 19:23:04 +00006833 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00006834 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00006835 CodeCompletionContext::CCC_Other);
Douglas Gregor636a61e2010-04-07 00:21:17 +00006836 Results.EnterNewScope();
Douglas Gregor75acd922011-09-27 23:30:47 +00006837 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
Douglas Gregor636a61e2010-04-07 00:21:17 +00006838 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
6839 MEnd = KnownMethods.end();
6840 M != MEnd; ++M) {
Benjamin Kramereb8c4462013-06-29 17:52:13 +00006841 ObjCMethodDecl *Method = M->second.getPointer();
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00006842 CodeCompletionBuilder Builder(Results.getAllocator(),
6843 Results.getCodeCompletionTUInfo());
Douglas Gregor636a61e2010-04-07 00:21:17 +00006844
6845 // If the result type was not already provided, add it to the
6846 // pattern as (type).
Douglas Gregor669a25a2011-02-17 00:22:45 +00006847 if (ReturnType.isNull())
Alp Toker314cc812014-01-25 16:55:45 +00006848 AddObjCPassingTypeChunk(Method->getReturnType(),
6849 Method->getObjCDeclQualifier(), Context, Policy,
6850 Builder);
Douglas Gregor636a61e2010-04-07 00:21:17 +00006851
6852 Selector Sel = Method->getSelector();
6853
6854 // Add the first part of the selector to the pattern.
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00006855 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregoraf2a6ae2011-02-18 22:29:55 +00006856 Sel.getNameForSlot(0)));
Douglas Gregor636a61e2010-04-07 00:21:17 +00006857
6858 // Add parameters to the pattern.
6859 unsigned I = 0;
6860 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
6861 PEnd = Method->param_end();
6862 P != PEnd; (void)++P, ++I) {
6863 // Add the part of the selector name.
6864 if (I == 0)
Douglas Gregorb278aaf2011-02-01 19:23:04 +00006865 Builder.AddTypedTextChunk(":");
Douglas Gregor636a61e2010-04-07 00:21:17 +00006866 else if (I < Sel.getNumArgs()) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00006867 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6868 Builder.AddTypedTextChunk(
Douglas Gregoraf2a6ae2011-02-18 22:29:55 +00006869 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
Douglas Gregor636a61e2010-04-07 00:21:17 +00006870 } else
6871 break;
6872
6873 // Add the parameter type.
Douglas Gregor29979142012-04-10 18:35:07 +00006874 AddObjCPassingTypeChunk((*P)->getOriginalType(),
6875 (*P)->getObjCDeclQualifier(),
6876 Context, Policy,
Douglas Gregor75acd922011-09-27 23:30:47 +00006877 Builder);
Douglas Gregor636a61e2010-04-07 00:21:17 +00006878
6879 if (IdentifierInfo *Id = (*P)->getIdentifier())
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00006880 Builder.AddTextChunk(Builder.getAllocator().CopyString( Id->getName()));
Douglas Gregor636a61e2010-04-07 00:21:17 +00006881 }
6882
6883 if (Method->isVariadic()) {
6884 if (Method->param_size() > 0)
Douglas Gregorb278aaf2011-02-01 19:23:04 +00006885 Builder.AddChunk(CodeCompletionString::CK_Comma);
6886 Builder.AddTextChunk("...");
Douglas Gregor400f5972010-08-31 05:13:43 +00006887 }
Douglas Gregor636a61e2010-04-07 00:21:17 +00006888
Douglas Gregord37c59d2010-05-28 00:57:46 +00006889 if (IsInImplementation && Results.includeCodePatterns()) {
Douglas Gregor636a61e2010-04-07 00:21:17 +00006890 // We will be defining the method here, so add a compound statement.
Douglas Gregorb278aaf2011-02-01 19:23:04 +00006891 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6892 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
6893 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
Alp Toker314cc812014-01-25 16:55:45 +00006894 if (!Method->getReturnType()->isVoidType()) {
Douglas Gregor636a61e2010-04-07 00:21:17 +00006895 // If the result type is not void, add a return clause.
Douglas Gregorb278aaf2011-02-01 19:23:04 +00006896 Builder.AddTextChunk("return");
6897 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6898 Builder.AddPlaceholderChunk("expression");
6899 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
Douglas Gregor636a61e2010-04-07 00:21:17 +00006900 } else
Douglas Gregorb278aaf2011-02-01 19:23:04 +00006901 Builder.AddPlaceholderChunk("statements");
Douglas Gregor636a61e2010-04-07 00:21:17 +00006902
Douglas Gregorb278aaf2011-02-01 19:23:04 +00006903 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
6904 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
Douglas Gregor636a61e2010-04-07 00:21:17 +00006905 }
6906
Douglas Gregor416b5752010-08-25 01:08:01 +00006907 unsigned Priority = CCP_CodePattern;
Benjamin Kramereb8c4462013-06-29 17:52:13 +00006908 if (!M->second.getInt())
Douglas Gregor416b5752010-08-25 01:08:01 +00006909 Priority += CCD_InBaseClass;
6910
Douglas Gregor78254c82012-03-27 23:34:16 +00006911 Results.AddResult(Result(Builder.TakeString(), Method, Priority));
Douglas Gregor636a61e2010-04-07 00:21:17 +00006912 }
6913
Douglas Gregor669a25a2011-02-17 00:22:45 +00006914 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
6915 // the properties in this class and its categories.
David Blaikiebbafb8a2012-03-11 07:00:24 +00006916 if (Context.getLangOpts().ObjC2) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006917 SmallVector<ObjCContainerDecl *, 4> Containers;
Douglas Gregor669a25a2011-02-17 00:22:45 +00006918 Containers.push_back(SearchDecl);
6919
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006920 VisitedSelectorSet KnownSelectors;
6921 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
6922 MEnd = KnownMethods.end();
6923 M != MEnd; ++M)
6924 KnownSelectors.insert(M->first);
6925
6926
Douglas Gregor669a25a2011-02-17 00:22:45 +00006927 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
6928 if (!IFace)
6929 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
6930 IFace = Category->getClassInterface();
6931
Aaron Ballman3fe486a2014-03-13 21:23:55 +00006932 if (IFace)
6933 for (auto *Cat : IFace->visible_categories())
6934 Containers.push_back(Cat);
Douglas Gregor669a25a2011-02-17 00:22:45 +00006935
Aaron Ballmandc4bea42014-03-13 18:47:37 +00006936 for (unsigned I = 0, N = Containers.size(); I != N; ++I)
Aaron Ballmand174edf2014-03-13 19:11:50 +00006937 for (auto *P : Containers[I]->properties())
Aaron Ballmandc4bea42014-03-13 18:47:37 +00006938 AddObjCKeyValueCompletions(P, IsInstanceMethod, ReturnType, Context,
Douglas Gregord4a8ced2011-05-04 23:50:46 +00006939 KnownSelectors, Results);
Douglas Gregor669a25a2011-02-17 00:22:45 +00006940 }
6941
Douglas Gregor636a61e2010-04-07 00:21:17 +00006942 Results.ExitScope();
6943
Douglas Gregor00c37ef2010-08-11 21:23:17 +00006944 HandleCodeCompleteResults(this, CodeCompleter,
6945 CodeCompletionContext::CCC_Other,
6946 Results.data(),Results.size());
Douglas Gregor636a61e2010-04-07 00:21:17 +00006947}
Douglas Gregor95887f92010-07-08 23:20:03 +00006948
6949void Sema::CodeCompleteObjCMethodDeclSelector(Scope *S,
6950 bool IsInstanceMethod,
Douglas Gregor45879692010-07-08 23:37:41 +00006951 bool AtParameterName,
John McCallba7bf592010-08-24 05:47:05 +00006952 ParsedType ReturnTy,
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00006953 ArrayRef<IdentifierInfo *> SelIdents) {
Douglas Gregor95887f92010-07-08 23:20:03 +00006954 // If we have an external source, load the entire class method
Sebastian Redld44cd6a2010-08-18 23:57:06 +00006955 // pool from the AST file.
Douglas Gregor95887f92010-07-08 23:20:03 +00006956 if (ExternalSource) {
6957 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6958 I != N; ++I) {
6959 Selector Sel = ExternalSource->GetExternalSelector(I);
Sebastian Redl75d8a322010-08-02 23:18:59 +00006960 if (Sel.isNull() || MethodPool.count(Sel))
Douglas Gregor95887f92010-07-08 23:20:03 +00006961 continue;
Sebastian Redl75d8a322010-08-02 23:18:59 +00006962
6963 ReadMethodPool(Sel);
Douglas Gregor95887f92010-07-08 23:20:03 +00006964 }
6965 }
6966
6967 // Build the set of methods we can see.
John McCall276321a2010-08-25 06:19:51 +00006968 typedef CodeCompletionResult Result;
Douglas Gregorb278aaf2011-02-01 19:23:04 +00006969 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00006970 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregorb278aaf2011-02-01 19:23:04 +00006971 CodeCompletionContext::CCC_Other);
Douglas Gregor95887f92010-07-08 23:20:03 +00006972
6973 if (ReturnTy)
6974 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
Sebastian Redl75d8a322010-08-02 23:18:59 +00006975
Douglas Gregor95887f92010-07-08 23:20:03 +00006976 Results.EnterNewScope();
Sebastian Redl75d8a322010-08-02 23:18:59 +00006977 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6978 MEnd = MethodPool.end();
6979 M != MEnd; ++M) {
6980 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first :
6981 &M->second.second;
6982 MethList && MethList->Method;
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00006983 MethList = MethList->getNext()) {
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00006984 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents))
Douglas Gregor95887f92010-07-08 23:20:03 +00006985 continue;
6986
Douglas Gregor45879692010-07-08 23:37:41 +00006987 if (AtParameterName) {
6988 // Suggest parameter names we've seen before.
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00006989 unsigned NumSelIdents = SelIdents.size();
Douglas Gregor45879692010-07-08 23:37:41 +00006990 if (NumSelIdents && NumSelIdents <= MethList->Method->param_size()) {
6991 ParmVarDecl *Param = MethList->Method->param_begin()[NumSelIdents-1];
6992 if (Param->getIdentifier()) {
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00006993 CodeCompletionBuilder Builder(Results.getAllocator(),
6994 Results.getCodeCompletionTUInfo());
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00006995 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregorb278aaf2011-02-01 19:23:04 +00006996 Param->getIdentifier()->getName()));
6997 Results.AddResult(Builder.TakeString());
Douglas Gregor45879692010-07-08 23:37:41 +00006998 }
6999 }
7000
7001 continue;
7002 }
7003
Douglas Gregor0a0e2b32013-01-31 04:52:16 +00007004 Result R(MethList->Method, Results.getBasePriority(MethList->Method), 0);
Dmitri Gribenko070a10e2013-06-16 03:47:57 +00007005 R.StartParameter = SelIdents.size();
Douglas Gregor95887f92010-07-08 23:20:03 +00007006 R.AllParametersAreInformative = false;
7007 R.DeclaringEntity = true;
7008 Results.MaybeAddResult(R, CurContext);
7009 }
7010 }
7011
7012 Results.ExitScope();
Douglas Gregor00c37ef2010-08-11 21:23:17 +00007013 HandleCodeCompleteResults(this, CodeCompleter,
7014 CodeCompletionContext::CCC_Other,
7015 Results.data(),Results.size());
Douglas Gregor95887f92010-07-08 23:20:03 +00007016}
Douglas Gregorb14904c2010-08-13 22:48:40 +00007017
Douglas Gregorec00a262010-08-24 22:20:20 +00007018void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007019 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00007020 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor0ac41382010-09-23 23:01:17 +00007021 CodeCompletionContext::CCC_PreprocessorDirective);
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007022 Results.EnterNewScope();
7023
7024 // #if <condition>
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00007025 CodeCompletionBuilder Builder(Results.getAllocator(),
7026 Results.getCodeCompletionTUInfo());
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007027 Builder.AddTypedTextChunk("if");
7028 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7029 Builder.AddPlaceholderChunk("condition");
7030 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007031
7032 // #ifdef <macro>
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007033 Builder.AddTypedTextChunk("ifdef");
7034 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7035 Builder.AddPlaceholderChunk("macro");
7036 Results.AddResult(Builder.TakeString());
7037
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007038 // #ifndef <macro>
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007039 Builder.AddTypedTextChunk("ifndef");
7040 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7041 Builder.AddPlaceholderChunk("macro");
7042 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007043
7044 if (InConditional) {
7045 // #elif <condition>
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007046 Builder.AddTypedTextChunk("elif");
7047 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7048 Builder.AddPlaceholderChunk("condition");
7049 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007050
7051 // #else
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007052 Builder.AddTypedTextChunk("else");
7053 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007054
7055 // #endif
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007056 Builder.AddTypedTextChunk("endif");
7057 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007058 }
7059
7060 // #include "header"
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007061 Builder.AddTypedTextChunk("include");
7062 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7063 Builder.AddTextChunk("\"");
7064 Builder.AddPlaceholderChunk("header");
7065 Builder.AddTextChunk("\"");
7066 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007067
7068 // #include <header>
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007069 Builder.AddTypedTextChunk("include");
7070 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7071 Builder.AddTextChunk("<");
7072 Builder.AddPlaceholderChunk("header");
7073 Builder.AddTextChunk(">");
7074 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007075
7076 // #define <macro>
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007077 Builder.AddTypedTextChunk("define");
7078 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7079 Builder.AddPlaceholderChunk("macro");
7080 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007081
7082 // #define <macro>(<args>)
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007083 Builder.AddTypedTextChunk("define");
7084 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7085 Builder.AddPlaceholderChunk("macro");
7086 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7087 Builder.AddPlaceholderChunk("args");
7088 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7089 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007090
7091 // #undef <macro>
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007092 Builder.AddTypedTextChunk("undef");
7093 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7094 Builder.AddPlaceholderChunk("macro");
7095 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007096
7097 // #line <number>
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007098 Builder.AddTypedTextChunk("line");
7099 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7100 Builder.AddPlaceholderChunk("number");
7101 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007102
7103 // #line <number> "filename"
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007104 Builder.AddTypedTextChunk("line");
7105 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7106 Builder.AddPlaceholderChunk("number");
7107 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7108 Builder.AddTextChunk("\"");
7109 Builder.AddPlaceholderChunk("filename");
7110 Builder.AddTextChunk("\"");
7111 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007112
7113 // #error <message>
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007114 Builder.AddTypedTextChunk("error");
7115 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7116 Builder.AddPlaceholderChunk("message");
7117 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007118
7119 // #pragma <arguments>
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007120 Builder.AddTypedTextChunk("pragma");
7121 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7122 Builder.AddPlaceholderChunk("arguments");
7123 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007124
David Blaikiebbafb8a2012-03-11 07:00:24 +00007125 if (getLangOpts().ObjC1) {
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007126 // #import "header"
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007127 Builder.AddTypedTextChunk("import");
7128 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7129 Builder.AddTextChunk("\"");
7130 Builder.AddPlaceholderChunk("header");
7131 Builder.AddTextChunk("\"");
7132 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007133
7134 // #import <header>
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007135 Builder.AddTypedTextChunk("import");
7136 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7137 Builder.AddTextChunk("<");
7138 Builder.AddPlaceholderChunk("header");
7139 Builder.AddTextChunk(">");
7140 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007141 }
7142
7143 // #include_next "header"
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007144 Builder.AddTypedTextChunk("include_next");
7145 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7146 Builder.AddTextChunk("\"");
7147 Builder.AddPlaceholderChunk("header");
7148 Builder.AddTextChunk("\"");
7149 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007150
7151 // #include_next <header>
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007152 Builder.AddTypedTextChunk("include_next");
7153 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7154 Builder.AddTextChunk("<");
7155 Builder.AddPlaceholderChunk("header");
7156 Builder.AddTextChunk(">");
7157 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007158
7159 // #warning <message>
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007160 Builder.AddTypedTextChunk("warning");
7161 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7162 Builder.AddPlaceholderChunk("message");
7163 Results.AddResult(Builder.TakeString());
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007164
7165 // Note: #ident and #sccs are such crazy anachronisms that we don't provide
7166 // completions for them. And __include_macros is a Clang-internal extension
7167 // that we don't want to encourage anyone to use.
7168
7169 // FIXME: we don't support #assert or #unassert, so don't suggest them.
7170 Results.ExitScope();
7171
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007172 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregor0de55ce2010-08-25 18:41:16 +00007173 CodeCompletionContext::CCC_PreprocessorDirective,
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007174 Results.data(), Results.size());
7175}
7176
7177void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
Douglas Gregorec00a262010-08-24 22:20:20 +00007178 CodeCompleteOrdinaryName(S,
John McCallfaf5fb42010-08-26 23:41:50 +00007179 S->getFnParent()? Sema::PCC_RecoveryInFunction
7180 : Sema::PCC_Namespace);
Douglas Gregor3a7ad252010-08-24 19:08:16 +00007181}
7182
Douglas Gregorec00a262010-08-24 22:20:20 +00007183void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007184 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00007185 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor0ac41382010-09-23 23:01:17 +00007186 IsDefinition? CodeCompletionContext::CCC_MacroName
7187 : CodeCompletionContext::CCC_MacroNameUse);
Douglas Gregor12785102010-08-24 20:21:13 +00007188 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
7189 // Add just the names of macros, not their arguments.
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00007190 CodeCompletionBuilder Builder(Results.getAllocator(),
7191 Results.getCodeCompletionTUInfo());
Douglas Gregor12785102010-08-24 20:21:13 +00007192 Results.EnterNewScope();
7193 for (Preprocessor::macro_iterator M = PP.macro_begin(),
7194 MEnd = PP.macro_end();
7195 M != MEnd; ++M) {
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00007196 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007197 M->first->getName()));
Argyrios Kyrtzidis5c8b1cd2012-09-27 00:24:09 +00007198 Results.AddResult(CodeCompletionResult(Builder.TakeString(),
7199 CCP_CodePattern,
7200 CXCursor_MacroDefinition));
Douglas Gregor12785102010-08-24 20:21:13 +00007201 }
7202 Results.ExitScope();
7203 } else if (IsDefinition) {
7204 // FIXME: Can we detect when the user just wrote an include guard above?
7205 }
7206
Douglas Gregor0ac41382010-09-23 23:01:17 +00007207 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
Douglas Gregor12785102010-08-24 20:21:13 +00007208 Results.data(), Results.size());
7209}
7210
Douglas Gregorec00a262010-08-24 22:20:20 +00007211void Sema::CodeCompletePreprocessorExpression() {
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007212 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00007213 CodeCompleter->getCodeCompletionTUInfo(),
Douglas Gregor0ac41382010-09-23 23:01:17 +00007214 CodeCompletionContext::CCC_PreprocessorExpression);
Douglas Gregorec00a262010-08-24 22:20:20 +00007215
7216 if (!CodeCompleter || CodeCompleter->includeMacros())
Douglas Gregor8cb17462012-10-09 16:01:50 +00007217 AddMacroResults(PP, Results, true);
Douglas Gregorec00a262010-08-24 22:20:20 +00007218
7219 // defined (<macro>)
7220 Results.EnterNewScope();
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00007221 CodeCompletionBuilder Builder(Results.getAllocator(),
7222 Results.getCodeCompletionTUInfo());
Douglas Gregorb278aaf2011-02-01 19:23:04 +00007223 Builder.AddTypedTextChunk("defined");
7224 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7225 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7226 Builder.AddPlaceholderChunk("macro");
7227 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7228 Results.AddResult(Builder.TakeString());
Douglas Gregorec00a262010-08-24 22:20:20 +00007229 Results.ExitScope();
7230
7231 HandleCodeCompleteResults(this, CodeCompleter,
7232 CodeCompletionContext::CCC_PreprocessorExpression,
7233 Results.data(), Results.size());
7234}
7235
7236void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
7237 IdentifierInfo *Macro,
7238 MacroInfo *MacroInfo,
7239 unsigned Argument) {
7240 // FIXME: In the future, we could provide "overload" results, much like we
7241 // do for function calls.
7242
Argyrios Kyrtzidis75f6cd22011-08-18 19:41:28 +00007243 // Now just ignore this. There will be another code-completion callback
7244 // for the expanded tokens.
Douglas Gregorec00a262010-08-24 22:20:20 +00007245}
7246
Douglas Gregor11583702010-08-25 17:04:25 +00007247void Sema::CodeCompleteNaturalLanguage() {
Douglas Gregor11583702010-08-25 17:04:25 +00007248 HandleCodeCompleteResults(this, CodeCompleter,
Douglas Gregorea736372010-08-25 17:10:00 +00007249 CodeCompletionContext::CCC_NaturalLanguage,
Douglas Gregor11583702010-08-25 17:04:25 +00007250 0, 0);
7251}
7252
Douglas Gregorbcbf46c2011-02-01 22:57:45 +00007253void Sema::GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00007254 CodeCompletionTUInfo &CCTUInfo,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00007255 SmallVectorImpl<CodeCompletionResult> &Results) {
Argyrios Kyrtzidis9d7c0fe2012-04-10 17:23:48 +00007256 ResultBuilder Builder(*this, Allocator, CCTUInfo,
7257 CodeCompletionContext::CCC_Recovery);
Douglas Gregor39982192010-08-15 06:18:01 +00007258 if (!CodeCompleter || CodeCompleter->includeGlobals()) {
7259 CodeCompletionDeclConsumer Consumer(Builder,
7260 Context.getTranslationUnitDecl());
7261 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
7262 Consumer);
7263 }
Douglas Gregorb14904c2010-08-13 22:48:40 +00007264
7265 if (!CodeCompleter || CodeCompleter->includeMacros())
Douglas Gregor8cb17462012-10-09 16:01:50 +00007266 AddMacroResults(PP, Builder, true);
Douglas Gregorb14904c2010-08-13 22:48:40 +00007267
7268 Results.clear();
7269 Results.insert(Results.end(),
7270 Builder.data(), Builder.data() + Builder.size());
7271}