File: | build/source/clang/lib/Sema/SemaCodeComplete.cpp |
Warning: | line 3800, column 5 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===---------------- SemaCodeComplete.cpp - Code Completion ----*- C++ -*-===// | |||
2 | // | |||
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |||
4 | // See https://llvm.org/LICENSE.txt for license information. | |||
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |||
6 | // | |||
7 | //===----------------------------------------------------------------------===// | |||
8 | // | |||
9 | // This file defines the code-completion semantic actions. | |||
10 | // | |||
11 | //===----------------------------------------------------------------------===// | |||
12 | #include "clang/AST/ASTConcept.h" | |||
13 | #include "clang/AST/Decl.h" | |||
14 | #include "clang/AST/DeclBase.h" | |||
15 | #include "clang/AST/DeclCXX.h" | |||
16 | #include "clang/AST/DeclObjC.h" | |||
17 | #include "clang/AST/DeclTemplate.h" | |||
18 | #include "clang/AST/Expr.h" | |||
19 | #include "clang/AST/ExprCXX.h" | |||
20 | #include "clang/AST/ExprConcepts.h" | |||
21 | #include "clang/AST/ExprObjC.h" | |||
22 | #include "clang/AST/NestedNameSpecifier.h" | |||
23 | #include "clang/AST/QualTypeNames.h" | |||
24 | #include "clang/AST/RecursiveASTVisitor.h" | |||
25 | #include "clang/AST/Type.h" | |||
26 | #include "clang/Basic/AttributeCommonInfo.h" | |||
27 | #include "clang/Basic/CharInfo.h" | |||
28 | #include "clang/Basic/OperatorKinds.h" | |||
29 | #include "clang/Basic/Specifiers.h" | |||
30 | #include "clang/Lex/HeaderSearch.h" | |||
31 | #include "clang/Lex/MacroInfo.h" | |||
32 | #include "clang/Lex/Preprocessor.h" | |||
33 | #include "clang/Sema/CodeCompleteConsumer.h" | |||
34 | #include "clang/Sema/DeclSpec.h" | |||
35 | #include "clang/Sema/Designator.h" | |||
36 | #include "clang/Sema/Lookup.h" | |||
37 | #include "clang/Sema/Overload.h" | |||
38 | #include "clang/Sema/ParsedAttr.h" | |||
39 | #include "clang/Sema/ParsedTemplate.h" | |||
40 | #include "clang/Sema/Scope.h" | |||
41 | #include "clang/Sema/ScopeInfo.h" | |||
42 | #include "clang/Sema/Sema.h" | |||
43 | #include "clang/Sema/SemaInternal.h" | |||
44 | #include "llvm/ADT/ArrayRef.h" | |||
45 | #include "llvm/ADT/DenseSet.h" | |||
46 | #include "llvm/ADT/SmallBitVector.h" | |||
47 | #include "llvm/ADT/SmallPtrSet.h" | |||
48 | #include "llvm/ADT/SmallString.h" | |||
49 | #include "llvm/ADT/StringExtras.h" | |||
50 | #include "llvm/ADT/StringSwitch.h" | |||
51 | #include "llvm/ADT/Twine.h" | |||
52 | #include "llvm/ADT/iterator_range.h" | |||
53 | #include "llvm/Support/Casting.h" | |||
54 | #include "llvm/Support/Path.h" | |||
55 | #include "llvm/Support/raw_ostream.h" | |||
56 | ||||
57 | #include <list> | |||
58 | #include <map> | |||
59 | #include <optional> | |||
60 | #include <string> | |||
61 | #include <vector> | |||
62 | ||||
63 | using namespace clang; | |||
64 | using namespace sema; | |||
65 | ||||
66 | namespace { | |||
67 | /// A container of code-completion results. | |||
68 | class ResultBuilder { | |||
69 | public: | |||
70 | /// The type of a name-lookup filter, which can be provided to the | |||
71 | /// name-lookup routines to specify which declarations should be included in | |||
72 | /// the result set (when it returns true) and which declarations should be | |||
73 | /// filtered out (returns false). | |||
74 | typedef bool (ResultBuilder::*LookupFilter)(const NamedDecl *) const; | |||
75 | ||||
76 | typedef CodeCompletionResult Result; | |||
77 | ||||
78 | private: | |||
79 | /// The actual results we have found. | |||
80 | std::vector<Result> Results; | |||
81 | ||||
82 | /// A record of all of the declarations we have found and placed | |||
83 | /// into the result set, used to ensure that no declaration ever gets into | |||
84 | /// the result set twice. | |||
85 | llvm::SmallPtrSet<const Decl *, 16> AllDeclsFound; | |||
86 | ||||
87 | typedef std::pair<const NamedDecl *, unsigned> DeclIndexPair; | |||
88 | ||||
89 | /// An entry in the shadow map, which is optimized to store | |||
90 | /// a single (declaration, index) mapping (the common case) but | |||
91 | /// can also store a list of (declaration, index) mappings. | |||
92 | class ShadowMapEntry { | |||
93 | typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector; | |||
94 | ||||
95 | /// Contains either the solitary NamedDecl * or a vector | |||
96 | /// of (declaration, index) pairs. | |||
97 | llvm::PointerUnion<const NamedDecl *, DeclIndexPairVector *> DeclOrVector; | |||
98 | ||||
99 | /// When the entry contains a single declaration, this is | |||
100 | /// the index associated with that entry. | |||
101 | unsigned SingleDeclIndex; | |||
102 | ||||
103 | public: | |||
104 | ShadowMapEntry() : SingleDeclIndex(0) {} | |||
105 | ShadowMapEntry(const ShadowMapEntry &) = delete; | |||
106 | ShadowMapEntry(ShadowMapEntry &&Move) { *this = std::move(Move); } | |||
107 | ShadowMapEntry &operator=(const ShadowMapEntry &) = delete; | |||
108 | ShadowMapEntry &operator=(ShadowMapEntry &&Move) { | |||
109 | SingleDeclIndex = Move.SingleDeclIndex; | |||
110 | DeclOrVector = Move.DeclOrVector; | |||
111 | Move.DeclOrVector = nullptr; | |||
112 | return *this; | |||
113 | } | |||
114 | ||||
115 | void Add(const NamedDecl *ND, unsigned Index) { | |||
116 | if (DeclOrVector.isNull()) { | |||
117 | // 0 - > 1 elements: just set the single element information. | |||
118 | DeclOrVector = ND; | |||
119 | SingleDeclIndex = Index; | |||
120 | return; | |||
121 | } | |||
122 | ||||
123 | if (const NamedDecl *PrevND = | |||
124 | DeclOrVector.dyn_cast<const NamedDecl *>()) { | |||
125 | // 1 -> 2 elements: create the vector of results and push in the | |||
126 | // existing declaration. | |||
127 | DeclIndexPairVector *Vec = new DeclIndexPairVector; | |||
128 | Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex)); | |||
129 | DeclOrVector = Vec; | |||
130 | } | |||
131 | ||||
132 | // Add the new element to the end of the vector. | |||
133 | DeclOrVector.get<DeclIndexPairVector *>()->push_back( | |||
134 | DeclIndexPair(ND, Index)); | |||
135 | } | |||
136 | ||||
137 | ~ShadowMapEntry() { | |||
138 | if (DeclIndexPairVector *Vec = | |||
139 | DeclOrVector.dyn_cast<DeclIndexPairVector *>()) { | |||
140 | delete Vec; | |||
141 | DeclOrVector = ((NamedDecl *)nullptr); | |||
142 | } | |||
143 | } | |||
144 | ||||
145 | // Iteration. | |||
146 | class iterator; | |||
147 | iterator begin() const; | |||
148 | iterator end() const; | |||
149 | }; | |||
150 | ||||
151 | /// A mapping from declaration names to the declarations that have | |||
152 | /// this name within a particular scope and their index within the list of | |||
153 | /// results. | |||
154 | typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap; | |||
155 | ||||
156 | /// The semantic analysis object for which results are being | |||
157 | /// produced. | |||
158 | Sema &SemaRef; | |||
159 | ||||
160 | /// The allocator used to allocate new code-completion strings. | |||
161 | CodeCompletionAllocator &Allocator; | |||
162 | ||||
163 | CodeCompletionTUInfo &CCTUInfo; | |||
164 | ||||
165 | /// If non-NULL, a filter function used to remove any code-completion | |||
166 | /// results that are not desirable. | |||
167 | LookupFilter Filter; | |||
168 | ||||
169 | /// Whether we should allow declarations as | |||
170 | /// nested-name-specifiers that would otherwise be filtered out. | |||
171 | bool AllowNestedNameSpecifiers; | |||
172 | ||||
173 | /// If set, the type that we would prefer our resulting value | |||
174 | /// declarations to have. | |||
175 | /// | |||
176 | /// Closely matching the preferred type gives a boost to a result's | |||
177 | /// priority. | |||
178 | CanQualType PreferredType; | |||
179 | ||||
180 | /// A list of shadow maps, which is used to model name hiding at | |||
181 | /// different levels of, e.g., the inheritance hierarchy. | |||
182 | std::list<ShadowMap> ShadowMaps; | |||
183 | ||||
184 | /// Overloaded C++ member functions found by SemaLookup. | |||
185 | /// Used to determine when one overload is dominated by another. | |||
186 | llvm::DenseMap<std::pair<DeclContext *, /*Name*/uintptr_t>, ShadowMapEntry> | |||
187 | OverloadMap; | |||
188 | ||||
189 | /// If we're potentially referring to a C++ member function, the set | |||
190 | /// of qualifiers applied to the object type. | |||
191 | Qualifiers ObjectTypeQualifiers; | |||
192 | /// The kind of the object expression, for rvalue/lvalue overloads. | |||
193 | ExprValueKind ObjectKind; | |||
194 | ||||
195 | /// Whether the \p ObjectTypeQualifiers field is active. | |||
196 | bool HasObjectTypeQualifiers; | |||
197 | ||||
198 | /// The selector that we prefer. | |||
199 | Selector PreferredSelector; | |||
200 | ||||
201 | /// The completion context in which we are gathering results. | |||
202 | CodeCompletionContext CompletionContext; | |||
203 | ||||
204 | /// If we are in an instance method definition, the \@implementation | |||
205 | /// object. | |||
206 | ObjCImplementationDecl *ObjCImplementation; | |||
207 | ||||
208 | void AdjustResultPriorityForDecl(Result &R); | |||
209 | ||||
210 | void MaybeAddConstructorResults(Result R); | |||
211 | ||||
212 | public: | |||
213 | explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator, | |||
214 | CodeCompletionTUInfo &CCTUInfo, | |||
215 | const CodeCompletionContext &CompletionContext, | |||
216 | LookupFilter Filter = nullptr) | |||
217 | : SemaRef(SemaRef), Allocator(Allocator), CCTUInfo(CCTUInfo), | |||
218 | Filter(Filter), AllowNestedNameSpecifiers(false), | |||
219 | HasObjectTypeQualifiers(false), CompletionContext(CompletionContext), | |||
220 | ObjCImplementation(nullptr) { | |||
221 | // If this is an Objective-C instance method definition, dig out the | |||
222 | // corresponding implementation. | |||
223 | switch (CompletionContext.getKind()) { | |||
224 | case CodeCompletionContext::CCC_Expression: | |||
225 | case CodeCompletionContext::CCC_ObjCMessageReceiver: | |||
226 | case CodeCompletionContext::CCC_ParenthesizedExpression: | |||
227 | case CodeCompletionContext::CCC_Statement: | |||
228 | case CodeCompletionContext::CCC_Recovery: | |||
229 | if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) | |||
230 | if (Method->isInstanceMethod()) | |||
231 | if (ObjCInterfaceDecl *Interface = Method->getClassInterface()) | |||
232 | ObjCImplementation = Interface->getImplementation(); | |||
233 | break; | |||
234 | ||||
235 | default: | |||
236 | break; | |||
237 | } | |||
238 | } | |||
239 | ||||
240 | /// Determine the priority for a reference to the given declaration. | |||
241 | unsigned getBasePriority(const NamedDecl *D); | |||
242 | ||||
243 | /// Whether we should include code patterns in the completion | |||
244 | /// results. | |||
245 | bool includeCodePatterns() const { | |||
246 | return SemaRef.CodeCompleter && | |||
247 | SemaRef.CodeCompleter->includeCodePatterns(); | |||
248 | } | |||
249 | ||||
250 | /// Set the filter used for code-completion results. | |||
251 | void setFilter(LookupFilter Filter) { this->Filter = Filter; } | |||
252 | ||||
253 | Result *data() { return Results.empty() ? nullptr : &Results.front(); } | |||
254 | unsigned size() const { return Results.size(); } | |||
255 | bool empty() const { return Results.empty(); } | |||
256 | ||||
257 | /// Specify the preferred type. | |||
258 | void setPreferredType(QualType T) { | |||
259 | PreferredType = SemaRef.Context.getCanonicalType(T); | |||
260 | } | |||
261 | ||||
262 | /// Set the cv-qualifiers on the object type, for us in filtering | |||
263 | /// calls to member functions. | |||
264 | /// | |||
265 | /// When there are qualifiers in this set, they will be used to filter | |||
266 | /// out member functions that aren't available (because there will be a | |||
267 | /// cv-qualifier mismatch) or prefer functions with an exact qualifier | |||
268 | /// match. | |||
269 | void setObjectTypeQualifiers(Qualifiers Quals, ExprValueKind Kind) { | |||
270 | ObjectTypeQualifiers = Quals; | |||
271 | ObjectKind = Kind; | |||
272 | HasObjectTypeQualifiers = true; | |||
273 | } | |||
274 | ||||
275 | /// Set the preferred selector. | |||
276 | /// | |||
277 | /// When an Objective-C method declaration result is added, and that | |||
278 | /// method's selector matches this preferred selector, we give that method | |||
279 | /// a slight priority boost. | |||
280 | void setPreferredSelector(Selector Sel) { PreferredSelector = Sel; } | |||
281 | ||||
282 | /// Retrieve the code-completion context for which results are | |||
283 | /// being collected. | |||
284 | const CodeCompletionContext &getCompletionContext() const { | |||
285 | return CompletionContext; | |||
286 | } | |||
287 | ||||
288 | /// Specify whether nested-name-specifiers are allowed. | |||
289 | void allowNestedNameSpecifiers(bool Allow = true) { | |||
290 | AllowNestedNameSpecifiers = Allow; | |||
291 | } | |||
292 | ||||
293 | /// Return the semantic analysis object for which we are collecting | |||
294 | /// code completion results. | |||
295 | Sema &getSema() const { return SemaRef; } | |||
296 | ||||
297 | /// Retrieve the allocator used to allocate code completion strings. | |||
298 | CodeCompletionAllocator &getAllocator() const { return Allocator; } | |||
299 | ||||
300 | CodeCompletionTUInfo &getCodeCompletionTUInfo() const { return CCTUInfo; } | |||
301 | ||||
302 | /// Determine whether the given declaration is at all interesting | |||
303 | /// as a code-completion result. | |||
304 | /// | |||
305 | /// \param ND the declaration that we are inspecting. | |||
306 | /// | |||
307 | /// \param AsNestedNameSpecifier will be set true if this declaration is | |||
308 | /// only interesting when it is a nested-name-specifier. | |||
309 | bool isInterestingDecl(const NamedDecl *ND, | |||
310 | bool &AsNestedNameSpecifier) const; | |||
311 | ||||
312 | /// Check whether the result is hidden by the Hiding declaration. | |||
313 | /// | |||
314 | /// \returns true if the result is hidden and cannot be found, false if | |||
315 | /// the hidden result could still be found. When false, \p R may be | |||
316 | /// modified to describe how the result can be found (e.g., via extra | |||
317 | /// qualification). | |||
318 | bool CheckHiddenResult(Result &R, DeclContext *CurContext, | |||
319 | const NamedDecl *Hiding); | |||
320 | ||||
321 | /// Add a new result to this result set (if it isn't already in one | |||
322 | /// of the shadow maps), or replace an existing result (for, e.g., a | |||
323 | /// redeclaration). | |||
324 | /// | |||
325 | /// \param R the result to add (if it is unique). | |||
326 | /// | |||
327 | /// \param CurContext the context in which this result will be named. | |||
328 | void MaybeAddResult(Result R, DeclContext *CurContext = nullptr); | |||
329 | ||||
330 | /// Add a new result to this result set, where we already know | |||
331 | /// the hiding declaration (if any). | |||
332 | /// | |||
333 | /// \param R the result to add (if it is unique). | |||
334 | /// | |||
335 | /// \param CurContext the context in which this result will be named. | |||
336 | /// | |||
337 | /// \param Hiding the declaration that hides the result. | |||
338 | /// | |||
339 | /// \param InBaseClass whether the result was found in a base | |||
340 | /// class of the searched context. | |||
341 | void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding, | |||
342 | bool InBaseClass); | |||
343 | ||||
344 | /// Add a new non-declaration result to this result set. | |||
345 | void AddResult(Result R); | |||
346 | ||||
347 | /// Enter into a new scope. | |||
348 | void EnterNewScope(); | |||
349 | ||||
350 | /// Exit from the current scope. | |||
351 | void ExitScope(); | |||
352 | ||||
353 | /// Ignore this declaration, if it is seen again. | |||
354 | void Ignore(const Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); } | |||
355 | ||||
356 | /// Add a visited context. | |||
357 | void addVisitedContext(DeclContext *Ctx) { | |||
358 | CompletionContext.addVisitedContext(Ctx); | |||
359 | } | |||
360 | ||||
361 | /// \name Name lookup predicates | |||
362 | /// | |||
363 | /// These predicates can be passed to the name lookup functions to filter the | |||
364 | /// results of name lookup. All of the predicates have the same type, so that | |||
365 | /// | |||
366 | //@{ | |||
367 | bool IsOrdinaryName(const NamedDecl *ND) const; | |||
368 | bool IsOrdinaryNonTypeName(const NamedDecl *ND) const; | |||
369 | bool IsIntegralConstantValue(const NamedDecl *ND) const; | |||
370 | bool IsOrdinaryNonValueName(const NamedDecl *ND) const; | |||
371 | bool IsNestedNameSpecifier(const NamedDecl *ND) const; | |||
372 | bool IsEnum(const NamedDecl *ND) const; | |||
373 | bool IsClassOrStruct(const NamedDecl *ND) const; | |||
374 | bool IsUnion(const NamedDecl *ND) const; | |||
375 | bool IsNamespace(const NamedDecl *ND) const; | |||
376 | bool IsNamespaceOrAlias(const NamedDecl *ND) const; | |||
377 | bool IsType(const NamedDecl *ND) const; | |||
378 | bool IsMember(const NamedDecl *ND) const; | |||
379 | bool IsObjCIvar(const NamedDecl *ND) const; | |||
380 | bool IsObjCMessageReceiver(const NamedDecl *ND) const; | |||
381 | bool IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const; | |||
382 | bool IsObjCCollection(const NamedDecl *ND) const; | |||
383 | bool IsImpossibleToSatisfy(const NamedDecl *ND) const; | |||
384 | //@} | |||
385 | }; | |||
386 | } // namespace | |||
387 | ||||
388 | void PreferredTypeBuilder::enterReturn(Sema &S, SourceLocation Tok) { | |||
389 | if (!Enabled) | |||
390 | return; | |||
391 | if (isa<BlockDecl>(S.CurContext)) { | |||
392 | if (sema::BlockScopeInfo *BSI = S.getCurBlock()) { | |||
393 | ComputeType = nullptr; | |||
394 | Type = BSI->ReturnType; | |||
395 | ExpectedLoc = Tok; | |||
396 | } | |||
397 | } else if (const auto *Function = dyn_cast<FunctionDecl>(S.CurContext)) { | |||
398 | ComputeType = nullptr; | |||
399 | Type = Function->getReturnType(); | |||
400 | ExpectedLoc = Tok; | |||
401 | } else if (const auto *Method = dyn_cast<ObjCMethodDecl>(S.CurContext)) { | |||
402 | ComputeType = nullptr; | |||
403 | Type = Method->getReturnType(); | |||
404 | ExpectedLoc = Tok; | |||
405 | } | |||
406 | } | |||
407 | ||||
408 | void PreferredTypeBuilder::enterVariableInit(SourceLocation Tok, Decl *D) { | |||
409 | if (!Enabled) | |||
410 | return; | |||
411 | auto *VD = llvm::dyn_cast_or_null<ValueDecl>(D); | |||
412 | ComputeType = nullptr; | |||
413 | Type = VD ? VD->getType() : QualType(); | |||
414 | ExpectedLoc = Tok; | |||
415 | } | |||
416 | ||||
417 | static QualType getDesignatedType(QualType BaseType, const Designation &Desig); | |||
418 | ||||
419 | void PreferredTypeBuilder::enterDesignatedInitializer(SourceLocation Tok, | |||
420 | QualType BaseType, | |||
421 | const Designation &D) { | |||
422 | if (!Enabled) | |||
423 | return; | |||
424 | ComputeType = nullptr; | |||
425 | Type = getDesignatedType(BaseType, D); | |||
426 | ExpectedLoc = Tok; | |||
427 | } | |||
428 | ||||
429 | void PreferredTypeBuilder::enterFunctionArgument( | |||
430 | SourceLocation Tok, llvm::function_ref<QualType()> ComputeType) { | |||
431 | if (!Enabled) | |||
432 | return; | |||
433 | this->ComputeType = ComputeType; | |||
434 | Type = QualType(); | |||
435 | ExpectedLoc = Tok; | |||
436 | } | |||
437 | ||||
438 | void PreferredTypeBuilder::enterParenExpr(SourceLocation Tok, | |||
439 | SourceLocation LParLoc) { | |||
440 | if (!Enabled) | |||
441 | return; | |||
442 | // expected type for parenthesized expression does not change. | |||
443 | if (ExpectedLoc == LParLoc) | |||
444 | ExpectedLoc = Tok; | |||
445 | } | |||
446 | ||||
447 | static QualType getPreferredTypeOfBinaryRHS(Sema &S, Expr *LHS, | |||
448 | tok::TokenKind Op) { | |||
449 | if (!LHS) | |||
450 | return QualType(); | |||
451 | ||||
452 | QualType LHSType = LHS->getType(); | |||
453 | if (LHSType->isPointerType()) { | |||
454 | if (Op == tok::plus || Op == tok::plusequal || Op == tok::minusequal) | |||
455 | return S.getASTContext().getPointerDiffType(); | |||
456 | // Pointer difference is more common than subtracting an int from a pointer. | |||
457 | if (Op == tok::minus) | |||
458 | return LHSType; | |||
459 | } | |||
460 | ||||
461 | switch (Op) { | |||
462 | // No way to infer the type of RHS from LHS. | |||
463 | case tok::comma: | |||
464 | return QualType(); | |||
465 | // Prefer the type of the left operand for all of these. | |||
466 | // Arithmetic operations. | |||
467 | case tok::plus: | |||
468 | case tok::plusequal: | |||
469 | case tok::minus: | |||
470 | case tok::minusequal: | |||
471 | case tok::percent: | |||
472 | case tok::percentequal: | |||
473 | case tok::slash: | |||
474 | case tok::slashequal: | |||
475 | case tok::star: | |||
476 | case tok::starequal: | |||
477 | // Assignment. | |||
478 | case tok::equal: | |||
479 | // Comparison operators. | |||
480 | case tok::equalequal: | |||
481 | case tok::exclaimequal: | |||
482 | case tok::less: | |||
483 | case tok::lessequal: | |||
484 | case tok::greater: | |||
485 | case tok::greaterequal: | |||
486 | case tok::spaceship: | |||
487 | return LHS->getType(); | |||
488 | // Binary shifts are often overloaded, so don't try to guess those. | |||
489 | case tok::greatergreater: | |||
490 | case tok::greatergreaterequal: | |||
491 | case tok::lessless: | |||
492 | case tok::lesslessequal: | |||
493 | if (LHSType->isIntegralOrEnumerationType()) | |||
494 | return S.getASTContext().IntTy; | |||
495 | return QualType(); | |||
496 | // Logical operators, assume we want bool. | |||
497 | case tok::ampamp: | |||
498 | case tok::pipepipe: | |||
499 | case tok::caretcaret: | |||
500 | return S.getASTContext().BoolTy; | |||
501 | // Operators often used for bit manipulation are typically used with the type | |||
502 | // of the left argument. | |||
503 | case tok::pipe: | |||
504 | case tok::pipeequal: | |||
505 | case tok::caret: | |||
506 | case tok::caretequal: | |||
507 | case tok::amp: | |||
508 | case tok::ampequal: | |||
509 | if (LHSType->isIntegralOrEnumerationType()) | |||
510 | return LHSType; | |||
511 | return QualType(); | |||
512 | // RHS should be a pointer to a member of the 'LHS' type, but we can't give | |||
513 | // any particular type here. | |||
514 | case tok::periodstar: | |||
515 | case tok::arrowstar: | |||
516 | return QualType(); | |||
517 | default: | |||
518 | // FIXME(ibiryukov): handle the missing op, re-add the assertion. | |||
519 | // assert(false && "unhandled binary op"); | |||
520 | return QualType(); | |||
521 | } | |||
522 | } | |||
523 | ||||
524 | /// Get preferred type for an argument of an unary expression. \p ContextType is | |||
525 | /// preferred type of the whole unary expression. | |||
526 | static QualType getPreferredTypeOfUnaryArg(Sema &S, QualType ContextType, | |||
527 | tok::TokenKind Op) { | |||
528 | switch (Op) { | |||
529 | case tok::exclaim: | |||
530 | return S.getASTContext().BoolTy; | |||
531 | case tok::amp: | |||
532 | if (!ContextType.isNull() && ContextType->isPointerType()) | |||
533 | return ContextType->getPointeeType(); | |||
534 | return QualType(); | |||
535 | case tok::star: | |||
536 | if (ContextType.isNull()) | |||
537 | return QualType(); | |||
538 | return S.getASTContext().getPointerType(ContextType.getNonReferenceType()); | |||
539 | case tok::plus: | |||
540 | case tok::minus: | |||
541 | case tok::tilde: | |||
542 | case tok::minusminus: | |||
543 | case tok::plusplus: | |||
544 | if (ContextType.isNull()) | |||
545 | return S.getASTContext().IntTy; | |||
546 | // leave as is, these operators typically return the same type. | |||
547 | return ContextType; | |||
548 | case tok::kw___real: | |||
549 | case tok::kw___imag: | |||
550 | return QualType(); | |||
551 | default: | |||
552 | assert(false && "unhandled unary op")(static_cast <bool> (false && "unhandled unary op" ) ? void (0) : __assert_fail ("false && \"unhandled unary op\"" , "clang/lib/Sema/SemaCodeComplete.cpp", 552, __extension__ __PRETTY_FUNCTION__ )); | |||
553 | return QualType(); | |||
554 | } | |||
555 | } | |||
556 | ||||
557 | void PreferredTypeBuilder::enterBinary(Sema &S, SourceLocation Tok, Expr *LHS, | |||
558 | tok::TokenKind Op) { | |||
559 | if (!Enabled) | |||
560 | return; | |||
561 | ComputeType = nullptr; | |||
562 | Type = getPreferredTypeOfBinaryRHS(S, LHS, Op); | |||
563 | ExpectedLoc = Tok; | |||
564 | } | |||
565 | ||||
566 | void PreferredTypeBuilder::enterMemAccess(Sema &S, SourceLocation Tok, | |||
567 | Expr *Base) { | |||
568 | if (!Enabled || !Base) | |||
569 | return; | |||
570 | // Do we have expected type for Base? | |||
571 | if (ExpectedLoc != Base->getBeginLoc()) | |||
572 | return; | |||
573 | // Keep the expected type, only update the location. | |||
574 | ExpectedLoc = Tok; | |||
575 | } | |||
576 | ||||
577 | void PreferredTypeBuilder::enterUnary(Sema &S, SourceLocation Tok, | |||
578 | tok::TokenKind OpKind, | |||
579 | SourceLocation OpLoc) { | |||
580 | if (!Enabled) | |||
581 | return; | |||
582 | ComputeType = nullptr; | |||
583 | Type = getPreferredTypeOfUnaryArg(S, this->get(OpLoc), OpKind); | |||
584 | ExpectedLoc = Tok; | |||
585 | } | |||
586 | ||||
587 | void PreferredTypeBuilder::enterSubscript(Sema &S, SourceLocation Tok, | |||
588 | Expr *LHS) { | |||
589 | if (!Enabled) | |||
590 | return; | |||
591 | ComputeType = nullptr; | |||
592 | Type = S.getASTContext().IntTy; | |||
593 | ExpectedLoc = Tok; | |||
594 | } | |||
595 | ||||
596 | void PreferredTypeBuilder::enterTypeCast(SourceLocation Tok, | |||
597 | QualType CastType) { | |||
598 | if (!Enabled) | |||
599 | return; | |||
600 | ComputeType = nullptr; | |||
601 | Type = !CastType.isNull() ? CastType.getCanonicalType() : QualType(); | |||
602 | ExpectedLoc = Tok; | |||
603 | } | |||
604 | ||||
605 | void PreferredTypeBuilder::enterCondition(Sema &S, SourceLocation Tok) { | |||
606 | if (!Enabled) | |||
607 | return; | |||
608 | ComputeType = nullptr; | |||
609 | Type = S.getASTContext().BoolTy; | |||
610 | ExpectedLoc = Tok; | |||
611 | } | |||
612 | ||||
613 | class ResultBuilder::ShadowMapEntry::iterator { | |||
614 | llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator; | |||
615 | unsigned SingleDeclIndex; | |||
616 | ||||
617 | public: | |||
618 | typedef DeclIndexPair value_type; | |||
619 | typedef value_type reference; | |||
620 | typedef std::ptrdiff_t difference_type; | |||
621 | typedef std::input_iterator_tag iterator_category; | |||
622 | ||||
623 | class pointer { | |||
624 | DeclIndexPair Value; | |||
625 | ||||
626 | public: | |||
627 | pointer(const DeclIndexPair &Value) : Value(Value) {} | |||
628 | ||||
629 | const DeclIndexPair *operator->() const { return &Value; } | |||
630 | }; | |||
631 | ||||
632 | iterator() : DeclOrIterator((NamedDecl *)nullptr), SingleDeclIndex(0) {} | |||
633 | ||||
634 | iterator(const NamedDecl *SingleDecl, unsigned Index) | |||
635 | : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) {} | |||
636 | ||||
637 | iterator(const DeclIndexPair *Iterator) | |||
638 | : DeclOrIterator(Iterator), SingleDeclIndex(0) {} | |||
639 | ||||
640 | iterator &operator++() { | |||
641 | if (DeclOrIterator.is<const NamedDecl *>()) { | |||
642 | DeclOrIterator = (NamedDecl *)nullptr; | |||
643 | SingleDeclIndex = 0; | |||
644 | return *this; | |||
645 | } | |||
646 | ||||
647 | const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair *>(); | |||
648 | ++I; | |||
649 | DeclOrIterator = I; | |||
650 | return *this; | |||
651 | } | |||
652 | ||||
653 | /*iterator operator++(int) { | |||
654 | iterator tmp(*this); | |||
655 | ++(*this); | |||
656 | return tmp; | |||
657 | }*/ | |||
658 | ||||
659 | reference operator*() const { | |||
660 | if (const NamedDecl *ND = DeclOrIterator.dyn_cast<const NamedDecl *>()) | |||
661 | return reference(ND, SingleDeclIndex); | |||
662 | ||||
663 | return *DeclOrIterator.get<const DeclIndexPair *>(); | |||
664 | } | |||
665 | ||||
666 | pointer operator->() const { return pointer(**this); } | |||
667 | ||||
668 | friend bool operator==(const iterator &X, const iterator &Y) { | |||
669 | return X.DeclOrIterator.getOpaqueValue() == | |||
670 | Y.DeclOrIterator.getOpaqueValue() && | |||
671 | X.SingleDeclIndex == Y.SingleDeclIndex; | |||
672 | } | |||
673 | ||||
674 | friend bool operator!=(const iterator &X, const iterator &Y) { | |||
675 | return !(X == Y); | |||
676 | } | |||
677 | }; | |||
678 | ||||
679 | ResultBuilder::ShadowMapEntry::iterator | |||
680 | ResultBuilder::ShadowMapEntry::begin() const { | |||
681 | if (DeclOrVector.isNull()) | |||
682 | return iterator(); | |||
683 | ||||
684 | if (const NamedDecl *ND = DeclOrVector.dyn_cast<const NamedDecl *>()) | |||
685 | return iterator(ND, SingleDeclIndex); | |||
686 | ||||
687 | return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin()); | |||
688 | } | |||
689 | ||||
690 | ResultBuilder::ShadowMapEntry::iterator | |||
691 | ResultBuilder::ShadowMapEntry::end() const { | |||
692 | if (DeclOrVector.is<const NamedDecl *>() || DeclOrVector.isNull()) | |||
693 | return iterator(); | |||
694 | ||||
695 | return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end()); | |||
696 | } | |||
697 | ||||
698 | /// Compute the qualification required to get from the current context | |||
699 | /// (\p CurContext) to the target context (\p TargetContext). | |||
700 | /// | |||
701 | /// \param Context the AST context in which the qualification will be used. | |||
702 | /// | |||
703 | /// \param CurContext the context where an entity is being named, which is | |||
704 | /// typically based on the current scope. | |||
705 | /// | |||
706 | /// \param TargetContext the context in which the named entity actually | |||
707 | /// resides. | |||
708 | /// | |||
709 | /// \returns a nested name specifier that refers into the target context, or | |||
710 | /// NULL if no qualification is needed. | |||
711 | static NestedNameSpecifier * | |||
712 | getRequiredQualification(ASTContext &Context, const DeclContext *CurContext, | |||
713 | const DeclContext *TargetContext) { | |||
714 | SmallVector<const DeclContext *, 4> TargetParents; | |||
715 | ||||
716 | for (const DeclContext *CommonAncestor = TargetContext; | |||
717 | CommonAncestor && !CommonAncestor->Encloses(CurContext); | |||
718 | CommonAncestor = CommonAncestor->getLookupParent()) { | |||
719 | if (CommonAncestor->isTransparentContext() || | |||
720 | CommonAncestor->isFunctionOrMethod()) | |||
721 | continue; | |||
722 | ||||
723 | TargetParents.push_back(CommonAncestor); | |||
724 | } | |||
725 | ||||
726 | NestedNameSpecifier *Result = nullptr; | |||
727 | while (!TargetParents.empty()) { | |||
728 | const DeclContext *Parent = TargetParents.pop_back_val(); | |||
729 | ||||
730 | if (const auto *Namespace = dyn_cast<NamespaceDecl>(Parent)) { | |||
731 | if (!Namespace->getIdentifier()) | |||
732 | continue; | |||
733 | ||||
734 | Result = NestedNameSpecifier::Create(Context, Result, Namespace); | |||
735 | } else if (const auto *TD = dyn_cast<TagDecl>(Parent)) | |||
736 | Result = NestedNameSpecifier::Create( | |||
737 | Context, Result, false, Context.getTypeDeclType(TD).getTypePtr()); | |||
738 | } | |||
739 | return Result; | |||
740 | } | |||
741 | ||||
742 | // Some declarations have reserved names that we don't want to ever show. | |||
743 | // Filter out names reserved for the implementation if they come from a | |||
744 | // system header. | |||
745 | static bool shouldIgnoreDueToReservedName(const NamedDecl *ND, Sema &SemaRef) { | |||
746 | ReservedIdentifierStatus Status = ND->isReserved(SemaRef.getLangOpts()); | |||
747 | // Ignore reserved names for compiler provided decls. | |||
748 | if (isReservedInAllContexts(Status) && ND->getLocation().isInvalid()) | |||
749 | return true; | |||
750 | ||||
751 | // For system headers ignore only double-underscore names. | |||
752 | // This allows for system headers providing private symbols with a single | |||
753 | // underscore. | |||
754 | if (Status == ReservedIdentifierStatus::StartsWithDoubleUnderscore && | |||
755 | SemaRef.SourceMgr.isInSystemHeader( | |||
756 | SemaRef.SourceMgr.getSpellingLoc(ND->getLocation()))) | |||
757 | return true; | |||
758 | ||||
759 | return false; | |||
760 | } | |||
761 | ||||
762 | bool ResultBuilder::isInterestingDecl(const NamedDecl *ND, | |||
763 | bool &AsNestedNameSpecifier) const { | |||
764 | AsNestedNameSpecifier = false; | |||
765 | ||||
766 | auto *Named = ND; | |||
767 | ND = ND->getUnderlyingDecl(); | |||
768 | ||||
769 | // Skip unnamed entities. | |||
770 | if (!ND->getDeclName()) | |||
771 | return false; | |||
772 | ||||
773 | // Friend declarations and declarations introduced due to friends are never | |||
774 | // added as results. | |||
775 | if (ND->getFriendObjectKind() == Decl::FOK_Undeclared) | |||
776 | return false; | |||
777 | ||||
778 | // Class template (partial) specializations are never added as results. | |||
779 | if (isa<ClassTemplateSpecializationDecl>(ND) || | |||
780 | isa<ClassTemplatePartialSpecializationDecl>(ND)) | |||
781 | return false; | |||
782 | ||||
783 | // Using declarations themselves are never added as results. | |||
784 | if (isa<UsingDecl>(ND)) | |||
785 | return false; | |||
786 | ||||
787 | if (shouldIgnoreDueToReservedName(ND, SemaRef)) | |||
788 | return false; | |||
789 | ||||
790 | if (Filter == &ResultBuilder::IsNestedNameSpecifier || | |||
791 | (isa<NamespaceDecl>(ND) && Filter != &ResultBuilder::IsNamespace && | |||
792 | Filter != &ResultBuilder::IsNamespaceOrAlias && Filter != nullptr)) | |||
793 | AsNestedNameSpecifier = true; | |||
794 | ||||
795 | // Filter out any unwanted results. | |||
796 | if (Filter && !(this->*Filter)(Named)) { | |||
797 | // Check whether it is interesting as a nested-name-specifier. | |||
798 | if (AllowNestedNameSpecifiers && SemaRef.getLangOpts().CPlusPlus && | |||
799 | IsNestedNameSpecifier(ND) && | |||
800 | (Filter != &ResultBuilder::IsMember || | |||
801 | (isa<CXXRecordDecl>(ND) && | |||
802 | cast<CXXRecordDecl>(ND)->isInjectedClassName()))) { | |||
803 | AsNestedNameSpecifier = true; | |||
804 | return true; | |||
805 | } | |||
806 | ||||
807 | return false; | |||
808 | } | |||
809 | // ... then it must be interesting! | |||
810 | return true; | |||
811 | } | |||
812 | ||||
813 | bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext, | |||
814 | const NamedDecl *Hiding) { | |||
815 | // In C, there is no way to refer to a hidden name. | |||
816 | // FIXME: This isn't true; we can find a tag name hidden by an ordinary | |||
817 | // name if we introduce the tag type. | |||
818 | if (!SemaRef.getLangOpts().CPlusPlus) | |||
819 | return true; | |||
820 | ||||
821 | const DeclContext *HiddenCtx = | |||
822 | R.Declaration->getDeclContext()->getRedeclContext(); | |||
823 | ||||
824 | // There is no way to qualify a name declared in a function or method. | |||
825 | if (HiddenCtx->isFunctionOrMethod()) | |||
826 | return true; | |||
827 | ||||
828 | if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext()) | |||
829 | return true; | |||
830 | ||||
831 | // We can refer to the result with the appropriate qualification. Do it. | |||
832 | R.Hidden = true; | |||
833 | R.QualifierIsInformative = false; | |||
834 | ||||
835 | if (!R.Qualifier) | |||
836 | R.Qualifier = getRequiredQualification(SemaRef.Context, CurContext, | |||
837 | R.Declaration->getDeclContext()); | |||
838 | return false; | |||
839 | } | |||
840 | ||||
841 | /// A simplified classification of types used to determine whether two | |||
842 | /// types are "similar enough" when adjusting priorities. | |||
843 | SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) { | |||
844 | switch (T->getTypeClass()) { | |||
845 | case Type::Builtin: | |||
846 | switch (cast<BuiltinType>(T)->getKind()) { | |||
847 | case BuiltinType::Void: | |||
848 | return STC_Void; | |||
849 | ||||
850 | case BuiltinType::NullPtr: | |||
851 | return STC_Pointer; | |||
852 | ||||
853 | case BuiltinType::Overload: | |||
854 | case BuiltinType::Dependent: | |||
855 | return STC_Other; | |||
856 | ||||
857 | case BuiltinType::ObjCId: | |||
858 | case BuiltinType::ObjCClass: | |||
859 | case BuiltinType::ObjCSel: | |||
860 | return STC_ObjectiveC; | |||
861 | ||||
862 | default: | |||
863 | return STC_Arithmetic; | |||
864 | } | |||
865 | ||||
866 | case Type::Complex: | |||
867 | return STC_Arithmetic; | |||
868 | ||||
869 | case Type::Pointer: | |||
870 | return STC_Pointer; | |||
871 | ||||
872 | case Type::BlockPointer: | |||
873 | return STC_Block; | |||
874 | ||||
875 | case Type::LValueReference: | |||
876 | case Type::RValueReference: | |||
877 | return getSimplifiedTypeClass(T->getAs<ReferenceType>()->getPointeeType()); | |||
878 | ||||
879 | case Type::ConstantArray: | |||
880 | case Type::IncompleteArray: | |||
881 | case Type::VariableArray: | |||
882 | case Type::DependentSizedArray: | |||
883 | return STC_Array; | |||
884 | ||||
885 | case Type::DependentSizedExtVector: | |||
886 | case Type::Vector: | |||
887 | case Type::ExtVector: | |||
888 | return STC_Arithmetic; | |||
889 | ||||
890 | case Type::FunctionProto: | |||
891 | case Type::FunctionNoProto: | |||
892 | return STC_Function; | |||
893 | ||||
894 | case Type::Record: | |||
895 | return STC_Record; | |||
896 | ||||
897 | case Type::Enum: | |||
898 | return STC_Arithmetic; | |||
899 | ||||
900 | case Type::ObjCObject: | |||
901 | case Type::ObjCInterface: | |||
902 | case Type::ObjCObjectPointer: | |||
903 | return STC_ObjectiveC; | |||
904 | ||||
905 | default: | |||
906 | return STC_Other; | |||
907 | } | |||
908 | } | |||
909 | ||||
910 | /// Get the type that a given expression will have if this declaration | |||
911 | /// is used as an expression in its "typical" code-completion form. | |||
912 | QualType clang::getDeclUsageType(ASTContext &C, const NamedDecl *ND) { | |||
913 | ND = ND->getUnderlyingDecl(); | |||
914 | ||||
915 | if (const auto *Type = dyn_cast<TypeDecl>(ND)) | |||
916 | return C.getTypeDeclType(Type); | |||
917 | if (const auto *Iface = dyn_cast<ObjCInterfaceDecl>(ND)) | |||
918 | return C.getObjCInterfaceType(Iface); | |||
919 | ||||
920 | QualType T; | |||
921 | if (const FunctionDecl *Function = ND->getAsFunction()) | |||
922 | T = Function->getCallResultType(); | |||
923 | else if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) | |||
924 | T = Method->getSendResultType(); | |||
925 | else if (const auto *Enumerator = dyn_cast<EnumConstantDecl>(ND)) | |||
926 | T = C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext())); | |||
927 | else if (const auto *Property = dyn_cast<ObjCPropertyDecl>(ND)) | |||
928 | T = Property->getType(); | |||
929 | else if (const auto *Value = dyn_cast<ValueDecl>(ND)) | |||
930 | T = Value->getType(); | |||
931 | ||||
932 | if (T.isNull()) | |||
933 | return QualType(); | |||
934 | ||||
935 | // Dig through references, function pointers, and block pointers to | |||
936 | // get down to the likely type of an expression when the entity is | |||
937 | // used. | |||
938 | do { | |||
939 | if (const auto *Ref = T->getAs<ReferenceType>()) { | |||
940 | T = Ref->getPointeeType(); | |||
941 | continue; | |||
942 | } | |||
943 | ||||
944 | if (const auto *Pointer = T->getAs<PointerType>()) { | |||
945 | if (Pointer->getPointeeType()->isFunctionType()) { | |||
946 | T = Pointer->getPointeeType(); | |||
947 | continue; | |||
948 | } | |||
949 | ||||
950 | break; | |||
951 | } | |||
952 | ||||
953 | if (const auto *Block = T->getAs<BlockPointerType>()) { | |||
954 | T = Block->getPointeeType(); | |||
955 | continue; | |||
956 | } | |||
957 | ||||
958 | if (const auto *Function = T->getAs<FunctionType>()) { | |||
959 | T = Function->getReturnType(); | |||
960 | continue; | |||
961 | } | |||
962 | ||||
963 | break; | |||
964 | } while (true); | |||
965 | ||||
966 | return T; | |||
967 | } | |||
968 | ||||
969 | unsigned ResultBuilder::getBasePriority(const NamedDecl *ND) { | |||
970 | if (!ND) | |||
971 | return CCP_Unlikely; | |||
972 | ||||
973 | // Context-based decisions. | |||
974 | const DeclContext *LexicalDC = ND->getLexicalDeclContext(); | |||
975 | if (LexicalDC->isFunctionOrMethod()) { | |||
976 | // _cmd is relatively rare | |||
977 | if (const auto *ImplicitParam = dyn_cast<ImplicitParamDecl>(ND)) | |||
978 | if (ImplicitParam->getIdentifier() && | |||
979 | ImplicitParam->getIdentifier()->isStr("_cmd")) | |||
980 | return CCP_ObjC_cmd; | |||
981 | ||||
982 | return CCP_LocalDeclaration; | |||
983 | } | |||
984 | ||||
985 | const DeclContext *DC = ND->getDeclContext()->getRedeclContext(); | |||
986 | if (DC->isRecord() || isa<ObjCContainerDecl>(DC)) { | |||
987 | // Explicit destructor calls are very rare. | |||
988 | if (isa<CXXDestructorDecl>(ND)) | |||
989 | return CCP_Unlikely; | |||
990 | // Explicit operator and conversion function calls are also very rare. | |||
991 | auto DeclNameKind = ND->getDeclName().getNameKind(); | |||
992 | if (DeclNameKind == DeclarationName::CXXOperatorName || | |||
993 | DeclNameKind == DeclarationName::CXXLiteralOperatorName || | |||
994 | DeclNameKind == DeclarationName::CXXConversionFunctionName) | |||
995 | return CCP_Unlikely; | |||
996 | return CCP_MemberDeclaration; | |||
997 | } | |||
998 | ||||
999 | // Content-based decisions. | |||
1000 | if (isa<EnumConstantDecl>(ND)) | |||
1001 | return CCP_Constant; | |||
1002 | ||||
1003 | // Use CCP_Type for type declarations unless we're in a statement, Objective-C | |||
1004 | // message receiver, or parenthesized expression context. There, it's as | |||
1005 | // likely that the user will want to write a type as other declarations. | |||
1006 | if ((isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) && | |||
1007 | !(CompletionContext.getKind() == CodeCompletionContext::CCC_Statement || | |||
1008 | CompletionContext.getKind() == | |||
1009 | CodeCompletionContext::CCC_ObjCMessageReceiver || | |||
1010 | CompletionContext.getKind() == | |||
1011 | CodeCompletionContext::CCC_ParenthesizedExpression)) | |||
1012 | return CCP_Type; | |||
1013 | ||||
1014 | return CCP_Declaration; | |||
1015 | } | |||
1016 | ||||
1017 | void ResultBuilder::AdjustResultPriorityForDecl(Result &R) { | |||
1018 | // If this is an Objective-C method declaration whose selector matches our | |||
1019 | // preferred selector, give it a priority boost. | |||
1020 | if (!PreferredSelector.isNull()) | |||
1021 | if (const auto *Method = dyn_cast<ObjCMethodDecl>(R.Declaration)) | |||
1022 | if (PreferredSelector == Method->getSelector()) | |||
1023 | R.Priority += CCD_SelectorMatch; | |||
1024 | ||||
1025 | // If we have a preferred type, adjust the priority for results with exactly- | |||
1026 | // matching or nearly-matching types. | |||
1027 | if (!PreferredType.isNull()) { | |||
1028 | QualType T = getDeclUsageType(SemaRef.Context, R.Declaration); | |||
1029 | if (!T.isNull()) { | |||
1030 | CanQualType TC = SemaRef.Context.getCanonicalType(T); | |||
1031 | // Check for exactly-matching types (modulo qualifiers). | |||
1032 | if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC)) | |||
1033 | R.Priority /= CCF_ExactTypeMatch; | |||
1034 | // Check for nearly-matching types, based on classification of each. | |||
1035 | else if ((getSimplifiedTypeClass(PreferredType) == | |||
1036 | getSimplifiedTypeClass(TC)) && | |||
1037 | !(PreferredType->isEnumeralType() && TC->isEnumeralType())) | |||
1038 | R.Priority /= CCF_SimilarTypeMatch; | |||
1039 | } | |||
1040 | } | |||
1041 | } | |||
1042 | ||||
1043 | static DeclContext::lookup_result getConstructors(ASTContext &Context, | |||
1044 | const CXXRecordDecl *Record) { | |||
1045 | QualType RecordTy = Context.getTypeDeclType(Record); | |||
1046 | DeclarationName ConstructorName = | |||
1047 | Context.DeclarationNames.getCXXConstructorName( | |||
1048 | Context.getCanonicalType(RecordTy)); | |||
1049 | return Record->lookup(ConstructorName); | |||
1050 | } | |||
1051 | ||||
1052 | void ResultBuilder::MaybeAddConstructorResults(Result R) { | |||
1053 | if (!SemaRef.getLangOpts().CPlusPlus || !R.Declaration || | |||
1054 | !CompletionContext.wantConstructorResults()) | |||
1055 | return; | |||
1056 | ||||
1057 | const NamedDecl *D = R.Declaration; | |||
1058 | const CXXRecordDecl *Record = nullptr; | |||
1059 | if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D)) | |||
1060 | Record = ClassTemplate->getTemplatedDecl(); | |||
1061 | else if ((Record = dyn_cast<CXXRecordDecl>(D))) { | |||
1062 | // Skip specializations and partial specializations. | |||
1063 | if (isa<ClassTemplateSpecializationDecl>(Record)) | |||
1064 | return; | |||
1065 | } else { | |||
1066 | // There are no constructors here. | |||
1067 | return; | |||
1068 | } | |||
1069 | ||||
1070 | Record = Record->getDefinition(); | |||
1071 | if (!Record) | |||
1072 | return; | |||
1073 | ||||
1074 | for (NamedDecl *Ctor : getConstructors(SemaRef.Context, Record)) { | |||
1075 | R.Declaration = Ctor; | |||
1076 | R.CursorKind = getCursorKindForDecl(R.Declaration); | |||
1077 | Results.push_back(R); | |||
1078 | } | |||
1079 | } | |||
1080 | ||||
1081 | static bool isConstructor(const Decl *ND) { | |||
1082 | if (const auto *Tmpl = dyn_cast<FunctionTemplateDecl>(ND)) | |||
1083 | ND = Tmpl->getTemplatedDecl(); | |||
1084 | return isa<CXXConstructorDecl>(ND); | |||
1085 | } | |||
1086 | ||||
1087 | void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) { | |||
1088 | assert(!ShadowMaps.empty() && "Must enter into a results scope")(static_cast <bool> (!ShadowMaps.empty() && "Must enter into a results scope" ) ? void (0) : __assert_fail ("!ShadowMaps.empty() && \"Must enter into a results scope\"" , "clang/lib/Sema/SemaCodeComplete.cpp", 1088, __extension__ __PRETTY_FUNCTION__ )); | |||
1089 | ||||
1090 | if (R.Kind != Result::RK_Declaration) { | |||
1091 | // For non-declaration results, just add the result. | |||
1092 | Results.push_back(R); | |||
1093 | return; | |||
1094 | } | |||
1095 | ||||
1096 | // Look through using declarations. | |||
1097 | if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) { | |||
1098 | CodeCompletionResult Result(Using->getTargetDecl(), | |||
1099 | getBasePriority(Using->getTargetDecl()), | |||
1100 | R.Qualifier, false, | |||
1101 | (R.Availability == CXAvailability_Available || | |||
1102 | R.Availability == CXAvailability_Deprecated), | |||
1103 | std::move(R.FixIts)); | |||
1104 | Result.ShadowDecl = Using; | |||
1105 | MaybeAddResult(Result, CurContext); | |||
1106 | return; | |||
1107 | } | |||
1108 | ||||
1109 | const Decl *CanonDecl = R.Declaration->getCanonicalDecl(); | |||
1110 | unsigned IDNS = CanonDecl->getIdentifierNamespace(); | |||
1111 | ||||
1112 | bool AsNestedNameSpecifier = false; | |||
1113 | if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier)) | |||
1114 | return; | |||
1115 | ||||
1116 | // C++ constructors are never found by name lookup. | |||
1117 | if (isConstructor(R.Declaration)) | |||
1118 | return; | |||
1119 | ||||
1120 | ShadowMap &SMap = ShadowMaps.back(); | |||
1121 | ShadowMapEntry::iterator I, IEnd; | |||
1122 | ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName()); | |||
1123 | if (NamePos != SMap.end()) { | |||
1124 | I = NamePos->second.begin(); | |||
1125 | IEnd = NamePos->second.end(); | |||
1126 | } | |||
1127 | ||||
1128 | for (; I != IEnd; ++I) { | |||
1129 | const NamedDecl *ND = I->first; | |||
1130 | unsigned Index = I->second; | |||
1131 | if (ND->getCanonicalDecl() == CanonDecl) { | |||
1132 | // This is a redeclaration. Always pick the newer declaration. | |||
1133 | Results[Index].Declaration = R.Declaration; | |||
1134 | ||||
1135 | // We're done. | |||
1136 | return; | |||
1137 | } | |||
1138 | } | |||
1139 | ||||
1140 | // This is a new declaration in this scope. However, check whether this | |||
1141 | // declaration name is hidden by a similarly-named declaration in an outer | |||
1142 | // scope. | |||
1143 | std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end(); | |||
1144 | --SMEnd; | |||
1145 | for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) { | |||
1146 | ShadowMapEntry::iterator I, IEnd; | |||
1147 | ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName()); | |||
1148 | if (NamePos != SM->end()) { | |||
1149 | I = NamePos->second.begin(); | |||
1150 | IEnd = NamePos->second.end(); | |||
1151 | } | |||
1152 | for (; I != IEnd; ++I) { | |||
1153 | // A tag declaration does not hide a non-tag declaration. | |||
1154 | if (I->first->hasTagIdentifierNamespace() && | |||
1155 | (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary | | |||
1156 | Decl::IDNS_LocalExtern | Decl::IDNS_ObjCProtocol))) | |||
1157 | continue; | |||
1158 | ||||
1159 | // Protocols are in distinct namespaces from everything else. | |||
1160 | if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol) || | |||
1161 | (IDNS & Decl::IDNS_ObjCProtocol)) && | |||
1162 | I->first->getIdentifierNamespace() != IDNS) | |||
1163 | continue; | |||
1164 | ||||
1165 | // The newly-added result is hidden by an entry in the shadow map. | |||
1166 | if (CheckHiddenResult(R, CurContext, I->first)) | |||
1167 | return; | |||
1168 | ||||
1169 | break; | |||
1170 | } | |||
1171 | } | |||
1172 | ||||
1173 | // Make sure that any given declaration only shows up in the result set once. | |||
1174 | if (!AllDeclsFound.insert(CanonDecl).second) | |||
1175 | return; | |||
1176 | ||||
1177 | // If the filter is for nested-name-specifiers, then this result starts a | |||
1178 | // nested-name-specifier. | |||
1179 | if (AsNestedNameSpecifier) { | |||
1180 | R.StartsNestedNameSpecifier = true; | |||
1181 | R.Priority = CCP_NestedNameSpecifier; | |||
1182 | } else | |||
1183 | AdjustResultPriorityForDecl(R); | |||
1184 | ||||
1185 | // If this result is supposed to have an informative qualifier, add one. | |||
1186 | if (R.QualifierIsInformative && !R.Qualifier && | |||
1187 | !R.StartsNestedNameSpecifier) { | |||
1188 | const DeclContext *Ctx = R.Declaration->getDeclContext(); | |||
1189 | if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx)) | |||
1190 | R.Qualifier = | |||
1191 | NestedNameSpecifier::Create(SemaRef.Context, nullptr, Namespace); | |||
1192 | else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx)) | |||
1193 | R.Qualifier = NestedNameSpecifier::Create( | |||
1194 | SemaRef.Context, nullptr, false, | |||
1195 | SemaRef.Context.getTypeDeclType(Tag).getTypePtr()); | |||
1196 | else | |||
1197 | R.QualifierIsInformative = false; | |||
1198 | } | |||
1199 | ||||
1200 | // Insert this result into the set of results and into the current shadow | |||
1201 | // map. | |||
1202 | SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size()); | |||
1203 | Results.push_back(R); | |||
1204 | ||||
1205 | if (!AsNestedNameSpecifier) | |||
1206 | MaybeAddConstructorResults(R); | |||
1207 | } | |||
1208 | ||||
1209 | static void setInBaseClass(ResultBuilder::Result &R) { | |||
1210 | R.Priority += CCD_InBaseClass; | |||
1211 | R.InBaseClass = true; | |||
1212 | } | |||
1213 | ||||
1214 | enum class OverloadCompare { BothViable, Dominates, Dominated }; | |||
1215 | // Will Candidate ever be called on the object, when overloaded with Incumbent? | |||
1216 | // Returns Dominates if Candidate is always called, Dominated if Incumbent is | |||
1217 | // always called, BothViable if either may be called depending on arguments. | |||
1218 | // Precondition: must actually be overloads! | |||
1219 | static OverloadCompare compareOverloads(const CXXMethodDecl &Candidate, | |||
1220 | const CXXMethodDecl &Incumbent, | |||
1221 | const Qualifiers &ObjectQuals, | |||
1222 | ExprValueKind ObjectKind) { | |||
1223 | // Base/derived shadowing is handled elsewhere. | |||
1224 | if (Candidate.getDeclContext() != Incumbent.getDeclContext()) | |||
1225 | return OverloadCompare::BothViable; | |||
1226 | if (Candidate.isVariadic() != Incumbent.isVariadic() || | |||
1227 | Candidate.getNumParams() != Incumbent.getNumParams() || | |||
1228 | Candidate.getMinRequiredArguments() != | |||
1229 | Incumbent.getMinRequiredArguments()) | |||
1230 | return OverloadCompare::BothViable; | |||
1231 | for (unsigned I = 0, E = Candidate.getNumParams(); I != E; ++I) | |||
1232 | if (Candidate.parameters()[I]->getType().getCanonicalType() != | |||
1233 | Incumbent.parameters()[I]->getType().getCanonicalType()) | |||
1234 | return OverloadCompare::BothViable; | |||
1235 | if (!Candidate.specific_attrs<EnableIfAttr>().empty() || | |||
1236 | !Incumbent.specific_attrs<EnableIfAttr>().empty()) | |||
1237 | return OverloadCompare::BothViable; | |||
1238 | // At this point, we know calls can't pick one or the other based on | |||
1239 | // arguments, so one of the two must win. (Or both fail, handled elsewhere). | |||
1240 | RefQualifierKind CandidateRef = Candidate.getRefQualifier(); | |||
1241 | RefQualifierKind IncumbentRef = Incumbent.getRefQualifier(); | |||
1242 | if (CandidateRef != IncumbentRef) { | |||
1243 | // If the object kind is LValue/RValue, there's one acceptable ref-qualifier | |||
1244 | // and it can't be mixed with ref-unqualified overloads (in valid code). | |||
1245 | ||||
1246 | // For xvalue objects, we prefer the rvalue overload even if we have to | |||
1247 | // add qualifiers (which is rare, because const&& is rare). | |||
1248 | if (ObjectKind == clang::VK_XValue) | |||
1249 | return CandidateRef == RQ_RValue ? OverloadCompare::Dominates | |||
1250 | : OverloadCompare::Dominated; | |||
1251 | } | |||
1252 | // Now the ref qualifiers are the same (or we're in some invalid state). | |||
1253 | // So make some decision based on the qualifiers. | |||
1254 | Qualifiers CandidateQual = Candidate.getMethodQualifiers(); | |||
1255 | Qualifiers IncumbentQual = Incumbent.getMethodQualifiers(); | |||
1256 | bool CandidateSuperset = CandidateQual.compatiblyIncludes(IncumbentQual); | |||
1257 | bool IncumbentSuperset = IncumbentQual.compatiblyIncludes(CandidateQual); | |||
1258 | if (CandidateSuperset == IncumbentSuperset) | |||
1259 | return OverloadCompare::BothViable; | |||
1260 | return IncumbentSuperset ? OverloadCompare::Dominates | |||
1261 | : OverloadCompare::Dominated; | |||
1262 | } | |||
1263 | ||||
1264 | void ResultBuilder::AddResult(Result R, DeclContext *CurContext, | |||
1265 | NamedDecl *Hiding, bool InBaseClass = false) { | |||
1266 | if (R.Kind != Result::RK_Declaration) { | |||
1267 | // For non-declaration results, just add the result. | |||
1268 | Results.push_back(R); | |||
1269 | return; | |||
1270 | } | |||
1271 | ||||
1272 | // Look through using declarations. | |||
1273 | if (const auto *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) { | |||
1274 | CodeCompletionResult Result(Using->getTargetDecl(), | |||
1275 | getBasePriority(Using->getTargetDecl()), | |||
1276 | R.Qualifier, false, | |||
1277 | (R.Availability == CXAvailability_Available || | |||
1278 | R.Availability == CXAvailability_Deprecated), | |||
1279 | std::move(R.FixIts)); | |||
1280 | Result.ShadowDecl = Using; | |||
1281 | AddResult(Result, CurContext, Hiding); | |||
1282 | return; | |||
1283 | } | |||
1284 | ||||
1285 | bool AsNestedNameSpecifier = false; | |||
1286 | if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier)) | |||
1287 | return; | |||
1288 | ||||
1289 | // C++ constructors are never found by name lookup. | |||
1290 | if (isConstructor(R.Declaration)) | |||
1291 | return; | |||
1292 | ||||
1293 | if (Hiding && CheckHiddenResult(R, CurContext, Hiding)) | |||
1294 | return; | |||
1295 | ||||
1296 | // Make sure that any given declaration only shows up in the result set once. | |||
1297 | if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()).second) | |||
1298 | return; | |||
1299 | ||||
1300 | // If the filter is for nested-name-specifiers, then this result starts a | |||
1301 | // nested-name-specifier. | |||
1302 | if (AsNestedNameSpecifier) { | |||
1303 | R.StartsNestedNameSpecifier = true; | |||
1304 | R.Priority = CCP_NestedNameSpecifier; | |||
1305 | } else if (Filter == &ResultBuilder::IsMember && !R.Qualifier && | |||
1306 | InBaseClass && | |||
1307 | isa<CXXRecordDecl>( | |||
1308 | R.Declaration->getDeclContext()->getRedeclContext())) | |||
1309 | R.QualifierIsInformative = true; | |||
1310 | ||||
1311 | // If this result is supposed to have an informative qualifier, add one. | |||
1312 | if (R.QualifierIsInformative && !R.Qualifier && | |||
1313 | !R.StartsNestedNameSpecifier) { | |||
1314 | const DeclContext *Ctx = R.Declaration->getDeclContext(); | |||
1315 | if (const auto *Namespace = dyn_cast<NamespaceDecl>(Ctx)) | |||
1316 | R.Qualifier = | |||
1317 | NestedNameSpecifier::Create(SemaRef.Context, nullptr, Namespace); | |||
1318 | else if (const auto *Tag = dyn_cast<TagDecl>(Ctx)) | |||
1319 | R.Qualifier = NestedNameSpecifier::Create( | |||
1320 | SemaRef.Context, nullptr, false, | |||
1321 | SemaRef.Context.getTypeDeclType(Tag).getTypePtr()); | |||
1322 | else | |||
1323 | R.QualifierIsInformative = false; | |||
1324 | } | |||
1325 | ||||
1326 | // Adjust the priority if this result comes from a base class. | |||
1327 | if (InBaseClass) | |||
1328 | setInBaseClass(R); | |||
1329 | ||||
1330 | AdjustResultPriorityForDecl(R); | |||
1331 | ||||
1332 | if (HasObjectTypeQualifiers) | |||
1333 | if (const auto *Method = dyn_cast<CXXMethodDecl>(R.Declaration)) | |||
1334 | if (Method->isInstance()) { | |||
1335 | Qualifiers MethodQuals = Method->getMethodQualifiers(); | |||
1336 | if (ObjectTypeQualifiers == MethodQuals) | |||
1337 | R.Priority += CCD_ObjectQualifierMatch; | |||
1338 | else if (ObjectTypeQualifiers - MethodQuals) { | |||
1339 | // The method cannot be invoked, because doing so would drop | |||
1340 | // qualifiers. | |||
1341 | return; | |||
1342 | } | |||
1343 | // Detect cases where a ref-qualified method cannot be invoked. | |||
1344 | switch (Method->getRefQualifier()) { | |||
1345 | case RQ_LValue: | |||
1346 | if (ObjectKind != VK_LValue && !MethodQuals.hasConst()) | |||
1347 | return; | |||
1348 | break; | |||
1349 | case RQ_RValue: | |||
1350 | if (ObjectKind == VK_LValue) | |||
1351 | return; | |||
1352 | break; | |||
1353 | case RQ_None: | |||
1354 | break; | |||
1355 | } | |||
1356 | ||||
1357 | /// Check whether this dominates another overloaded method, which should | |||
1358 | /// be suppressed (or vice versa). | |||
1359 | /// Motivating case is const_iterator begin() const vs iterator begin(). | |||
1360 | auto &OverloadSet = OverloadMap[std::make_pair( | |||
1361 | CurContext, Method->getDeclName().getAsOpaqueInteger())]; | |||
1362 | for (const DeclIndexPair Entry : OverloadSet) { | |||
1363 | Result &Incumbent = Results[Entry.second]; | |||
1364 | switch (compareOverloads(*Method, | |||
1365 | *cast<CXXMethodDecl>(Incumbent.Declaration), | |||
1366 | ObjectTypeQualifiers, ObjectKind)) { | |||
1367 | case OverloadCompare::Dominates: | |||
1368 | // Replace the dominated overload with this one. | |||
1369 | // FIXME: if the overload dominates multiple incumbents then we | |||
1370 | // should remove all. But two overloads is by far the common case. | |||
1371 | Incumbent = std::move(R); | |||
1372 | return; | |||
1373 | case OverloadCompare::Dominated: | |||
1374 | // This overload can't be called, drop it. | |||
1375 | return; | |||
1376 | case OverloadCompare::BothViable: | |||
1377 | break; | |||
1378 | } | |||
1379 | } | |||
1380 | OverloadSet.Add(Method, Results.size()); | |||
1381 | } | |||
1382 | ||||
1383 | // When completing a non-static member function (and not via | |||
1384 | // dot/arrow member access) and we're not inside that class' scope, | |||
1385 | // it can't be a call. | |||
1386 | if (CompletionContext.getKind() == clang::CodeCompletionContext::CCC_Symbol) { | |||
1387 | const auto *Method = dyn_cast<CXXMethodDecl>(R.getDeclaration()); | |||
1388 | if (Method && !Method->isStatic()) { | |||
1389 | // Find the class scope that we're currently in. | |||
1390 | // We could e.g. be inside a lambda, so walk up the DeclContext until we | |||
1391 | // find a CXXMethodDecl. | |||
1392 | const auto *CurrentClassScope = [&]() -> const CXXRecordDecl * { | |||
1393 | for (DeclContext *Ctx = SemaRef.CurContext; Ctx; | |||
1394 | Ctx = Ctx->getParent()) { | |||
1395 | const auto *CtxMethod = llvm::dyn_cast<CXXMethodDecl>(Ctx); | |||
1396 | if (CtxMethod && !CtxMethod->getParent()->isLambda()) { | |||
1397 | return CtxMethod->getParent(); | |||
1398 | } | |||
1399 | } | |||
1400 | return nullptr; | |||
1401 | }(); | |||
1402 | ||||
1403 | R.FunctionCanBeCall = | |||
1404 | CurrentClassScope && | |||
1405 | (CurrentClassScope == Method->getParent() || | |||
1406 | CurrentClassScope->isDerivedFrom(Method->getParent())); | |||
1407 | } | |||
1408 | } | |||
1409 | ||||
1410 | // Insert this result into the set of results. | |||
1411 | Results.push_back(R); | |||
1412 | ||||
1413 | if (!AsNestedNameSpecifier) | |||
1414 | MaybeAddConstructorResults(R); | |||
1415 | } | |||
1416 | ||||
1417 | void ResultBuilder::AddResult(Result R) { | |||
1418 | assert(R.Kind != Result::RK_Declaration &&(static_cast <bool> (R.Kind != Result::RK_Declaration && "Declaration results need more context") ? void (0) : __assert_fail ("R.Kind != Result::RK_Declaration && \"Declaration results need more context\"" , "clang/lib/Sema/SemaCodeComplete.cpp", 1419, __extension__ __PRETTY_FUNCTION__ )) | |||
1419 | "Declaration results need more context")(static_cast <bool> (R.Kind != Result::RK_Declaration && "Declaration results need more context") ? void (0) : __assert_fail ("R.Kind != Result::RK_Declaration && \"Declaration results need more context\"" , "clang/lib/Sema/SemaCodeComplete.cpp", 1419, __extension__ __PRETTY_FUNCTION__ )); | |||
1420 | Results.push_back(R); | |||
1421 | } | |||
1422 | ||||
1423 | /// Enter into a new scope. | |||
1424 | void ResultBuilder::EnterNewScope() { ShadowMaps.emplace_back(); } | |||
1425 | ||||
1426 | /// Exit from the current scope. | |||
1427 | void ResultBuilder::ExitScope() { | |||
1428 | ShadowMaps.pop_back(); | |||
1429 | } | |||
1430 | ||||
1431 | /// Determines whether this given declaration will be found by | |||
1432 | /// ordinary name lookup. | |||
1433 | bool ResultBuilder::IsOrdinaryName(const NamedDecl *ND) const { | |||
1434 | ND = ND->getUnderlyingDecl(); | |||
1435 | ||||
1436 | // If name lookup finds a local extern declaration, then we are in a | |||
1437 | // context where it behaves like an ordinary name. | |||
1438 | unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern; | |||
1439 | if (SemaRef.getLangOpts().CPlusPlus) | |||
1440 | IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member; | |||
1441 | else if (SemaRef.getLangOpts().ObjC) { | |||
1442 | if (isa<ObjCIvarDecl>(ND)) | |||
1443 | return true; | |||
1444 | } | |||
1445 | ||||
1446 | return ND->getIdentifierNamespace() & IDNS; | |||
1447 | } | |||
1448 | ||||
1449 | /// Determines whether this given declaration will be found by | |||
1450 | /// ordinary name lookup but is not a type name. | |||
1451 | bool ResultBuilder::IsOrdinaryNonTypeName(const NamedDecl *ND) const { | |||
1452 | ND = ND->getUnderlyingDecl(); | |||
1453 | if (isa<TypeDecl>(ND)) | |||
1454 | return false; | |||
1455 | // Objective-C interfaces names are not filtered by this method because they | |||
1456 | // can be used in a class property expression. We can still filter out | |||
1457 | // @class declarations though. | |||
1458 | if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND)) { | |||
1459 | if (!ID->getDefinition()) | |||
1460 | return false; | |||
1461 | } | |||
1462 | ||||
1463 | unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern; | |||
1464 | if (SemaRef.getLangOpts().CPlusPlus) | |||
1465 | IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member; | |||
1466 | else if (SemaRef.getLangOpts().ObjC) { | |||
1467 | if (isa<ObjCIvarDecl>(ND)) | |||
1468 | return true; | |||
1469 | } | |||
1470 | ||||
1471 | return ND->getIdentifierNamespace() & IDNS; | |||
1472 | } | |||
1473 | ||||
1474 | bool ResultBuilder::IsIntegralConstantValue(const NamedDecl *ND) const { | |||
1475 | if (!IsOrdinaryNonTypeName(ND)) | |||
1476 | return false; | |||
1477 | ||||
1478 | if (const auto *VD = dyn_cast<ValueDecl>(ND->getUnderlyingDecl())) | |||
1479 | if (VD->getType()->isIntegralOrEnumerationType()) | |||
1480 | return true; | |||
1481 | ||||
1482 | return false; | |||
1483 | } | |||
1484 | ||||
1485 | /// Determines whether this given declaration will be found by | |||
1486 | /// ordinary name lookup. | |||
1487 | bool ResultBuilder::IsOrdinaryNonValueName(const NamedDecl *ND) const { | |||
1488 | ND = ND->getUnderlyingDecl(); | |||
1489 | ||||
1490 | unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern; | |||
1491 | if (SemaRef.getLangOpts().CPlusPlus) | |||
1492 | IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace; | |||
1493 | ||||
1494 | return (ND->getIdentifierNamespace() & IDNS) && !isa<ValueDecl>(ND) && | |||
1495 | !isa<FunctionTemplateDecl>(ND) && !isa<ObjCPropertyDecl>(ND); | |||
1496 | } | |||
1497 | ||||
1498 | /// Determines whether the given declaration is suitable as the | |||
1499 | /// start of a C++ nested-name-specifier, e.g., a class or namespace. | |||
1500 | bool ResultBuilder::IsNestedNameSpecifier(const NamedDecl *ND) const { | |||
1501 | // Allow us to find class templates, too. | |||
1502 | if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND)) | |||
1503 | ND = ClassTemplate->getTemplatedDecl(); | |||
1504 | ||||
1505 | return SemaRef.isAcceptableNestedNameSpecifier(ND); | |||
1506 | } | |||
1507 | ||||
1508 | /// Determines whether the given declaration is an enumeration. | |||
1509 | bool ResultBuilder::IsEnum(const NamedDecl *ND) const { | |||
1510 | return isa<EnumDecl>(ND); | |||
1511 | } | |||
1512 | ||||
1513 | /// Determines whether the given declaration is a class or struct. | |||
1514 | bool ResultBuilder::IsClassOrStruct(const NamedDecl *ND) const { | |||
1515 | // Allow us to find class templates, too. | |||
1516 | if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND)) | |||
1517 | ND = ClassTemplate->getTemplatedDecl(); | |||
1518 | ||||
1519 | // For purposes of this check, interfaces match too. | |||
1520 | if (const auto *RD = dyn_cast<RecordDecl>(ND)) | |||
1521 | return RD->getTagKind() == TTK_Class || RD->getTagKind() == TTK_Struct || | |||
1522 | RD->getTagKind() == TTK_Interface; | |||
1523 | ||||
1524 | return false; | |||
1525 | } | |||
1526 | ||||
1527 | /// Determines whether the given declaration is a union. | |||
1528 | bool ResultBuilder::IsUnion(const NamedDecl *ND) const { | |||
1529 | // Allow us to find class templates, too. | |||
1530 | if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND)) | |||
1531 | ND = ClassTemplate->getTemplatedDecl(); | |||
1532 | ||||
1533 | if (const auto *RD = dyn_cast<RecordDecl>(ND)) | |||
1534 | return RD->getTagKind() == TTK_Union; | |||
1535 | ||||
1536 | return false; | |||
1537 | } | |||
1538 | ||||
1539 | /// Determines whether the given declaration is a namespace. | |||
1540 | bool ResultBuilder::IsNamespace(const NamedDecl *ND) const { | |||
1541 | return isa<NamespaceDecl>(ND); | |||
1542 | } | |||
1543 | ||||
1544 | /// Determines whether the given declaration is a namespace or | |||
1545 | /// namespace alias. | |||
1546 | bool ResultBuilder::IsNamespaceOrAlias(const NamedDecl *ND) const { | |||
1547 | return isa<NamespaceDecl>(ND->getUnderlyingDecl()); | |||
1548 | } | |||
1549 | ||||
1550 | /// Determines whether the given declaration is a type. | |||
1551 | bool ResultBuilder::IsType(const NamedDecl *ND) const { | |||
1552 | ND = ND->getUnderlyingDecl(); | |||
1553 | return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND); | |||
1554 | } | |||
1555 | ||||
1556 | /// Determines which members of a class should be visible via | |||
1557 | /// "." or "->". Only value declarations, nested name specifiers, and | |||
1558 | /// using declarations thereof should show up. | |||
1559 | bool ResultBuilder::IsMember(const NamedDecl *ND) const { | |||
1560 | ND = ND->getUnderlyingDecl(); | |||
1561 | return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) || | |||
1562 | isa<ObjCPropertyDecl>(ND); | |||
1563 | } | |||
1564 | ||||
1565 | static bool isObjCReceiverType(ASTContext &C, QualType T) { | |||
1566 | T = C.getCanonicalType(T); | |||
1567 | switch (T->getTypeClass()) { | |||
1568 | case Type::ObjCObject: | |||
1569 | case Type::ObjCInterface: | |||
1570 | case Type::ObjCObjectPointer: | |||
1571 | return true; | |||
1572 | ||||
1573 | case Type::Builtin: | |||
1574 | switch (cast<BuiltinType>(T)->getKind()) { | |||
1575 | case BuiltinType::ObjCId: | |||
1576 | case BuiltinType::ObjCClass: | |||
1577 | case BuiltinType::ObjCSel: | |||
1578 | return true; | |||
1579 | ||||
1580 | default: | |||
1581 | break; | |||
1582 | } | |||
1583 | return false; | |||
1584 | ||||
1585 | default: | |||
1586 | break; | |||
1587 | } | |||
1588 | ||||
1589 | if (!C.getLangOpts().CPlusPlus) | |||
1590 | return false; | |||
1591 | ||||
1592 | // FIXME: We could perform more analysis here to determine whether a | |||
1593 | // particular class type has any conversions to Objective-C types. For now, | |||
1594 | // just accept all class types. | |||
1595 | return T->isDependentType() || T->isRecordType(); | |||
1596 | } | |||
1597 | ||||
1598 | bool ResultBuilder::IsObjCMessageReceiver(const NamedDecl *ND) const { | |||
1599 | QualType T = getDeclUsageType(SemaRef.Context, ND); | |||
1600 | if (T.isNull()) | |||
1601 | return false; | |||
1602 | ||||
1603 | T = SemaRef.Context.getBaseElementType(T); | |||
1604 | return isObjCReceiverType(SemaRef.Context, T); | |||
1605 | } | |||
1606 | ||||
1607 | bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture( | |||
1608 | const NamedDecl *ND) const { | |||
1609 | if (IsObjCMessageReceiver(ND)) | |||
1610 | return true; | |||
1611 | ||||
1612 | const auto *Var = dyn_cast<VarDecl>(ND); | |||
1613 | if (!Var) | |||
1614 | return false; | |||
1615 | ||||
1616 | return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>(); | |||
1617 | } | |||
1618 | ||||
1619 | bool ResultBuilder::IsObjCCollection(const NamedDecl *ND) const { | |||
1620 | if ((SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) || | |||
1621 | (!SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND))) | |||
1622 | return false; | |||
1623 | ||||
1624 | QualType T = getDeclUsageType(SemaRef.Context, ND); | |||
1625 | if (T.isNull()) | |||
1626 | return false; | |||
1627 | ||||
1628 | T = SemaRef.Context.getBaseElementType(T); | |||
1629 | return T->isObjCObjectType() || T->isObjCObjectPointerType() || | |||
1630 | T->isObjCIdType() || | |||
1631 | (SemaRef.getLangOpts().CPlusPlus && T->isRecordType()); | |||
1632 | } | |||
1633 | ||||
1634 | bool ResultBuilder::IsImpossibleToSatisfy(const NamedDecl *ND) const { | |||
1635 | return false; | |||
1636 | } | |||
1637 | ||||
1638 | /// Determines whether the given declaration is an Objective-C | |||
1639 | /// instance variable. | |||
1640 | bool ResultBuilder::IsObjCIvar(const NamedDecl *ND) const { | |||
1641 | return isa<ObjCIvarDecl>(ND); | |||
1642 | } | |||
1643 | ||||
1644 | namespace { | |||
1645 | ||||
1646 | /// Visible declaration consumer that adds a code-completion result | |||
1647 | /// for each visible declaration. | |||
1648 | class CodeCompletionDeclConsumer : public VisibleDeclConsumer { | |||
1649 | ResultBuilder &Results; | |||
1650 | DeclContext *InitialLookupCtx; | |||
1651 | // NamingClass and BaseType are used for access-checking. See | |||
1652 | // Sema::IsSimplyAccessible for details. | |||
1653 | CXXRecordDecl *NamingClass; | |||
1654 | QualType BaseType; | |||
1655 | std::vector<FixItHint> FixIts; | |||
1656 | ||||
1657 | public: | |||
1658 | CodeCompletionDeclConsumer( | |||
1659 | ResultBuilder &Results, DeclContext *InitialLookupCtx, | |||
1660 | QualType BaseType = QualType(), | |||
1661 | std::vector<FixItHint> FixIts = std::vector<FixItHint>()) | |||
1662 | : Results(Results), InitialLookupCtx(InitialLookupCtx), | |||
1663 | FixIts(std::move(FixIts)) { | |||
1664 | NamingClass = llvm::dyn_cast<CXXRecordDecl>(InitialLookupCtx); | |||
1665 | // If BaseType was not provided explicitly, emulate implicit 'this->'. | |||
1666 | if (BaseType.isNull()) { | |||
1667 | auto ThisType = Results.getSema().getCurrentThisType(); | |||
1668 | if (!ThisType.isNull()) { | |||
1669 | assert(ThisType->isPointerType())(static_cast <bool> (ThisType->isPointerType()) ? void (0) : __assert_fail ("ThisType->isPointerType()", "clang/lib/Sema/SemaCodeComplete.cpp" , 1669, __extension__ __PRETTY_FUNCTION__)); | |||
1670 | BaseType = ThisType->getPointeeType(); | |||
1671 | if (!NamingClass) | |||
1672 | NamingClass = BaseType->getAsCXXRecordDecl(); | |||
1673 | } | |||
1674 | } | |||
1675 | this->BaseType = BaseType; | |||
1676 | } | |||
1677 | ||||
1678 | void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx, | |||
1679 | bool InBaseClass) override { | |||
1680 | ResultBuilder::Result Result(ND, Results.getBasePriority(ND), nullptr, | |||
1681 | false, IsAccessible(ND, Ctx), FixIts); | |||
1682 | Results.AddResult(Result, InitialLookupCtx, Hiding, InBaseClass); | |||
1683 | } | |||
1684 | ||||
1685 | void EnteredContext(DeclContext *Ctx) override { | |||
1686 | Results.addVisitedContext(Ctx); | |||
1687 | } | |||
1688 | ||||
1689 | private: | |||
1690 | bool IsAccessible(NamedDecl *ND, DeclContext *Ctx) { | |||
1691 | // Naming class to use for access check. In most cases it was provided | |||
1692 | // explicitly (e.g. member access (lhs.foo) or qualified lookup (X::)), | |||
1693 | // for unqualified lookup we fallback to the \p Ctx in which we found the | |||
1694 | // member. | |||
1695 | auto *NamingClass = this->NamingClass; | |||
1696 | QualType BaseType = this->BaseType; | |||
1697 | if (auto *Cls = llvm::dyn_cast_or_null<CXXRecordDecl>(Ctx)) { | |||
1698 | if (!NamingClass) | |||
1699 | NamingClass = Cls; | |||
1700 | // When we emulate implicit 'this->' in an unqualified lookup, we might | |||
1701 | // end up with an invalid naming class. In that case, we avoid emulating | |||
1702 | // 'this->' qualifier to satisfy preconditions of the access checking. | |||
1703 | if (NamingClass->getCanonicalDecl() != Cls->getCanonicalDecl() && | |||
1704 | !NamingClass->isDerivedFrom(Cls)) { | |||
1705 | NamingClass = Cls; | |||
1706 | BaseType = QualType(); | |||
1707 | } | |||
1708 | } else { | |||
1709 | // The decl was found outside the C++ class, so only ObjC access checks | |||
1710 | // apply. Those do not rely on NamingClass and BaseType, so we clear them | |||
1711 | // out. | |||
1712 | NamingClass = nullptr; | |||
1713 | BaseType = QualType(); | |||
1714 | } | |||
1715 | return Results.getSema().IsSimplyAccessible(ND, NamingClass, BaseType); | |||
1716 | } | |||
1717 | }; | |||
1718 | } // namespace | |||
1719 | ||||
1720 | /// Add type specifiers for the current language as keyword results. | |||
1721 | static void AddTypeSpecifierResults(const LangOptions &LangOpts, | |||
1722 | ResultBuilder &Results) { | |||
1723 | typedef CodeCompletionResult Result; | |||
1724 | Results.AddResult(Result("short", CCP_Type)); | |||
1725 | Results.AddResult(Result("long", CCP_Type)); | |||
1726 | Results.AddResult(Result("signed", CCP_Type)); | |||
1727 | Results.AddResult(Result("unsigned", CCP_Type)); | |||
1728 | Results.AddResult(Result("void", CCP_Type)); | |||
1729 | Results.AddResult(Result("char", CCP_Type)); | |||
1730 | Results.AddResult(Result("int", CCP_Type)); | |||
1731 | Results.AddResult(Result("float", CCP_Type)); | |||
1732 | Results.AddResult(Result("double", CCP_Type)); | |||
1733 | Results.AddResult(Result("enum", CCP_Type)); | |||
1734 | Results.AddResult(Result("struct", CCP_Type)); | |||
1735 | Results.AddResult(Result("union", CCP_Type)); | |||
1736 | Results.AddResult(Result("const", CCP_Type)); | |||
1737 | Results.AddResult(Result("volatile", CCP_Type)); | |||
1738 | ||||
1739 | if (LangOpts.C99) { | |||
1740 | // C99-specific | |||
1741 | Results.AddResult(Result("_Complex", CCP_Type)); | |||
1742 | Results.AddResult(Result("_Imaginary", CCP_Type)); | |||
1743 | Results.AddResult(Result("_Bool", CCP_Type)); | |||
1744 | Results.AddResult(Result("restrict", CCP_Type)); | |||
1745 | } | |||
1746 | ||||
1747 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
1748 | Results.getCodeCompletionTUInfo()); | |||
1749 | if (LangOpts.CPlusPlus) { | |||
1750 | // C++-specific | |||
1751 | Results.AddResult( | |||
1752 | Result("bool", CCP_Type + (LangOpts.ObjC ? CCD_bool_in_ObjC : 0))); | |||
1753 | Results.AddResult(Result("class", CCP_Type)); | |||
1754 | Results.AddResult(Result("wchar_t", CCP_Type)); | |||
1755 | ||||
1756 | // typename name | |||
1757 | Builder.AddTypedTextChunk("typename"); | |||
1758 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
1759 | Builder.AddPlaceholderChunk("name"); | |||
1760 | Results.AddResult(Result(Builder.TakeString())); | |||
1761 | ||||
1762 | if (LangOpts.CPlusPlus11) { | |||
1763 | Results.AddResult(Result("auto", CCP_Type)); | |||
1764 | Results.AddResult(Result("char16_t", CCP_Type)); | |||
1765 | Results.AddResult(Result("char32_t", CCP_Type)); | |||
1766 | ||||
1767 | Builder.AddTypedTextChunk("decltype"); | |||
1768 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
1769 | Builder.AddPlaceholderChunk("expression"); | |||
1770 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
1771 | Results.AddResult(Result(Builder.TakeString())); | |||
1772 | } | |||
1773 | } else | |||
1774 | Results.AddResult(Result("__auto_type", CCP_Type)); | |||
1775 | ||||
1776 | // GNU keywords | |||
1777 | if (LangOpts.GNUKeywords) { | |||
1778 | // FIXME: Enable when we actually support decimal floating point. | |||
1779 | // Results.AddResult(Result("_Decimal32")); | |||
1780 | // Results.AddResult(Result("_Decimal64")); | |||
1781 | // Results.AddResult(Result("_Decimal128")); | |||
1782 | ||||
1783 | Builder.AddTypedTextChunk("typeof"); | |||
1784 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
1785 | Builder.AddPlaceholderChunk("expression"); | |||
1786 | Results.AddResult(Result(Builder.TakeString())); | |||
1787 | ||||
1788 | Builder.AddTypedTextChunk("typeof"); | |||
1789 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
1790 | Builder.AddPlaceholderChunk("type"); | |||
1791 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
1792 | Results.AddResult(Result(Builder.TakeString())); | |||
1793 | } | |||
1794 | ||||
1795 | // Nullability | |||
1796 | Results.AddResult(Result("_Nonnull", CCP_Type)); | |||
1797 | Results.AddResult(Result("_Null_unspecified", CCP_Type)); | |||
1798 | Results.AddResult(Result("_Nullable", CCP_Type)); | |||
1799 | } | |||
1800 | ||||
1801 | static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC, | |||
1802 | const LangOptions &LangOpts, | |||
1803 | ResultBuilder &Results) { | |||
1804 | typedef CodeCompletionResult Result; | |||
1805 | // Note: we don't suggest either "auto" or "register", because both | |||
1806 | // are pointless as storage specifiers. Elsewhere, we suggest "auto" | |||
1807 | // in C++0x as a type specifier. | |||
1808 | Results.AddResult(Result("extern")); | |||
1809 | Results.AddResult(Result("static")); | |||
1810 | ||||
1811 | if (LangOpts.CPlusPlus11) { | |||
1812 | CodeCompletionAllocator &Allocator = Results.getAllocator(); | |||
1813 | CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo()); | |||
1814 | ||||
1815 | // alignas | |||
1816 | Builder.AddTypedTextChunk("alignas"); | |||
1817 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
1818 | Builder.AddPlaceholderChunk("expression"); | |||
1819 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
1820 | Results.AddResult(Result(Builder.TakeString())); | |||
1821 | ||||
1822 | Results.AddResult(Result("constexpr")); | |||
1823 | Results.AddResult(Result("thread_local")); | |||
1824 | } | |||
1825 | } | |||
1826 | ||||
1827 | static void AddFunctionSpecifiers(Sema::ParserCompletionContext CCC, | |||
1828 | const LangOptions &LangOpts, | |||
1829 | ResultBuilder &Results) { | |||
1830 | typedef CodeCompletionResult Result; | |||
1831 | switch (CCC) { | |||
1832 | case Sema::PCC_Class: | |||
1833 | case Sema::PCC_MemberTemplate: | |||
1834 | if (LangOpts.CPlusPlus) { | |||
1835 | Results.AddResult(Result("explicit")); | |||
1836 | Results.AddResult(Result("friend")); | |||
1837 | Results.AddResult(Result("mutable")); | |||
1838 | Results.AddResult(Result("virtual")); | |||
1839 | } | |||
1840 | [[fallthrough]]; | |||
1841 | ||||
1842 | case Sema::PCC_ObjCInterface: | |||
1843 | case Sema::PCC_ObjCImplementation: | |||
1844 | case Sema::PCC_Namespace: | |||
1845 | case Sema::PCC_Template: | |||
1846 | if (LangOpts.CPlusPlus || LangOpts.C99) | |||
1847 | Results.AddResult(Result("inline")); | |||
1848 | break; | |||
1849 | ||||
1850 | case Sema::PCC_ObjCInstanceVariableList: | |||
1851 | case Sema::PCC_Expression: | |||
1852 | case Sema::PCC_Statement: | |||
1853 | case Sema::PCC_ForInit: | |||
1854 | case Sema::PCC_Condition: | |||
1855 | case Sema::PCC_RecoveryInFunction: | |||
1856 | case Sema::PCC_Type: | |||
1857 | case Sema::PCC_ParenthesizedExpression: | |||
1858 | case Sema::PCC_LocalDeclarationSpecifiers: | |||
1859 | break; | |||
1860 | } | |||
1861 | } | |||
1862 | ||||
1863 | static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt); | |||
1864 | static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt); | |||
1865 | static void AddObjCVisibilityResults(const LangOptions &LangOpts, | |||
1866 | ResultBuilder &Results, bool NeedAt); | |||
1867 | static void AddObjCImplementationResults(const LangOptions &LangOpts, | |||
1868 | ResultBuilder &Results, bool NeedAt); | |||
1869 | static void AddObjCInterfaceResults(const LangOptions &LangOpts, | |||
1870 | ResultBuilder &Results, bool NeedAt); | |||
1871 | static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt); | |||
1872 | ||||
1873 | static void AddTypedefResult(ResultBuilder &Results) { | |||
1874 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
1875 | Results.getCodeCompletionTUInfo()); | |||
1876 | Builder.AddTypedTextChunk("typedef"); | |||
1877 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
1878 | Builder.AddPlaceholderChunk("type"); | |||
1879 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
1880 | Builder.AddPlaceholderChunk("name"); | |||
1881 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
1882 | Results.AddResult(CodeCompletionResult(Builder.TakeString())); | |||
1883 | } | |||
1884 | ||||
1885 | // using name = type | |||
1886 | static void AddUsingAliasResult(CodeCompletionBuilder &Builder, | |||
1887 | ResultBuilder &Results) { | |||
1888 | Builder.AddTypedTextChunk("using"); | |||
1889 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
1890 | Builder.AddPlaceholderChunk("name"); | |||
1891 | Builder.AddChunk(CodeCompletionString::CK_Equal); | |||
1892 | Builder.AddPlaceholderChunk("type"); | |||
1893 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
1894 | Results.AddResult(CodeCompletionResult(Builder.TakeString())); | |||
1895 | } | |||
1896 | ||||
1897 | static bool WantTypesInContext(Sema::ParserCompletionContext CCC, | |||
1898 | const LangOptions &LangOpts) { | |||
1899 | switch (CCC) { | |||
1900 | case Sema::PCC_Namespace: | |||
1901 | case Sema::PCC_Class: | |||
1902 | case Sema::PCC_ObjCInstanceVariableList: | |||
1903 | case Sema::PCC_Template: | |||
1904 | case Sema::PCC_MemberTemplate: | |||
1905 | case Sema::PCC_Statement: | |||
1906 | case Sema::PCC_RecoveryInFunction: | |||
1907 | case Sema::PCC_Type: | |||
1908 | case Sema::PCC_ParenthesizedExpression: | |||
1909 | case Sema::PCC_LocalDeclarationSpecifiers: | |||
1910 | return true; | |||
1911 | ||||
1912 | case Sema::PCC_Expression: | |||
1913 | case Sema::PCC_Condition: | |||
1914 | return LangOpts.CPlusPlus; | |||
1915 | ||||
1916 | case Sema::PCC_ObjCInterface: | |||
1917 | case Sema::PCC_ObjCImplementation: | |||
1918 | return false; | |||
1919 | ||||
1920 | case Sema::PCC_ForInit: | |||
1921 | return LangOpts.CPlusPlus || LangOpts.ObjC || LangOpts.C99; | |||
1922 | } | |||
1923 | ||||
1924 | llvm_unreachable("Invalid ParserCompletionContext!")::llvm::llvm_unreachable_internal("Invalid ParserCompletionContext!" , "clang/lib/Sema/SemaCodeComplete.cpp", 1924); | |||
1925 | } | |||
1926 | ||||
1927 | static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context, | |||
1928 | const Preprocessor &PP) { | |||
1929 | PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP); | |||
1930 | Policy.AnonymousTagLocations = false; | |||
1931 | Policy.SuppressStrongLifetime = true; | |||
1932 | Policy.SuppressUnwrittenScope = true; | |||
1933 | Policy.SuppressScope = true; | |||
1934 | Policy.CleanUglifiedParameters = true; | |||
1935 | return Policy; | |||
1936 | } | |||
1937 | ||||
1938 | /// Retrieve a printing policy suitable for code completion. | |||
1939 | static PrintingPolicy getCompletionPrintingPolicy(Sema &S) { | |||
1940 | return getCompletionPrintingPolicy(S.Context, S.PP); | |||
1941 | } | |||
1942 | ||||
1943 | /// Retrieve the string representation of the given type as a string | |||
1944 | /// that has the appropriate lifetime for code completion. | |||
1945 | /// | |||
1946 | /// This routine provides a fast path where we provide constant strings for | |||
1947 | /// common type names. | |||
1948 | static const char *GetCompletionTypeString(QualType T, ASTContext &Context, | |||
1949 | const PrintingPolicy &Policy, | |||
1950 | CodeCompletionAllocator &Allocator) { | |||
1951 | if (!T.getLocalQualifiers()) { | |||
1952 | // Built-in type names are constant strings. | |||
1953 | if (const BuiltinType *BT = dyn_cast<BuiltinType>(T)) | |||
1954 | return BT->getNameAsCString(Policy); | |||
1955 | ||||
1956 | // Anonymous tag types are constant strings. | |||
1957 | if (const TagType *TagT = dyn_cast<TagType>(T)) | |||
1958 | if (TagDecl *Tag = TagT->getDecl()) | |||
1959 | if (!Tag->hasNameForLinkage()) { | |||
1960 | switch (Tag->getTagKind()) { | |||
1961 | case TTK_Struct: | |||
1962 | return "struct <anonymous>"; | |||
1963 | case TTK_Interface: | |||
1964 | return "__interface <anonymous>"; | |||
1965 | case TTK_Class: | |||
1966 | return "class <anonymous>"; | |||
1967 | case TTK_Union: | |||
1968 | return "union <anonymous>"; | |||
1969 | case TTK_Enum: | |||
1970 | return "enum <anonymous>"; | |||
1971 | } | |||
1972 | } | |||
1973 | } | |||
1974 | ||||
1975 | // Slow path: format the type as a string. | |||
1976 | std::string Result; | |||
1977 | T.getAsStringInternal(Result, Policy); | |||
1978 | return Allocator.CopyString(Result); | |||
1979 | } | |||
1980 | ||||
1981 | /// Add a completion for "this", if we're in a member function. | |||
1982 | static void addThisCompletion(Sema &S, ResultBuilder &Results) { | |||
1983 | QualType ThisTy = S.getCurrentThisType(); | |||
1984 | if (ThisTy.isNull()) | |||
1985 | return; | |||
1986 | ||||
1987 | CodeCompletionAllocator &Allocator = Results.getAllocator(); | |||
1988 | CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo()); | |||
1989 | PrintingPolicy Policy = getCompletionPrintingPolicy(S); | |||
1990 | Builder.AddResultTypeChunk( | |||
1991 | GetCompletionTypeString(ThisTy, S.Context, Policy, Allocator)); | |||
1992 | Builder.AddTypedTextChunk("this"); | |||
1993 | Results.AddResult(CodeCompletionResult(Builder.TakeString())); | |||
1994 | } | |||
1995 | ||||
1996 | static void AddStaticAssertResult(CodeCompletionBuilder &Builder, | |||
1997 | ResultBuilder &Results, | |||
1998 | const LangOptions &LangOpts) { | |||
1999 | if (!LangOpts.CPlusPlus11) | |||
2000 | return; | |||
2001 | ||||
2002 | Builder.AddTypedTextChunk("static_assert"); | |||
2003 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2004 | Builder.AddPlaceholderChunk("expression"); | |||
2005 | Builder.AddChunk(CodeCompletionString::CK_Comma); | |||
2006 | Builder.AddPlaceholderChunk("message"); | |||
2007 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2008 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2009 | Results.AddResult(CodeCompletionResult(Builder.TakeString())); | |||
2010 | } | |||
2011 | ||||
2012 | static void AddOverrideResults(ResultBuilder &Results, | |||
2013 | const CodeCompletionContext &CCContext, | |||
2014 | CodeCompletionBuilder &Builder) { | |||
2015 | Sema &S = Results.getSema(); | |||
2016 | const auto *CR = llvm::dyn_cast<CXXRecordDecl>(S.CurContext); | |||
2017 | // If not inside a class/struct/union return empty. | |||
2018 | if (!CR) | |||
2019 | return; | |||
2020 | // First store overrides within current class. | |||
2021 | // These are stored by name to make querying fast in the later step. | |||
2022 | llvm::StringMap<std::vector<FunctionDecl *>> Overrides; | |||
2023 | for (auto *Method : CR->methods()) { | |||
2024 | if (!Method->isVirtual() || !Method->getIdentifier()) | |||
2025 | continue; | |||
2026 | Overrides[Method->getName()].push_back(Method); | |||
2027 | } | |||
2028 | ||||
2029 | for (const auto &Base : CR->bases()) { | |||
2030 | const auto *BR = Base.getType().getTypePtr()->getAsCXXRecordDecl(); | |||
2031 | if (!BR) | |||
2032 | continue; | |||
2033 | for (auto *Method : BR->methods()) { | |||
2034 | if (!Method->isVirtual() || !Method->getIdentifier()) | |||
2035 | continue; | |||
2036 | const auto it = Overrides.find(Method->getName()); | |||
2037 | bool IsOverriden = false; | |||
2038 | if (it != Overrides.end()) { | |||
2039 | for (auto *MD : it->second) { | |||
2040 | // If the method in current body is not an overload of this virtual | |||
2041 | // function, then it overrides this one. | |||
2042 | if (!S.IsOverload(MD, Method, false)) { | |||
2043 | IsOverriden = true; | |||
2044 | break; | |||
2045 | } | |||
2046 | } | |||
2047 | } | |||
2048 | if (!IsOverriden) { | |||
2049 | // Generates a new CodeCompletionResult by taking this function and | |||
2050 | // converting it into an override declaration with only one chunk in the | |||
2051 | // final CodeCompletionString as a TypedTextChunk. | |||
2052 | std::string OverrideSignature; | |||
2053 | llvm::raw_string_ostream OS(OverrideSignature); | |||
2054 | CodeCompletionResult CCR(Method, 0); | |||
2055 | PrintingPolicy Policy = | |||
2056 | getCompletionPrintingPolicy(S.getASTContext(), S.getPreprocessor()); | |||
2057 | auto *CCS = CCR.createCodeCompletionStringForOverride( | |||
2058 | S.getPreprocessor(), S.getASTContext(), Builder, | |||
2059 | /*IncludeBriefComments=*/false, CCContext, Policy); | |||
2060 | Results.AddResult(CodeCompletionResult(CCS, Method, CCP_CodePattern)); | |||
2061 | } | |||
2062 | } | |||
2063 | } | |||
2064 | } | |||
2065 | ||||
2066 | /// Add language constructs that show up for "ordinary" names. | |||
2067 | static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC, Scope *S, | |||
2068 | Sema &SemaRef, ResultBuilder &Results) { | |||
2069 | CodeCompletionAllocator &Allocator = Results.getAllocator(); | |||
2070 | CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo()); | |||
2071 | ||||
2072 | typedef CodeCompletionResult Result; | |||
2073 | switch (CCC) { | |||
2074 | case Sema::PCC_Namespace: | |||
2075 | if (SemaRef.getLangOpts().CPlusPlus) { | |||
2076 | if (Results.includeCodePatterns()) { | |||
2077 | // namespace <identifier> { declarations } | |||
2078 | Builder.AddTypedTextChunk("namespace"); | |||
2079 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2080 | Builder.AddPlaceholderChunk("identifier"); | |||
2081 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2082 | Builder.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
2083 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2084 | Builder.AddPlaceholderChunk("declarations"); | |||
2085 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2086 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
2087 | Results.AddResult(Result(Builder.TakeString())); | |||
2088 | } | |||
2089 | ||||
2090 | // namespace identifier = identifier ; | |||
2091 | Builder.AddTypedTextChunk("namespace"); | |||
2092 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2093 | Builder.AddPlaceholderChunk("name"); | |||
2094 | Builder.AddChunk(CodeCompletionString::CK_Equal); | |||
2095 | Builder.AddPlaceholderChunk("namespace"); | |||
2096 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2097 | Results.AddResult(Result(Builder.TakeString())); | |||
2098 | ||||
2099 | // Using directives | |||
2100 | Builder.AddTypedTextChunk("using namespace"); | |||
2101 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2102 | Builder.AddPlaceholderChunk("identifier"); | |||
2103 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2104 | Results.AddResult(Result(Builder.TakeString())); | |||
2105 | ||||
2106 | // asm(string-literal) | |||
2107 | Builder.AddTypedTextChunk("asm"); | |||
2108 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2109 | Builder.AddPlaceholderChunk("string-literal"); | |||
2110 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2111 | Results.AddResult(Result(Builder.TakeString())); | |||
2112 | ||||
2113 | if (Results.includeCodePatterns()) { | |||
2114 | // Explicit template instantiation | |||
2115 | Builder.AddTypedTextChunk("template"); | |||
2116 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2117 | Builder.AddPlaceholderChunk("declaration"); | |||
2118 | Results.AddResult(Result(Builder.TakeString())); | |||
2119 | } else { | |||
2120 | Results.AddResult(Result("template", CodeCompletionResult::RK_Keyword)); | |||
2121 | } | |||
2122 | } | |||
2123 | ||||
2124 | if (SemaRef.getLangOpts().ObjC) | |||
2125 | AddObjCTopLevelResults(Results, true); | |||
2126 | ||||
2127 | AddTypedefResult(Results); | |||
2128 | [[fallthrough]]; | |||
2129 | ||||
2130 | case Sema::PCC_Class: | |||
2131 | if (SemaRef.getLangOpts().CPlusPlus) { | |||
2132 | // Using declaration | |||
2133 | Builder.AddTypedTextChunk("using"); | |||
2134 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2135 | Builder.AddPlaceholderChunk("qualifier"); | |||
2136 | Builder.AddTextChunk("::"); | |||
2137 | Builder.AddPlaceholderChunk("name"); | |||
2138 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2139 | Results.AddResult(Result(Builder.TakeString())); | |||
2140 | ||||
2141 | if (SemaRef.getLangOpts().CPlusPlus11) | |||
2142 | AddUsingAliasResult(Builder, Results); | |||
2143 | ||||
2144 | // using typename qualifier::name (only in a dependent context) | |||
2145 | if (SemaRef.CurContext->isDependentContext()) { | |||
2146 | Builder.AddTypedTextChunk("using typename"); | |||
2147 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2148 | Builder.AddPlaceholderChunk("qualifier"); | |||
2149 | Builder.AddTextChunk("::"); | |||
2150 | Builder.AddPlaceholderChunk("name"); | |||
2151 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2152 | Results.AddResult(Result(Builder.TakeString())); | |||
2153 | } | |||
2154 | ||||
2155 | AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts()); | |||
2156 | ||||
2157 | if (CCC == Sema::PCC_Class) { | |||
2158 | AddTypedefResult(Results); | |||
2159 | ||||
2160 | bool IsNotInheritanceScope = !S->isClassInheritanceScope(); | |||
2161 | // public: | |||
2162 | Builder.AddTypedTextChunk("public"); | |||
2163 | if (IsNotInheritanceScope && Results.includeCodePatterns()) | |||
2164 | Builder.AddChunk(CodeCompletionString::CK_Colon); | |||
2165 | Results.AddResult(Result(Builder.TakeString())); | |||
2166 | ||||
2167 | // protected: | |||
2168 | Builder.AddTypedTextChunk("protected"); | |||
2169 | if (IsNotInheritanceScope && Results.includeCodePatterns()) | |||
2170 | Builder.AddChunk(CodeCompletionString::CK_Colon); | |||
2171 | Results.AddResult(Result(Builder.TakeString())); | |||
2172 | ||||
2173 | // private: | |||
2174 | Builder.AddTypedTextChunk("private"); | |||
2175 | if (IsNotInheritanceScope && Results.includeCodePatterns()) | |||
2176 | Builder.AddChunk(CodeCompletionString::CK_Colon); | |||
2177 | Results.AddResult(Result(Builder.TakeString())); | |||
2178 | ||||
2179 | // FIXME: This adds override results only if we are at the first word of | |||
2180 | // the declaration/definition. Also call this from other sides to have | |||
2181 | // more use-cases. | |||
2182 | AddOverrideResults(Results, CodeCompletionContext::CCC_ClassStructUnion, | |||
2183 | Builder); | |||
2184 | } | |||
2185 | } | |||
2186 | [[fallthrough]]; | |||
2187 | ||||
2188 | case Sema::PCC_Template: | |||
2189 | case Sema::PCC_MemberTemplate: | |||
2190 | if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) { | |||
2191 | // template < parameters > | |||
2192 | Builder.AddTypedTextChunk("template"); | |||
2193 | Builder.AddChunk(CodeCompletionString::CK_LeftAngle); | |||
2194 | Builder.AddPlaceholderChunk("parameters"); | |||
2195 | Builder.AddChunk(CodeCompletionString::CK_RightAngle); | |||
2196 | Results.AddResult(Result(Builder.TakeString())); | |||
2197 | } else { | |||
2198 | Results.AddResult(Result("template", CodeCompletionResult::RK_Keyword)); | |||
2199 | } | |||
2200 | ||||
2201 | AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results); | |||
2202 | AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results); | |||
2203 | break; | |||
2204 | ||||
2205 | case Sema::PCC_ObjCInterface: | |||
2206 | AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true); | |||
2207 | AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results); | |||
2208 | AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results); | |||
2209 | break; | |||
2210 | ||||
2211 | case Sema::PCC_ObjCImplementation: | |||
2212 | AddObjCImplementationResults(SemaRef.getLangOpts(), Results, true); | |||
2213 | AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results); | |||
2214 | AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results); | |||
2215 | break; | |||
2216 | ||||
2217 | case Sema::PCC_ObjCInstanceVariableList: | |||
2218 | AddObjCVisibilityResults(SemaRef.getLangOpts(), Results, true); | |||
2219 | break; | |||
2220 | ||||
2221 | case Sema::PCC_RecoveryInFunction: | |||
2222 | case Sema::PCC_Statement: { | |||
2223 | if (SemaRef.getLangOpts().CPlusPlus11) | |||
2224 | AddUsingAliasResult(Builder, Results); | |||
2225 | ||||
2226 | AddTypedefResult(Results); | |||
2227 | ||||
2228 | if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() && | |||
2229 | SemaRef.getLangOpts().CXXExceptions) { | |||
2230 | Builder.AddTypedTextChunk("try"); | |||
2231 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2232 | Builder.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
2233 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2234 | Builder.AddPlaceholderChunk("statements"); | |||
2235 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2236 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
2237 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2238 | Builder.AddTextChunk("catch"); | |||
2239 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2240 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2241 | Builder.AddPlaceholderChunk("declaration"); | |||
2242 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2243 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2244 | Builder.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
2245 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2246 | Builder.AddPlaceholderChunk("statements"); | |||
2247 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2248 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
2249 | Results.AddResult(Result(Builder.TakeString())); | |||
2250 | } | |||
2251 | if (SemaRef.getLangOpts().ObjC) | |||
2252 | AddObjCStatementResults(Results, true); | |||
2253 | ||||
2254 | if (Results.includeCodePatterns()) { | |||
2255 | // if (condition) { statements } | |||
2256 | Builder.AddTypedTextChunk("if"); | |||
2257 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2258 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2259 | if (SemaRef.getLangOpts().CPlusPlus) | |||
2260 | Builder.AddPlaceholderChunk("condition"); | |||
2261 | else | |||
2262 | Builder.AddPlaceholderChunk("expression"); | |||
2263 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2264 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2265 | Builder.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
2266 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2267 | Builder.AddPlaceholderChunk("statements"); | |||
2268 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2269 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
2270 | Results.AddResult(Result(Builder.TakeString())); | |||
2271 | ||||
2272 | // switch (condition) { } | |||
2273 | Builder.AddTypedTextChunk("switch"); | |||
2274 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2275 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2276 | if (SemaRef.getLangOpts().CPlusPlus) | |||
2277 | Builder.AddPlaceholderChunk("condition"); | |||
2278 | else | |||
2279 | Builder.AddPlaceholderChunk("expression"); | |||
2280 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2281 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2282 | Builder.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
2283 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2284 | Builder.AddPlaceholderChunk("cases"); | |||
2285 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2286 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
2287 | Results.AddResult(Result(Builder.TakeString())); | |||
2288 | } | |||
2289 | ||||
2290 | // Switch-specific statements. | |||
2291 | if (SemaRef.getCurFunction() && | |||
2292 | !SemaRef.getCurFunction()->SwitchStack.empty()) { | |||
2293 | // case expression: | |||
2294 | Builder.AddTypedTextChunk("case"); | |||
2295 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2296 | Builder.AddPlaceholderChunk("expression"); | |||
2297 | Builder.AddChunk(CodeCompletionString::CK_Colon); | |||
2298 | Results.AddResult(Result(Builder.TakeString())); | |||
2299 | ||||
2300 | // default: | |||
2301 | Builder.AddTypedTextChunk("default"); | |||
2302 | Builder.AddChunk(CodeCompletionString::CK_Colon); | |||
2303 | Results.AddResult(Result(Builder.TakeString())); | |||
2304 | } | |||
2305 | ||||
2306 | if (Results.includeCodePatterns()) { | |||
2307 | /// while (condition) { statements } | |||
2308 | Builder.AddTypedTextChunk("while"); | |||
2309 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2310 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2311 | if (SemaRef.getLangOpts().CPlusPlus) | |||
2312 | Builder.AddPlaceholderChunk("condition"); | |||
2313 | else | |||
2314 | Builder.AddPlaceholderChunk("expression"); | |||
2315 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2316 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2317 | Builder.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
2318 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2319 | Builder.AddPlaceholderChunk("statements"); | |||
2320 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2321 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
2322 | Results.AddResult(Result(Builder.TakeString())); | |||
2323 | ||||
2324 | // do { statements } while ( expression ); | |||
2325 | Builder.AddTypedTextChunk("do"); | |||
2326 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2327 | Builder.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
2328 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2329 | Builder.AddPlaceholderChunk("statements"); | |||
2330 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2331 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
2332 | Builder.AddTextChunk("while"); | |||
2333 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2334 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2335 | Builder.AddPlaceholderChunk("expression"); | |||
2336 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2337 | Results.AddResult(Result(Builder.TakeString())); | |||
2338 | ||||
2339 | // for ( for-init-statement ; condition ; expression ) { statements } | |||
2340 | Builder.AddTypedTextChunk("for"); | |||
2341 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2342 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2343 | if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99) | |||
2344 | Builder.AddPlaceholderChunk("init-statement"); | |||
2345 | else | |||
2346 | Builder.AddPlaceholderChunk("init-expression"); | |||
2347 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2348 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2349 | Builder.AddPlaceholderChunk("condition"); | |||
2350 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2351 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2352 | Builder.AddPlaceholderChunk("inc-expression"); | |||
2353 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2354 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2355 | Builder.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
2356 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2357 | Builder.AddPlaceholderChunk("statements"); | |||
2358 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2359 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
2360 | Results.AddResult(Result(Builder.TakeString())); | |||
2361 | ||||
2362 | if (SemaRef.getLangOpts().CPlusPlus11 || SemaRef.getLangOpts().ObjC) { | |||
2363 | // for ( range_declaration (:|in) range_expression ) { statements } | |||
2364 | Builder.AddTypedTextChunk("for"); | |||
2365 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2366 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2367 | Builder.AddPlaceholderChunk("range-declaration"); | |||
2368 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2369 | if (SemaRef.getLangOpts().ObjC) | |||
2370 | Builder.AddTextChunk("in"); | |||
2371 | else | |||
2372 | Builder.AddChunk(CodeCompletionString::CK_Colon); | |||
2373 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2374 | Builder.AddPlaceholderChunk("range-expression"); | |||
2375 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2376 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2377 | Builder.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
2378 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2379 | Builder.AddPlaceholderChunk("statements"); | |||
2380 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
2381 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
2382 | Results.AddResult(Result(Builder.TakeString())); | |||
2383 | } | |||
2384 | } | |||
2385 | ||||
2386 | if (S->getContinueParent()) { | |||
2387 | // continue ; | |||
2388 | Builder.AddTypedTextChunk("continue"); | |||
2389 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2390 | Results.AddResult(Result(Builder.TakeString())); | |||
2391 | } | |||
2392 | ||||
2393 | if (S->getBreakParent()) { | |||
2394 | // break ; | |||
2395 | Builder.AddTypedTextChunk("break"); | |||
2396 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2397 | Results.AddResult(Result(Builder.TakeString())); | |||
2398 | } | |||
2399 | ||||
2400 | // "return expression ;" or "return ;", depending on the return type. | |||
2401 | QualType ReturnType; | |||
2402 | if (const auto *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext)) | |||
2403 | ReturnType = Function->getReturnType(); | |||
2404 | else if (const auto *Method = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext)) | |||
2405 | ReturnType = Method->getReturnType(); | |||
2406 | else if (SemaRef.getCurBlock() && | |||
2407 | !SemaRef.getCurBlock()->ReturnType.isNull()) | |||
2408 | ReturnType = SemaRef.getCurBlock()->ReturnType;; | |||
2409 | if (ReturnType.isNull() || ReturnType->isVoidType()) { | |||
2410 | Builder.AddTypedTextChunk("return"); | |||
2411 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2412 | Results.AddResult(Result(Builder.TakeString())); | |||
2413 | } else { | |||
2414 | assert(!ReturnType.isNull())(static_cast <bool> (!ReturnType.isNull()) ? void (0) : __assert_fail ("!ReturnType.isNull()", "clang/lib/Sema/SemaCodeComplete.cpp" , 2414, __extension__ __PRETTY_FUNCTION__)); | |||
2415 | // "return expression ;" | |||
2416 | Builder.AddTypedTextChunk("return"); | |||
2417 | Builder.AddChunk(clang::CodeCompletionString::CK_HorizontalSpace); | |||
2418 | Builder.AddPlaceholderChunk("expression"); | |||
2419 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2420 | Results.AddResult(Result(Builder.TakeString())); | |||
2421 | // When boolean, also add 'return true;' and 'return false;'. | |||
2422 | if (ReturnType->isBooleanType()) { | |||
2423 | Builder.AddTypedTextChunk("return true"); | |||
2424 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2425 | Results.AddResult(Result(Builder.TakeString())); | |||
2426 | ||||
2427 | Builder.AddTypedTextChunk("return false"); | |||
2428 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2429 | Results.AddResult(Result(Builder.TakeString())); | |||
2430 | } | |||
2431 | // For pointers, suggest 'return nullptr' in C++. | |||
2432 | if (SemaRef.getLangOpts().CPlusPlus11 && | |||
2433 | (ReturnType->isPointerType() || ReturnType->isMemberPointerType())) { | |||
2434 | Builder.AddTypedTextChunk("return nullptr"); | |||
2435 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2436 | Results.AddResult(Result(Builder.TakeString())); | |||
2437 | } | |||
2438 | } | |||
2439 | ||||
2440 | // goto identifier ; | |||
2441 | Builder.AddTypedTextChunk("goto"); | |||
2442 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2443 | Builder.AddPlaceholderChunk("label"); | |||
2444 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2445 | Results.AddResult(Result(Builder.TakeString())); | |||
2446 | ||||
2447 | // Using directives | |||
2448 | Builder.AddTypedTextChunk("using namespace"); | |||
2449 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2450 | Builder.AddPlaceholderChunk("identifier"); | |||
2451 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
2452 | Results.AddResult(Result(Builder.TakeString())); | |||
2453 | ||||
2454 | AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts()); | |||
2455 | } | |||
2456 | [[fallthrough]]; | |||
2457 | ||||
2458 | // Fall through (for statement expressions). | |||
2459 | case Sema::PCC_ForInit: | |||
2460 | case Sema::PCC_Condition: | |||
2461 | AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results); | |||
2462 | // Fall through: conditions and statements can have expressions. | |||
2463 | [[fallthrough]]; | |||
2464 | ||||
2465 | case Sema::PCC_ParenthesizedExpression: | |||
2466 | if (SemaRef.getLangOpts().ObjCAutoRefCount && | |||
2467 | CCC == Sema::PCC_ParenthesizedExpression) { | |||
2468 | // (__bridge <type>)<expression> | |||
2469 | Builder.AddTypedTextChunk("__bridge"); | |||
2470 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2471 | Builder.AddPlaceholderChunk("type"); | |||
2472 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2473 | Builder.AddPlaceholderChunk("expression"); | |||
2474 | Results.AddResult(Result(Builder.TakeString())); | |||
2475 | ||||
2476 | // (__bridge_transfer <Objective-C type>)<expression> | |||
2477 | Builder.AddTypedTextChunk("__bridge_transfer"); | |||
2478 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2479 | Builder.AddPlaceholderChunk("Objective-C type"); | |||
2480 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2481 | Builder.AddPlaceholderChunk("expression"); | |||
2482 | Results.AddResult(Result(Builder.TakeString())); | |||
2483 | ||||
2484 | // (__bridge_retained <CF type>)<expression> | |||
2485 | Builder.AddTypedTextChunk("__bridge_retained"); | |||
2486 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2487 | Builder.AddPlaceholderChunk("CF type"); | |||
2488 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2489 | Builder.AddPlaceholderChunk("expression"); | |||
2490 | Results.AddResult(Result(Builder.TakeString())); | |||
2491 | } | |||
2492 | // Fall through | |||
2493 | [[fallthrough]]; | |||
2494 | ||||
2495 | case Sema::PCC_Expression: { | |||
2496 | if (SemaRef.getLangOpts().CPlusPlus) { | |||
2497 | // 'this', if we're in a non-static member function. | |||
2498 | addThisCompletion(SemaRef, Results); | |||
2499 | ||||
2500 | // true | |||
2501 | Builder.AddResultTypeChunk("bool"); | |||
2502 | Builder.AddTypedTextChunk("true"); | |||
2503 | Results.AddResult(Result(Builder.TakeString())); | |||
2504 | ||||
2505 | // false | |||
2506 | Builder.AddResultTypeChunk("bool"); | |||
2507 | Builder.AddTypedTextChunk("false"); | |||
2508 | Results.AddResult(Result(Builder.TakeString())); | |||
2509 | ||||
2510 | if (SemaRef.getLangOpts().RTTI) { | |||
2511 | // dynamic_cast < type-id > ( expression ) | |||
2512 | Builder.AddTypedTextChunk("dynamic_cast"); | |||
2513 | Builder.AddChunk(CodeCompletionString::CK_LeftAngle); | |||
2514 | Builder.AddPlaceholderChunk("type"); | |||
2515 | Builder.AddChunk(CodeCompletionString::CK_RightAngle); | |||
2516 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2517 | Builder.AddPlaceholderChunk("expression"); | |||
2518 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2519 | Results.AddResult(Result(Builder.TakeString())); | |||
2520 | } | |||
2521 | ||||
2522 | // static_cast < type-id > ( expression ) | |||
2523 | Builder.AddTypedTextChunk("static_cast"); | |||
2524 | Builder.AddChunk(CodeCompletionString::CK_LeftAngle); | |||
2525 | Builder.AddPlaceholderChunk("type"); | |||
2526 | Builder.AddChunk(CodeCompletionString::CK_RightAngle); | |||
2527 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2528 | Builder.AddPlaceholderChunk("expression"); | |||
2529 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2530 | Results.AddResult(Result(Builder.TakeString())); | |||
2531 | ||||
2532 | // reinterpret_cast < type-id > ( expression ) | |||
2533 | Builder.AddTypedTextChunk("reinterpret_cast"); | |||
2534 | Builder.AddChunk(CodeCompletionString::CK_LeftAngle); | |||
2535 | Builder.AddPlaceholderChunk("type"); | |||
2536 | Builder.AddChunk(CodeCompletionString::CK_RightAngle); | |||
2537 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2538 | Builder.AddPlaceholderChunk("expression"); | |||
2539 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2540 | Results.AddResult(Result(Builder.TakeString())); | |||
2541 | ||||
2542 | // const_cast < type-id > ( expression ) | |||
2543 | Builder.AddTypedTextChunk("const_cast"); | |||
2544 | Builder.AddChunk(CodeCompletionString::CK_LeftAngle); | |||
2545 | Builder.AddPlaceholderChunk("type"); | |||
2546 | Builder.AddChunk(CodeCompletionString::CK_RightAngle); | |||
2547 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2548 | Builder.AddPlaceholderChunk("expression"); | |||
2549 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2550 | Results.AddResult(Result(Builder.TakeString())); | |||
2551 | ||||
2552 | if (SemaRef.getLangOpts().RTTI) { | |||
2553 | // typeid ( expression-or-type ) | |||
2554 | Builder.AddResultTypeChunk("std::type_info"); | |||
2555 | Builder.AddTypedTextChunk("typeid"); | |||
2556 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2557 | Builder.AddPlaceholderChunk("expression-or-type"); | |||
2558 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2559 | Results.AddResult(Result(Builder.TakeString())); | |||
2560 | } | |||
2561 | ||||
2562 | // new T ( ... ) | |||
2563 | Builder.AddTypedTextChunk("new"); | |||
2564 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2565 | Builder.AddPlaceholderChunk("type"); | |||
2566 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2567 | Builder.AddPlaceholderChunk("expressions"); | |||
2568 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2569 | Results.AddResult(Result(Builder.TakeString())); | |||
2570 | ||||
2571 | // new T [ ] ( ... ) | |||
2572 | Builder.AddTypedTextChunk("new"); | |||
2573 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2574 | Builder.AddPlaceholderChunk("type"); | |||
2575 | Builder.AddChunk(CodeCompletionString::CK_LeftBracket); | |||
2576 | Builder.AddPlaceholderChunk("size"); | |||
2577 | Builder.AddChunk(CodeCompletionString::CK_RightBracket); | |||
2578 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2579 | Builder.AddPlaceholderChunk("expressions"); | |||
2580 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2581 | Results.AddResult(Result(Builder.TakeString())); | |||
2582 | ||||
2583 | // delete expression | |||
2584 | Builder.AddResultTypeChunk("void"); | |||
2585 | Builder.AddTypedTextChunk("delete"); | |||
2586 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2587 | Builder.AddPlaceholderChunk("expression"); | |||
2588 | Results.AddResult(Result(Builder.TakeString())); | |||
2589 | ||||
2590 | // delete [] expression | |||
2591 | Builder.AddResultTypeChunk("void"); | |||
2592 | Builder.AddTypedTextChunk("delete"); | |||
2593 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2594 | Builder.AddChunk(CodeCompletionString::CK_LeftBracket); | |||
2595 | Builder.AddChunk(CodeCompletionString::CK_RightBracket); | |||
2596 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2597 | Builder.AddPlaceholderChunk("expression"); | |||
2598 | Results.AddResult(Result(Builder.TakeString())); | |||
2599 | ||||
2600 | if (SemaRef.getLangOpts().CXXExceptions) { | |||
2601 | // throw expression | |||
2602 | Builder.AddResultTypeChunk("void"); | |||
2603 | Builder.AddTypedTextChunk("throw"); | |||
2604 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
2605 | Builder.AddPlaceholderChunk("expression"); | |||
2606 | Results.AddResult(Result(Builder.TakeString())); | |||
2607 | } | |||
2608 | ||||
2609 | // FIXME: Rethrow? | |||
2610 | ||||
2611 | if (SemaRef.getLangOpts().CPlusPlus11) { | |||
2612 | // nullptr | |||
2613 | Builder.AddResultTypeChunk("std::nullptr_t"); | |||
2614 | Builder.AddTypedTextChunk("nullptr"); | |||
2615 | Results.AddResult(Result(Builder.TakeString())); | |||
2616 | ||||
2617 | // alignof | |||
2618 | Builder.AddResultTypeChunk("size_t"); | |||
2619 | Builder.AddTypedTextChunk("alignof"); | |||
2620 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2621 | Builder.AddPlaceholderChunk("type"); | |||
2622 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2623 | Results.AddResult(Result(Builder.TakeString())); | |||
2624 | ||||
2625 | // noexcept | |||
2626 | Builder.AddResultTypeChunk("bool"); | |||
2627 | Builder.AddTypedTextChunk("noexcept"); | |||
2628 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2629 | Builder.AddPlaceholderChunk("expression"); | |||
2630 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2631 | Results.AddResult(Result(Builder.TakeString())); | |||
2632 | ||||
2633 | // sizeof... expression | |||
2634 | Builder.AddResultTypeChunk("size_t"); | |||
2635 | Builder.AddTypedTextChunk("sizeof..."); | |||
2636 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2637 | Builder.AddPlaceholderChunk("parameter-pack"); | |||
2638 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2639 | Results.AddResult(Result(Builder.TakeString())); | |||
2640 | } | |||
2641 | } | |||
2642 | ||||
2643 | if (SemaRef.getLangOpts().ObjC) { | |||
2644 | // Add "super", if we're in an Objective-C class with a superclass. | |||
2645 | if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) { | |||
2646 | // The interface can be NULL. | |||
2647 | if (ObjCInterfaceDecl *ID = Method->getClassInterface()) | |||
2648 | if (ID->getSuperClass()) { | |||
2649 | std::string SuperType; | |||
2650 | SuperType = ID->getSuperClass()->getNameAsString(); | |||
2651 | if (Method->isInstanceMethod()) | |||
2652 | SuperType += " *"; | |||
2653 | ||||
2654 | Builder.AddResultTypeChunk(Allocator.CopyString(SuperType)); | |||
2655 | Builder.AddTypedTextChunk("super"); | |||
2656 | Results.AddResult(Result(Builder.TakeString())); | |||
2657 | } | |||
2658 | } | |||
2659 | ||||
2660 | AddObjCExpressionResults(Results, true); | |||
2661 | } | |||
2662 | ||||
2663 | if (SemaRef.getLangOpts().C11) { | |||
2664 | // _Alignof | |||
2665 | Builder.AddResultTypeChunk("size_t"); | |||
2666 | if (SemaRef.PP.isMacroDefined("alignof")) | |||
2667 | Builder.AddTypedTextChunk("alignof"); | |||
2668 | else | |||
2669 | Builder.AddTypedTextChunk("_Alignof"); | |||
2670 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2671 | Builder.AddPlaceholderChunk("type"); | |||
2672 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2673 | Results.AddResult(Result(Builder.TakeString())); | |||
2674 | } | |||
2675 | ||||
2676 | if (SemaRef.getLangOpts().C2x) { | |||
2677 | // nullptr | |||
2678 | Builder.AddResultTypeChunk("nullptr_t"); | |||
2679 | Builder.AddTypedTextChunk("nullptr"); | |||
2680 | Results.AddResult(Result(Builder.TakeString())); | |||
2681 | } | |||
2682 | ||||
2683 | // sizeof expression | |||
2684 | Builder.AddResultTypeChunk("size_t"); | |||
2685 | Builder.AddTypedTextChunk("sizeof"); | |||
2686 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
2687 | Builder.AddPlaceholderChunk("expression-or-type"); | |||
2688 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
2689 | Results.AddResult(Result(Builder.TakeString())); | |||
2690 | break; | |||
2691 | } | |||
2692 | ||||
2693 | case Sema::PCC_Type: | |||
2694 | case Sema::PCC_LocalDeclarationSpecifiers: | |||
2695 | break; | |||
2696 | } | |||
2697 | ||||
2698 | if (WantTypesInContext(CCC, SemaRef.getLangOpts())) | |||
2699 | AddTypeSpecifierResults(SemaRef.getLangOpts(), Results); | |||
2700 | ||||
2701 | if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type) | |||
2702 | Results.AddResult(Result("operator")); | |||
2703 | } | |||
2704 | ||||
2705 | /// If the given declaration has an associated type, add it as a result | |||
2706 | /// type chunk. | |||
2707 | static void AddResultTypeChunk(ASTContext &Context, | |||
2708 | const PrintingPolicy &Policy, | |||
2709 | const NamedDecl *ND, QualType BaseType, | |||
2710 | CodeCompletionBuilder &Result) { | |||
2711 | if (!ND) | |||
2712 | return; | |||
2713 | ||||
2714 | // Skip constructors and conversion functions, which have their return types | |||
2715 | // built into their names. | |||
2716 | if (isConstructor(ND) || isa<CXXConversionDecl>(ND)) | |||
2717 | return; | |||
2718 | ||||
2719 | // Determine the type of the declaration (if it has a type). | |||
2720 | QualType T; | |||
2721 | if (const FunctionDecl *Function = ND->getAsFunction()) | |||
2722 | T = Function->getReturnType(); | |||
2723 | else if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) { | |||
2724 | if (!BaseType.isNull()) | |||
2725 | T = Method->getSendResultType(BaseType); | |||
2726 | else | |||
2727 | T = Method->getReturnType(); | |||
2728 | } else if (const auto *Enumerator = dyn_cast<EnumConstantDecl>(ND)) { | |||
2729 | T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext())); | |||
2730 | T = clang::TypeName::getFullyQualifiedType(T, Context); | |||
2731 | } else if (isa<UnresolvedUsingValueDecl>(ND)) { | |||
2732 | /* Do nothing: ignore unresolved using declarations*/ | |||
2733 | } else if (const auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) { | |||
2734 | if (!BaseType.isNull()) | |||
2735 | T = Ivar->getUsageType(BaseType); | |||
2736 | else | |||
2737 | T = Ivar->getType(); | |||
2738 | } else if (const auto *Value = dyn_cast<ValueDecl>(ND)) { | |||
2739 | T = Value->getType(); | |||
2740 | } else if (const auto *Property = dyn_cast<ObjCPropertyDecl>(ND)) { | |||
2741 | if (!BaseType.isNull()) | |||
2742 | T = Property->getUsageType(BaseType); | |||
2743 | else | |||
2744 | T = Property->getType(); | |||
2745 | } | |||
2746 | ||||
2747 | if (T.isNull() || Context.hasSameType(T, Context.DependentTy)) | |||
2748 | return; | |||
2749 | ||||
2750 | Result.AddResultTypeChunk( | |||
2751 | GetCompletionTypeString(T, Context, Policy, Result.getAllocator())); | |||
2752 | } | |||
2753 | ||||
2754 | static void MaybeAddSentinel(Preprocessor &PP, | |||
2755 | const NamedDecl *FunctionOrMethod, | |||
2756 | CodeCompletionBuilder &Result) { | |||
2757 | if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>()) | |||
2758 | if (Sentinel->getSentinel() == 0) { | |||
2759 | if (PP.getLangOpts().ObjC && PP.isMacroDefined("nil")) | |||
2760 | Result.AddTextChunk(", nil"); | |||
2761 | else if (PP.isMacroDefined("NULL")) | |||
2762 | Result.AddTextChunk(", NULL"); | |||
2763 | else | |||
2764 | Result.AddTextChunk(", (void*)0"); | |||
2765 | } | |||
2766 | } | |||
2767 | ||||
2768 | static std::string formatObjCParamQualifiers(unsigned ObjCQuals, | |||
2769 | QualType &Type) { | |||
2770 | std::string Result; | |||
2771 | if (ObjCQuals & Decl::OBJC_TQ_In) | |||
2772 | Result += "in "; | |||
2773 | else if (ObjCQuals & Decl::OBJC_TQ_Inout) | |||
2774 | Result += "inout "; | |||
2775 | else if (ObjCQuals & Decl::OBJC_TQ_Out) | |||
2776 | Result += "out "; | |||
2777 | if (ObjCQuals & Decl::OBJC_TQ_Bycopy) | |||
2778 | Result += "bycopy "; | |||
2779 | else if (ObjCQuals & Decl::OBJC_TQ_Byref) | |||
2780 | Result += "byref "; | |||
2781 | if (ObjCQuals & Decl::OBJC_TQ_Oneway) | |||
2782 | Result += "oneway "; | |||
2783 | if (ObjCQuals & Decl::OBJC_TQ_CSNullability) { | |||
2784 | if (auto nullability = AttributedType::stripOuterNullability(Type)) { | |||
2785 | switch (*nullability) { | |||
2786 | case NullabilityKind::NonNull: | |||
2787 | Result += "nonnull "; | |||
2788 | break; | |||
2789 | ||||
2790 | case NullabilityKind::Nullable: | |||
2791 | Result += "nullable "; | |||
2792 | break; | |||
2793 | ||||
2794 | case NullabilityKind::Unspecified: | |||
2795 | Result += "null_unspecified "; | |||
2796 | break; | |||
2797 | ||||
2798 | case NullabilityKind::NullableResult: | |||
2799 | llvm_unreachable("Not supported as a context-sensitive keyword!")::llvm::llvm_unreachable_internal("Not supported as a context-sensitive keyword!" , "clang/lib/Sema/SemaCodeComplete.cpp", 2799); | |||
2800 | break; | |||
2801 | } | |||
2802 | } | |||
2803 | } | |||
2804 | return Result; | |||
2805 | } | |||
2806 | ||||
2807 | /// Tries to find the most appropriate type location for an Objective-C | |||
2808 | /// block placeholder. | |||
2809 | /// | |||
2810 | /// This function ignores things like typedefs and qualifiers in order to | |||
2811 | /// present the most relevant and accurate block placeholders in code completion | |||
2812 | /// results. | |||
2813 | static void findTypeLocationForBlockDecl(const TypeSourceInfo *TSInfo, | |||
2814 | FunctionTypeLoc &Block, | |||
2815 | FunctionProtoTypeLoc &BlockProto, | |||
2816 | bool SuppressBlock = false) { | |||
2817 | if (!TSInfo) | |||
2818 | return; | |||
2819 | TypeLoc TL = TSInfo->getTypeLoc().getUnqualifiedLoc(); | |||
2820 | while (true) { | |||
2821 | // Look through typedefs. | |||
2822 | if (!SuppressBlock) { | |||
2823 | if (TypedefTypeLoc TypedefTL = TL.getAsAdjusted<TypedefTypeLoc>()) { | |||
2824 | if (TypeSourceInfo *InnerTSInfo = | |||
2825 | TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) { | |||
2826 | TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc(); | |||
2827 | continue; | |||
2828 | } | |||
2829 | } | |||
2830 | ||||
2831 | // Look through qualified types | |||
2832 | if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) { | |||
2833 | TL = QualifiedTL.getUnqualifiedLoc(); | |||
2834 | continue; | |||
2835 | } | |||
2836 | ||||
2837 | if (AttributedTypeLoc AttrTL = TL.getAs<AttributedTypeLoc>()) { | |||
2838 | TL = AttrTL.getModifiedLoc(); | |||
2839 | continue; | |||
2840 | } | |||
2841 | } | |||
2842 | ||||
2843 | // Try to get the function prototype behind the block pointer type, | |||
2844 | // then we're done. | |||
2845 | if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) { | |||
2846 | TL = BlockPtr.getPointeeLoc().IgnoreParens(); | |||
2847 | Block = TL.getAs<FunctionTypeLoc>(); | |||
2848 | BlockProto = TL.getAs<FunctionProtoTypeLoc>(); | |||
2849 | } | |||
2850 | break; | |||
2851 | } | |||
2852 | } | |||
2853 | ||||
2854 | static std::string formatBlockPlaceholder( | |||
2855 | const PrintingPolicy &Policy, const NamedDecl *BlockDecl, | |||
2856 | FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto, | |||
2857 | bool SuppressBlockName = false, bool SuppressBlock = false, | |||
2858 | std::optional<ArrayRef<QualType>> ObjCSubsts = std::nullopt); | |||
2859 | ||||
2860 | static std::string FormatFunctionParameter( | |||
2861 | const PrintingPolicy &Policy, const DeclaratorDecl *Param, | |||
2862 | bool SuppressName = false, bool SuppressBlock = false, | |||
2863 | std::optional<ArrayRef<QualType>> ObjCSubsts = std::nullopt) { | |||
2864 | // Params are unavailable in FunctionTypeLoc if the FunctionType is invalid. | |||
2865 | // It would be better to pass in the param Type, which is usually available. | |||
2866 | // But this case is rare, so just pretend we fell back to int as elsewhere. | |||
2867 | if (!Param) | |||
2868 | return "int"; | |||
2869 | Decl::ObjCDeclQualifier ObjCQual = Decl::OBJC_TQ_None; | |||
2870 | if (const auto *PVD = dyn_cast<ParmVarDecl>(Param)) | |||
2871 | ObjCQual = PVD->getObjCDeclQualifier(); | |||
2872 | bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext()); | |||
2873 | if (Param->getType()->isDependentType() || | |||
2874 | !Param->getType()->isBlockPointerType()) { | |||
2875 | // The argument for a dependent or non-block parameter is a placeholder | |||
2876 | // containing that parameter's type. | |||
2877 | std::string Result; | |||
2878 | ||||
2879 | if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName) | |||
2880 | Result = std::string(Param->getIdentifier()->deuglifiedName()); | |||
2881 | ||||
2882 | QualType Type = Param->getType(); | |||
2883 | if (ObjCSubsts) | |||
2884 | Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts, | |||
2885 | ObjCSubstitutionContext::Parameter); | |||
2886 | if (ObjCMethodParam) { | |||
2887 | Result = "(" + formatObjCParamQualifiers(ObjCQual, Type); | |||
2888 | Result += Type.getAsString(Policy) + ")"; | |||
2889 | if (Param->getIdentifier() && !SuppressName) | |||
2890 | Result += Param->getIdentifier()->deuglifiedName(); | |||
2891 | } else { | |||
2892 | Type.getAsStringInternal(Result, Policy); | |||
2893 | } | |||
2894 | return Result; | |||
2895 | } | |||
2896 | ||||
2897 | // The argument for a block pointer parameter is a block literal with | |||
2898 | // the appropriate type. | |||
2899 | FunctionTypeLoc Block; | |||
2900 | FunctionProtoTypeLoc BlockProto; | |||
2901 | findTypeLocationForBlockDecl(Param->getTypeSourceInfo(), Block, BlockProto, | |||
2902 | SuppressBlock); | |||
2903 | // Try to retrieve the block type information from the property if this is a | |||
2904 | // parameter in a setter. | |||
2905 | if (!Block && ObjCMethodParam && | |||
2906 | cast<ObjCMethodDecl>(Param->getDeclContext())->isPropertyAccessor()) { | |||
2907 | if (const auto *PD = cast<ObjCMethodDecl>(Param->getDeclContext()) | |||
2908 | ->findPropertyDecl(/*CheckOverrides=*/false)) | |||
2909 | findTypeLocationForBlockDecl(PD->getTypeSourceInfo(), Block, BlockProto, | |||
2910 | SuppressBlock); | |||
2911 | } | |||
2912 | ||||
2913 | if (!Block) { | |||
2914 | // We were unable to find a FunctionProtoTypeLoc with parameter names | |||
2915 | // for the block; just use the parameter type as a placeholder. | |||
2916 | std::string Result; | |||
2917 | if (!ObjCMethodParam && Param->getIdentifier()) | |||
2918 | Result = std::string(Param->getIdentifier()->deuglifiedName()); | |||
2919 | ||||
2920 | QualType Type = Param->getType().getUnqualifiedType(); | |||
2921 | ||||
2922 | if (ObjCMethodParam) { | |||
2923 | Result = Type.getAsString(Policy); | |||
2924 | std::string Quals = formatObjCParamQualifiers(ObjCQual, Type); | |||
2925 | if (!Quals.empty()) | |||
2926 | Result = "(" + Quals + " " + Result + ")"; | |||
2927 | if (Result.back() != ')') | |||
2928 | Result += " "; | |||
2929 | if (Param->getIdentifier()) | |||
2930 | Result += Param->getIdentifier()->deuglifiedName(); | |||
2931 | } else { | |||
2932 | Type.getAsStringInternal(Result, Policy); | |||
2933 | } | |||
2934 | ||||
2935 | return Result; | |||
2936 | } | |||
2937 | ||||
2938 | // We have the function prototype behind the block pointer type, as it was | |||
2939 | // written in the source. | |||
2940 | return formatBlockPlaceholder(Policy, Param, Block, BlockProto, | |||
2941 | /*SuppressBlockName=*/false, SuppressBlock, | |||
2942 | ObjCSubsts); | |||
2943 | } | |||
2944 | ||||
2945 | /// Returns a placeholder string that corresponds to an Objective-C block | |||
2946 | /// declaration. | |||
2947 | /// | |||
2948 | /// \param BlockDecl A declaration with an Objective-C block type. | |||
2949 | /// | |||
2950 | /// \param Block The most relevant type location for that block type. | |||
2951 | /// | |||
2952 | /// \param SuppressBlockName Determines whether or not the name of the block | |||
2953 | /// declaration is included in the resulting string. | |||
2954 | static std::string | |||
2955 | formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl, | |||
2956 | FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto, | |||
2957 | bool SuppressBlockName, bool SuppressBlock, | |||
2958 | std::optional<ArrayRef<QualType>> ObjCSubsts) { | |||
2959 | std::string Result; | |||
2960 | QualType ResultType = Block.getTypePtr()->getReturnType(); | |||
2961 | if (ObjCSubsts) | |||
2962 | ResultType = | |||
2963 | ResultType.substObjCTypeArgs(BlockDecl->getASTContext(), *ObjCSubsts, | |||
2964 | ObjCSubstitutionContext::Result); | |||
2965 | if (!ResultType->isVoidType() || SuppressBlock) | |||
2966 | ResultType.getAsStringInternal(Result, Policy); | |||
2967 | ||||
2968 | // Format the parameter list. | |||
2969 | std::string Params; | |||
2970 | if (!BlockProto || Block.getNumParams() == 0) { | |||
2971 | if (BlockProto && BlockProto.getTypePtr()->isVariadic()) | |||
2972 | Params = "(...)"; | |||
2973 | else | |||
2974 | Params = "(void)"; | |||
2975 | } else { | |||
2976 | Params += "("; | |||
2977 | for (unsigned I = 0, N = Block.getNumParams(); I != N; ++I) { | |||
2978 | if (I) | |||
2979 | Params += ", "; | |||
2980 | Params += FormatFunctionParameter(Policy, Block.getParam(I), | |||
2981 | /*SuppressName=*/false, | |||
2982 | /*SuppressBlock=*/true, ObjCSubsts); | |||
2983 | ||||
2984 | if (I == N - 1 && BlockProto.getTypePtr()->isVariadic()) | |||
2985 | Params += ", ..."; | |||
2986 | } | |||
2987 | Params += ")"; | |||
2988 | } | |||
2989 | ||||
2990 | if (SuppressBlock) { | |||
2991 | // Format as a parameter. | |||
2992 | Result = Result + " (^"; | |||
2993 | if (!SuppressBlockName && BlockDecl->getIdentifier()) | |||
2994 | Result += BlockDecl->getIdentifier()->getName(); | |||
2995 | Result += ")"; | |||
2996 | Result += Params; | |||
2997 | } else { | |||
2998 | // Format as a block literal argument. | |||
2999 | Result = '^' + Result; | |||
3000 | Result += Params; | |||
3001 | ||||
3002 | if (!SuppressBlockName && BlockDecl->getIdentifier()) | |||
3003 | Result += BlockDecl->getIdentifier()->getName(); | |||
3004 | } | |||
3005 | ||||
3006 | return Result; | |||
3007 | } | |||
3008 | ||||
3009 | static std::string GetDefaultValueString(const ParmVarDecl *Param, | |||
3010 | const SourceManager &SM, | |||
3011 | const LangOptions &LangOpts) { | |||
3012 | const SourceRange SrcRange = Param->getDefaultArgRange(); | |||
3013 | CharSourceRange CharSrcRange = CharSourceRange::getTokenRange(SrcRange); | |||
3014 | bool Invalid = CharSrcRange.isInvalid(); | |||
3015 | if (Invalid) | |||
3016 | return ""; | |||
3017 | StringRef srcText = | |||
3018 | Lexer::getSourceText(CharSrcRange, SM, LangOpts, &Invalid); | |||
3019 | if (Invalid) | |||
3020 | return ""; | |||
3021 | ||||
3022 | if (srcText.empty() || srcText == "=") { | |||
3023 | // Lexer can't determine the value. | |||
3024 | // This happens if the code is incorrect (for example class is forward | |||
3025 | // declared). | |||
3026 | return ""; | |||
3027 | } | |||
3028 | std::string DefValue(srcText.str()); | |||
3029 | // FIXME: remove this check if the Lexer::getSourceText value is fixed and | |||
3030 | // this value always has (or always does not have) '=' in front of it | |||
3031 | if (DefValue.at(0) != '=') { | |||
3032 | // If we don't have '=' in front of value. | |||
3033 | // Lexer returns built-in types values without '=' and user-defined types | |||
3034 | // values with it. | |||
3035 | return " = " + DefValue; | |||
3036 | } | |||
3037 | return " " + DefValue; | |||
3038 | } | |||
3039 | ||||
3040 | /// Add function parameter chunks to the given code completion string. | |||
3041 | static void AddFunctionParameterChunks(Preprocessor &PP, | |||
3042 | const PrintingPolicy &Policy, | |||
3043 | const FunctionDecl *Function, | |||
3044 | CodeCompletionBuilder &Result, | |||
3045 | unsigned Start = 0, | |||
3046 | bool InOptional = false) { | |||
3047 | bool FirstParameter = true; | |||
3048 | ||||
3049 | for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) { | |||
3050 | const ParmVarDecl *Param = Function->getParamDecl(P); | |||
3051 | ||||
3052 | if (Param->hasDefaultArg() && !InOptional) { | |||
3053 | // When we see an optional default argument, put that argument and | |||
3054 | // the remaining default arguments into a new, optional string. | |||
3055 | CodeCompletionBuilder Opt(Result.getAllocator(), | |||
3056 | Result.getCodeCompletionTUInfo()); | |||
3057 | if (!FirstParameter) | |||
3058 | Opt.AddChunk(CodeCompletionString::CK_Comma); | |||
3059 | AddFunctionParameterChunks(PP, Policy, Function, Opt, P, true); | |||
3060 | Result.AddOptionalChunk(Opt.TakeString()); | |||
3061 | break; | |||
3062 | } | |||
3063 | ||||
3064 | if (FirstParameter) | |||
3065 | FirstParameter = false; | |||
3066 | else | |||
3067 | Result.AddChunk(CodeCompletionString::CK_Comma); | |||
3068 | ||||
3069 | InOptional = false; | |||
3070 | ||||
3071 | // Format the placeholder string. | |||
3072 | std::string PlaceholderStr = FormatFunctionParameter(Policy, Param); | |||
3073 | if (Param->hasDefaultArg()) | |||
3074 | PlaceholderStr += | |||
3075 | GetDefaultValueString(Param, PP.getSourceManager(), PP.getLangOpts()); | |||
3076 | ||||
3077 | if (Function->isVariadic() && P == N - 1) | |||
3078 | PlaceholderStr += ", ..."; | |||
3079 | ||||
3080 | // Add the placeholder string. | |||
3081 | Result.AddPlaceholderChunk( | |||
3082 | Result.getAllocator().CopyString(PlaceholderStr)); | |||
3083 | } | |||
3084 | ||||
3085 | if (const auto *Proto = Function->getType()->getAs<FunctionProtoType>()) | |||
3086 | if (Proto->isVariadic()) { | |||
3087 | if (Proto->getNumParams() == 0) | |||
3088 | Result.AddPlaceholderChunk("..."); | |||
3089 | ||||
3090 | MaybeAddSentinel(PP, Function, Result); | |||
3091 | } | |||
3092 | } | |||
3093 | ||||
3094 | /// Add template parameter chunks to the given code completion string. | |||
3095 | static void AddTemplateParameterChunks( | |||
3096 | ASTContext &Context, const PrintingPolicy &Policy, | |||
3097 | const TemplateDecl *Template, CodeCompletionBuilder &Result, | |||
3098 | unsigned MaxParameters = 0, unsigned Start = 0, bool InDefaultArg = false) { | |||
3099 | bool FirstParameter = true; | |||
3100 | ||||
3101 | // Prefer to take the template parameter names from the first declaration of | |||
3102 | // the template. | |||
3103 | Template = cast<TemplateDecl>(Template->getCanonicalDecl()); | |||
3104 | ||||
3105 | TemplateParameterList *Params = Template->getTemplateParameters(); | |||
3106 | TemplateParameterList::iterator PEnd = Params->end(); | |||
3107 | if (MaxParameters) | |||
3108 | PEnd = Params->begin() + MaxParameters; | |||
3109 | for (TemplateParameterList::iterator P = Params->begin() + Start; P != PEnd; | |||
3110 | ++P) { | |||
3111 | bool HasDefaultArg = false; | |||
3112 | std::string PlaceholderStr; | |||
3113 | if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) { | |||
3114 | if (TTP->wasDeclaredWithTypename()) | |||
3115 | PlaceholderStr = "typename"; | |||
3116 | else if (const auto *TC = TTP->getTypeConstraint()) { | |||
3117 | llvm::raw_string_ostream OS(PlaceholderStr); | |||
3118 | TC->print(OS, Policy); | |||
3119 | OS.flush(); | |||
3120 | } else | |||
3121 | PlaceholderStr = "class"; | |||
3122 | ||||
3123 | if (TTP->getIdentifier()) { | |||
3124 | PlaceholderStr += ' '; | |||
3125 | PlaceholderStr += TTP->getIdentifier()->deuglifiedName(); | |||
3126 | } | |||
3127 | ||||
3128 | HasDefaultArg = TTP->hasDefaultArgument(); | |||
3129 | } else if (NonTypeTemplateParmDecl *NTTP = | |||
3130 | dyn_cast<NonTypeTemplateParmDecl>(*P)) { | |||
3131 | if (NTTP->getIdentifier()) | |||
3132 | PlaceholderStr = std::string(NTTP->getIdentifier()->deuglifiedName()); | |||
3133 | NTTP->getType().getAsStringInternal(PlaceholderStr, Policy); | |||
3134 | HasDefaultArg = NTTP->hasDefaultArgument(); | |||
3135 | } else { | |||
3136 | assert(isa<TemplateTemplateParmDecl>(*P))(static_cast <bool> (isa<TemplateTemplateParmDecl> (*P)) ? void (0) : __assert_fail ("isa<TemplateTemplateParmDecl>(*P)" , "clang/lib/Sema/SemaCodeComplete.cpp", 3136, __extension__ __PRETTY_FUNCTION__ )); | |||
3137 | TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P); | |||
3138 | ||||
3139 | // Since putting the template argument list into the placeholder would | |||
3140 | // be very, very long, we just use an abbreviation. | |||
3141 | PlaceholderStr = "template<...> class"; | |||
3142 | if (TTP->getIdentifier()) { | |||
3143 | PlaceholderStr += ' '; | |||
3144 | PlaceholderStr += TTP->getIdentifier()->deuglifiedName(); | |||
3145 | } | |||
3146 | ||||
3147 | HasDefaultArg = TTP->hasDefaultArgument(); | |||
3148 | } | |||
3149 | ||||
3150 | if (HasDefaultArg && !InDefaultArg) { | |||
3151 | // When we see an optional default argument, put that argument and | |||
3152 | // the remaining default arguments into a new, optional string. | |||
3153 | CodeCompletionBuilder Opt(Result.getAllocator(), | |||
3154 | Result.getCodeCompletionTUInfo()); | |||
3155 | if (!FirstParameter) | |||
3156 | Opt.AddChunk(CodeCompletionString::CK_Comma); | |||
3157 | AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters, | |||
3158 | P - Params->begin(), true); | |||
3159 | Result.AddOptionalChunk(Opt.TakeString()); | |||
3160 | break; | |||
3161 | } | |||
3162 | ||||
3163 | InDefaultArg = false; | |||
3164 | ||||
3165 | if (FirstParameter) | |||
3166 | FirstParameter = false; | |||
3167 | else | |||
3168 | Result.AddChunk(CodeCompletionString::CK_Comma); | |||
3169 | ||||
3170 | // Add the placeholder string. | |||
3171 | Result.AddPlaceholderChunk( | |||
3172 | Result.getAllocator().CopyString(PlaceholderStr)); | |||
3173 | } | |||
3174 | } | |||
3175 | ||||
3176 | /// Add a qualifier to the given code-completion string, if the | |||
3177 | /// provided nested-name-specifier is non-NULL. | |||
3178 | static void AddQualifierToCompletionString(CodeCompletionBuilder &Result, | |||
3179 | NestedNameSpecifier *Qualifier, | |||
3180 | bool QualifierIsInformative, | |||
3181 | ASTContext &Context, | |||
3182 | const PrintingPolicy &Policy) { | |||
3183 | if (!Qualifier) | |||
3184 | return; | |||
3185 | ||||
3186 | std::string PrintedNNS; | |||
3187 | { | |||
3188 | llvm::raw_string_ostream OS(PrintedNNS); | |||
3189 | Qualifier->print(OS, Policy); | |||
3190 | } | |||
3191 | if (QualifierIsInformative) | |||
3192 | Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS)); | |||
3193 | else | |||
3194 | Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS)); | |||
3195 | } | |||
3196 | ||||
3197 | static void | |||
3198 | AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result, | |||
3199 | const FunctionDecl *Function) { | |||
3200 | const auto *Proto = Function->getType()->getAs<FunctionProtoType>(); | |||
3201 | if (!Proto || !Proto->getMethodQuals()) | |||
3202 | return; | |||
3203 | ||||
3204 | // FIXME: Add ref-qualifier! | |||
3205 | ||||
3206 | // Handle single qualifiers without copying | |||
3207 | if (Proto->getMethodQuals().hasOnlyConst()) { | |||
3208 | Result.AddInformativeChunk(" const"); | |||
3209 | return; | |||
3210 | } | |||
3211 | ||||
3212 | if (Proto->getMethodQuals().hasOnlyVolatile()) { | |||
3213 | Result.AddInformativeChunk(" volatile"); | |||
3214 | return; | |||
3215 | } | |||
3216 | ||||
3217 | if (Proto->getMethodQuals().hasOnlyRestrict()) { | |||
3218 | Result.AddInformativeChunk(" restrict"); | |||
3219 | return; | |||
3220 | } | |||
3221 | ||||
3222 | // Handle multiple qualifiers. | |||
3223 | std::string QualsStr; | |||
3224 | if (Proto->isConst()) | |||
3225 | QualsStr += " const"; | |||
3226 | if (Proto->isVolatile()) | |||
3227 | QualsStr += " volatile"; | |||
3228 | if (Proto->isRestrict()) | |||
3229 | QualsStr += " restrict"; | |||
3230 | Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr)); | |||
3231 | } | |||
3232 | ||||
3233 | /// Add the name of the given declaration | |||
3234 | static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy, | |||
3235 | const NamedDecl *ND, | |||
3236 | CodeCompletionBuilder &Result) { | |||
3237 | DeclarationName Name = ND->getDeclName(); | |||
3238 | if (!Name) | |||
3239 | return; | |||
3240 | ||||
3241 | switch (Name.getNameKind()) { | |||
3242 | case DeclarationName::CXXOperatorName: { | |||
3243 | const char *OperatorName = nullptr; | |||
3244 | switch (Name.getCXXOverloadedOperator()) { | |||
3245 | case OO_None: | |||
3246 | case OO_Conditional: | |||
3247 | case NUM_OVERLOADED_OPERATORS: | |||
3248 | OperatorName = "operator"; | |||
3249 | break; | |||
3250 | ||||
3251 | #define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \ | |||
3252 | case OO_##Name: \ | |||
3253 | OperatorName = "operator" Spelling; \ | |||
3254 | break; | |||
3255 | #define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemberOnly) | |||
3256 | #include "clang/Basic/OperatorKinds.def" | |||
3257 | ||||
3258 | case OO_New: | |||
3259 | OperatorName = "operator new"; | |||
3260 | break; | |||
3261 | case OO_Delete: | |||
3262 | OperatorName = "operator delete"; | |||
3263 | break; | |||
3264 | case OO_Array_New: | |||
3265 | OperatorName = "operator new[]"; | |||
3266 | break; | |||
3267 | case OO_Array_Delete: | |||
3268 | OperatorName = "operator delete[]"; | |||
3269 | break; | |||
3270 | case OO_Call: | |||
3271 | OperatorName = "operator()"; | |||
3272 | break; | |||
3273 | case OO_Subscript: | |||
3274 | OperatorName = "operator[]"; | |||
3275 | break; | |||
3276 | } | |||
3277 | Result.AddTypedTextChunk(OperatorName); | |||
3278 | break; | |||
3279 | } | |||
3280 | ||||
3281 | case DeclarationName::Identifier: | |||
3282 | case DeclarationName::CXXConversionFunctionName: | |||
3283 | case DeclarationName::CXXDestructorName: | |||
3284 | case DeclarationName::CXXLiteralOperatorName: | |||
3285 | Result.AddTypedTextChunk( | |||
3286 | Result.getAllocator().CopyString(ND->getNameAsString())); | |||
3287 | break; | |||
3288 | ||||
3289 | case DeclarationName::CXXDeductionGuideName: | |||
3290 | case DeclarationName::CXXUsingDirective: | |||
3291 | case DeclarationName::ObjCZeroArgSelector: | |||
3292 | case DeclarationName::ObjCOneArgSelector: | |||
3293 | case DeclarationName::ObjCMultiArgSelector: | |||
3294 | break; | |||
3295 | ||||
3296 | case DeclarationName::CXXConstructorName: { | |||
3297 | CXXRecordDecl *Record = nullptr; | |||
3298 | QualType Ty = Name.getCXXNameType(); | |||
3299 | if (const auto *RecordTy = Ty->getAs<RecordType>()) | |||
3300 | Record = cast<CXXRecordDecl>(RecordTy->getDecl()); | |||
3301 | else if (const auto *InjectedTy = Ty->getAs<InjectedClassNameType>()) | |||
3302 | Record = InjectedTy->getDecl(); | |||
3303 | else { | |||
3304 | Result.AddTypedTextChunk( | |||
3305 | Result.getAllocator().CopyString(ND->getNameAsString())); | |||
3306 | break; | |||
3307 | } | |||
3308 | ||||
3309 | Result.AddTypedTextChunk( | |||
3310 | Result.getAllocator().CopyString(Record->getNameAsString())); | |||
3311 | if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) { | |||
3312 | Result.AddChunk(CodeCompletionString::CK_LeftAngle); | |||
3313 | AddTemplateParameterChunks(Context, Policy, Template, Result); | |||
3314 | Result.AddChunk(CodeCompletionString::CK_RightAngle); | |||
3315 | } | |||
3316 | break; | |||
3317 | } | |||
3318 | } | |||
3319 | } | |||
3320 | ||||
3321 | CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString( | |||
3322 | Sema &S, const CodeCompletionContext &CCContext, | |||
3323 | CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo, | |||
3324 | bool IncludeBriefComments) { | |||
3325 | return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator, | |||
3326 | CCTUInfo, IncludeBriefComments); | |||
3327 | } | |||
3328 | ||||
3329 | CodeCompletionString *CodeCompletionResult::CreateCodeCompletionStringForMacro( | |||
3330 | Preprocessor &PP, CodeCompletionAllocator &Allocator, | |||
3331 | CodeCompletionTUInfo &CCTUInfo) { | |||
3332 | assert(Kind == RK_Macro)(static_cast <bool> (Kind == RK_Macro) ? void (0) : __assert_fail ("Kind == RK_Macro", "clang/lib/Sema/SemaCodeComplete.cpp", 3332 , __extension__ __PRETTY_FUNCTION__)); | |||
3333 | CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability); | |||
3334 | const MacroInfo *MI = PP.getMacroInfo(Macro); | |||
3335 | Result.AddTypedTextChunk(Result.getAllocator().CopyString(Macro->getName())); | |||
3336 | ||||
3337 | if (!MI || !MI->isFunctionLike()) | |||
3338 | return Result.TakeString(); | |||
3339 | ||||
3340 | // Format a function-like macro with placeholders for the arguments. | |||
3341 | Result.AddChunk(CodeCompletionString::CK_LeftParen); | |||
3342 | MacroInfo::param_iterator A = MI->param_begin(), AEnd = MI->param_end(); | |||
3343 | ||||
3344 | // C99 variadic macros add __VA_ARGS__ at the end. Skip it. | |||
3345 | if (MI->isC99Varargs()) { | |||
3346 | --AEnd; | |||
3347 | ||||
3348 | if (A == AEnd) { | |||
3349 | Result.AddPlaceholderChunk("..."); | |||
3350 | } | |||
3351 | } | |||
3352 | ||||
3353 | for (MacroInfo::param_iterator A = MI->param_begin(); A != AEnd; ++A) { | |||
3354 | if (A != MI->param_begin()) | |||
3355 | Result.AddChunk(CodeCompletionString::CK_Comma); | |||
3356 | ||||
3357 | if (MI->isVariadic() && (A + 1) == AEnd) { | |||
3358 | SmallString<32> Arg = (*A)->getName(); | |||
3359 | if (MI->isC99Varargs()) | |||
3360 | Arg += ", ..."; | |||
3361 | else | |||
3362 | Arg += "..."; | |||
3363 | Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg)); | |||
3364 | break; | |||
3365 | } | |||
3366 | ||||
3367 | // Non-variadic macros are simple. | |||
3368 | Result.AddPlaceholderChunk( | |||
3369 | Result.getAllocator().CopyString((*A)->getName())); | |||
3370 | } | |||
3371 | Result.AddChunk(CodeCompletionString::CK_RightParen); | |||
3372 | return Result.TakeString(); | |||
3373 | } | |||
3374 | ||||
3375 | /// If possible, create a new code completion string for the given | |||
3376 | /// result. | |||
3377 | /// | |||
3378 | /// \returns Either a new, heap-allocated code completion string describing | |||
3379 | /// how to use this result, or NULL to indicate that the string or name of the | |||
3380 | /// result is all that is needed. | |||
3381 | CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString( | |||
3382 | ASTContext &Ctx, Preprocessor &PP, const CodeCompletionContext &CCContext, | |||
3383 | CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo, | |||
3384 | bool IncludeBriefComments) { | |||
3385 | if (Kind == RK_Macro) | |||
3386 | return CreateCodeCompletionStringForMacro(PP, Allocator, CCTUInfo); | |||
3387 | ||||
3388 | CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability); | |||
3389 | ||||
3390 | PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP); | |||
3391 | if (Kind == RK_Pattern) { | |||
3392 | Pattern->Priority = Priority; | |||
3393 | Pattern->Availability = Availability; | |||
3394 | ||||
3395 | if (Declaration) { | |||
3396 | Result.addParentContext(Declaration->getDeclContext()); | |||
3397 | Pattern->ParentName = Result.getParentName(); | |||
3398 | if (const RawComment *RC = | |||
3399 | getPatternCompletionComment(Ctx, Declaration)) { | |||
3400 | Result.addBriefComment(RC->getBriefText(Ctx)); | |||
3401 | Pattern->BriefComment = Result.getBriefComment(); | |||
3402 | } | |||
3403 | } | |||
3404 | ||||
3405 | return Pattern; | |||
3406 | } | |||
3407 | ||||
3408 | if (Kind == RK_Keyword) { | |||
3409 | Result.AddTypedTextChunk(Keyword); | |||
3410 | return Result.TakeString(); | |||
3411 | } | |||
3412 | assert(Kind == RK_Declaration && "Missed a result kind?")(static_cast <bool> (Kind == RK_Declaration && "Missed a result kind?" ) ? void (0) : __assert_fail ("Kind == RK_Declaration && \"Missed a result kind?\"" , "clang/lib/Sema/SemaCodeComplete.cpp", 3412, __extension__ __PRETTY_FUNCTION__ )); | |||
3413 | return createCodeCompletionStringForDecl( | |||
3414 | PP, Ctx, Result, IncludeBriefComments, CCContext, Policy); | |||
3415 | } | |||
3416 | ||||
3417 | static void printOverrideString(const CodeCompletionString &CCS, | |||
3418 | std::string &BeforeName, | |||
3419 | std::string &NameAndSignature) { | |||
3420 | bool SeenTypedChunk = false; | |||
3421 | for (auto &Chunk : CCS) { | |||
3422 | if (Chunk.Kind == CodeCompletionString::CK_Optional) { | |||
3423 | assert(SeenTypedChunk && "optional parameter before name")(static_cast <bool> (SeenTypedChunk && "optional parameter before name" ) ? void (0) : __assert_fail ("SeenTypedChunk && \"optional parameter before name\"" , "clang/lib/Sema/SemaCodeComplete.cpp", 3423, __extension__ __PRETTY_FUNCTION__ )); | |||
3424 | // Note that we put all chunks inside into NameAndSignature. | |||
3425 | printOverrideString(*Chunk.Optional, NameAndSignature, NameAndSignature); | |||
3426 | continue; | |||
3427 | } | |||
3428 | SeenTypedChunk |= Chunk.Kind == CodeCompletionString::CK_TypedText; | |||
3429 | if (SeenTypedChunk) | |||
3430 | NameAndSignature += Chunk.Text; | |||
3431 | else | |||
3432 | BeforeName += Chunk.Text; | |||
3433 | } | |||
3434 | } | |||
3435 | ||||
3436 | CodeCompletionString * | |||
3437 | CodeCompletionResult::createCodeCompletionStringForOverride( | |||
3438 | Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result, | |||
3439 | bool IncludeBriefComments, const CodeCompletionContext &CCContext, | |||
3440 | PrintingPolicy &Policy) { | |||
3441 | auto *CCS = createCodeCompletionStringForDecl(PP, Ctx, Result, | |||
3442 | /*IncludeBriefComments=*/false, | |||
3443 | CCContext, Policy); | |||
3444 | std::string BeforeName; | |||
3445 | std::string NameAndSignature; | |||
3446 | // For overrides all chunks go into the result, none are informative. | |||
3447 | printOverrideString(*CCS, BeforeName, NameAndSignature); | |||
3448 | NameAndSignature += " override"; | |||
3449 | ||||
3450 | Result.AddTextChunk(Result.getAllocator().CopyString(BeforeName)); | |||
3451 | Result.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
3452 | Result.AddTypedTextChunk(Result.getAllocator().CopyString(NameAndSignature)); | |||
3453 | return Result.TakeString(); | |||
3454 | } | |||
3455 | ||||
3456 | // FIXME: Right now this works well with lambdas. Add support for other functor | |||
3457 | // types like std::function. | |||
3458 | static const NamedDecl *extractFunctorCallOperator(const NamedDecl *ND) { | |||
3459 | const auto *VD = dyn_cast<VarDecl>(ND); | |||
3460 | if (!VD) | |||
3461 | return nullptr; | |||
3462 | const auto *RecordDecl = VD->getType()->getAsCXXRecordDecl(); | |||
3463 | if (!RecordDecl || !RecordDecl->isLambda()) | |||
3464 | return nullptr; | |||
3465 | return RecordDecl->getLambdaCallOperator(); | |||
3466 | } | |||
3467 | ||||
3468 | CodeCompletionString *CodeCompletionResult::createCodeCompletionStringForDecl( | |||
3469 | Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result, | |||
3470 | bool IncludeBriefComments, const CodeCompletionContext &CCContext, | |||
3471 | PrintingPolicy &Policy) { | |||
3472 | const NamedDecl *ND = Declaration; | |||
3473 | Result.addParentContext(ND->getDeclContext()); | |||
3474 | ||||
3475 | if (IncludeBriefComments) { | |||
3476 | // Add documentation comment, if it exists. | |||
3477 | if (const RawComment *RC = getCompletionComment(Ctx, Declaration)) { | |||
3478 | Result.addBriefComment(RC->getBriefText(Ctx)); | |||
3479 | } | |||
3480 | } | |||
3481 | ||||
3482 | if (StartsNestedNameSpecifier) { | |||
3483 | Result.AddTypedTextChunk( | |||
3484 | Result.getAllocator().CopyString(ND->getNameAsString())); | |||
3485 | Result.AddTextChunk("::"); | |||
3486 | return Result.TakeString(); | |||
3487 | } | |||
3488 | ||||
3489 | for (const auto *I : ND->specific_attrs<AnnotateAttr>()) | |||
3490 | Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation())); | |||
3491 | ||||
3492 | auto AddFunctionTypeAndResult = [&](const FunctionDecl *Function) { | |||
3493 | AddResultTypeChunk(Ctx, Policy, Function, CCContext.getBaseType(), Result); | |||
3494 | AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, | |||
3495 | Ctx, Policy); | |||
3496 | AddTypedNameChunk(Ctx, Policy, ND, Result); | |||
3497 | Result.AddChunk(CodeCompletionString::CK_LeftParen); | |||
3498 | AddFunctionParameterChunks(PP, Policy, Function, Result); | |||
3499 | Result.AddChunk(CodeCompletionString::CK_RightParen); | |||
3500 | AddFunctionTypeQualsToCompletionString(Result, Function); | |||
3501 | }; | |||
3502 | ||||
3503 | if (const auto *Function = dyn_cast<FunctionDecl>(ND)) { | |||
3504 | AddFunctionTypeAndResult(Function); | |||
3505 | return Result.TakeString(); | |||
3506 | } | |||
3507 | ||||
3508 | if (const auto *CallOperator = | |||
3509 | dyn_cast_or_null<FunctionDecl>(extractFunctorCallOperator(ND))) { | |||
3510 | AddFunctionTypeAndResult(CallOperator); | |||
3511 | return Result.TakeString(); | |||
3512 | } | |||
3513 | ||||
3514 | AddResultTypeChunk(Ctx, Policy, ND, CCContext.getBaseType(), Result); | |||
3515 | ||||
3516 | if (const FunctionTemplateDecl *FunTmpl = | |||
3517 | dyn_cast<FunctionTemplateDecl>(ND)) { | |||
3518 | AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, | |||
3519 | Ctx, Policy); | |||
3520 | FunctionDecl *Function = FunTmpl->getTemplatedDecl(); | |||
3521 | AddTypedNameChunk(Ctx, Policy, Function, Result); | |||
3522 | ||||
3523 | // Figure out which template parameters are deduced (or have default | |||
3524 | // arguments). | |||
3525 | llvm::SmallBitVector Deduced; | |||
3526 | Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced); | |||
3527 | unsigned LastDeducibleArgument; | |||
3528 | for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0; | |||
3529 | --LastDeducibleArgument) { | |||
3530 | if (!Deduced[LastDeducibleArgument - 1]) { | |||
3531 | // C++0x: Figure out if the template argument has a default. If so, | |||
3532 | // the user doesn't need to type this argument. | |||
3533 | // FIXME: We need to abstract template parameters better! | |||
3534 | bool HasDefaultArg = false; | |||
3535 | NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam( | |||
3536 | LastDeducibleArgument - 1); | |||
3537 | if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) | |||
3538 | HasDefaultArg = TTP->hasDefaultArgument(); | |||
3539 | else if (NonTypeTemplateParmDecl *NTTP = | |||
3540 | dyn_cast<NonTypeTemplateParmDecl>(Param)) | |||
3541 | HasDefaultArg = NTTP->hasDefaultArgument(); | |||
3542 | else { | |||
3543 | assert(isa<TemplateTemplateParmDecl>(Param))(static_cast <bool> (isa<TemplateTemplateParmDecl> (Param)) ? void (0) : __assert_fail ("isa<TemplateTemplateParmDecl>(Param)" , "clang/lib/Sema/SemaCodeComplete.cpp", 3543, __extension__ __PRETTY_FUNCTION__ )); | |||
3544 | HasDefaultArg = | |||
3545 | cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument(); | |||
3546 | } | |||
3547 | ||||
3548 | if (!HasDefaultArg) | |||
3549 | break; | |||
3550 | } | |||
3551 | } | |||
3552 | ||||
3553 | if (LastDeducibleArgument) { | |||
3554 | // Some of the function template arguments cannot be deduced from a | |||
3555 | // function call, so we introduce an explicit template argument list | |||
3556 | // containing all of the arguments up to the first deducible argument. | |||
3557 | Result.AddChunk(CodeCompletionString::CK_LeftAngle); | |||
3558 | AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result, | |||
3559 | LastDeducibleArgument); | |||
3560 | Result.AddChunk(CodeCompletionString::CK_RightAngle); | |||
3561 | } | |||
3562 | ||||
3563 | // Add the function parameters | |||
3564 | Result.AddChunk(CodeCompletionString::CK_LeftParen); | |||
3565 | AddFunctionParameterChunks(PP, Policy, Function, Result); | |||
3566 | Result.AddChunk(CodeCompletionString::CK_RightParen); | |||
3567 | AddFunctionTypeQualsToCompletionString(Result, Function); | |||
3568 | return Result.TakeString(); | |||
3569 | } | |||
3570 | ||||
3571 | if (const auto *Template = dyn_cast<TemplateDecl>(ND)) { | |||
3572 | AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, | |||
3573 | Ctx, Policy); | |||
3574 | Result.AddTypedTextChunk( | |||
3575 | Result.getAllocator().CopyString(Template->getNameAsString())); | |||
3576 | Result.AddChunk(CodeCompletionString::CK_LeftAngle); | |||
3577 | AddTemplateParameterChunks(Ctx, Policy, Template, Result); | |||
3578 | Result.AddChunk(CodeCompletionString::CK_RightAngle); | |||
3579 | return Result.TakeString(); | |||
3580 | } | |||
3581 | ||||
3582 | if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) { | |||
3583 | Selector Sel = Method->getSelector(); | |||
3584 | if (Sel.isUnarySelector()) { | |||
3585 | Result.AddTypedTextChunk( | |||
3586 | Result.getAllocator().CopyString(Sel.getNameForSlot(0))); | |||
3587 | return Result.TakeString(); | |||
3588 | } | |||
3589 | ||||
3590 | std::string SelName = Sel.getNameForSlot(0).str(); | |||
3591 | SelName += ':'; | |||
3592 | if (StartParameter == 0) | |||
3593 | Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName)); | |||
3594 | else { | |||
3595 | Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName)); | |||
3596 | ||||
3597 | // If there is only one parameter, and we're past it, add an empty | |||
3598 | // typed-text chunk since there is nothing to type. | |||
3599 | if (Method->param_size() == 1) | |||
3600 | Result.AddTypedTextChunk(""); | |||
3601 | } | |||
3602 | unsigned Idx = 0; | |||
3603 | // The extra Idx < Sel.getNumArgs() check is needed due to legacy C-style | |||
3604 | // method parameters. | |||
3605 | for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(), | |||
3606 | PEnd = Method->param_end(); | |||
3607 | P != PEnd && Idx < Sel.getNumArgs(); (void)++P, ++Idx) { | |||
3608 | if (Idx > 0) { | |||
3609 | std::string Keyword; | |||
3610 | if (Idx > StartParameter) | |||
3611 | Result.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
3612 | if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx)) | |||
3613 | Keyword += II->getName(); | |||
3614 | Keyword += ":"; | |||
3615 | if (Idx < StartParameter || AllParametersAreInformative) | |||
3616 | Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword)); | |||
3617 | else | |||
3618 | Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword)); | |||
3619 | } | |||
3620 | ||||
3621 | // If we're before the starting parameter, skip the placeholder. | |||
3622 | if (Idx < StartParameter) | |||
3623 | continue; | |||
3624 | ||||
3625 | std::string Arg; | |||
3626 | QualType ParamType = (*P)->getType(); | |||
3627 | std::optional<ArrayRef<QualType>> ObjCSubsts; | |||
3628 | if (!CCContext.getBaseType().isNull()) | |||
3629 | ObjCSubsts = CCContext.getBaseType()->getObjCSubstitutions(Method); | |||
3630 | ||||
3631 | if (ParamType->isBlockPointerType() && !DeclaringEntity) | |||
3632 | Arg = FormatFunctionParameter(Policy, *P, true, | |||
3633 | /*SuppressBlock=*/false, ObjCSubsts); | |||
3634 | else { | |||
3635 | if (ObjCSubsts) | |||
3636 | ParamType = ParamType.substObjCTypeArgs( | |||
3637 | Ctx, *ObjCSubsts, ObjCSubstitutionContext::Parameter); | |||
3638 | Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(), | |||
3639 | ParamType); | |||
3640 | Arg += ParamType.getAsString(Policy) + ")"; | |||
3641 | if (IdentifierInfo *II = (*P)->getIdentifier()) | |||
3642 | if (DeclaringEntity || AllParametersAreInformative) | |||
3643 | Arg += II->getName(); | |||
3644 | } | |||
3645 | ||||
3646 | if (Method->isVariadic() && (P + 1) == PEnd) | |||
3647 | Arg += ", ..."; | |||
3648 | ||||
3649 | if (DeclaringEntity) | |||
3650 | Result.AddTextChunk(Result.getAllocator().CopyString(Arg)); | |||
3651 | else if (AllParametersAreInformative) | |||
3652 | Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg)); | |||
3653 | else | |||
3654 | Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg)); | |||
3655 | } | |||
3656 | ||||
3657 | if (Method->isVariadic()) { | |||
3658 | if (Method->param_size() == 0) { | |||
3659 | if (DeclaringEntity) | |||
3660 | Result.AddTextChunk(", ..."); | |||
3661 | else if (AllParametersAreInformative) | |||
3662 | Result.AddInformativeChunk(", ..."); | |||
3663 | else | |||
3664 | Result.AddPlaceholderChunk(", ..."); | |||
3665 | } | |||
3666 | ||||
3667 | MaybeAddSentinel(PP, Method, Result); | |||
3668 | } | |||
3669 | ||||
3670 | return Result.TakeString(); | |||
3671 | } | |||
3672 | ||||
3673 | if (Qualifier) | |||
3674 | AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, | |||
3675 | Ctx, Policy); | |||
3676 | ||||
3677 | Result.AddTypedTextChunk( | |||
3678 | Result.getAllocator().CopyString(ND->getNameAsString())); | |||
3679 | return Result.TakeString(); | |||
3680 | } | |||
3681 | ||||
3682 | const RawComment *clang::getCompletionComment(const ASTContext &Ctx, | |||
3683 | const NamedDecl *ND) { | |||
3684 | if (!ND) | |||
3685 | return nullptr; | |||
3686 | if (auto *RC = Ctx.getRawCommentForAnyRedecl(ND)) | |||
3687 | return RC; | |||
3688 | ||||
3689 | // Try to find comment from a property for ObjC methods. | |||
3690 | const auto *M = dyn_cast<ObjCMethodDecl>(ND); | |||
3691 | if (!M) | |||
3692 | return nullptr; | |||
3693 | const ObjCPropertyDecl *PDecl = M->findPropertyDecl(); | |||
3694 | if (!PDecl) | |||
3695 | return nullptr; | |||
3696 | ||||
3697 | return Ctx.getRawCommentForAnyRedecl(PDecl); | |||
3698 | } | |||
3699 | ||||
3700 | const RawComment *clang::getPatternCompletionComment(const ASTContext &Ctx, | |||
3701 | const NamedDecl *ND) { | |||
3702 | const auto *M = dyn_cast_or_null<ObjCMethodDecl>(ND); | |||
3703 | if (!M || !M->isPropertyAccessor()) | |||
3704 | return nullptr; | |||
3705 | ||||
3706 | // Provide code completion comment for self.GetterName where | |||
3707 | // GetterName is the getter method for a property with name | |||
3708 | // different from the property name (declared via a property | |||
3709 | // getter attribute. | |||
3710 | const ObjCPropertyDecl *PDecl = M->findPropertyDecl(); | |||
3711 | if (!PDecl) | |||
3712 | return nullptr; | |||
3713 | if (PDecl->getGetterName() == M->getSelector() && | |||
3714 | PDecl->getIdentifier() != M->getIdentifier()) { | |||
3715 | if (auto *RC = Ctx.getRawCommentForAnyRedecl(M)) | |||
3716 | return RC; | |||
3717 | if (auto *RC = Ctx.getRawCommentForAnyRedecl(PDecl)) | |||
3718 | return RC; | |||
3719 | } | |||
3720 | return nullptr; | |||
3721 | } | |||
3722 | ||||
3723 | const RawComment *clang::getParameterComment( | |||
3724 | const ASTContext &Ctx, | |||
3725 | const CodeCompleteConsumer::OverloadCandidate &Result, unsigned ArgIndex) { | |||
3726 | auto FDecl = Result.getFunction(); | |||
3727 | if (!FDecl) | |||
3728 | return nullptr; | |||
3729 | if (ArgIndex < FDecl->getNumParams()) | |||
3730 | return Ctx.getRawCommentForAnyRedecl(FDecl->getParamDecl(ArgIndex)); | |||
3731 | return nullptr; | |||
3732 | } | |||
3733 | ||||
3734 | static void AddOverloadAggregateChunks(const RecordDecl *RD, | |||
3735 | const PrintingPolicy &Policy, | |||
3736 | CodeCompletionBuilder &Result, | |||
3737 | unsigned CurrentArg) { | |||
3738 | unsigned ChunkIndex = 0; | |||
3739 | auto AddChunk = [&](llvm::StringRef Placeholder) { | |||
3740 | if (ChunkIndex > 0) | |||
3741 | Result.AddChunk(CodeCompletionString::CK_Comma); | |||
3742 | const char *Copy = Result.getAllocator().CopyString(Placeholder); | |||
3743 | if (ChunkIndex == CurrentArg) | |||
3744 | Result.AddCurrentParameterChunk(Copy); | |||
3745 | else | |||
3746 | Result.AddPlaceholderChunk(Copy); | |||
3747 | ++ChunkIndex; | |||
3748 | }; | |||
3749 | // Aggregate initialization has all bases followed by all fields. | |||
3750 | // (Bases are not legal in C++11 but in that case we never get here). | |||
3751 | if (auto *CRD = llvm::dyn_cast<CXXRecordDecl>(RD)) { | |||
3752 | for (const auto &Base : CRD->bases()) | |||
3753 | AddChunk(Base.getType().getAsString(Policy)); | |||
3754 | } | |||
3755 | for (const auto &Field : RD->fields()) | |||
3756 | AddChunk(FormatFunctionParameter(Policy, Field)); | |||
3757 | } | |||
3758 | ||||
3759 | /// Add function overload parameter chunks to the given code completion | |||
3760 | /// string. | |||
3761 | static void AddOverloadParameterChunks( | |||
3762 | ASTContext &Context, const PrintingPolicy &Policy, | |||
3763 | const FunctionDecl *Function, const FunctionProtoType *Prototype, | |||
3764 | FunctionProtoTypeLoc PrototypeLoc, CodeCompletionBuilder &Result, | |||
3765 | unsigned CurrentArg, unsigned Start = 0, bool InOptional = false) { | |||
3766 | if (!Function
| |||
3767 | Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "..."); | |||
3768 | return; | |||
3769 | } | |||
3770 | ||||
3771 | bool FirstParameter = true; | |||
3772 | unsigned NumParams = | |||
3773 | Function
| |||
3774 | ||||
3775 | for (unsigned P = Start; P != NumParams; ++P) { | |||
3776 | if (Function
| |||
3777 | // When we see an optional default argument, put that argument and | |||
3778 | // the remaining default arguments into a new, optional string. | |||
3779 | CodeCompletionBuilder Opt(Result.getAllocator(), | |||
3780 | Result.getCodeCompletionTUInfo()); | |||
3781 | if (!FirstParameter) | |||
3782 | Opt.AddChunk(CodeCompletionString::CK_Comma); | |||
3783 | // Optional sections are nested. | |||
3784 | AddOverloadParameterChunks(Context, Policy, Function, Prototype, | |||
3785 | PrototypeLoc, Opt, CurrentArg, P, | |||
3786 | /*InOptional=*/true); | |||
3787 | Result.AddOptionalChunk(Opt.TakeString()); | |||
3788 | return; | |||
3789 | } | |||
3790 | ||||
3791 | if (FirstParameter
| |||
3792 | FirstParameter = false; | |||
3793 | else | |||
3794 | Result.AddChunk(CodeCompletionString::CK_Comma); | |||
3795 | ||||
3796 | InOptional = false; | |||
3797 | ||||
3798 | // Format the placeholder string. | |||
3799 | std::string Placeholder; | |||
3800 | assert(P < Prototype->getNumParams())(static_cast <bool> (P < Prototype->getNumParams( )) ? void (0) : __assert_fail ("P < Prototype->getNumParams()" , "clang/lib/Sema/SemaCodeComplete.cpp", 3800, __extension__ __PRETTY_FUNCTION__ )); | |||
| ||||
3801 | if (Function || PrototypeLoc) { | |||
3802 | const ParmVarDecl *Param = | |||
3803 | Function ? Function->getParamDecl(P) : PrototypeLoc.getParam(P); | |||
3804 | Placeholder = FormatFunctionParameter(Policy, Param); | |||
3805 | if (Param->hasDefaultArg()) | |||
3806 | Placeholder += GetDefaultValueString(Param, Context.getSourceManager(), | |||
3807 | Context.getLangOpts()); | |||
3808 | } else { | |||
3809 | Placeholder = Prototype->getParamType(P).getAsString(Policy); | |||
3810 | } | |||
3811 | ||||
3812 | if (P == CurrentArg) | |||
3813 | Result.AddCurrentParameterChunk( | |||
3814 | Result.getAllocator().CopyString(Placeholder)); | |||
3815 | else | |||
3816 | Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Placeholder)); | |||
3817 | } | |||
3818 | ||||
3819 | if (Prototype && Prototype->isVariadic()) { | |||
3820 | CodeCompletionBuilder Opt(Result.getAllocator(), | |||
3821 | Result.getCodeCompletionTUInfo()); | |||
3822 | if (!FirstParameter) | |||
3823 | Opt.AddChunk(CodeCompletionString::CK_Comma); | |||
3824 | ||||
3825 | if (CurrentArg < NumParams) | |||
3826 | Opt.AddPlaceholderChunk("..."); | |||
3827 | else | |||
3828 | Opt.AddCurrentParameterChunk("..."); | |||
3829 | ||||
3830 | Result.AddOptionalChunk(Opt.TakeString()); | |||
3831 | } | |||
3832 | } | |||
3833 | ||||
3834 | static std::string | |||
3835 | formatTemplateParameterPlaceholder(const NamedDecl *Param, bool &Optional, | |||
3836 | const PrintingPolicy &Policy) { | |||
3837 | if (const auto *Type = dyn_cast<TemplateTypeParmDecl>(Param)) { | |||
3838 | Optional = Type->hasDefaultArgument(); | |||
3839 | } else if (const auto *NonType = dyn_cast<NonTypeTemplateParmDecl>(Param)) { | |||
3840 | Optional = NonType->hasDefaultArgument(); | |||
3841 | } else if (const auto *Template = dyn_cast<TemplateTemplateParmDecl>(Param)) { | |||
3842 | Optional = Template->hasDefaultArgument(); | |||
3843 | } | |||
3844 | std::string Result; | |||
3845 | llvm::raw_string_ostream OS(Result); | |||
3846 | Param->print(OS, Policy); | |||
3847 | return Result; | |||
3848 | } | |||
3849 | ||||
3850 | static std::string templateResultType(const TemplateDecl *TD, | |||
3851 | const PrintingPolicy &Policy) { | |||
3852 | if (const auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) | |||
3853 | return CTD->getTemplatedDecl()->getKindName().str(); | |||
3854 | if (const auto *VTD = dyn_cast<VarTemplateDecl>(TD)) | |||
3855 | return VTD->getTemplatedDecl()->getType().getAsString(Policy); | |||
3856 | if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(TD)) | |||
3857 | return FTD->getTemplatedDecl()->getReturnType().getAsString(Policy); | |||
3858 | if (isa<TypeAliasTemplateDecl>(TD)) | |||
3859 | return "type"; | |||
3860 | if (isa<TemplateTemplateParmDecl>(TD)) | |||
3861 | return "class"; | |||
3862 | if (isa<ConceptDecl>(TD)) | |||
3863 | return "concept"; | |||
3864 | return ""; | |||
3865 | } | |||
3866 | ||||
3867 | static CodeCompletionString *createTemplateSignatureString( | |||
3868 | const TemplateDecl *TD, CodeCompletionBuilder &Builder, unsigned CurrentArg, | |||
3869 | const PrintingPolicy &Policy) { | |||
3870 | llvm::ArrayRef<NamedDecl *> Params = TD->getTemplateParameters()->asArray(); | |||
3871 | CodeCompletionBuilder OptionalBuilder(Builder.getAllocator(), | |||
3872 | Builder.getCodeCompletionTUInfo()); | |||
3873 | std::string ResultType = templateResultType(TD, Policy); | |||
3874 | if (!ResultType.empty()) | |||
3875 | Builder.AddResultTypeChunk(Builder.getAllocator().CopyString(ResultType)); | |||
3876 | Builder.AddTextChunk( | |||
3877 | Builder.getAllocator().CopyString(TD->getNameAsString())); | |||
3878 | Builder.AddChunk(CodeCompletionString::CK_LeftAngle); | |||
3879 | // Initially we're writing into the main string. Once we see an optional arg | |||
3880 | // (with default), we're writing into the nested optional chunk. | |||
3881 | CodeCompletionBuilder *Current = &Builder; | |||
3882 | for (unsigned I = 0; I < Params.size(); ++I) { | |||
3883 | bool Optional = false; | |||
3884 | std::string Placeholder = | |||
3885 | formatTemplateParameterPlaceholder(Params[I], Optional, Policy); | |||
3886 | if (Optional) | |||
3887 | Current = &OptionalBuilder; | |||
3888 | if (I > 0) | |||
3889 | Current->AddChunk(CodeCompletionString::CK_Comma); | |||
3890 | Current->AddChunk(I == CurrentArg | |||
3891 | ? CodeCompletionString::CK_CurrentParameter | |||
3892 | : CodeCompletionString::CK_Placeholder, | |||
3893 | Current->getAllocator().CopyString(Placeholder)); | |||
3894 | } | |||
3895 | // Add the optional chunk to the main string if we ever used it. | |||
3896 | if (Current == &OptionalBuilder) | |||
3897 | Builder.AddOptionalChunk(OptionalBuilder.TakeString()); | |||
3898 | Builder.AddChunk(CodeCompletionString::CK_RightAngle); | |||
3899 | // For function templates, ResultType was the function's return type. | |||
3900 | // Give some clue this is a function. (Don't show the possibly-bulky params). | |||
3901 | if (isa<FunctionTemplateDecl>(TD)) | |||
3902 | Builder.AddInformativeChunk("()"); | |||
3903 | return Builder.TakeString(); | |||
3904 | } | |||
3905 | ||||
3906 | CodeCompletionString * | |||
3907 | CodeCompleteConsumer::OverloadCandidate::CreateSignatureString( | |||
3908 | unsigned CurrentArg, Sema &S, CodeCompletionAllocator &Allocator, | |||
3909 | CodeCompletionTUInfo &CCTUInfo, bool IncludeBriefComments, | |||
3910 | bool Braced) const { | |||
3911 | PrintingPolicy Policy = getCompletionPrintingPolicy(S); | |||
3912 | // Show signatures of constructors as they are declared: | |||
3913 | // vector(int n) rather than vector<string>(int n) | |||
3914 | // This is less noisy without being less clear, and avoids tricky cases. | |||
3915 | Policy.SuppressTemplateArgsInCXXConstructors = true; | |||
3916 | ||||
3917 | // FIXME: Set priority, availability appropriately. | |||
3918 | CodeCompletionBuilder Result(Allocator, CCTUInfo, 1, | |||
3919 | CXAvailability_Available); | |||
3920 | ||||
3921 | if (getKind() == CK_Template) | |||
| ||||
3922 | return createTemplateSignatureString(getTemplate(), Result, CurrentArg, | |||
3923 | Policy); | |||
3924 | ||||
3925 | FunctionDecl *FDecl = getFunction(); | |||
3926 | const FunctionProtoType *Proto = | |||
3927 | dyn_cast_or_null<FunctionProtoType>(getFunctionType()); | |||
3928 | ||||
3929 | // First, the name/type of the callee. | |||
3930 | if (getKind() == CK_Aggregate) { | |||
3931 | Result.AddTextChunk( | |||
3932 | Result.getAllocator().CopyString(getAggregate()->getName())); | |||
3933 | } else if (FDecl) { | |||
3934 | if (IncludeBriefComments) { | |||
3935 | if (auto RC = getParameterComment(S.getASTContext(), *this, CurrentArg)) | |||
3936 | Result.addBriefComment(RC->getBriefText(S.getASTContext())); | |||
3937 | } | |||
3938 | AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result); | |||
3939 | ||||
3940 | std::string Name; | |||
3941 | llvm::raw_string_ostream OS(Name); | |||
3942 | FDecl->getDeclName().print(OS, Policy); | |||
3943 | Result.AddTextChunk(Result.getAllocator().CopyString(OS.str())); | |||
3944 | } else { | |||
3945 | // Function without a declaration. Just give the return type. | |||
3946 | Result.AddResultTypeChunk(Result.getAllocator().CopyString( | |||
3947 | getFunctionType()->getReturnType().getAsString(Policy))); | |||
3948 | } | |||
3949 | ||||
3950 | // Next, the brackets and parameters. | |||
3951 | Result.AddChunk(Braced ? CodeCompletionString::CK_LeftBrace | |||
3952 | : CodeCompletionString::CK_LeftParen); | |||
3953 | if (getKind() == CK_Aggregate) | |||
3954 | AddOverloadAggregateChunks(getAggregate(), Policy, Result, CurrentArg); | |||
3955 | else | |||
3956 | AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, | |||
3957 | getFunctionProtoTypeLoc(), Result, CurrentArg); | |||
3958 | Result.AddChunk(Braced ? CodeCompletionString::CK_RightBrace | |||
3959 | : CodeCompletionString::CK_RightParen); | |||
3960 | ||||
3961 | return Result.TakeString(); | |||
3962 | } | |||
3963 | ||||
3964 | unsigned clang::getMacroUsagePriority(StringRef MacroName, | |||
3965 | const LangOptions &LangOpts, | |||
3966 | bool PreferredTypeIsPointer) { | |||
3967 | unsigned Priority = CCP_Macro; | |||
3968 | ||||
3969 | // Treat the "nil", "Nil" and "NULL" macros as null pointer constants. | |||
3970 | if (MacroName.equals("nil") || MacroName.equals("NULL") || | |||
3971 | MacroName.equals("Nil")) { | |||
3972 | Priority = CCP_Constant; | |||
3973 | if (PreferredTypeIsPointer) | |||
3974 | Priority = Priority / CCF_SimilarTypeMatch; | |||
3975 | } | |||
3976 | // Treat "YES", "NO", "true", and "false" as constants. | |||
3977 | else if (MacroName.equals("YES") || MacroName.equals("NO") || | |||
3978 | MacroName.equals("true") || MacroName.equals("false")) | |||
3979 | Priority = CCP_Constant; | |||
3980 | // Treat "bool" as a type. | |||
3981 | else if (MacroName.equals("bool")) | |||
3982 | Priority = CCP_Type + (LangOpts.ObjC ? CCD_bool_in_ObjC : 0); | |||
3983 | ||||
3984 | return Priority; | |||
3985 | } | |||
3986 | ||||
3987 | CXCursorKind clang::getCursorKindForDecl(const Decl *D) { | |||
3988 | if (!D) | |||
3989 | return CXCursor_UnexposedDecl; | |||
3990 | ||||
3991 | switch (D->getKind()) { | |||
3992 | case Decl::Enum: | |||
3993 | return CXCursor_EnumDecl; | |||
3994 | case Decl::EnumConstant: | |||
3995 | return CXCursor_EnumConstantDecl; | |||
3996 | case Decl::Field: | |||
3997 | return CXCursor_FieldDecl; | |||
3998 | case Decl::Function: | |||
3999 | return CXCursor_FunctionDecl; | |||
4000 | case Decl::ObjCCategory: | |||
4001 | return CXCursor_ObjCCategoryDecl; | |||
4002 | case Decl::ObjCCategoryImpl: | |||
4003 | return CXCursor_ObjCCategoryImplDecl; | |||
4004 | case Decl::ObjCImplementation: | |||
4005 | return CXCursor_ObjCImplementationDecl; | |||
4006 | ||||
4007 | case Decl::ObjCInterface: | |||
4008 | return CXCursor_ObjCInterfaceDecl; | |||
4009 | case Decl::ObjCIvar: | |||
4010 | return CXCursor_ObjCIvarDecl; | |||
4011 | case Decl::ObjCMethod: | |||
4012 | return cast<ObjCMethodDecl>(D)->isInstanceMethod() | |||
4013 | ? CXCursor_ObjCInstanceMethodDecl | |||
4014 | : CXCursor_ObjCClassMethodDecl; | |||
4015 | case Decl::CXXMethod: | |||
4016 | return CXCursor_CXXMethod; | |||
4017 | case Decl::CXXConstructor: | |||
4018 | return CXCursor_Constructor; | |||
4019 | case Decl::CXXDestructor: | |||
4020 | return CXCursor_Destructor; | |||
4021 | case Decl::CXXConversion: | |||
4022 | return CXCursor_ConversionFunction; | |||
4023 | case Decl::ObjCProperty: | |||
4024 | return CXCursor_ObjCPropertyDecl; | |||
4025 | case Decl::ObjCProtocol: | |||
4026 | return CXCursor_ObjCProtocolDecl; | |||
4027 | case Decl::ParmVar: | |||
4028 | return CXCursor_ParmDecl; | |||
4029 | case Decl::Typedef: | |||
4030 | return CXCursor_TypedefDecl; | |||
4031 | case Decl::TypeAlias: | |||
4032 | return CXCursor_TypeAliasDecl; | |||
4033 | case Decl::TypeAliasTemplate: | |||
4034 | return CXCursor_TypeAliasTemplateDecl; | |||
4035 | case Decl::Var: | |||
4036 | return CXCursor_VarDecl; | |||
4037 | case Decl::Namespace: | |||
4038 | return CXCursor_Namespace; | |||
4039 | case Decl::NamespaceAlias: | |||
4040 | return CXCursor_NamespaceAlias; | |||
4041 | case Decl::TemplateTypeParm: | |||
4042 | return CXCursor_TemplateTypeParameter; | |||
4043 | case Decl::NonTypeTemplateParm: | |||
4044 | return CXCursor_NonTypeTemplateParameter; | |||
4045 | case Decl::TemplateTemplateParm: | |||
4046 | return CXCursor_TemplateTemplateParameter; | |||
4047 | case Decl::FunctionTemplate: | |||
4048 | return CXCursor_FunctionTemplate; | |||
4049 | case Decl::ClassTemplate: | |||
4050 | return CXCursor_ClassTemplate; | |||
4051 | case Decl::AccessSpec: | |||
4052 | return CXCursor_CXXAccessSpecifier; | |||
4053 | case Decl::ClassTemplatePartialSpecialization: | |||
4054 | return CXCursor_ClassTemplatePartialSpecialization; | |||
4055 | case Decl::UsingDirective: | |||
4056 | return CXCursor_UsingDirective; | |||
4057 | case Decl::StaticAssert: | |||
4058 | return CXCursor_StaticAssert; | |||
4059 | case Decl::Friend: | |||
4060 | return CXCursor_FriendDecl; | |||
4061 | case Decl::TranslationUnit: | |||
4062 | return CXCursor_TranslationUnit; | |||
4063 | ||||
4064 | case Decl::Using: | |||
4065 | case Decl::UnresolvedUsingValue: | |||
4066 | case Decl::UnresolvedUsingTypename: | |||
4067 | return CXCursor_UsingDeclaration; | |||
4068 | ||||
4069 | case Decl::UsingEnum: | |||
4070 | return CXCursor_EnumDecl; | |||
4071 | ||||
4072 | case Decl::ObjCPropertyImpl: | |||
4073 | switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) { | |||
4074 | case ObjCPropertyImplDecl::Dynamic: | |||
4075 | return CXCursor_ObjCDynamicDecl; | |||
4076 | ||||
4077 | case ObjCPropertyImplDecl::Synthesize: | |||
4078 | return CXCursor_ObjCSynthesizeDecl; | |||
4079 | } | |||
4080 | llvm_unreachable("Unexpected Kind!")::llvm::llvm_unreachable_internal("Unexpected Kind!", "clang/lib/Sema/SemaCodeComplete.cpp" , 4080); | |||
4081 | ||||
4082 | case Decl::Import: | |||
4083 | return CXCursor_ModuleImportDecl; | |||
4084 | ||||
4085 | case Decl::ObjCTypeParam: | |||
4086 | return CXCursor_TemplateTypeParameter; | |||
4087 | ||||
4088 | case Decl::Concept: | |||
4089 | return CXCursor_ConceptDecl; | |||
4090 | ||||
4091 | default: | |||
4092 | if (const auto *TD = dyn_cast<TagDecl>(D)) { | |||
4093 | switch (TD->getTagKind()) { | |||
4094 | case TTK_Interface: // fall through | |||
4095 | case TTK_Struct: | |||
4096 | return CXCursor_StructDecl; | |||
4097 | case TTK_Class: | |||
4098 | return CXCursor_ClassDecl; | |||
4099 | case TTK_Union: | |||
4100 | return CXCursor_UnionDecl; | |||
4101 | case TTK_Enum: | |||
4102 | return CXCursor_EnumDecl; | |||
4103 | } | |||
4104 | } | |||
4105 | } | |||
4106 | ||||
4107 | return CXCursor_UnexposedDecl; | |||
4108 | } | |||
4109 | ||||
4110 | static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results, | |||
4111 | bool LoadExternal, bool IncludeUndefined, | |||
4112 | bool TargetTypeIsPointer = false) { | |||
4113 | typedef CodeCompletionResult Result; | |||
4114 | ||||
4115 | Results.EnterNewScope(); | |||
4116 | ||||
4117 | for (Preprocessor::macro_iterator M = PP.macro_begin(LoadExternal), | |||
4118 | MEnd = PP.macro_end(LoadExternal); | |||
4119 | M != MEnd; ++M) { | |||
4120 | auto MD = PP.getMacroDefinition(M->first); | |||
4121 | if (IncludeUndefined || MD) { | |||
4122 | MacroInfo *MI = MD.getMacroInfo(); | |||
4123 | if (MI && MI->isUsedForHeaderGuard()) | |||
4124 | continue; | |||
4125 | ||||
4126 | Results.AddResult( | |||
4127 | Result(M->first, MI, | |||
4128 | getMacroUsagePriority(M->first->getName(), PP.getLangOpts(), | |||
4129 | TargetTypeIsPointer))); | |||
4130 | } | |||
4131 | } | |||
4132 | ||||
4133 | Results.ExitScope(); | |||
4134 | } | |||
4135 | ||||
4136 | static void AddPrettyFunctionResults(const LangOptions &LangOpts, | |||
4137 | ResultBuilder &Results) { | |||
4138 | typedef CodeCompletionResult Result; | |||
4139 | ||||
4140 | Results.EnterNewScope(); | |||
4141 | ||||
4142 | Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant)); | |||
4143 | Results.AddResult(Result("__FUNCTION__", CCP_Constant)); | |||
4144 | if (LangOpts.C99 || LangOpts.CPlusPlus11) | |||
4145 | Results.AddResult(Result("__func__", CCP_Constant)); | |||
4146 | Results.ExitScope(); | |||
4147 | } | |||
4148 | ||||
4149 | static void HandleCodeCompleteResults(Sema *S, | |||
4150 | CodeCompleteConsumer *CodeCompleter, | |||
4151 | const CodeCompletionContext &Context, | |||
4152 | CodeCompletionResult *Results, | |||
4153 | unsigned NumResults) { | |||
4154 | if (CodeCompleter) | |||
4155 | CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults); | |||
4156 | } | |||
4157 | ||||
4158 | static CodeCompletionContext | |||
4159 | mapCodeCompletionContext(Sema &S, Sema::ParserCompletionContext PCC) { | |||
4160 | switch (PCC) { | |||
4161 | case Sema::PCC_Namespace: | |||
4162 | return CodeCompletionContext::CCC_TopLevel; | |||
4163 | ||||
4164 | case Sema::PCC_Class: | |||
4165 | return CodeCompletionContext::CCC_ClassStructUnion; | |||
4166 | ||||
4167 | case Sema::PCC_ObjCInterface: | |||
4168 | return CodeCompletionContext::CCC_ObjCInterface; | |||
4169 | ||||
4170 | case Sema::PCC_ObjCImplementation: | |||
4171 | return CodeCompletionContext::CCC_ObjCImplementation; | |||
4172 | ||||
4173 | case Sema::PCC_ObjCInstanceVariableList: | |||
4174 | return CodeCompletionContext::CCC_ObjCIvarList; | |||
4175 | ||||
4176 | case Sema::PCC_Template: | |||
4177 | case Sema::PCC_MemberTemplate: | |||
4178 | if (S.CurContext->isFileContext()) | |||
4179 | return CodeCompletionContext::CCC_TopLevel; | |||
4180 | if (S.CurContext->isRecord()) | |||
4181 | return CodeCompletionContext::CCC_ClassStructUnion; | |||
4182 | return CodeCompletionContext::CCC_Other; | |||
4183 | ||||
4184 | case Sema::PCC_RecoveryInFunction: | |||
4185 | return CodeCompletionContext::CCC_Recovery; | |||
4186 | ||||
4187 | case Sema::PCC_ForInit: | |||
4188 | if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 || | |||
4189 | S.getLangOpts().ObjC) | |||
4190 | return CodeCompletionContext::CCC_ParenthesizedExpression; | |||
4191 | else | |||
4192 | return CodeCompletionContext::CCC_Expression; | |||
4193 | ||||
4194 | case Sema::PCC_Expression: | |||
4195 | return CodeCompletionContext::CCC_Expression; | |||
4196 | case Sema::PCC_Condition: | |||
4197 | return CodeCompletionContext(CodeCompletionContext::CCC_Expression, | |||
4198 | S.getASTContext().BoolTy); | |||
4199 | ||||
4200 | case Sema::PCC_Statement: | |||
4201 | return CodeCompletionContext::CCC_Statement; | |||
4202 | ||||
4203 | case Sema::PCC_Type: | |||
4204 | return CodeCompletionContext::CCC_Type; | |||
4205 | ||||
4206 | case Sema::PCC_ParenthesizedExpression: | |||
4207 | return CodeCompletionContext::CCC_ParenthesizedExpression; | |||
4208 | ||||
4209 | case Sema::PCC_LocalDeclarationSpecifiers: | |||
4210 | return CodeCompletionContext::CCC_Type; | |||
4211 | } | |||
4212 | ||||
4213 | llvm_unreachable("Invalid ParserCompletionContext!")::llvm::llvm_unreachable_internal("Invalid ParserCompletionContext!" , "clang/lib/Sema/SemaCodeComplete.cpp", 4213); | |||
4214 | } | |||
4215 | ||||
4216 | /// If we're in a C++ virtual member function, add completion results | |||
4217 | /// that invoke the functions we override, since it's common to invoke the | |||
4218 | /// overridden function as well as adding new functionality. | |||
4219 | /// | |||
4220 | /// \param S The semantic analysis object for which we are generating results. | |||
4221 | /// | |||
4222 | /// \param InContext This context in which the nested-name-specifier preceding | |||
4223 | /// the code-completion point | |||
4224 | static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext, | |||
4225 | ResultBuilder &Results) { | |||
4226 | // Look through blocks. | |||
4227 | DeclContext *CurContext = S.CurContext; | |||
4228 | while (isa<BlockDecl>(CurContext)) | |||
4229 | CurContext = CurContext->getParent(); | |||
4230 | ||||
4231 | CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext); | |||
4232 | if (!Method || !Method->isVirtual()) | |||
4233 | return; | |||
4234 | ||||
4235 | // We need to have names for all of the parameters, if we're going to | |||
4236 | // generate a forwarding call. | |||
4237 | for (auto *P : Method->parameters()) | |||
4238 | if (!P->getDeclName()) | |||
4239 | return; | |||
4240 | ||||
4241 | PrintingPolicy Policy = getCompletionPrintingPolicy(S); | |||
4242 | for (const CXXMethodDecl *Overridden : Method->overridden_methods()) { | |||
4243 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
4244 | Results.getCodeCompletionTUInfo()); | |||
4245 | if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl()) | |||
4246 | continue; | |||
4247 | ||||
4248 | // If we need a nested-name-specifier, add one now. | |||
4249 | if (!InContext) { | |||
4250 | NestedNameSpecifier *NNS = getRequiredQualification( | |||
4251 | S.Context, CurContext, Overridden->getDeclContext()); | |||
4252 | if (NNS) { | |||
4253 | std::string Str; | |||
4254 | llvm::raw_string_ostream OS(Str); | |||
4255 | NNS->print(OS, Policy); | |||
4256 | Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str())); | |||
4257 | } | |||
4258 | } else if (!InContext->Equals(Overridden->getDeclContext())) | |||
4259 | continue; | |||
4260 | ||||
4261 | Builder.AddTypedTextChunk( | |||
4262 | Results.getAllocator().CopyString(Overridden->getNameAsString())); | |||
4263 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
4264 | bool FirstParam = true; | |||
4265 | for (auto *P : Method->parameters()) { | |||
4266 | if (FirstParam) | |||
4267 | FirstParam = false; | |||
4268 | else | |||
4269 | Builder.AddChunk(CodeCompletionString::CK_Comma); | |||
4270 | ||||
4271 | Builder.AddPlaceholderChunk( | |||
4272 | Results.getAllocator().CopyString(P->getIdentifier()->getName())); | |||
4273 | } | |||
4274 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
4275 | Results.AddResult(CodeCompletionResult( | |||
4276 | Builder.TakeString(), CCP_SuperCompletion, CXCursor_CXXMethod, | |||
4277 | CXAvailability_Available, Overridden)); | |||
4278 | Results.Ignore(Overridden); | |||
4279 | } | |||
4280 | } | |||
4281 | ||||
4282 | void Sema::CodeCompleteModuleImport(SourceLocation ImportLoc, | |||
4283 | ModuleIdPath Path) { | |||
4284 | typedef CodeCompletionResult Result; | |||
4285 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
4286 | CodeCompleter->getCodeCompletionTUInfo(), | |||
4287 | CodeCompletionContext::CCC_Other); | |||
4288 | Results.EnterNewScope(); | |||
4289 | ||||
4290 | CodeCompletionAllocator &Allocator = Results.getAllocator(); | |||
4291 | CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo()); | |||
4292 | typedef CodeCompletionResult Result; | |||
4293 | if (Path.empty()) { | |||
4294 | // Enumerate all top-level modules. | |||
4295 | SmallVector<Module *, 8> Modules; | |||
4296 | PP.getHeaderSearchInfo().collectAllModules(Modules); | |||
4297 | for (unsigned I = 0, N = Modules.size(); I != N; ++I) { | |||
4298 | Builder.AddTypedTextChunk( | |||
4299 | Builder.getAllocator().CopyString(Modules[I]->Name)); | |||
4300 | Results.AddResult(Result( | |||
4301 | Builder.TakeString(), CCP_Declaration, CXCursor_ModuleImportDecl, | |||
4302 | Modules[I]->isAvailable() ? CXAvailability_Available | |||
4303 | : CXAvailability_NotAvailable)); | |||
4304 | } | |||
4305 | } else if (getLangOpts().Modules) { | |||
4306 | // Load the named module. | |||
4307 | Module *Mod = | |||
4308 | PP.getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible, | |||
4309 | /*IsInclusionDirective=*/false); | |||
4310 | // Enumerate submodules. | |||
4311 | if (Mod) { | |||
4312 | for (auto *Submodule : Mod->submodules()) { | |||
4313 | Builder.AddTypedTextChunk( | |||
4314 | Builder.getAllocator().CopyString(Submodule->Name)); | |||
4315 | Results.AddResult(Result( | |||
4316 | Builder.TakeString(), CCP_Declaration, CXCursor_ModuleImportDecl, | |||
4317 | Submodule->isAvailable() ? CXAvailability_Available | |||
4318 | : CXAvailability_NotAvailable)); | |||
4319 | } | |||
4320 | } | |||
4321 | } | |||
4322 | Results.ExitScope(); | |||
4323 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
4324 | Results.data(), Results.size()); | |||
4325 | } | |||
4326 | ||||
4327 | void Sema::CodeCompleteOrdinaryName(Scope *S, | |||
4328 | ParserCompletionContext CompletionContext) { | |||
4329 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
4330 | CodeCompleter->getCodeCompletionTUInfo(), | |||
4331 | mapCodeCompletionContext(*this, CompletionContext)); | |||
4332 | Results.EnterNewScope(); | |||
4333 | ||||
4334 | // Determine how to filter results, e.g., so that the names of | |||
4335 | // values (functions, enumerators, function templates, etc.) are | |||
4336 | // only allowed where we can have an expression. | |||
4337 | switch (CompletionContext) { | |||
4338 | case PCC_Namespace: | |||
4339 | case PCC_Class: | |||
4340 | case PCC_ObjCInterface: | |||
4341 | case PCC_ObjCImplementation: | |||
4342 | case PCC_ObjCInstanceVariableList: | |||
4343 | case PCC_Template: | |||
4344 | case PCC_MemberTemplate: | |||
4345 | case PCC_Type: | |||
4346 | case PCC_LocalDeclarationSpecifiers: | |||
4347 | Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName); | |||
4348 | break; | |||
4349 | ||||
4350 | case PCC_Statement: | |||
4351 | case PCC_ParenthesizedExpression: | |||
4352 | case PCC_Expression: | |||
4353 | case PCC_ForInit: | |||
4354 | case PCC_Condition: | |||
4355 | if (WantTypesInContext(CompletionContext, getLangOpts())) | |||
4356 | Results.setFilter(&ResultBuilder::IsOrdinaryName); | |||
4357 | else | |||
4358 | Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName); | |||
4359 | ||||
4360 | if (getLangOpts().CPlusPlus) | |||
4361 | MaybeAddOverrideCalls(*this, /*InContext=*/nullptr, Results); | |||
4362 | break; | |||
4363 | ||||
4364 | case PCC_RecoveryInFunction: | |||
4365 | // Unfiltered | |||
4366 | break; | |||
4367 | } | |||
4368 | ||||
4369 | // If we are in a C++ non-static member function, check the qualifiers on | |||
4370 | // the member function to filter/prioritize the results list. | |||
4371 | auto ThisType = getCurrentThisType(); | |||
4372 | if (!ThisType.isNull()) | |||
4373 | Results.setObjectTypeQualifiers(ThisType->getPointeeType().getQualifiers(), | |||
4374 | VK_LValue); | |||
4375 | ||||
4376 | CodeCompletionDeclConsumer Consumer(Results, CurContext); | |||
4377 | LookupVisibleDecls(S, LookupOrdinaryName, Consumer, | |||
4378 | CodeCompleter->includeGlobals(), | |||
4379 | CodeCompleter->loadExternal()); | |||
4380 | ||||
4381 | AddOrdinaryNameResults(CompletionContext, S, *this, Results); | |||
4382 | Results.ExitScope(); | |||
4383 | ||||
4384 | switch (CompletionContext) { | |||
4385 | case PCC_ParenthesizedExpression: | |||
4386 | case PCC_Expression: | |||
4387 | case PCC_Statement: | |||
4388 | case PCC_RecoveryInFunction: | |||
4389 | if (S->getFnParent()) | |||
4390 | AddPrettyFunctionResults(getLangOpts(), Results); | |||
4391 | break; | |||
4392 | ||||
4393 | case PCC_Namespace: | |||
4394 | case PCC_Class: | |||
4395 | case PCC_ObjCInterface: | |||
4396 | case PCC_ObjCImplementation: | |||
4397 | case PCC_ObjCInstanceVariableList: | |||
4398 | case PCC_Template: | |||
4399 | case PCC_MemberTemplate: | |||
4400 | case PCC_ForInit: | |||
4401 | case PCC_Condition: | |||
4402 | case PCC_Type: | |||
4403 | case PCC_LocalDeclarationSpecifiers: | |||
4404 | break; | |||
4405 | } | |||
4406 | ||||
4407 | if (CodeCompleter->includeMacros()) | |||
4408 | AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false); | |||
4409 | ||||
4410 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
4411 | Results.data(), Results.size()); | |||
4412 | } | |||
4413 | ||||
4414 | static void AddClassMessageCompletions(Sema &SemaRef, Scope *S, | |||
4415 | ParsedType Receiver, | |||
4416 | ArrayRef<IdentifierInfo *> SelIdents, | |||
4417 | bool AtArgumentExpression, bool IsSuper, | |||
4418 | ResultBuilder &Results); | |||
4419 | ||||
4420 | void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS, | |||
4421 | bool AllowNonIdentifiers, | |||
4422 | bool AllowNestedNameSpecifiers) { | |||
4423 | typedef CodeCompletionResult Result; | |||
4424 | ResultBuilder Results( | |||
4425 | *this, CodeCompleter->getAllocator(), | |||
4426 | CodeCompleter->getCodeCompletionTUInfo(), | |||
4427 | AllowNestedNameSpecifiers | |||
4428 | // FIXME: Try to separate codepath leading here to deduce whether we | |||
4429 | // need an existing symbol or a new one. | |||
4430 | ? CodeCompletionContext::CCC_SymbolOrNewName | |||
4431 | : CodeCompletionContext::CCC_NewName); | |||
4432 | Results.EnterNewScope(); | |||
4433 | ||||
4434 | // Type qualifiers can come after names. | |||
4435 | Results.AddResult(Result("const")); | |||
4436 | Results.AddResult(Result("volatile")); | |||
4437 | if (getLangOpts().C99) | |||
4438 | Results.AddResult(Result("restrict")); | |||
4439 | ||||
4440 | if (getLangOpts().CPlusPlus) { | |||
4441 | if (getLangOpts().CPlusPlus11 && | |||
4442 | (DS.getTypeSpecType() == DeclSpec::TST_class || | |||
4443 | DS.getTypeSpecType() == DeclSpec::TST_struct)) | |||
4444 | Results.AddResult("final"); | |||
4445 | ||||
4446 | if (AllowNonIdentifiers) { | |||
4447 | Results.AddResult(Result("operator")); | |||
4448 | } | |||
4449 | ||||
4450 | // Add nested-name-specifiers. | |||
4451 | if (AllowNestedNameSpecifiers) { | |||
4452 | Results.allowNestedNameSpecifiers(); | |||
4453 | Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy); | |||
4454 | CodeCompletionDeclConsumer Consumer(Results, CurContext); | |||
4455 | LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer, | |||
4456 | CodeCompleter->includeGlobals(), | |||
4457 | CodeCompleter->loadExternal()); | |||
4458 | Results.setFilter(nullptr); | |||
4459 | } | |||
4460 | } | |||
4461 | Results.ExitScope(); | |||
4462 | ||||
4463 | // If we're in a context where we might have an expression (rather than a | |||
4464 | // declaration), and what we've seen so far is an Objective-C type that could | |||
4465 | // be a receiver of a class message, this may be a class message send with | |||
4466 | // the initial opening bracket '[' missing. Add appropriate completions. | |||
4467 | if (AllowNonIdentifiers && !AllowNestedNameSpecifiers && | |||
4468 | DS.getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier && | |||
4469 | DS.getTypeSpecType() == DeclSpec::TST_typename && | |||
4470 | DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified && | |||
4471 | DS.getTypeSpecSign() == TypeSpecifierSign::Unspecified && | |||
4472 | !DS.isTypeAltiVecVector() && S && | |||
4473 | (S->getFlags() & Scope::DeclScope) != 0 && | |||
4474 | (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope | | |||
4475 | Scope::FunctionPrototypeScope | Scope::AtCatchScope)) == | |||
4476 | 0) { | |||
4477 | ParsedType T = DS.getRepAsType(); | |||
4478 | if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType()) | |||
4479 | AddClassMessageCompletions(*this, S, T, std::nullopt, false, false, | |||
4480 | Results); | |||
4481 | } | |||
4482 | ||||
4483 | // Note that we intentionally suppress macro results here, since we do not | |||
4484 | // encourage using macros to produce the names of entities. | |||
4485 | ||||
4486 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
4487 | Results.data(), Results.size()); | |||
4488 | } | |||
4489 | ||||
4490 | static const char *underscoreAttrScope(llvm::StringRef Scope) { | |||
4491 | if (Scope == "clang") | |||
4492 | return "_Clang"; | |||
4493 | if (Scope == "gnu") | |||
4494 | return "__gnu__"; | |||
4495 | return nullptr; | |||
4496 | } | |||
4497 | ||||
4498 | static const char *noUnderscoreAttrScope(llvm::StringRef Scope) { | |||
4499 | if (Scope == "_Clang") | |||
4500 | return "clang"; | |||
4501 | if (Scope == "__gnu__") | |||
4502 | return "gnu"; | |||
4503 | return nullptr; | |||
4504 | } | |||
4505 | ||||
4506 | void Sema::CodeCompleteAttribute(AttributeCommonInfo::Syntax Syntax, | |||
4507 | AttributeCompletion Completion, | |||
4508 | const IdentifierInfo *InScope) { | |||
4509 | if (Completion == AttributeCompletion::None) | |||
4510 | return; | |||
4511 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
4512 | CodeCompleter->getCodeCompletionTUInfo(), | |||
4513 | CodeCompletionContext::CCC_Attribute); | |||
4514 | ||||
4515 | // We're going to iterate over the normalized spellings of the attribute. | |||
4516 | // These don't include "underscore guarding": the normalized spelling is | |||
4517 | // clang::foo but you can also write _Clang::__foo__. | |||
4518 | // | |||
4519 | // (Clang supports a mix like clang::__foo__ but we won't suggest it: either | |||
4520 | // you care about clashing with macros or you don't). | |||
4521 | // | |||
4522 | // So if we're already in a scope, we determine its canonical spellings | |||
4523 | // (for comparison with normalized attr spelling) and remember whether it was | |||
4524 | // underscore-guarded (so we know how to spell contained attributes). | |||
4525 | llvm::StringRef InScopeName; | |||
4526 | bool InScopeUnderscore = false; | |||
4527 | if (InScope) { | |||
4528 | InScopeName = InScope->getName(); | |||
4529 | if (const char *NoUnderscore = noUnderscoreAttrScope(InScopeName)) { | |||
4530 | InScopeName = NoUnderscore; | |||
4531 | InScopeUnderscore = true; | |||
4532 | } | |||
4533 | } | |||
4534 | bool SyntaxSupportsGuards = Syntax == AttributeCommonInfo::AS_GNU || | |||
4535 | Syntax == AttributeCommonInfo::AS_CXX11 || | |||
4536 | Syntax == AttributeCommonInfo::AS_C2x; | |||
4537 | ||||
4538 | llvm::DenseSet<llvm::StringRef> FoundScopes; | |||
4539 | auto AddCompletions = [&](const ParsedAttrInfo &A) { | |||
4540 | if (A.IsTargetSpecific && !A.existsInTarget(Context.getTargetInfo())) | |||
4541 | return; | |||
4542 | if (!A.acceptsLangOpts(getLangOpts())) | |||
4543 | return; | |||
4544 | for (const auto &S : A.Spellings) { | |||
4545 | if (S.Syntax != Syntax) | |||
4546 | continue; | |||
4547 | llvm::StringRef Name = S.NormalizedFullName; | |||
4548 | llvm::StringRef Scope; | |||
4549 | if ((Syntax == AttributeCommonInfo::AS_CXX11 || | |||
4550 | Syntax == AttributeCommonInfo::AS_C2x)) { | |||
4551 | std::tie(Scope, Name) = Name.split("::"); | |||
4552 | if (Name.empty()) // oops, unscoped | |||
4553 | std::swap(Name, Scope); | |||
4554 | } | |||
4555 | ||||
4556 | // Do we just want a list of scopes rather than attributes? | |||
4557 | if (Completion == AttributeCompletion::Scope) { | |||
4558 | // Make sure to emit each scope only once. | |||
4559 | if (!Scope.empty() && FoundScopes.insert(Scope).second) { | |||
4560 | Results.AddResult( | |||
4561 | CodeCompletionResult(Results.getAllocator().CopyString(Scope))); | |||
4562 | // Include alternate form (__gnu__ instead of gnu). | |||
4563 | if (const char *Scope2 = underscoreAttrScope(Scope)) | |||
4564 | Results.AddResult(CodeCompletionResult(Scope2)); | |||
4565 | } | |||
4566 | continue; | |||
4567 | } | |||
4568 | ||||
4569 | // If a scope was specified, it must match but we don't need to print it. | |||
4570 | if (!InScopeName.empty()) { | |||
4571 | if (Scope != InScopeName) | |||
4572 | continue; | |||
4573 | Scope = ""; | |||
4574 | } | |||
4575 | ||||
4576 | auto Add = [&](llvm::StringRef Scope, llvm::StringRef Name, | |||
4577 | bool Underscores) { | |||
4578 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
4579 | Results.getCodeCompletionTUInfo()); | |||
4580 | llvm::SmallString<32> Text; | |||
4581 | if (!Scope.empty()) { | |||
4582 | Text.append(Scope); | |||
4583 | Text.append("::"); | |||
4584 | } | |||
4585 | if (Underscores) | |||
4586 | Text.append("__"); | |||
4587 | Text.append(Name); | |||
4588 | if (Underscores) | |||
4589 | Text.append("__"); | |||
4590 | Builder.AddTypedTextChunk(Results.getAllocator().CopyString(Text)); | |||
4591 | ||||
4592 | if (!A.ArgNames.empty()) { | |||
4593 | Builder.AddChunk(CodeCompletionString::CK_LeftParen, "("); | |||
4594 | bool First = true; | |||
4595 | for (const char *Arg : A.ArgNames) { | |||
4596 | if (!First) | |||
4597 | Builder.AddChunk(CodeCompletionString::CK_Comma, ", "); | |||
4598 | First = false; | |||
4599 | Builder.AddPlaceholderChunk(Arg); | |||
4600 | } | |||
4601 | Builder.AddChunk(CodeCompletionString::CK_RightParen, ")"); | |||
4602 | } | |||
4603 | ||||
4604 | Results.AddResult(Builder.TakeString()); | |||
4605 | }; | |||
4606 | ||||
4607 | // Generate the non-underscore-guarded result. | |||
4608 | // Note this is (a suffix of) the NormalizedFullName, no need to copy. | |||
4609 | // If an underscore-guarded scope was specified, only the | |||
4610 | // underscore-guarded attribute name is relevant. | |||
4611 | if (!InScopeUnderscore) | |||
4612 | Add(Scope, Name, /*Underscores=*/false); | |||
4613 | ||||
4614 | // Generate the underscore-guarded version, for syntaxes that support it. | |||
4615 | // We skip this if the scope was already spelled and not guarded, or | |||
4616 | // we must spell it and can't guard it. | |||
4617 | if (!(InScope && !InScopeUnderscore) && SyntaxSupportsGuards) { | |||
4618 | llvm::SmallString<32> Guarded; | |||
4619 | if (Scope.empty()) { | |||
4620 | Add(Scope, Name, /*Underscores=*/true); | |||
4621 | } else { | |||
4622 | const char *GuardedScope = underscoreAttrScope(Scope); | |||
4623 | if (!GuardedScope) | |||
4624 | continue; | |||
4625 | Add(GuardedScope, Name, /*Underscores=*/true); | |||
4626 | } | |||
4627 | } | |||
4628 | ||||
4629 | // It may be nice to include the Kind so we can look up the docs later. | |||
4630 | } | |||
4631 | }; | |||
4632 | ||||
4633 | for (const auto *A : ParsedAttrInfo::getAllBuiltin()) | |||
4634 | AddCompletions(*A); | |||
4635 | for (const auto &Entry : ParsedAttrInfoRegistry::entries()) | |||
4636 | AddCompletions(*Entry.instantiate()); | |||
4637 | ||||
4638 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
4639 | Results.data(), Results.size()); | |||
4640 | } | |||
4641 | ||||
4642 | struct Sema::CodeCompleteExpressionData { | |||
4643 | CodeCompleteExpressionData(QualType PreferredType = QualType(), | |||
4644 | bool IsParenthesized = false) | |||
4645 | : PreferredType(PreferredType), IntegralConstantExpression(false), | |||
4646 | ObjCCollection(false), IsParenthesized(IsParenthesized) {} | |||
4647 | ||||
4648 | QualType PreferredType; | |||
4649 | bool IntegralConstantExpression; | |||
4650 | bool ObjCCollection; | |||
4651 | bool IsParenthesized; | |||
4652 | SmallVector<Decl *, 4> IgnoreDecls; | |||
4653 | }; | |||
4654 | ||||
4655 | namespace { | |||
4656 | /// Information that allows to avoid completing redundant enumerators. | |||
4657 | struct CoveredEnumerators { | |||
4658 | llvm::SmallPtrSet<EnumConstantDecl *, 8> Seen; | |||
4659 | NestedNameSpecifier *SuggestedQualifier = nullptr; | |||
4660 | }; | |||
4661 | } // namespace | |||
4662 | ||||
4663 | static void AddEnumerators(ResultBuilder &Results, ASTContext &Context, | |||
4664 | EnumDecl *Enum, DeclContext *CurContext, | |||
4665 | const CoveredEnumerators &Enumerators) { | |||
4666 | NestedNameSpecifier *Qualifier = Enumerators.SuggestedQualifier; | |||
4667 | if (Context.getLangOpts().CPlusPlus && !Qualifier && Enumerators.Seen.empty()) { | |||
4668 | // If there are no prior enumerators in C++, check whether we have to | |||
4669 | // qualify the names of the enumerators that we suggest, because they | |||
4670 | // may not be visible in this scope. | |||
4671 | Qualifier = getRequiredQualification(Context, CurContext, Enum); | |||
4672 | } | |||
4673 | ||||
4674 | Results.EnterNewScope(); | |||
4675 | for (auto *E : Enum->enumerators()) { | |||
4676 | if (Enumerators.Seen.count(E)) | |||
4677 | continue; | |||
4678 | ||||
4679 | CodeCompletionResult R(E, CCP_EnumInCase, Qualifier); | |||
4680 | Results.AddResult(R, CurContext, nullptr, false); | |||
4681 | } | |||
4682 | Results.ExitScope(); | |||
4683 | } | |||
4684 | ||||
4685 | /// Try to find a corresponding FunctionProtoType for function-like types (e.g. | |||
4686 | /// function pointers, std::function, etc). | |||
4687 | static const FunctionProtoType *TryDeconstructFunctionLike(QualType T) { | |||
4688 | assert(!T.isNull())(static_cast <bool> (!T.isNull()) ? void (0) : __assert_fail ("!T.isNull()", "clang/lib/Sema/SemaCodeComplete.cpp", 4688, __extension__ __PRETTY_FUNCTION__)); | |||
4689 | // Try to extract first template argument from std::function<> and similar. | |||
4690 | // Note we only handle the sugared types, they closely match what users wrote. | |||
4691 | // We explicitly choose to not handle ClassTemplateSpecializationDecl. | |||
4692 | if (auto *Specialization = T->getAs<TemplateSpecializationType>()) { | |||
4693 | if (Specialization->template_arguments().size() != 1) | |||
4694 | return nullptr; | |||
4695 | const TemplateArgument &Argument = Specialization->template_arguments()[0]; | |||
4696 | if (Argument.getKind() != TemplateArgument::Type) | |||
4697 | return nullptr; | |||
4698 | return Argument.getAsType()->getAs<FunctionProtoType>(); | |||
4699 | } | |||
4700 | // Handle other cases. | |||
4701 | if (T->isPointerType()) | |||
4702 | T = T->getPointeeType(); | |||
4703 | return T->getAs<FunctionProtoType>(); | |||
4704 | } | |||
4705 | ||||
4706 | /// Adds a pattern completion for a lambda expression with the specified | |||
4707 | /// parameter types and placeholders for parameter names. | |||
4708 | static void AddLambdaCompletion(ResultBuilder &Results, | |||
4709 | llvm::ArrayRef<QualType> Parameters, | |||
4710 | const LangOptions &LangOpts) { | |||
4711 | if (!Results.includeCodePatterns()) | |||
4712 | return; | |||
4713 | CodeCompletionBuilder Completion(Results.getAllocator(), | |||
4714 | Results.getCodeCompletionTUInfo()); | |||
4715 | // [](<parameters>) {} | |||
4716 | Completion.AddChunk(CodeCompletionString::CK_LeftBracket); | |||
4717 | Completion.AddPlaceholderChunk("="); | |||
4718 | Completion.AddChunk(CodeCompletionString::CK_RightBracket); | |||
4719 | if (!Parameters.empty()) { | |||
4720 | Completion.AddChunk(CodeCompletionString::CK_LeftParen); | |||
4721 | bool First = true; | |||
4722 | for (auto Parameter : Parameters) { | |||
4723 | if (!First) | |||
4724 | Completion.AddChunk(CodeCompletionString::ChunkKind::CK_Comma); | |||
4725 | else | |||
4726 | First = false; | |||
4727 | ||||
4728 | constexpr llvm::StringLiteral NamePlaceholder = "!#!NAME_GOES_HERE!#!"; | |||
4729 | std::string Type = std::string(NamePlaceholder); | |||
4730 | Parameter.getAsStringInternal(Type, PrintingPolicy(LangOpts)); | |||
4731 | llvm::StringRef Prefix, Suffix; | |||
4732 | std::tie(Prefix, Suffix) = llvm::StringRef(Type).split(NamePlaceholder); | |||
4733 | Prefix = Prefix.rtrim(); | |||
4734 | Suffix = Suffix.ltrim(); | |||
4735 | ||||
4736 | Completion.AddTextChunk(Completion.getAllocator().CopyString(Prefix)); | |||
4737 | Completion.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
4738 | Completion.AddPlaceholderChunk("parameter"); | |||
4739 | Completion.AddTextChunk(Completion.getAllocator().CopyString(Suffix)); | |||
4740 | }; | |||
4741 | Completion.AddChunk(CodeCompletionString::CK_RightParen); | |||
4742 | } | |||
4743 | Completion.AddChunk(clang::CodeCompletionString::CK_HorizontalSpace); | |||
4744 | Completion.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
4745 | Completion.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
4746 | Completion.AddPlaceholderChunk("body"); | |||
4747 | Completion.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
4748 | Completion.AddChunk(CodeCompletionString::CK_RightBrace); | |||
4749 | ||||
4750 | Results.AddResult(Completion.TakeString()); | |||
4751 | } | |||
4752 | ||||
4753 | /// Perform code-completion in an expression context when we know what | |||
4754 | /// type we're looking for. | |||
4755 | void Sema::CodeCompleteExpression(Scope *S, | |||
4756 | const CodeCompleteExpressionData &Data) { | |||
4757 | ResultBuilder Results( | |||
4758 | *this, CodeCompleter->getAllocator(), | |||
4759 | CodeCompleter->getCodeCompletionTUInfo(), | |||
4760 | CodeCompletionContext( | |||
4761 | Data.IsParenthesized | |||
4762 | ? CodeCompletionContext::CCC_ParenthesizedExpression | |||
4763 | : CodeCompletionContext::CCC_Expression, | |||
4764 | Data.PreferredType)); | |||
4765 | auto PCC = | |||
4766 | Data.IsParenthesized ? PCC_ParenthesizedExpression : PCC_Expression; | |||
4767 | if (Data.ObjCCollection) | |||
4768 | Results.setFilter(&ResultBuilder::IsObjCCollection); | |||
4769 | else if (Data.IntegralConstantExpression) | |||
4770 | Results.setFilter(&ResultBuilder::IsIntegralConstantValue); | |||
4771 | else if (WantTypesInContext(PCC, getLangOpts())) | |||
4772 | Results.setFilter(&ResultBuilder::IsOrdinaryName); | |||
4773 | else | |||
4774 | Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName); | |||
4775 | ||||
4776 | if (!Data.PreferredType.isNull()) | |||
4777 | Results.setPreferredType(Data.PreferredType.getNonReferenceType()); | |||
4778 | ||||
4779 | // Ignore any declarations that we were told that we don't care about. | |||
4780 | for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I) | |||
4781 | Results.Ignore(Data.IgnoreDecls[I]); | |||
4782 | ||||
4783 | CodeCompletionDeclConsumer Consumer(Results, CurContext); | |||
4784 | LookupVisibleDecls(S, LookupOrdinaryName, Consumer, | |||
4785 | CodeCompleter->includeGlobals(), | |||
4786 | CodeCompleter->loadExternal()); | |||
4787 | ||||
4788 | Results.EnterNewScope(); | |||
4789 | AddOrdinaryNameResults(PCC, S, *this, Results); | |||
4790 | Results.ExitScope(); | |||
4791 | ||||
4792 | bool PreferredTypeIsPointer = false; | |||
4793 | if (!Data.PreferredType.isNull()) { | |||
4794 | PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType() || | |||
4795 | Data.PreferredType->isMemberPointerType() || | |||
4796 | Data.PreferredType->isBlockPointerType(); | |||
4797 | if (Data.PreferredType->isEnumeralType()) { | |||
4798 | EnumDecl *Enum = Data.PreferredType->castAs<EnumType>()->getDecl(); | |||
4799 | if (auto *Def = Enum->getDefinition()) | |||
4800 | Enum = Def; | |||
4801 | // FIXME: collect covered enumerators in cases like: | |||
4802 | // if (x == my_enum::one) { ... } else if (x == ^) {} | |||
4803 | AddEnumerators(Results, Context, Enum, CurContext, CoveredEnumerators()); | |||
4804 | } | |||
4805 | } | |||
4806 | ||||
4807 | if (S->getFnParent() && !Data.ObjCCollection && | |||
4808 | !Data.IntegralConstantExpression) | |||
4809 | AddPrettyFunctionResults(getLangOpts(), Results); | |||
4810 | ||||
4811 | if (CodeCompleter->includeMacros()) | |||
4812 | AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false, | |||
4813 | PreferredTypeIsPointer); | |||
4814 | ||||
4815 | // Complete a lambda expression when preferred type is a function. | |||
4816 | if (!Data.PreferredType.isNull() && getLangOpts().CPlusPlus11) { | |||
4817 | if (const FunctionProtoType *F = | |||
4818 | TryDeconstructFunctionLike(Data.PreferredType)) | |||
4819 | AddLambdaCompletion(Results, F->getParamTypes(), getLangOpts()); | |||
4820 | } | |||
4821 | ||||
4822 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
4823 | Results.data(), Results.size()); | |||
4824 | } | |||
4825 | ||||
4826 | void Sema::CodeCompleteExpression(Scope *S, QualType PreferredType, | |||
4827 | bool IsParenthesized) { | |||
4828 | return CodeCompleteExpression( | |||
4829 | S, CodeCompleteExpressionData(PreferredType, IsParenthesized)); | |||
4830 | } | |||
4831 | ||||
4832 | void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E, | |||
4833 | QualType PreferredType) { | |||
4834 | if (E.isInvalid()) | |||
4835 | CodeCompleteExpression(S, PreferredType); | |||
4836 | else if (getLangOpts().ObjC) | |||
4837 | CodeCompleteObjCInstanceMessage(S, E.get(), std::nullopt, false); | |||
4838 | } | |||
4839 | ||||
4840 | /// The set of properties that have already been added, referenced by | |||
4841 | /// property name. | |||
4842 | typedef llvm::SmallPtrSet<IdentifierInfo *, 16> AddedPropertiesSet; | |||
4843 | ||||
4844 | /// Retrieve the container definition, if any? | |||
4845 | static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) { | |||
4846 | if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) { | |||
4847 | if (Interface->hasDefinition()) | |||
4848 | return Interface->getDefinition(); | |||
4849 | ||||
4850 | return Interface; | |||
4851 | } | |||
4852 | ||||
4853 | if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { | |||
4854 | if (Protocol->hasDefinition()) | |||
4855 | return Protocol->getDefinition(); | |||
4856 | ||||
4857 | return Protocol; | |||
4858 | } | |||
4859 | return Container; | |||
4860 | } | |||
4861 | ||||
4862 | /// Adds a block invocation code completion result for the given block | |||
4863 | /// declaration \p BD. | |||
4864 | static void AddObjCBlockCall(ASTContext &Context, const PrintingPolicy &Policy, | |||
4865 | CodeCompletionBuilder &Builder, | |||
4866 | const NamedDecl *BD, | |||
4867 | const FunctionTypeLoc &BlockLoc, | |||
4868 | const FunctionProtoTypeLoc &BlockProtoLoc) { | |||
4869 | Builder.AddResultTypeChunk( | |||
4870 | GetCompletionTypeString(BlockLoc.getReturnLoc().getType(), Context, | |||
4871 | Policy, Builder.getAllocator())); | |||
4872 | ||||
4873 | AddTypedNameChunk(Context, Policy, BD, Builder); | |||
4874 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
4875 | ||||
4876 | if (BlockProtoLoc && BlockProtoLoc.getTypePtr()->isVariadic()) { | |||
4877 | Builder.AddPlaceholderChunk("..."); | |||
4878 | } else { | |||
4879 | for (unsigned I = 0, N = BlockLoc.getNumParams(); I != N; ++I) { | |||
4880 | if (I) | |||
4881 | Builder.AddChunk(CodeCompletionString::CK_Comma); | |||
4882 | ||||
4883 | // Format the placeholder string. | |||
4884 | std::string PlaceholderStr = | |||
4885 | FormatFunctionParameter(Policy, BlockLoc.getParam(I)); | |||
4886 | ||||
4887 | if (I == N - 1 && BlockProtoLoc && | |||
4888 | BlockProtoLoc.getTypePtr()->isVariadic()) | |||
4889 | PlaceholderStr += ", ..."; | |||
4890 | ||||
4891 | // Add the placeholder string. | |||
4892 | Builder.AddPlaceholderChunk( | |||
4893 | Builder.getAllocator().CopyString(PlaceholderStr)); | |||
4894 | } | |||
4895 | } | |||
4896 | ||||
4897 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
4898 | } | |||
4899 | ||||
4900 | static void | |||
4901 | AddObjCProperties(const CodeCompletionContext &CCContext, | |||
4902 | ObjCContainerDecl *Container, bool AllowCategories, | |||
4903 | bool AllowNullaryMethods, DeclContext *CurContext, | |||
4904 | AddedPropertiesSet &AddedProperties, ResultBuilder &Results, | |||
4905 | bool IsBaseExprStatement = false, | |||
4906 | bool IsClassProperty = false, bool InOriginalClass = true) { | |||
4907 | typedef CodeCompletionResult Result; | |||
4908 | ||||
4909 | // Retrieve the definition. | |||
4910 | Container = getContainerDef(Container); | |||
4911 | ||||
4912 | // Add properties in this container. | |||
4913 | const auto AddProperty = [&](const ObjCPropertyDecl *P) { | |||
4914 | if (!AddedProperties.insert(P->getIdentifier()).second) | |||
4915 | return; | |||
4916 | ||||
4917 | // FIXME: Provide block invocation completion for non-statement | |||
4918 | // expressions. | |||
4919 | if (!P->getType().getTypePtr()->isBlockPointerType() || | |||
4920 | !IsBaseExprStatement) { | |||
4921 | Result R = Result(P, Results.getBasePriority(P), nullptr); | |||
4922 | if (!InOriginalClass) | |||
4923 | setInBaseClass(R); | |||
4924 | Results.MaybeAddResult(R, CurContext); | |||
4925 | return; | |||
4926 | } | |||
4927 | ||||
4928 | // Block setter and invocation completion is provided only when we are able | |||
4929 | // to find the FunctionProtoTypeLoc with parameter names for the block. | |||
4930 | FunctionTypeLoc BlockLoc; | |||
4931 | FunctionProtoTypeLoc BlockProtoLoc; | |||
4932 | findTypeLocationForBlockDecl(P->getTypeSourceInfo(), BlockLoc, | |||
4933 | BlockProtoLoc); | |||
4934 | if (!BlockLoc) { | |||
4935 | Result R = Result(P, Results.getBasePriority(P), nullptr); | |||
4936 | if (!InOriginalClass) | |||
4937 | setInBaseClass(R); | |||
4938 | Results.MaybeAddResult(R, CurContext); | |||
4939 | return; | |||
4940 | } | |||
4941 | ||||
4942 | // The default completion result for block properties should be the block | |||
4943 | // invocation completion when the base expression is a statement. | |||
4944 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
4945 | Results.getCodeCompletionTUInfo()); | |||
4946 | AddObjCBlockCall(Container->getASTContext(), | |||
4947 | getCompletionPrintingPolicy(Results.getSema()), Builder, P, | |||
4948 | BlockLoc, BlockProtoLoc); | |||
4949 | Result R = Result(Builder.TakeString(), P, Results.getBasePriority(P)); | |||
4950 | if (!InOriginalClass) | |||
4951 | setInBaseClass(R); | |||
4952 | Results.MaybeAddResult(R, CurContext); | |||
4953 | ||||
4954 | // Provide additional block setter completion iff the base expression is a | |||
4955 | // statement and the block property is mutable. | |||
4956 | if (!P->isReadOnly()) { | |||
4957 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
4958 | Results.getCodeCompletionTUInfo()); | |||
4959 | AddResultTypeChunk(Container->getASTContext(), | |||
4960 | getCompletionPrintingPolicy(Results.getSema()), P, | |||
4961 | CCContext.getBaseType(), Builder); | |||
4962 | Builder.AddTypedTextChunk( | |||
4963 | Results.getAllocator().CopyString(P->getName())); | |||
4964 | Builder.AddChunk(CodeCompletionString::CK_Equal); | |||
4965 | ||||
4966 | std::string PlaceholderStr = formatBlockPlaceholder( | |||
4967 | getCompletionPrintingPolicy(Results.getSema()), P, BlockLoc, | |||
4968 | BlockProtoLoc, /*SuppressBlockName=*/true); | |||
4969 | // Add the placeholder string. | |||
4970 | Builder.AddPlaceholderChunk( | |||
4971 | Builder.getAllocator().CopyString(PlaceholderStr)); | |||
4972 | ||||
4973 | // When completing blocks properties that return void the default | |||
4974 | // property completion result should show up before the setter, | |||
4975 | // otherwise the setter completion should show up before the default | |||
4976 | // property completion, as we normally want to use the result of the | |||
4977 | // call. | |||
4978 | Result R = | |||
4979 | Result(Builder.TakeString(), P, | |||
4980 | Results.getBasePriority(P) + | |||
4981 | (BlockLoc.getTypePtr()->getReturnType()->isVoidType() | |||
4982 | ? CCD_BlockPropertySetter | |||
4983 | : -CCD_BlockPropertySetter)); | |||
4984 | if (!InOriginalClass) | |||
4985 | setInBaseClass(R); | |||
4986 | Results.MaybeAddResult(R, CurContext); | |||
4987 | } | |||
4988 | }; | |||
4989 | ||||
4990 | if (IsClassProperty) { | |||
4991 | for (const auto *P : Container->class_properties()) | |||
4992 | AddProperty(P); | |||
4993 | } else { | |||
4994 | for (const auto *P : Container->instance_properties()) | |||
4995 | AddProperty(P); | |||
4996 | } | |||
4997 | ||||
4998 | // Add nullary methods or implicit class properties | |||
4999 | if (AllowNullaryMethods) { | |||
5000 | ASTContext &Context = Container->getASTContext(); | |||
5001 | PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema()); | |||
5002 | // Adds a method result | |||
5003 | const auto AddMethod = [&](const ObjCMethodDecl *M) { | |||
5004 | IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0); | |||
5005 | if (!Name) | |||
5006 | return; | |||
5007 | if (!AddedProperties.insert(Name).second) | |||
5008 | return; | |||
5009 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
5010 | Results.getCodeCompletionTUInfo()); | |||
5011 | AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(), Builder); | |||
5012 | Builder.AddTypedTextChunk( | |||
5013 | Results.getAllocator().CopyString(Name->getName())); | |||
5014 | Result R = Result(Builder.TakeString(), M, | |||
5015 | CCP_MemberDeclaration + CCD_MethodAsProperty); | |||
5016 | if (!InOriginalClass) | |||
5017 | setInBaseClass(R); | |||
5018 | Results.MaybeAddResult(R, CurContext); | |||
5019 | }; | |||
5020 | ||||
5021 | if (IsClassProperty) { | |||
5022 | for (const auto *M : Container->methods()) { | |||
5023 | // Gather the class method that can be used as implicit property | |||
5024 | // getters. Methods with arguments or methods that return void aren't | |||
5025 | // added to the results as they can't be used as a getter. | |||
5026 | if (!M->getSelector().isUnarySelector() || | |||
5027 | M->getReturnType()->isVoidType() || M->isInstanceMethod()) | |||
5028 | continue; | |||
5029 | AddMethod(M); | |||
5030 | } | |||
5031 | } else { | |||
5032 | for (auto *M : Container->methods()) { | |||
5033 | if (M->getSelector().isUnarySelector()) | |||
5034 | AddMethod(M); | |||
5035 | } | |||
5036 | } | |||
5037 | } | |||
5038 | ||||
5039 | // Add properties in referenced protocols. | |||
5040 | if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { | |||
5041 | for (auto *P : Protocol->protocols()) | |||
5042 | AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods, | |||
5043 | CurContext, AddedProperties, Results, | |||
5044 | IsBaseExprStatement, IsClassProperty, | |||
5045 | /*InOriginalClass*/ false); | |||
5046 | } else if (ObjCInterfaceDecl *IFace = | |||
5047 | dyn_cast<ObjCInterfaceDecl>(Container)) { | |||
5048 | if (AllowCategories) { | |||
5049 | // Look through categories. | |||
5050 | for (auto *Cat : IFace->known_categories()) | |||
5051 | AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods, | |||
5052 | CurContext, AddedProperties, Results, | |||
5053 | IsBaseExprStatement, IsClassProperty, | |||
5054 | InOriginalClass); | |||
5055 | } | |||
5056 | ||||
5057 | // Look through protocols. | |||
5058 | for (auto *I : IFace->all_referenced_protocols()) | |||
5059 | AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods, | |||
5060 | CurContext, AddedProperties, Results, | |||
5061 | IsBaseExprStatement, IsClassProperty, | |||
5062 | /*InOriginalClass*/ false); | |||
5063 | ||||
5064 | // Look in the superclass. | |||
5065 | if (IFace->getSuperClass()) | |||
5066 | AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories, | |||
5067 | AllowNullaryMethods, CurContext, AddedProperties, | |||
5068 | Results, IsBaseExprStatement, IsClassProperty, | |||
5069 | /*InOriginalClass*/ false); | |||
5070 | } else if (const auto *Category = | |||
5071 | dyn_cast<ObjCCategoryDecl>(Container)) { | |||
5072 | // Look through protocols. | |||
5073 | for (auto *P : Category->protocols()) | |||
5074 | AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods, | |||
5075 | CurContext, AddedProperties, Results, | |||
5076 | IsBaseExprStatement, IsClassProperty, | |||
5077 | /*InOriginalClass*/ false); | |||
5078 | } | |||
5079 | } | |||
5080 | ||||
5081 | static void | |||
5082 | AddRecordMembersCompletionResults(Sema &SemaRef, ResultBuilder &Results, | |||
5083 | Scope *S, QualType BaseType, | |||
5084 | ExprValueKind BaseKind, RecordDecl *RD, | |||
5085 | std::optional<FixItHint> AccessOpFixIt) { | |||
5086 | // Indicate that we are performing a member access, and the cv-qualifiers | |||
5087 | // for the base object type. | |||
5088 | Results.setObjectTypeQualifiers(BaseType.getQualifiers(), BaseKind); | |||
5089 | ||||
5090 | // Access to a C/C++ class, struct, or union. | |||
5091 | Results.allowNestedNameSpecifiers(); | |||
5092 | std::vector<FixItHint> FixIts; | |||
5093 | if (AccessOpFixIt) | |||
5094 | FixIts.emplace_back(*AccessOpFixIt); | |||
5095 | CodeCompletionDeclConsumer Consumer(Results, RD, BaseType, std::move(FixIts)); | |||
5096 | SemaRef.LookupVisibleDecls(RD, Sema::LookupMemberName, Consumer, | |||
5097 | SemaRef.CodeCompleter->includeGlobals(), | |||
5098 | /*IncludeDependentBases=*/true, | |||
5099 | SemaRef.CodeCompleter->loadExternal()); | |||
5100 | ||||
5101 | if (SemaRef.getLangOpts().CPlusPlus) { | |||
5102 | if (!Results.empty()) { | |||
5103 | // The "template" keyword can follow "->" or "." in the grammar. | |||
5104 | // However, we only want to suggest the template keyword if something | |||
5105 | // is dependent. | |||
5106 | bool IsDependent = BaseType->isDependentType(); | |||
5107 | if (!IsDependent) { | |||
5108 | for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent()) | |||
5109 | if (DeclContext *Ctx = DepScope->getEntity()) { | |||
5110 | IsDependent = Ctx->isDependentContext(); | |||
5111 | break; | |||
5112 | } | |||
5113 | } | |||
5114 | ||||
5115 | if (IsDependent) | |||
5116 | Results.AddResult(CodeCompletionResult("template")); | |||
5117 | } | |||
5118 | } | |||
5119 | } | |||
5120 | ||||
5121 | // Returns the RecordDecl inside the BaseType, falling back to primary template | |||
5122 | // in case of specializations. Since we might not have a decl for the | |||
5123 | // instantiation/specialization yet, e.g. dependent code. | |||
5124 | static RecordDecl *getAsRecordDecl(QualType BaseType) { | |||
5125 | BaseType = BaseType.getNonReferenceType(); | |||
5126 | if (auto *RD = BaseType->getAsRecordDecl()) { | |||
5127 | if (const auto *CTSD = | |||
5128 | llvm::dyn_cast<ClassTemplateSpecializationDecl>(RD)) { | |||
5129 | // Template might not be instantiated yet, fall back to primary template | |||
5130 | // in such cases. | |||
5131 | if (CTSD->getTemplateSpecializationKind() == TSK_Undeclared) | |||
5132 | RD = CTSD->getSpecializedTemplate()->getTemplatedDecl(); | |||
5133 | } | |||
5134 | return RD; | |||
5135 | } | |||
5136 | ||||
5137 | if (const auto *TST = BaseType->getAs<TemplateSpecializationType>()) { | |||
5138 | if (const auto *TD = dyn_cast_or_null<ClassTemplateDecl>( | |||
5139 | TST->getTemplateName().getAsTemplateDecl())) { | |||
5140 | return TD->getTemplatedDecl(); | |||
5141 | } | |||
5142 | } | |||
5143 | ||||
5144 | return nullptr; | |||
5145 | } | |||
5146 | ||||
5147 | namespace { | |||
5148 | // Collects completion-relevant information about a concept-constrainted type T. | |||
5149 | // In particular, examines the constraint expressions to find members of T. | |||
5150 | // | |||
5151 | // The design is very simple: we walk down each constraint looking for | |||
5152 | // expressions of the form T.foo(). | |||
5153 | // If we're extra lucky, the return type is specified. | |||
5154 | // We don't do any clever handling of && or || in constraint expressions, we | |||
5155 | // take members from both branches. | |||
5156 | // | |||
5157 | // For example, given: | |||
5158 | // template <class T> concept X = requires (T t, string& s) { t.print(s); }; | |||
5159 | // template <X U> void foo(U u) { u.^ } | |||
5160 | // We want to suggest the inferred member function 'print(string)'. | |||
5161 | // We see that u has type U, so X<U> holds. | |||
5162 | // X<U> requires t.print(s) to be valid, where t has type U (substituted for T). | |||
5163 | // By looking at the CallExpr we find the signature of print(). | |||
5164 | // | |||
5165 | // While we tend to know in advance which kind of members (access via . -> ::) | |||
5166 | // we want, it's simpler just to gather them all and post-filter. | |||
5167 | // | |||
5168 | // FIXME: some of this machinery could be used for non-concept type-parms too, | |||
5169 | // enabling completion for type parameters based on other uses of that param. | |||
5170 | // | |||
5171 | // FIXME: there are other cases where a type can be constrained by a concept, | |||
5172 | // e.g. inside `if constexpr(ConceptSpecializationExpr) { ... }` | |||
5173 | class ConceptInfo { | |||
5174 | public: | |||
5175 | // Describes a likely member of a type, inferred by concept constraints. | |||
5176 | // Offered as a code completion for T. T-> and T:: contexts. | |||
5177 | struct Member { | |||
5178 | // Always non-null: we only handle members with ordinary identifier names. | |||
5179 | const IdentifierInfo *Name = nullptr; | |||
5180 | // Set for functions we've seen called. | |||
5181 | // We don't have the declared parameter types, only the actual types of | |||
5182 | // arguments we've seen. These are still valuable, as it's hard to render | |||
5183 | // a useful function completion with neither parameter types nor names! | |||
5184 | std::optional<SmallVector<QualType, 1>> ArgTypes; | |||
5185 | // Whether this is accessed as T.member, T->member, or T::member. | |||
5186 | enum AccessOperator { | |||
5187 | Colons, | |||
5188 | Arrow, | |||
5189 | Dot, | |||
5190 | } Operator = Dot; | |||
5191 | // What's known about the type of a variable or return type of a function. | |||
5192 | const TypeConstraint *ResultType = nullptr; | |||
5193 | // FIXME: also track: | |||
5194 | // - kind of entity (function/variable/type), to expose structured results | |||
5195 | // - template args kinds/types, as a proxy for template params | |||
5196 | ||||
5197 | // For now we simply return these results as "pattern" strings. | |||
5198 | CodeCompletionString *render(Sema &S, CodeCompletionAllocator &Alloc, | |||
5199 | CodeCompletionTUInfo &Info) const { | |||
5200 | CodeCompletionBuilder B(Alloc, Info); | |||
5201 | // Result type | |||
5202 | if (ResultType) { | |||
5203 | std::string AsString; | |||
5204 | { | |||
5205 | llvm::raw_string_ostream OS(AsString); | |||
5206 | QualType ExactType = deduceType(*ResultType); | |||
5207 | if (!ExactType.isNull()) | |||
5208 | ExactType.print(OS, getCompletionPrintingPolicy(S)); | |||
5209 | else | |||
5210 | ResultType->print(OS, getCompletionPrintingPolicy(S)); | |||
5211 | } | |||
5212 | B.AddResultTypeChunk(Alloc.CopyString(AsString)); | |||
5213 | } | |||
5214 | // Member name | |||
5215 | B.AddTypedTextChunk(Alloc.CopyString(Name->getName())); | |||
5216 | // Function argument list | |||
5217 | if (ArgTypes) { | |||
5218 | B.AddChunk(clang::CodeCompletionString::CK_LeftParen); | |||
5219 | bool First = true; | |||
5220 | for (QualType Arg : *ArgTypes) { | |||
5221 | if (First) | |||
5222 | First = false; | |||
5223 | else { | |||
5224 | B.AddChunk(clang::CodeCompletionString::CK_Comma); | |||
5225 | B.AddChunk(clang::CodeCompletionString::CK_HorizontalSpace); | |||
5226 | } | |||
5227 | B.AddPlaceholderChunk(Alloc.CopyString( | |||
5228 | Arg.getAsString(getCompletionPrintingPolicy(S)))); | |||
5229 | } | |||
5230 | B.AddChunk(clang::CodeCompletionString::CK_RightParen); | |||
5231 | } | |||
5232 | return B.TakeString(); | |||
5233 | } | |||
5234 | }; | |||
5235 | ||||
5236 | // BaseType is the type parameter T to infer members from. | |||
5237 | // T must be accessible within S, as we use it to find the template entity | |||
5238 | // that T is attached to in order to gather the relevant constraints. | |||
5239 | ConceptInfo(const TemplateTypeParmType &BaseType, Scope *S) { | |||
5240 | auto *TemplatedEntity = getTemplatedEntity(BaseType.getDecl(), S); | |||
5241 | for (const Expr *E : constraintsForTemplatedEntity(TemplatedEntity)) | |||
5242 | believe(E, &BaseType); | |||
5243 | } | |||
5244 | ||||
5245 | std::vector<Member> members() { | |||
5246 | std::vector<Member> Results; | |||
5247 | for (const auto &E : this->Results) | |||
5248 | Results.push_back(E.second); | |||
5249 | llvm::sort(Results, [](const Member &L, const Member &R) { | |||
5250 | return L.Name->getName() < R.Name->getName(); | |||
5251 | }); | |||
5252 | return Results; | |||
5253 | } | |||
5254 | ||||
5255 | private: | |||
5256 | // Infer members of T, given that the expression E (dependent on T) is true. | |||
5257 | void believe(const Expr *E, const TemplateTypeParmType *T) { | |||
5258 | if (!E || !T) | |||
5259 | return; | |||
5260 | if (auto *CSE = dyn_cast<ConceptSpecializationExpr>(E)) { | |||
5261 | // If the concept is | |||
5262 | // template <class A, class B> concept CD = f<A, B>(); | |||
5263 | // And the concept specialization is | |||
5264 | // CD<int, T> | |||
5265 | // Then we're substituting T for B, so we want to make f<A, B>() true | |||
5266 | // by adding members to B - i.e. believe(f<A, B>(), B); | |||
5267 | // | |||
5268 | // For simplicity: | |||
5269 | // - we don't attempt to substitute int for A | |||
5270 | // - when T is used in other ways (like CD<T*>) we ignore it | |||
5271 | ConceptDecl *CD = CSE->getNamedConcept(); | |||
5272 | TemplateParameterList *Params = CD->getTemplateParameters(); | |||
5273 | unsigned Index = 0; | |||
5274 | for (const auto &Arg : CSE->getTemplateArguments()) { | |||
5275 | if (Index >= Params->size()) | |||
5276 | break; // Won't happen in valid code. | |||
5277 | if (isApprox(Arg, T)) { | |||
5278 | auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Params->getParam(Index)); | |||
5279 | if (!TTPD) | |||
5280 | continue; | |||
5281 | // T was used as an argument, and bound to the parameter TT. | |||
5282 | auto *TT = cast<TemplateTypeParmType>(TTPD->getTypeForDecl()); | |||
5283 | // So now we know the constraint as a function of TT is true. | |||
5284 | believe(CD->getConstraintExpr(), TT); | |||
5285 | // (concepts themselves have no associated constraints to require) | |||
5286 | } | |||
5287 | ||||
5288 | ++Index; | |||
5289 | } | |||
5290 | } else if (auto *BO = dyn_cast<BinaryOperator>(E)) { | |||
5291 | // For A && B, we can infer members from both branches. | |||
5292 | // For A || B, the union is still more useful than the intersection. | |||
5293 | if (BO->getOpcode() == BO_LAnd || BO->getOpcode() == BO_LOr) { | |||
5294 | believe(BO->getLHS(), T); | |||
5295 | believe(BO->getRHS(), T); | |||
5296 | } | |||
5297 | } else if (auto *RE = dyn_cast<RequiresExpr>(E)) { | |||
5298 | // A requires(){...} lets us infer members from each requirement. | |||
5299 | for (const concepts::Requirement *Req : RE->getRequirements()) { | |||
5300 | if (!Req->isDependent()) | |||
5301 | continue; // Can't tell us anything about T. | |||
5302 | // Now Req cannot a substitution-error: those aren't dependent. | |||
5303 | ||||
5304 | if (auto *TR = dyn_cast<concepts::TypeRequirement>(Req)) { | |||
5305 | // Do a full traversal so we get `foo` from `typename T::foo::bar`. | |||
5306 | QualType AssertedType = TR->getType()->getType(); | |||
5307 | ValidVisitor(this, T).TraverseType(AssertedType); | |||
5308 | } else if (auto *ER = dyn_cast<concepts::ExprRequirement>(Req)) { | |||
5309 | ValidVisitor Visitor(this, T); | |||
5310 | // If we have a type constraint on the value of the expression, | |||
5311 | // AND the whole outer expression describes a member, then we'll | |||
5312 | // be able to use the constraint to provide the return type. | |||
5313 | if (ER->getReturnTypeRequirement().isTypeConstraint()) { | |||
5314 | Visitor.OuterType = | |||
5315 | ER->getReturnTypeRequirement().getTypeConstraint(); | |||
5316 | Visitor.OuterExpr = ER->getExpr(); | |||
5317 | } | |||
5318 | Visitor.TraverseStmt(ER->getExpr()); | |||
5319 | } else if (auto *NR = dyn_cast<concepts::NestedRequirement>(Req)) { | |||
5320 | believe(NR->getConstraintExpr(), T); | |||
5321 | } | |||
5322 | } | |||
5323 | } | |||
5324 | } | |||
5325 | ||||
5326 | // This visitor infers members of T based on traversing expressions/types | |||
5327 | // that involve T. It is invoked with code known to be valid for T. | |||
5328 | class ValidVisitor : public RecursiveASTVisitor<ValidVisitor> { | |||
5329 | ConceptInfo *Outer; | |||
5330 | const TemplateTypeParmType *T; | |||
5331 | ||||
5332 | CallExpr *Caller = nullptr; | |||
5333 | Expr *Callee = nullptr; | |||
5334 | ||||
5335 | public: | |||
5336 | // If set, OuterExpr is constrained by OuterType. | |||
5337 | Expr *OuterExpr = nullptr; | |||
5338 | const TypeConstraint *OuterType = nullptr; | |||
5339 | ||||
5340 | ValidVisitor(ConceptInfo *Outer, const TemplateTypeParmType *T) | |||
5341 | : Outer(Outer), T(T) { | |||
5342 | assert(T)(static_cast <bool> (T) ? void (0) : __assert_fail ("T" , "clang/lib/Sema/SemaCodeComplete.cpp", 5342, __extension__ __PRETTY_FUNCTION__ )); | |||
5343 | } | |||
5344 | ||||
5345 | // In T.foo or T->foo, `foo` is a member function/variable. | |||
5346 | bool VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) { | |||
5347 | const Type *Base = E->getBaseType().getTypePtr(); | |||
5348 | bool IsArrow = E->isArrow(); | |||
5349 | if (Base->isPointerType() && IsArrow) { | |||
5350 | IsArrow = false; | |||
5351 | Base = Base->getPointeeType().getTypePtr(); | |||
5352 | } | |||
5353 | if (isApprox(Base, T)) | |||
5354 | addValue(E, E->getMember(), IsArrow ? Member::Arrow : Member::Dot); | |||
5355 | return true; | |||
5356 | } | |||
5357 | ||||
5358 | // In T::foo, `foo` is a static member function/variable. | |||
5359 | bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { | |||
5360 | if (E->getQualifier() && isApprox(E->getQualifier()->getAsType(), T)) | |||
5361 | addValue(E, E->getDeclName(), Member::Colons); | |||
5362 | return true; | |||
5363 | } | |||
5364 | ||||
5365 | // In T::typename foo, `foo` is a type. | |||
5366 | bool VisitDependentNameType(DependentNameType *DNT) { | |||
5367 | const auto *Q = DNT->getQualifier(); | |||
5368 | if (Q && isApprox(Q->getAsType(), T)) | |||
5369 | addType(DNT->getIdentifier()); | |||
5370 | return true; | |||
5371 | } | |||
5372 | ||||
5373 | // In T::foo::bar, `foo` must be a type. | |||
5374 | // VisitNNS() doesn't exist, and TraverseNNS isn't always called :-( | |||
5375 | bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSL) { | |||
5376 | if (NNSL) { | |||
5377 | NestedNameSpecifier *NNS = NNSL.getNestedNameSpecifier(); | |||
5378 | const auto *Q = NNS->getPrefix(); | |||
5379 | if (Q && isApprox(Q->getAsType(), T)) | |||
5380 | addType(NNS->getAsIdentifier()); | |||
5381 | } | |||
5382 | // FIXME: also handle T::foo<X>::bar | |||
5383 | return RecursiveASTVisitor::TraverseNestedNameSpecifierLoc(NNSL); | |||
5384 | } | |||
5385 | ||||
5386 | // FIXME also handle T::foo<X> | |||
5387 | ||||
5388 | // Track the innermost caller/callee relationship so we can tell if a | |||
5389 | // nested expr is being called as a function. | |||
5390 | bool VisitCallExpr(CallExpr *CE) { | |||
5391 | Caller = CE; | |||
5392 | Callee = CE->getCallee(); | |||
5393 | return true; | |||
5394 | } | |||
5395 | ||||
5396 | private: | |||
5397 | void addResult(Member &&M) { | |||
5398 | auto R = Outer->Results.try_emplace(M.Name); | |||
5399 | Member &O = R.first->second; | |||
5400 | // Overwrite existing if the new member has more info. | |||
5401 | // The preference of . vs :: vs -> is fairly arbitrary. | |||
5402 | if (/*Inserted*/ R.second || | |||
5403 | std::make_tuple(M.ArgTypes.has_value(), M.ResultType != nullptr, | |||
5404 | M.Operator) > std::make_tuple(O.ArgTypes.has_value(), | |||
5405 | O.ResultType != nullptr, | |||
5406 | O.Operator)) | |||
5407 | O = std::move(M); | |||
5408 | } | |||
5409 | ||||
5410 | void addType(const IdentifierInfo *Name) { | |||
5411 | if (!Name) | |||
5412 | return; | |||
5413 | Member M; | |||
5414 | M.Name = Name; | |||
5415 | M.Operator = Member::Colons; | |||
5416 | addResult(std::move(M)); | |||
5417 | } | |||
5418 | ||||
5419 | void addValue(Expr *E, DeclarationName Name, | |||
5420 | Member::AccessOperator Operator) { | |||
5421 | if (!Name.isIdentifier()) | |||
5422 | return; | |||
5423 | Member Result; | |||
5424 | Result.Name = Name.getAsIdentifierInfo(); | |||
5425 | Result.Operator = Operator; | |||
5426 | // If this is the callee of an immediately-enclosing CallExpr, then | |||
5427 | // treat it as a method, otherwise it's a variable. | |||
5428 | if (Caller != nullptr && Callee == E) { | |||
5429 | Result.ArgTypes.emplace(); | |||
5430 | for (const auto *Arg : Caller->arguments()) | |||
5431 | Result.ArgTypes->push_back(Arg->getType()); | |||
5432 | if (Caller == OuterExpr) { | |||
5433 | Result.ResultType = OuterType; | |||
5434 | } | |||
5435 | } else { | |||
5436 | if (E == OuterExpr) | |||
5437 | Result.ResultType = OuterType; | |||
5438 | } | |||
5439 | addResult(std::move(Result)); | |||
5440 | } | |||
5441 | }; | |||
5442 | ||||
5443 | static bool isApprox(const TemplateArgument &Arg, const Type *T) { | |||
5444 | return Arg.getKind() == TemplateArgument::Type && | |||
5445 | isApprox(Arg.getAsType().getTypePtr(), T); | |||
5446 | } | |||
5447 | ||||
5448 | static bool isApprox(const Type *T1, const Type *T2) { | |||
5449 | return T1 && T2 && | |||
5450 | T1->getCanonicalTypeUnqualified() == | |||
5451 | T2->getCanonicalTypeUnqualified(); | |||
5452 | } | |||
5453 | ||||
5454 | // Returns the DeclContext immediately enclosed by the template parameter | |||
5455 | // scope. For primary templates, this is the templated (e.g.) CXXRecordDecl. | |||
5456 | // For specializations, this is e.g. ClassTemplatePartialSpecializationDecl. | |||
5457 | static DeclContext *getTemplatedEntity(const TemplateTypeParmDecl *D, | |||
5458 | Scope *S) { | |||
5459 | if (D == nullptr) | |||
5460 | return nullptr; | |||
5461 | Scope *Inner = nullptr; | |||
5462 | while (S) { | |||
5463 | if (S->isTemplateParamScope() && S->isDeclScope(D)) | |||
5464 | return Inner ? Inner->getEntity() : nullptr; | |||
5465 | Inner = S; | |||
5466 | S = S->getParent(); | |||
5467 | } | |||
5468 | return nullptr; | |||
5469 | } | |||
5470 | ||||
5471 | // Gets all the type constraint expressions that might apply to the type | |||
5472 | // variables associated with DC (as returned by getTemplatedEntity()). | |||
5473 | static SmallVector<const Expr *, 1> | |||
5474 | constraintsForTemplatedEntity(DeclContext *DC) { | |||
5475 | SmallVector<const Expr *, 1> Result; | |||
5476 | if (DC == nullptr) | |||
5477 | return Result; | |||
5478 | // Primary templates can have constraints. | |||
5479 | if (const auto *TD = cast<Decl>(DC)->getDescribedTemplate()) | |||
5480 | TD->getAssociatedConstraints(Result); | |||
5481 | // Partial specializations may have constraints. | |||
5482 | if (const auto *CTPSD = | |||
5483 | dyn_cast<ClassTemplatePartialSpecializationDecl>(DC)) | |||
5484 | CTPSD->getAssociatedConstraints(Result); | |||
5485 | if (const auto *VTPSD = dyn_cast<VarTemplatePartialSpecializationDecl>(DC)) | |||
5486 | VTPSD->getAssociatedConstraints(Result); | |||
5487 | return Result; | |||
5488 | } | |||
5489 | ||||
5490 | // Attempt to find the unique type satisfying a constraint. | |||
5491 | // This lets us show e.g. `int` instead of `std::same_as<int>`. | |||
5492 | static QualType deduceType(const TypeConstraint &T) { | |||
5493 | // Assume a same_as<T> return type constraint is std::same_as or equivalent. | |||
5494 | // In this case the return type is T. | |||
5495 | DeclarationName DN = T.getNamedConcept()->getDeclName(); | |||
5496 | if (DN.isIdentifier() && DN.getAsIdentifierInfo()->isStr("same_as")) | |||
5497 | if (const auto *Args = T.getTemplateArgsAsWritten()) | |||
5498 | if (Args->getNumTemplateArgs() == 1) { | |||
5499 | const auto &Arg = Args->arguments().front().getArgument(); | |||
5500 | if (Arg.getKind() == TemplateArgument::Type) | |||
5501 | return Arg.getAsType(); | |||
5502 | } | |||
5503 | return {}; | |||
5504 | } | |||
5505 | ||||
5506 | llvm::DenseMap<const IdentifierInfo *, Member> Results; | |||
5507 | }; | |||
5508 | ||||
5509 | // Returns a type for E that yields acceptable member completions. | |||
5510 | // In particular, when E->getType() is DependentTy, try to guess a likely type. | |||
5511 | // We accept some lossiness (like dropping parameters). | |||
5512 | // We only try to handle common expressions on the LHS of MemberExpr. | |||
5513 | QualType getApproximateType(const Expr *E) { | |||
5514 | if (E->getType().isNull()) | |||
5515 | return QualType(); | |||
5516 | E = E->IgnoreParenImpCasts(); | |||
5517 | QualType Unresolved = E->getType(); | |||
5518 | // We only resolve DependentTy, or undeduced autos (including auto* etc). | |||
5519 | if (!Unresolved->isSpecificBuiltinType(BuiltinType::Dependent)) { | |||
5520 | AutoType *Auto = Unresolved->getContainedAutoType(); | |||
5521 | if (!Auto || !Auto->isUndeducedAutoType()) | |||
5522 | return Unresolved; | |||
5523 | } | |||
5524 | // A call: approximate-resolve callee to a function type, get its return type | |||
5525 | if (const CallExpr *CE = llvm::dyn_cast<CallExpr>(E)) { | |||
5526 | QualType Callee = getApproximateType(CE->getCallee()); | |||
5527 | if (Callee.isNull() || | |||
5528 | Callee->isSpecificPlaceholderType(BuiltinType::BoundMember)) | |||
5529 | Callee = Expr::findBoundMemberType(CE->getCallee()); | |||
5530 | if (Callee.isNull()) | |||
5531 | return Unresolved; | |||
5532 | ||||
5533 | if (const auto *FnTypePtr = Callee->getAs<PointerType>()) { | |||
5534 | Callee = FnTypePtr->getPointeeType(); | |||
5535 | } else if (const auto *BPT = Callee->getAs<BlockPointerType>()) { | |||
5536 | Callee = BPT->getPointeeType(); | |||
5537 | } | |||
5538 | if (const FunctionType *FnType = Callee->getAs<FunctionType>()) | |||
5539 | return FnType->getReturnType().getNonReferenceType(); | |||
5540 | ||||
5541 | // Unresolved call: try to guess the return type. | |||
5542 | if (const auto *OE = llvm::dyn_cast<OverloadExpr>(CE->getCallee())) { | |||
5543 | // If all candidates have the same approximate return type, use it. | |||
5544 | // Discard references and const to allow more to be "the same". | |||
5545 | // (In particular, if there's one candidate + ADL, resolve it). | |||
5546 | const Type *Common = nullptr; | |||
5547 | for (const auto *D : OE->decls()) { | |||
5548 | QualType ReturnType; | |||
5549 | if (const auto *FD = llvm::dyn_cast<FunctionDecl>(D)) | |||
5550 | ReturnType = FD->getReturnType(); | |||
5551 | else if (const auto *FTD = llvm::dyn_cast<FunctionTemplateDecl>(D)) | |||
5552 | ReturnType = FTD->getTemplatedDecl()->getReturnType(); | |||
5553 | if (ReturnType.isNull()) | |||
5554 | continue; | |||
5555 | const Type *Candidate = | |||
5556 | ReturnType.getNonReferenceType().getCanonicalType().getTypePtr(); | |||
5557 | if (Common && Common != Candidate) | |||
5558 | return Unresolved; // Multiple candidates. | |||
5559 | Common = Candidate; | |||
5560 | } | |||
5561 | if (Common != nullptr) | |||
5562 | return QualType(Common, 0); | |||
5563 | } | |||
5564 | } | |||
5565 | // A dependent member: approximate-resolve the base, then lookup. | |||
5566 | if (const auto *CDSME = llvm::dyn_cast<CXXDependentScopeMemberExpr>(E)) { | |||
5567 | QualType Base = CDSME->isImplicitAccess() | |||
5568 | ? CDSME->getBaseType() | |||
5569 | : getApproximateType(CDSME->getBase()); | |||
5570 | if (CDSME->isArrow() && !Base.isNull()) | |||
5571 | Base = Base->getPointeeType(); // could handle unique_ptr etc here? | |||
5572 | auto *RD = | |||
5573 | Base.isNull() | |||
5574 | ? nullptr | |||
5575 | : llvm::dyn_cast_or_null<CXXRecordDecl>(getAsRecordDecl(Base)); | |||
5576 | if (RD && RD->isCompleteDefinition()) { | |||
5577 | // Look up member heuristically, including in bases. | |||
5578 | for (const auto *Member : RD->lookupDependentName( | |||
5579 | CDSME->getMember(), [](const NamedDecl *Member) { | |||
5580 | return llvm::isa<ValueDecl>(Member); | |||
5581 | })) { | |||
5582 | return llvm::cast<ValueDecl>(Member)->getType().getNonReferenceType(); | |||
5583 | } | |||
5584 | } | |||
5585 | } | |||
5586 | // A reference to an `auto` variable: approximate-resolve its initializer. | |||
5587 | if (const auto *DRE = llvm::dyn_cast<DeclRefExpr>(E)) { | |||
5588 | if (const auto *VD = llvm::dyn_cast<VarDecl>(DRE->getDecl())) { | |||
5589 | if (VD->hasInit()) | |||
5590 | return getApproximateType(VD->getInit()); | |||
5591 | } | |||
5592 | } | |||
5593 | return Unresolved; | |||
5594 | } | |||
5595 | ||||
5596 | // If \p Base is ParenListExpr, assume a chain of comma operators and pick the | |||
5597 | // last expr. We expect other ParenListExprs to be resolved to e.g. constructor | |||
5598 | // calls before here. (So the ParenListExpr should be nonempty, but check just | |||
5599 | // in case) | |||
5600 | Expr *unwrapParenList(Expr *Base) { | |||
5601 | if (auto *PLE = llvm::dyn_cast_or_null<ParenListExpr>(Base)) { | |||
5602 | if (PLE->getNumExprs() == 0) | |||
5603 | return nullptr; | |||
5604 | Base = PLE->getExpr(PLE->getNumExprs() - 1); | |||
5605 | } | |||
5606 | return Base; | |||
5607 | } | |||
5608 | ||||
5609 | } // namespace | |||
5610 | ||||
5611 | void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, | |||
5612 | Expr *OtherOpBase, | |||
5613 | SourceLocation OpLoc, bool IsArrow, | |||
5614 | bool IsBaseExprStatement, | |||
5615 | QualType PreferredType) { | |||
5616 | Base = unwrapParenList(Base); | |||
5617 | OtherOpBase = unwrapParenList(OtherOpBase); | |||
5618 | if (!Base || !CodeCompleter) | |||
5619 | return; | |||
5620 | ||||
5621 | ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow); | |||
5622 | if (ConvertedBase.isInvalid()) | |||
5623 | return; | |||
5624 | QualType ConvertedBaseType = getApproximateType(ConvertedBase.get()); | |||
5625 | ||||
5626 | enum CodeCompletionContext::Kind contextKind; | |||
5627 | ||||
5628 | if (IsArrow) { | |||
5629 | if (const auto *Ptr = ConvertedBaseType->getAs<PointerType>()) | |||
5630 | ConvertedBaseType = Ptr->getPointeeType(); | |||
5631 | } | |||
5632 | ||||
5633 | if (IsArrow) { | |||
5634 | contextKind = CodeCompletionContext::CCC_ArrowMemberAccess; | |||
5635 | } else { | |||
5636 | if (ConvertedBaseType->isObjCObjectPointerType() || | |||
5637 | ConvertedBaseType->isObjCObjectOrInterfaceType()) { | |||
5638 | contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess; | |||
5639 | } else { | |||
5640 | contextKind = CodeCompletionContext::CCC_DotMemberAccess; | |||
5641 | } | |||
5642 | } | |||
5643 | ||||
5644 | CodeCompletionContext CCContext(contextKind, ConvertedBaseType); | |||
5645 | CCContext.setPreferredType(PreferredType); | |||
5646 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
5647 | CodeCompleter->getCodeCompletionTUInfo(), CCContext, | |||
5648 | &ResultBuilder::IsMember); | |||
5649 | ||||
5650 | auto DoCompletion = [&](Expr *Base, bool IsArrow, | |||
5651 | std::optional<FixItHint> AccessOpFixIt) -> bool { | |||
5652 | if (!Base) | |||
5653 | return false; | |||
5654 | ||||
5655 | ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow); | |||
5656 | if (ConvertedBase.isInvalid()) | |||
5657 | return false; | |||
5658 | Base = ConvertedBase.get(); | |||
5659 | ||||
5660 | QualType BaseType = getApproximateType(Base); | |||
5661 | if (BaseType.isNull()) | |||
5662 | return false; | |||
5663 | ExprValueKind BaseKind = Base->getValueKind(); | |||
5664 | ||||
5665 | if (IsArrow) { | |||
5666 | if (const PointerType *Ptr = BaseType->getAs<PointerType>()) { | |||
5667 | BaseType = Ptr->getPointeeType(); | |||
5668 | BaseKind = VK_LValue; | |||
5669 | } else if (BaseType->isObjCObjectPointerType() || | |||
5670 | BaseType->isTemplateTypeParmType()) { | |||
5671 | // Both cases (dot/arrow) handled below. | |||
5672 | } else { | |||
5673 | return false; | |||
5674 | } | |||
5675 | } | |||
5676 | ||||
5677 | if (RecordDecl *RD = getAsRecordDecl(BaseType)) { | |||
5678 | AddRecordMembersCompletionResults(*this, Results, S, BaseType, BaseKind, | |||
5679 | RD, std::move(AccessOpFixIt)); | |||
5680 | } else if (const auto *TTPT = | |||
5681 | dyn_cast<TemplateTypeParmType>(BaseType.getTypePtr())) { | |||
5682 | auto Operator = | |||
5683 | IsArrow ? ConceptInfo::Member::Arrow : ConceptInfo::Member::Dot; | |||
5684 | for (const auto &R : ConceptInfo(*TTPT, S).members()) { | |||
5685 | if (R.Operator != Operator) | |||
5686 | continue; | |||
5687 | CodeCompletionResult Result( | |||
5688 | R.render(*this, CodeCompleter->getAllocator(), | |||
5689 | CodeCompleter->getCodeCompletionTUInfo())); | |||
5690 | if (AccessOpFixIt) | |||
5691 | Result.FixIts.push_back(*AccessOpFixIt); | |||
5692 | Results.AddResult(std::move(Result)); | |||
5693 | } | |||
5694 | } else if (!IsArrow && BaseType->isObjCObjectPointerType()) { | |||
5695 | // Objective-C property reference. Bail if we're performing fix-it code | |||
5696 | // completion since Objective-C properties are normally backed by ivars, | |||
5697 | // most Objective-C fix-its here would have little value. | |||
5698 | if (AccessOpFixIt) { | |||
5699 | return false; | |||
5700 | } | |||
5701 | AddedPropertiesSet AddedProperties; | |||
5702 | ||||
5703 | if (const ObjCObjectPointerType *ObjCPtr = | |||
5704 | BaseType->getAsObjCInterfacePointerType()) { | |||
5705 | // Add property results based on our interface. | |||
5706 | assert(ObjCPtr && "Non-NULL pointer guaranteed above!")(static_cast <bool> (ObjCPtr && "Non-NULL pointer guaranteed above!" ) ? void (0) : __assert_fail ("ObjCPtr && \"Non-NULL pointer guaranteed above!\"" , "clang/lib/Sema/SemaCodeComplete.cpp", 5706, __extension__ __PRETTY_FUNCTION__ )); | |||
5707 | AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true, | |||
5708 | /*AllowNullaryMethods=*/true, CurContext, | |||
5709 | AddedProperties, Results, IsBaseExprStatement); | |||
5710 | } | |||
5711 | ||||
5712 | // Add properties from the protocols in a qualified interface. | |||
5713 | for (auto *I : BaseType->castAs<ObjCObjectPointerType>()->quals()) | |||
5714 | AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true, | |||
5715 | CurContext, AddedProperties, Results, | |||
5716 | IsBaseExprStatement, /*IsClassProperty*/ false, | |||
5717 | /*InOriginalClass*/ false); | |||
5718 | } else if ((IsArrow && BaseType->isObjCObjectPointerType()) || | |||
5719 | (!IsArrow && BaseType->isObjCObjectType())) { | |||
5720 | // Objective-C instance variable access. Bail if we're performing fix-it | |||
5721 | // code completion since Objective-C properties are normally backed by | |||
5722 | // ivars, most Objective-C fix-its here would have little value. | |||
5723 | if (AccessOpFixIt) { | |||
5724 | return false; | |||
5725 | } | |||
5726 | ObjCInterfaceDecl *Class = nullptr; | |||
5727 | if (const ObjCObjectPointerType *ObjCPtr = | |||
5728 | BaseType->getAs<ObjCObjectPointerType>()) | |||
5729 | Class = ObjCPtr->getInterfaceDecl(); | |||
5730 | else | |||
5731 | Class = BaseType->castAs<ObjCObjectType>()->getInterface(); | |||
5732 | ||||
5733 | // Add all ivars from this class and its superclasses. | |||
5734 | if (Class) { | |||
5735 | CodeCompletionDeclConsumer Consumer(Results, Class, BaseType); | |||
5736 | Results.setFilter(&ResultBuilder::IsObjCIvar); | |||
5737 | LookupVisibleDecls( | |||
5738 | Class, LookupMemberName, Consumer, CodeCompleter->includeGlobals(), | |||
5739 | /*IncludeDependentBases=*/false, CodeCompleter->loadExternal()); | |||
5740 | } | |||
5741 | } | |||
5742 | ||||
5743 | // FIXME: How do we cope with isa? | |||
5744 | return true; | |||
5745 | }; | |||
5746 | ||||
5747 | Results.EnterNewScope(); | |||
5748 | ||||
5749 | bool CompletionSucceded = DoCompletion(Base, IsArrow, std::nullopt); | |||
5750 | if (CodeCompleter->includeFixIts()) { | |||
5751 | const CharSourceRange OpRange = | |||
5752 | CharSourceRange::getTokenRange(OpLoc, OpLoc); | |||
5753 | CompletionSucceded |= DoCompletion( | |||
5754 | OtherOpBase, !IsArrow, | |||
5755 | FixItHint::CreateReplacement(OpRange, IsArrow ? "." : "->")); | |||
5756 | } | |||
5757 | ||||
5758 | Results.ExitScope(); | |||
5759 | ||||
5760 | if (!CompletionSucceded) | |||
5761 | return; | |||
5762 | ||||
5763 | // Hand off the results found for code completion. | |||
5764 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
5765 | Results.data(), Results.size()); | |||
5766 | } | |||
5767 | ||||
5768 | void Sema::CodeCompleteObjCClassPropertyRefExpr(Scope *S, | |||
5769 | IdentifierInfo &ClassName, | |||
5770 | SourceLocation ClassNameLoc, | |||
5771 | bool IsBaseExprStatement) { | |||
5772 | IdentifierInfo *ClassNamePtr = &ClassName; | |||
5773 | ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(ClassNamePtr, ClassNameLoc); | |||
5774 | if (!IFace) | |||
5775 | return; | |||
5776 | CodeCompletionContext CCContext( | |||
5777 | CodeCompletionContext::CCC_ObjCPropertyAccess); | |||
5778 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
5779 | CodeCompleter->getCodeCompletionTUInfo(), CCContext, | |||
5780 | &ResultBuilder::IsMember); | |||
5781 | Results.EnterNewScope(); | |||
5782 | AddedPropertiesSet AddedProperties; | |||
5783 | AddObjCProperties(CCContext, IFace, true, | |||
5784 | /*AllowNullaryMethods=*/true, CurContext, AddedProperties, | |||
5785 | Results, IsBaseExprStatement, | |||
5786 | /*IsClassProperty=*/true); | |||
5787 | Results.ExitScope(); | |||
5788 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
5789 | Results.data(), Results.size()); | |||
5790 | } | |||
5791 | ||||
5792 | void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) { | |||
5793 | if (!CodeCompleter) | |||
5794 | return; | |||
5795 | ||||
5796 | ResultBuilder::LookupFilter Filter = nullptr; | |||
5797 | enum CodeCompletionContext::Kind ContextKind = | |||
5798 | CodeCompletionContext::CCC_Other; | |||
5799 | switch ((DeclSpec::TST)TagSpec) { | |||
5800 | case DeclSpec::TST_enum: | |||
5801 | Filter = &ResultBuilder::IsEnum; | |||
5802 | ContextKind = CodeCompletionContext::CCC_EnumTag; | |||
5803 | break; | |||
5804 | ||||
5805 | case DeclSpec::TST_union: | |||
5806 | Filter = &ResultBuilder::IsUnion; | |||
5807 | ContextKind = CodeCompletionContext::CCC_UnionTag; | |||
5808 | break; | |||
5809 | ||||
5810 | case DeclSpec::TST_struct: | |||
5811 | case DeclSpec::TST_class: | |||
5812 | case DeclSpec::TST_interface: | |||
5813 | Filter = &ResultBuilder::IsClassOrStruct; | |||
5814 | ContextKind = CodeCompletionContext::CCC_ClassOrStructTag; | |||
5815 | break; | |||
5816 | ||||
5817 | default: | |||
5818 | llvm_unreachable("Unknown type specifier kind in CodeCompleteTag")::llvm::llvm_unreachable_internal("Unknown type specifier kind in CodeCompleteTag" , "clang/lib/Sema/SemaCodeComplete.cpp", 5818); | |||
5819 | } | |||
5820 | ||||
5821 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
5822 | CodeCompleter->getCodeCompletionTUInfo(), ContextKind); | |||
5823 | CodeCompletionDeclConsumer Consumer(Results, CurContext); | |||
5824 | ||||
5825 | // First pass: look for tags. | |||
5826 | Results.setFilter(Filter); | |||
5827 | LookupVisibleDecls(S, LookupTagName, Consumer, | |||
5828 | CodeCompleter->includeGlobals(), | |||
5829 | CodeCompleter->loadExternal()); | |||
5830 | ||||
5831 | if (CodeCompleter->includeGlobals()) { | |||
5832 | // Second pass: look for nested name specifiers. | |||
5833 | Results.setFilter(&ResultBuilder::IsNestedNameSpecifier); | |||
5834 | LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer, | |||
5835 | CodeCompleter->includeGlobals(), | |||
5836 | CodeCompleter->loadExternal()); | |||
5837 | } | |||
5838 | ||||
5839 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
5840 | Results.data(), Results.size()); | |||
5841 | } | |||
5842 | ||||
5843 | static void AddTypeQualifierResults(DeclSpec &DS, ResultBuilder &Results, | |||
5844 | const LangOptions &LangOpts) { | |||
5845 | if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const)) | |||
5846 | Results.AddResult("const"); | |||
5847 | if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile)) | |||
5848 | Results.AddResult("volatile"); | |||
5849 | if (LangOpts.C99 && !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict)) | |||
5850 | Results.AddResult("restrict"); | |||
5851 | if (LangOpts.C11 && !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic)) | |||
5852 | Results.AddResult("_Atomic"); | |||
5853 | if (LangOpts.MSVCCompat && !(DS.getTypeQualifiers() & DeclSpec::TQ_unaligned)) | |||
5854 | Results.AddResult("__unaligned"); | |||
5855 | } | |||
5856 | ||||
5857 | void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) { | |||
5858 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
5859 | CodeCompleter->getCodeCompletionTUInfo(), | |||
5860 | CodeCompletionContext::CCC_TypeQualifiers); | |||
5861 | Results.EnterNewScope(); | |||
5862 | AddTypeQualifierResults(DS, Results, LangOpts); | |||
5863 | Results.ExitScope(); | |||
5864 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
5865 | Results.data(), Results.size()); | |||
5866 | } | |||
5867 | ||||
5868 | void Sema::CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D, | |||
5869 | const VirtSpecifiers *VS) { | |||
5870 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
5871 | CodeCompleter->getCodeCompletionTUInfo(), | |||
5872 | CodeCompletionContext::CCC_TypeQualifiers); | |||
5873 | Results.EnterNewScope(); | |||
5874 | AddTypeQualifierResults(DS, Results, LangOpts); | |||
5875 | if (LangOpts.CPlusPlus11) { | |||
5876 | Results.AddResult("noexcept"); | |||
5877 | if (D.getContext() == DeclaratorContext::Member && !D.isCtorOrDtor() && | |||
5878 | !D.isStaticMember()) { | |||
5879 | if (!VS || !VS->isFinalSpecified()) | |||
5880 | Results.AddResult("final"); | |||
5881 | if (!VS || !VS->isOverrideSpecified()) | |||
5882 | Results.AddResult("override"); | |||
5883 | } | |||
5884 | } | |||
5885 | Results.ExitScope(); | |||
5886 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
5887 | Results.data(), Results.size()); | |||
5888 | } | |||
5889 | ||||
5890 | void Sema::CodeCompleteBracketDeclarator(Scope *S) { | |||
5891 | CodeCompleteExpression(S, QualType(getASTContext().getSizeType())); | |||
5892 | } | |||
5893 | ||||
5894 | void Sema::CodeCompleteCase(Scope *S) { | |||
5895 | if (getCurFunction()->SwitchStack.empty() || !CodeCompleter) | |||
5896 | return; | |||
5897 | ||||
5898 | SwitchStmt *Switch = getCurFunction()->SwitchStack.back().getPointer(); | |||
5899 | // Condition expression might be invalid, do not continue in this case. | |||
5900 | if (!Switch->getCond()) | |||
5901 | return; | |||
5902 | QualType type = Switch->getCond()->IgnoreImplicit()->getType(); | |||
5903 | if (!type->isEnumeralType()) { | |||
5904 | CodeCompleteExpressionData Data(type); | |||
5905 | Data.IntegralConstantExpression = true; | |||
5906 | CodeCompleteExpression(S, Data); | |||
5907 | return; | |||
5908 | } | |||
5909 | ||||
5910 | // Code-complete the cases of a switch statement over an enumeration type | |||
5911 | // by providing the list of | |||
5912 | EnumDecl *Enum = type->castAs<EnumType>()->getDecl(); | |||
5913 | if (EnumDecl *Def = Enum->getDefinition()) | |||
5914 | Enum = Def; | |||
5915 | ||||
5916 | // Determine which enumerators we have already seen in the switch statement. | |||
5917 | // FIXME: Ideally, we would also be able to look *past* the code-completion | |||
5918 | // token, in case we are code-completing in the middle of the switch and not | |||
5919 | // at the end. However, we aren't able to do so at the moment. | |||
5920 | CoveredEnumerators Enumerators; | |||
5921 | for (SwitchCase *SC = Switch->getSwitchCaseList(); SC; | |||
5922 | SC = SC->getNextSwitchCase()) { | |||
5923 | CaseStmt *Case = dyn_cast<CaseStmt>(SC); | |||
5924 | if (!Case) | |||
5925 | continue; | |||
5926 | ||||
5927 | Expr *CaseVal = Case->getLHS()->IgnoreParenCasts(); | |||
5928 | if (auto *DRE = dyn_cast<DeclRefExpr>(CaseVal)) | |||
5929 | if (auto *Enumerator = | |||
5930 | dyn_cast<EnumConstantDecl>(DRE->getDecl())) { | |||
5931 | // We look into the AST of the case statement to determine which | |||
5932 | // enumerator was named. Alternatively, we could compute the value of | |||
5933 | // the integral constant expression, then compare it against the | |||
5934 | // values of each enumerator. However, value-based approach would not | |||
5935 | // work as well with C++ templates where enumerators declared within a | |||
5936 | // template are type- and value-dependent. | |||
5937 | Enumerators.Seen.insert(Enumerator); | |||
5938 | ||||
5939 | // If this is a qualified-id, keep track of the nested-name-specifier | |||
5940 | // so that we can reproduce it as part of code completion, e.g., | |||
5941 | // | |||
5942 | // switch (TagD.getKind()) { | |||
5943 | // case TagDecl::TK_enum: | |||
5944 | // break; | |||
5945 | // case XXX | |||
5946 | // | |||
5947 | // At the XXX, our completions are TagDecl::TK_union, | |||
5948 | // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union, | |||
5949 | // TK_struct, and TK_class. | |||
5950 | Enumerators.SuggestedQualifier = DRE->getQualifier(); | |||
5951 | } | |||
5952 | } | |||
5953 | ||||
5954 | // Add any enumerators that have not yet been mentioned. | |||
5955 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
5956 | CodeCompleter->getCodeCompletionTUInfo(), | |||
5957 | CodeCompletionContext::CCC_Expression); | |||
5958 | AddEnumerators(Results, Context, Enum, CurContext, Enumerators); | |||
5959 | ||||
5960 | if (CodeCompleter->includeMacros()) { | |||
5961 | AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false); | |||
5962 | } | |||
5963 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
5964 | Results.data(), Results.size()); | |||
5965 | } | |||
5966 | ||||
5967 | static bool anyNullArguments(ArrayRef<Expr *> Args) { | |||
5968 | if (Args.size() && !Args.data()) | |||
5969 | return true; | |||
5970 | ||||
5971 | for (unsigned I = 0; I != Args.size(); ++I) | |||
5972 | if (!Args[I]) | |||
5973 | return true; | |||
5974 | ||||
5975 | return false; | |||
5976 | } | |||
5977 | ||||
5978 | typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate; | |||
5979 | ||||
5980 | static void mergeCandidatesWithResults( | |||
5981 | Sema &SemaRef, SmallVectorImpl<ResultCandidate> &Results, | |||
5982 | OverloadCandidateSet &CandidateSet, SourceLocation Loc, size_t ArgSize) { | |||
5983 | // Sort the overload candidate set by placing the best overloads first. | |||
5984 | llvm::stable_sort(CandidateSet, [&](const OverloadCandidate &X, | |||
5985 | const OverloadCandidate &Y) { | |||
5986 | return isBetterOverloadCandidate(SemaRef, X, Y, Loc, | |||
5987 | CandidateSet.getKind()); | |||
5988 | }); | |||
5989 | ||||
5990 | // Add the remaining viable overload candidates as code-completion results. | |||
5991 | for (OverloadCandidate &Candidate : CandidateSet) { | |||
5992 | if (Candidate.Function) { | |||
5993 | if (Candidate.Function->isDeleted()) | |||
5994 | continue; | |||
5995 | if (shouldEnforceArgLimit(/*PartialOverloading=*/true, | |||
5996 | Candidate.Function) && | |||
5997 | Candidate.Function->getNumParams() <= ArgSize && | |||
5998 | // Having zero args is annoying, normally we don't surface a function | |||
5999 | // with 2 params, if you already have 2 params, because you are | |||
6000 | // inserting the 3rd now. But with zero, it helps the user to figure | |||
6001 | // out there are no overloads that take any arguments. Hence we are | |||
6002 | // keeping the overload. | |||
6003 | ArgSize > 0) | |||
6004 | continue; | |||
6005 | } | |||
6006 | if (Candidate.Viable) | |||
6007 | Results.push_back(ResultCandidate(Candidate.Function)); | |||
6008 | } | |||
6009 | } | |||
6010 | ||||
6011 | /// Get the type of the Nth parameter from a given set of overload | |||
6012 | /// candidates. | |||
6013 | static QualType getParamType(Sema &SemaRef, | |||
6014 | ArrayRef<ResultCandidate> Candidates, unsigned N) { | |||
6015 | ||||
6016 | // Given the overloads 'Candidates' for a function call matching all arguments | |||
6017 | // up to N, return the type of the Nth parameter if it is the same for all | |||
6018 | // overload candidates. | |||
6019 | QualType ParamType; | |||
6020 | for (auto &Candidate : Candidates) { | |||
6021 | QualType CandidateParamType = Candidate.getParamType(N); | |||
6022 | if (CandidateParamType.isNull()) | |||
6023 | continue; | |||
6024 | if (ParamType.isNull()) { | |||
6025 | ParamType = CandidateParamType; | |||
6026 | continue; | |||
6027 | } | |||
6028 | if (!SemaRef.Context.hasSameUnqualifiedType( | |||
6029 | ParamType.getNonReferenceType(), | |||
6030 | CandidateParamType.getNonReferenceType())) | |||
6031 | // Two conflicting types, give up. | |||
6032 | return QualType(); | |||
6033 | } | |||
6034 | ||||
6035 | return ParamType; | |||
6036 | } | |||
6037 | ||||
6038 | static QualType | |||
6039 | ProduceSignatureHelp(Sema &SemaRef, MutableArrayRef<ResultCandidate> Candidates, | |||
6040 | unsigned CurrentArg, SourceLocation OpenParLoc, | |||
6041 | bool Braced) { | |||
6042 | if (Candidates.empty()) | |||
6043 | return QualType(); | |||
6044 | if (SemaRef.getPreprocessor().isCodeCompletionReached()) | |||
6045 | SemaRef.CodeCompleter->ProcessOverloadCandidates( | |||
6046 | SemaRef, CurrentArg, Candidates.data(), Candidates.size(), OpenParLoc, | |||
6047 | Braced); | |||
6048 | return getParamType(SemaRef, Candidates, CurrentArg); | |||
6049 | } | |||
6050 | ||||
6051 | // Given a callee expression `Fn`, if the call is through a function pointer, | |||
6052 | // try to find the declaration of the corresponding function pointer type, | |||
6053 | // so that we can recover argument names from it. | |||
6054 | static FunctionProtoTypeLoc GetPrototypeLoc(Expr *Fn) { | |||
6055 | TypeLoc Target; | |||
6056 | if (const auto *T = Fn->getType().getTypePtr()->getAs<TypedefType>()) { | |||
6057 | Target = T->getDecl()->getTypeSourceInfo()->getTypeLoc(); | |||
6058 | ||||
6059 | } else if (const auto *DR = dyn_cast<DeclRefExpr>(Fn)) { | |||
6060 | const auto *D = DR->getDecl(); | |||
6061 | if (const auto *const VD = dyn_cast<VarDecl>(D)) { | |||
6062 | Target = VD->getTypeSourceInfo()->getTypeLoc(); | |||
6063 | } | |||
6064 | } | |||
6065 | ||||
6066 | if (!Target) | |||
6067 | return {}; | |||
6068 | ||||
6069 | if (auto P = Target.getAs<PointerTypeLoc>()) { | |||
6070 | Target = P.getPointeeLoc(); | |||
6071 | } | |||
6072 | ||||
6073 | if (auto P = Target.getAs<ParenTypeLoc>()) { | |||
6074 | Target = P.getInnerLoc(); | |||
6075 | } | |||
6076 | ||||
6077 | if (auto F = Target.getAs<FunctionProtoTypeLoc>()) { | |||
6078 | return F; | |||
6079 | } | |||
6080 | ||||
6081 | return {}; | |||
6082 | } | |||
6083 | ||||
6084 | QualType Sema::ProduceCallSignatureHelp(Expr *Fn, ArrayRef<Expr *> Args, | |||
6085 | SourceLocation OpenParLoc) { | |||
6086 | Fn = unwrapParenList(Fn); | |||
6087 | if (!CodeCompleter || !Fn) | |||
6088 | return QualType(); | |||
6089 | ||||
6090 | // FIXME: Provide support for variadic template functions. | |||
6091 | // Ignore type-dependent call expressions entirely. | |||
6092 | if (Fn->isTypeDependent() || anyNullArguments(Args)) | |||
6093 | return QualType(); | |||
6094 | // In presence of dependent args we surface all possible signatures using the | |||
6095 | // non-dependent args in the prefix. Afterwards we do a post filtering to make | |||
6096 | // sure provided candidates satisfy parameter count restrictions. | |||
6097 | auto ArgsWithoutDependentTypes = | |||
6098 | Args.take_while([](Expr *Arg) { return !Arg->isTypeDependent(); }); | |||
6099 | ||||
6100 | SmallVector<ResultCandidate, 8> Results; | |||
6101 | ||||
6102 | Expr *NakedFn = Fn->IgnoreParenCasts(); | |||
6103 | // Build an overload candidate set based on the functions we find. | |||
6104 | SourceLocation Loc = Fn->getExprLoc(); | |||
6105 | OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal); | |||
6106 | ||||
6107 | if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn)) { | |||
6108 | AddOverloadedCallCandidates(ULE, ArgsWithoutDependentTypes, CandidateSet, | |||
6109 | /*PartialOverloading=*/true); | |||
6110 | } else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) { | |||
6111 | TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr; | |||
6112 | if (UME->hasExplicitTemplateArgs()) { | |||
6113 | UME->copyTemplateArgumentsInto(TemplateArgsBuffer); | |||
6114 | TemplateArgs = &TemplateArgsBuffer; | |||
6115 | } | |||
6116 | ||||
6117 | // Add the base as first argument (use a nullptr if the base is implicit). | |||
6118 | SmallVector<Expr *, 12> ArgExprs( | |||
6119 | 1, UME->isImplicitAccess() ? nullptr : UME->getBase()); | |||
6120 | ArgExprs.append(ArgsWithoutDependentTypes.begin(), | |||
6121 | ArgsWithoutDependentTypes.end()); | |||
6122 | UnresolvedSet<8> Decls; | |||
6123 | Decls.append(UME->decls_begin(), UME->decls_end()); | |||
6124 | const bool FirstArgumentIsBase = !UME->isImplicitAccess() && UME->getBase(); | |||
6125 | AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs, | |||
6126 | /*SuppressUserConversions=*/false, | |||
6127 | /*PartialOverloading=*/true, FirstArgumentIsBase); | |||
6128 | } else { | |||
6129 | FunctionDecl *FD = nullptr; | |||
6130 | if (auto *MCE = dyn_cast<MemberExpr>(NakedFn)) | |||
6131 | FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl()); | |||
6132 | else if (auto *DRE = dyn_cast<DeclRefExpr>(NakedFn)) | |||
6133 | FD = dyn_cast<FunctionDecl>(DRE->getDecl()); | |||
6134 | if (FD) { // We check whether it's a resolved function declaration. | |||
6135 | if (!getLangOpts().CPlusPlus || | |||
6136 | !FD->getType()->getAs<FunctionProtoType>()) | |||
6137 | Results.push_back(ResultCandidate(FD)); | |||
6138 | else | |||
6139 | AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()), | |||
6140 | ArgsWithoutDependentTypes, CandidateSet, | |||
6141 | /*SuppressUserConversions=*/false, | |||
6142 | /*PartialOverloading=*/true); | |||
6143 | ||||
6144 | } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) { | |||
6145 | // If expression's type is CXXRecordDecl, it may overload the function | |||
6146 | // call operator, so we check if it does and add them as candidates. | |||
6147 | // A complete type is needed to lookup for member function call operators. | |||
6148 | if (isCompleteType(Loc, NakedFn->getType())) { | |||
6149 | DeclarationName OpName = | |||
6150 | Context.DeclarationNames.getCXXOperatorName(OO_Call); | |||
6151 | LookupResult R(*this, OpName, Loc, LookupOrdinaryName); | |||
6152 | LookupQualifiedName(R, DC); | |||
6153 | R.suppressDiagnostics(); | |||
6154 | SmallVector<Expr *, 12> ArgExprs(1, NakedFn); | |||
6155 | ArgExprs.append(ArgsWithoutDependentTypes.begin(), | |||
6156 | ArgsWithoutDependentTypes.end()); | |||
6157 | AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet, | |||
6158 | /*ExplicitArgs=*/nullptr, | |||
6159 | /*SuppressUserConversions=*/false, | |||
6160 | /*PartialOverloading=*/true); | |||
6161 | } | |||
6162 | } else { | |||
6163 | // Lastly we check whether expression's type is function pointer or | |||
6164 | // function. | |||
6165 | ||||
6166 | FunctionProtoTypeLoc P = GetPrototypeLoc(NakedFn); | |||
6167 | QualType T = NakedFn->getType(); | |||
6168 | if (!T->getPointeeType().isNull()) | |||
6169 | T = T->getPointeeType(); | |||
6170 | ||||
6171 | if (auto FP = T->getAs<FunctionProtoType>()) { | |||
6172 | if (!TooManyArguments(FP->getNumParams(), | |||
6173 | ArgsWithoutDependentTypes.size(), | |||
6174 | /*PartialOverloading=*/true) || | |||
6175 | FP->isVariadic()) { | |||
6176 | if (P) { | |||
6177 | Results.push_back(ResultCandidate(P)); | |||
6178 | } else { | |||
6179 | Results.push_back(ResultCandidate(FP)); | |||
6180 | } | |||
6181 | } | |||
6182 | } else if (auto FT = T->getAs<FunctionType>()) | |||
6183 | // No prototype and declaration, it may be a K & R style function. | |||
6184 | Results.push_back(ResultCandidate(FT)); | |||
6185 | } | |||
6186 | } | |||
6187 | mergeCandidatesWithResults(*this, Results, CandidateSet, Loc, Args.size()); | |||
6188 | QualType ParamType = ProduceSignatureHelp(*this, Results, Args.size(), | |||
6189 | OpenParLoc, /*Braced=*/false); | |||
6190 | return !CandidateSet.empty() ? ParamType : QualType(); | |||
6191 | } | |||
6192 | ||||
6193 | // Determine which param to continue aggregate initialization from after | |||
6194 | // a designated initializer. | |||
6195 | // | |||
6196 | // Given struct S { int a,b,c,d,e; }: | |||
6197 | // after `S{.b=1,` we want to suggest c to continue | |||
6198 | // after `S{.b=1, 2,` we continue with d (this is legal C and ext in C++) | |||
6199 | // after `S{.b=1, .a=2,` we continue with b (this is legal C and ext in C++) | |||
6200 | // | |||
6201 | // Possible outcomes: | |||
6202 | // - we saw a designator for a field, and continue from the returned index. | |||
6203 | // Only aggregate initialization is allowed. | |||
6204 | // - we saw a designator, but it was complex or we couldn't find the field. | |||
6205 | // Only aggregate initialization is possible, but we can't assist with it. | |||
6206 | // Returns an out-of-range index. | |||
6207 | // - we saw no designators, just positional arguments. | |||
6208 | // Returns std::nullopt. | |||
6209 | static std::optional<unsigned> | |||
6210 | getNextAggregateIndexAfterDesignatedInit(const ResultCandidate &Aggregate, | |||
6211 | ArrayRef<Expr *> Args) { | |||
6212 | static constexpr unsigned Invalid = std::numeric_limits<unsigned>::max(); | |||
6213 | assert(Aggregate.getKind() == ResultCandidate::CK_Aggregate)(static_cast <bool> (Aggregate.getKind() == ResultCandidate ::CK_Aggregate) ? void (0) : __assert_fail ("Aggregate.getKind() == ResultCandidate::CK_Aggregate" , "clang/lib/Sema/SemaCodeComplete.cpp", 6213, __extension__ __PRETTY_FUNCTION__ )); | |||
6214 | ||||
6215 | // Look for designated initializers. | |||
6216 | // They're in their syntactic form, not yet resolved to fields. | |||
6217 | const IdentifierInfo *DesignatedFieldName = nullptr; | |||
6218 | unsigned ArgsAfterDesignator = 0; | |||
6219 | for (const Expr *Arg : Args) { | |||
6220 | if (const auto *DIE = dyn_cast<DesignatedInitExpr>(Arg)) { | |||
6221 | if (DIE->size() == 1 && DIE->getDesignator(0)->isFieldDesignator()) { | |||
6222 | DesignatedFieldName = DIE->getDesignator(0)->getFieldName(); | |||
6223 | ArgsAfterDesignator = 0; | |||
6224 | } else { | |||
6225 | return Invalid; // Complicated designator. | |||
6226 | } | |||
6227 | } else if (isa<DesignatedInitUpdateExpr>(Arg)) { | |||
6228 | return Invalid; // Unsupported. | |||
6229 | } else { | |||
6230 | ++ArgsAfterDesignator; | |||
6231 | } | |||
6232 | } | |||
6233 | if (!DesignatedFieldName) | |||
6234 | return std::nullopt; | |||
6235 | ||||
6236 | // Find the index within the class's fields. | |||
6237 | // (Probing getParamDecl() directly would be quadratic in number of fields). | |||
6238 | unsigned DesignatedIndex = 0; | |||
6239 | const FieldDecl *DesignatedField = nullptr; | |||
6240 | for (const auto *Field : Aggregate.getAggregate()->fields()) { | |||
6241 | if (Field->getIdentifier() == DesignatedFieldName) { | |||
6242 | DesignatedField = Field; | |||
6243 | break; | |||
6244 | } | |||
6245 | ++DesignatedIndex; | |||
6246 | } | |||
6247 | if (!DesignatedField) | |||
6248 | return Invalid; // Designator referred to a missing field, give up. | |||
6249 | ||||
6250 | // Find the index within the aggregate (which may have leading bases). | |||
6251 | unsigned AggregateSize = Aggregate.getNumParams(); | |||
6252 | while (DesignatedIndex < AggregateSize && | |||
6253 | Aggregate.getParamDecl(DesignatedIndex) != DesignatedField) | |||
6254 | ++DesignatedIndex; | |||
6255 | ||||
6256 | // Continue from the index after the last named field. | |||
6257 | return DesignatedIndex + ArgsAfterDesignator + 1; | |||
6258 | } | |||
6259 | ||||
6260 | QualType Sema::ProduceConstructorSignatureHelp(QualType Type, | |||
6261 | SourceLocation Loc, | |||
6262 | ArrayRef<Expr *> Args, | |||
6263 | SourceLocation OpenParLoc, | |||
6264 | bool Braced) { | |||
6265 | if (!CodeCompleter) | |||
6266 | return QualType(); | |||
6267 | SmallVector<ResultCandidate, 8> Results; | |||
6268 | ||||
6269 | // A complete type is needed to lookup for constructors. | |||
6270 | RecordDecl *RD = | |||
6271 | isCompleteType(Loc, Type) ? Type->getAsRecordDecl() : nullptr; | |||
6272 | if (!RD) | |||
6273 | return Type; | |||
6274 | CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD); | |||
6275 | ||||
6276 | // Consider aggregate initialization. | |||
6277 | // We don't check that types so far are correct. | |||
6278 | // We also don't handle C99/C++17 brace-elision, we assume init-list elements | |||
6279 | // are 1:1 with fields. | |||
6280 | // FIXME: it would be nice to support "unwrapping" aggregates that contain | |||
6281 | // a single subaggregate, like std::array<T, N> -> T __elements[N]. | |||
6282 | if (Braced && !RD->isUnion() && | |||
6283 | (!LangOpts.CPlusPlus || (CRD && CRD->isAggregate()))) { | |||
6284 | ResultCandidate AggregateSig(RD); | |||
6285 | unsigned AggregateSize = AggregateSig.getNumParams(); | |||
6286 | ||||
6287 | if (auto NextIndex = | |||
6288 | getNextAggregateIndexAfterDesignatedInit(AggregateSig, Args)) { | |||
6289 | // A designator was used, only aggregate init is possible. | |||
6290 | if (*NextIndex >= AggregateSize) | |||
6291 | return Type; | |||
6292 | Results.push_back(AggregateSig); | |||
6293 | return ProduceSignatureHelp(*this, Results, *NextIndex, OpenParLoc, | |||
6294 | Braced); | |||
6295 | } | |||
6296 | ||||
6297 | // Describe aggregate initialization, but also constructors below. | |||
6298 | if (Args.size() < AggregateSize) | |||
6299 | Results.push_back(AggregateSig); | |||
6300 | } | |||
6301 | ||||
6302 | // FIXME: Provide support for member initializers. | |||
6303 | // FIXME: Provide support for variadic template constructors. | |||
6304 | ||||
6305 | if (CRD) { | |||
6306 | OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal); | |||
6307 | for (NamedDecl *C : LookupConstructors(CRD)) { | |||
6308 | if (auto *FD = dyn_cast<FunctionDecl>(C)) { | |||
6309 | // FIXME: we can't yet provide correct signature help for initializer | |||
6310 | // list constructors, so skip them entirely. | |||
6311 | if (Braced && LangOpts.CPlusPlus && isInitListConstructor(FD)) | |||
6312 | continue; | |||
6313 | AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()), Args, | |||
6314 | CandidateSet, | |||
6315 | /*SuppressUserConversions=*/false, | |||
6316 | /*PartialOverloading=*/true, | |||
6317 | /*AllowExplicit*/ true); | |||
6318 | } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(C)) { | |||
6319 | if (Braced && LangOpts.CPlusPlus && | |||
6320 | isInitListConstructor(FTD->getTemplatedDecl())) | |||
6321 | continue; | |||
6322 | ||||
6323 | AddTemplateOverloadCandidate( | |||
6324 | FTD, DeclAccessPair::make(FTD, C->getAccess()), | |||
6325 | /*ExplicitTemplateArgs=*/nullptr, Args, CandidateSet, | |||
6326 | /*SuppressUserConversions=*/false, | |||
6327 | /*PartialOverloading=*/true); | |||
6328 | } | |||
6329 | } | |||
6330 | mergeCandidatesWithResults(*this, Results, CandidateSet, Loc, Args.size()); | |||
6331 | } | |||
6332 | ||||
6333 | return ProduceSignatureHelp(*this, Results, Args.size(), OpenParLoc, Braced); | |||
6334 | } | |||
6335 | ||||
6336 | QualType Sema::ProduceCtorInitMemberSignatureHelp( | |||
6337 | Decl *ConstructorDecl, CXXScopeSpec SS, ParsedType TemplateTypeTy, | |||
6338 | ArrayRef<Expr *> ArgExprs, IdentifierInfo *II, SourceLocation OpenParLoc, | |||
6339 | bool Braced) { | |||
6340 | if (!CodeCompleter) | |||
6341 | return QualType(); | |||
6342 | ||||
6343 | CXXConstructorDecl *Constructor = | |||
6344 | dyn_cast<CXXConstructorDecl>(ConstructorDecl); | |||
6345 | if (!Constructor) | |||
6346 | return QualType(); | |||
6347 | // FIXME: Add support for Base class constructors as well. | |||
6348 | if (ValueDecl *MemberDecl = tryLookupCtorInitMemberDecl( | |||
6349 | Constructor->getParent(), SS, TemplateTypeTy, II)) | |||
6350 | return ProduceConstructorSignatureHelp(MemberDecl->getType(), | |||
6351 | MemberDecl->getLocation(), ArgExprs, | |||
6352 | OpenParLoc, Braced); | |||
6353 | return QualType(); | |||
6354 | } | |||
6355 | ||||
6356 | static bool argMatchesTemplateParams(const ParsedTemplateArgument &Arg, | |||
6357 | unsigned Index, | |||
6358 | const TemplateParameterList &Params) { | |||
6359 | const NamedDecl *Param; | |||
6360 | if (Index < Params.size()) | |||
6361 | Param = Params.getParam(Index); | |||
6362 | else if (Params.hasParameterPack()) | |||
6363 | Param = Params.asArray().back(); | |||
6364 | else | |||
6365 | return false; // too many args | |||
6366 | ||||
6367 | switch (Arg.getKind()) { | |||
6368 | case ParsedTemplateArgument::Type: | |||
6369 | return llvm::isa<TemplateTypeParmDecl>(Param); // constraints not checked | |||
6370 | case ParsedTemplateArgument::NonType: | |||
6371 | return llvm::isa<NonTypeTemplateParmDecl>(Param); // type not checked | |||
6372 | case ParsedTemplateArgument::Template: | |||
6373 | return llvm::isa<TemplateTemplateParmDecl>(Param); // signature not checked | |||
6374 | } | |||
6375 | llvm_unreachable("Unhandled switch case")::llvm::llvm_unreachable_internal("Unhandled switch case", "clang/lib/Sema/SemaCodeComplete.cpp" , 6375); | |||
6376 | } | |||
6377 | ||||
6378 | QualType Sema::ProduceTemplateArgumentSignatureHelp( | |||
6379 | TemplateTy ParsedTemplate, ArrayRef<ParsedTemplateArgument> Args, | |||
6380 | SourceLocation LAngleLoc) { | |||
6381 | if (!CodeCompleter || !ParsedTemplate) | |||
6382 | return QualType(); | |||
6383 | ||||
6384 | SmallVector<ResultCandidate, 8> Results; | |||
6385 | auto Consider = [&](const TemplateDecl *TD) { | |||
6386 | // Only add if the existing args are compatible with the template. | |||
6387 | bool Matches = true; | |||
6388 | for (unsigned I = 0; I < Args.size(); ++I) { | |||
6389 | if (!argMatchesTemplateParams(Args[I], I, *TD->getTemplateParameters())) { | |||
6390 | Matches = false; | |||
6391 | break; | |||
6392 | } | |||
6393 | } | |||
6394 | if (Matches) | |||
6395 | Results.emplace_back(TD); | |||
6396 | }; | |||
6397 | ||||
6398 | TemplateName Template = ParsedTemplate.get(); | |||
6399 | if (const auto *TD = Template.getAsTemplateDecl()) { | |||
6400 | Consider(TD); | |||
6401 | } else if (const auto *OTS = Template.getAsOverloadedTemplate()) { | |||
6402 | for (const NamedDecl *ND : *OTS) | |||
6403 | if (const auto *TD = llvm::dyn_cast<TemplateDecl>(ND)) | |||
6404 | Consider(TD); | |||
6405 | } | |||
6406 | return ProduceSignatureHelp(*this, Results, Args.size(), LAngleLoc, | |||
6407 | /*Braced=*/false); | |||
6408 | } | |||
6409 | ||||
6410 | static QualType getDesignatedType(QualType BaseType, const Designation &Desig) { | |||
6411 | for (unsigned I = 0; I < Desig.getNumDesignators(); ++I) { | |||
6412 | if (BaseType.isNull()) | |||
6413 | break; | |||
6414 | QualType NextType; | |||
6415 | const auto &D = Desig.getDesignator(I); | |||
6416 | if (D.isArrayDesignator() || D.isArrayRangeDesignator()) { | |||
6417 | if (BaseType->isArrayType()) | |||
6418 | NextType = BaseType->getAsArrayTypeUnsafe()->getElementType(); | |||
6419 | } else { | |||
6420 | assert(D.isFieldDesignator())(static_cast <bool> (D.isFieldDesignator()) ? void (0) : __assert_fail ("D.isFieldDesignator()", "clang/lib/Sema/SemaCodeComplete.cpp" , 6420, __extension__ __PRETTY_FUNCTION__)); | |||
6421 | auto *RD = getAsRecordDecl(BaseType); | |||
6422 | if (RD && RD->isCompleteDefinition()) { | |||
6423 | for (const auto *Member : RD->lookup(D.getFieldDecl())) | |||
6424 | if (const FieldDecl *FD = llvm::dyn_cast<FieldDecl>(Member)) { | |||
6425 | NextType = FD->getType(); | |||
6426 | break; | |||
6427 | } | |||
6428 | } | |||
6429 | } | |||
6430 | BaseType = NextType; | |||
6431 | } | |||
6432 | return BaseType; | |||
6433 | } | |||
6434 | ||||
6435 | void Sema::CodeCompleteDesignator(QualType BaseType, | |||
6436 | llvm::ArrayRef<Expr *> InitExprs, | |||
6437 | const Designation &D) { | |||
6438 | BaseType = getDesignatedType(BaseType, D); | |||
6439 | if (BaseType.isNull()) | |||
6440 | return; | |||
6441 | const auto *RD = getAsRecordDecl(BaseType); | |||
6442 | if (!RD || RD->fields().empty()) | |||
6443 | return; | |||
6444 | ||||
6445 | CodeCompletionContext CCC(CodeCompletionContext::CCC_DotMemberAccess, | |||
6446 | BaseType); | |||
6447 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
6448 | CodeCompleter->getCodeCompletionTUInfo(), CCC); | |||
6449 | ||||
6450 | Results.EnterNewScope(); | |||
6451 | for (const Decl *D : RD->decls()) { | |||
6452 | const FieldDecl *FD; | |||
6453 | if (auto *IFD = dyn_cast<IndirectFieldDecl>(D)) | |||
6454 | FD = IFD->getAnonField(); | |||
6455 | else if (auto *DFD = dyn_cast<FieldDecl>(D)) | |||
6456 | FD = DFD; | |||
6457 | else | |||
6458 | continue; | |||
6459 | ||||
6460 | // FIXME: Make use of previous designators to mark any fields before those | |||
6461 | // inaccessible, and also compute the next initializer priority. | |||
6462 | ResultBuilder::Result Result(FD, Results.getBasePriority(FD)); | |||
6463 | Results.AddResult(Result, CurContext, /*Hiding=*/nullptr); | |||
6464 | } | |||
6465 | Results.ExitScope(); | |||
6466 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
6467 | Results.data(), Results.size()); | |||
6468 | } | |||
6469 | ||||
6470 | void Sema::CodeCompleteInitializer(Scope *S, Decl *D) { | |||
6471 | ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D); | |||
6472 | if (!VD) { | |||
6473 | CodeCompleteOrdinaryName(S, PCC_Expression); | |||
6474 | return; | |||
6475 | } | |||
6476 | ||||
6477 | CodeCompleteExpressionData Data; | |||
6478 | Data.PreferredType = VD->getType(); | |||
6479 | // Ignore VD to avoid completing the variable itself, e.g. in 'int foo = ^'. | |||
6480 | Data.IgnoreDecls.push_back(VD); | |||
6481 | ||||
6482 | CodeCompleteExpression(S, Data); | |||
6483 | } | |||
6484 | ||||
6485 | void Sema::CodeCompleteAfterIf(Scope *S, bool IsBracedThen) { | |||
6486 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
6487 | CodeCompleter->getCodeCompletionTUInfo(), | |||
6488 | mapCodeCompletionContext(*this, PCC_Statement)); | |||
6489 | Results.setFilter(&ResultBuilder::IsOrdinaryName); | |||
6490 | Results.EnterNewScope(); | |||
6491 | ||||
6492 | CodeCompletionDeclConsumer Consumer(Results, CurContext); | |||
6493 | LookupVisibleDecls(S, LookupOrdinaryName, Consumer, | |||
6494 | CodeCompleter->includeGlobals(), | |||
6495 | CodeCompleter->loadExternal()); | |||
6496 | ||||
6497 | AddOrdinaryNameResults(PCC_Statement, S, *this, Results); | |||
6498 | ||||
6499 | // "else" block | |||
6500 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
6501 | Results.getCodeCompletionTUInfo()); | |||
6502 | ||||
6503 | auto AddElseBodyPattern = [&] { | |||
6504 | if (IsBracedThen) { | |||
6505 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
6506 | Builder.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
6507 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
6508 | Builder.AddPlaceholderChunk("statements"); | |||
6509 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
6510 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
6511 | } else { | |||
6512 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
6513 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
6514 | Builder.AddPlaceholderChunk("statement"); | |||
6515 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
6516 | } | |||
6517 | }; | |||
6518 | Builder.AddTypedTextChunk("else"); | |||
6519 | if (Results.includeCodePatterns()) | |||
6520 | AddElseBodyPattern(); | |||
6521 | Results.AddResult(Builder.TakeString()); | |||
6522 | ||||
6523 | // "else if" block | |||
6524 | Builder.AddTypedTextChunk("else if"); | |||
6525 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
6526 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
6527 | if (getLangOpts().CPlusPlus) | |||
6528 | Builder.AddPlaceholderChunk("condition"); | |||
6529 | else | |||
6530 | Builder.AddPlaceholderChunk("expression"); | |||
6531 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
6532 | if (Results.includeCodePatterns()) { | |||
6533 | AddElseBodyPattern(); | |||
6534 | } | |||
6535 | Results.AddResult(Builder.TakeString()); | |||
6536 | ||||
6537 | Results.ExitScope(); | |||
6538 | ||||
6539 | if (S->getFnParent()) | |||
6540 | AddPrettyFunctionResults(getLangOpts(), Results); | |||
6541 | ||||
6542 | if (CodeCompleter->includeMacros()) | |||
6543 | AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false); | |||
6544 | ||||
6545 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
6546 | Results.data(), Results.size()); | |||
6547 | } | |||
6548 | ||||
6549 | void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, | |||
6550 | bool EnteringContext, | |||
6551 | bool IsUsingDeclaration, QualType BaseType, | |||
6552 | QualType PreferredType) { | |||
6553 | if (SS.isEmpty() || !CodeCompleter) | |||
6554 | return; | |||
6555 | ||||
6556 | CodeCompletionContext CC(CodeCompletionContext::CCC_Symbol, PreferredType); | |||
6557 | CC.setIsUsingDeclaration(IsUsingDeclaration); | |||
6558 | CC.setCXXScopeSpecifier(SS); | |||
6559 | ||||
6560 | // We want to keep the scope specifier even if it's invalid (e.g. the scope | |||
6561 | // "a::b::" is not corresponding to any context/namespace in the AST), since | |||
6562 | // it can be useful for global code completion which have information about | |||
6563 | // contexts/symbols that are not in the AST. | |||
6564 | if (SS.isInvalid()) { | |||
6565 | // As SS is invalid, we try to collect accessible contexts from the current | |||
6566 | // scope with a dummy lookup so that the completion consumer can try to | |||
6567 | // guess what the specified scope is. | |||
6568 | ResultBuilder DummyResults(*this, CodeCompleter->getAllocator(), | |||
6569 | CodeCompleter->getCodeCompletionTUInfo(), CC); | |||
6570 | if (!PreferredType.isNull()) | |||
6571 | DummyResults.setPreferredType(PreferredType); | |||
6572 | if (S->getEntity()) { | |||
6573 | CodeCompletionDeclConsumer Consumer(DummyResults, S->getEntity(), | |||
6574 | BaseType); | |||
6575 | LookupVisibleDecls(S, LookupOrdinaryName, Consumer, | |||
6576 | /*IncludeGlobalScope=*/false, | |||
6577 | /*LoadExternal=*/false); | |||
6578 | } | |||
6579 | HandleCodeCompleteResults(this, CodeCompleter, | |||
6580 | DummyResults.getCompletionContext(), nullptr, 0); | |||
6581 | return; | |||
6582 | } | |||
6583 | // Always pretend to enter a context to ensure that a dependent type | |||
6584 | // resolves to a dependent record. | |||
6585 | DeclContext *Ctx = computeDeclContext(SS, /*EnteringContext=*/true); | |||
6586 | ||||
6587 | // Try to instantiate any non-dependent declaration contexts before | |||
6588 | // we look in them. Bail out if we fail. | |||
6589 | NestedNameSpecifier *NNS = SS.getScopeRep(); | |||
6590 | if (NNS != nullptr && SS.isValid() && !NNS->isDependent()) { | |||
6591 | if (Ctx == nullptr || RequireCompleteDeclContext(SS, Ctx)) | |||
6592 | return; | |||
6593 | } | |||
6594 | ||||
6595 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
6596 | CodeCompleter->getCodeCompletionTUInfo(), CC); | |||
6597 | if (!PreferredType.isNull()) | |||
6598 | Results.setPreferredType(PreferredType); | |||
6599 | Results.EnterNewScope(); | |||
6600 | ||||
6601 | // The "template" keyword can follow "::" in the grammar, but only | |||
6602 | // put it into the grammar if the nested-name-specifier is dependent. | |||
6603 | // FIXME: results is always empty, this appears to be dead. | |||
6604 | if (!Results.empty() && NNS->isDependent()) | |||
6605 | Results.AddResult("template"); | |||
6606 | ||||
6607 | // If the scope is a concept-constrained type parameter, infer nested | |||
6608 | // members based on the constraints. | |||
6609 | if (const auto *TTPT = | |||
6610 | dyn_cast_or_null<TemplateTypeParmType>(NNS->getAsType())) { | |||
6611 | for (const auto &R : ConceptInfo(*TTPT, S).members()) { | |||
6612 | if (R.Operator != ConceptInfo::Member::Colons) | |||
6613 | continue; | |||
6614 | Results.AddResult(CodeCompletionResult( | |||
6615 | R.render(*this, CodeCompleter->getAllocator(), | |||
6616 | CodeCompleter->getCodeCompletionTUInfo()))); | |||
6617 | } | |||
6618 | } | |||
6619 | ||||
6620 | // Add calls to overridden virtual functions, if there are any. | |||
6621 | // | |||
6622 | // FIXME: This isn't wonderful, because we don't know whether we're actually | |||
6623 | // in a context that permits expressions. This is a general issue with | |||
6624 | // qualified-id completions. | |||
6625 | if (Ctx && !EnteringContext) | |||
6626 | MaybeAddOverrideCalls(*this, Ctx, Results); | |||
6627 | Results.ExitScope(); | |||
6628 | ||||
6629 | if (Ctx && | |||
6630 | (CodeCompleter->includeNamespaceLevelDecls() || !Ctx->isFileContext())) { | |||
6631 | CodeCompletionDeclConsumer Consumer(Results, Ctx, BaseType); | |||
6632 | LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer, | |||
6633 | /*IncludeGlobalScope=*/true, | |||
6634 | /*IncludeDependentBases=*/true, | |||
6635 | CodeCompleter->loadExternal()); | |||
6636 | } | |||
6637 | ||||
6638 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
6639 | Results.data(), Results.size()); | |||
6640 | } | |||
6641 | ||||
6642 | void Sema::CodeCompleteUsing(Scope *S) { | |||
6643 | if (!CodeCompleter) | |||
6644 | return; | |||
6645 | ||||
6646 | // This can be both a using alias or using declaration, in the former we | |||
6647 | // expect a new name and a symbol in the latter case. | |||
6648 | CodeCompletionContext Context(CodeCompletionContext::CCC_SymbolOrNewName); | |||
6649 | Context.setIsUsingDeclaration(true); | |||
6650 | ||||
6651 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
6652 | CodeCompleter->getCodeCompletionTUInfo(), Context, | |||
6653 | &ResultBuilder::IsNestedNameSpecifier); | |||
6654 | Results.EnterNewScope(); | |||
6655 | ||||
6656 | // If we aren't in class scope, we could see the "namespace" keyword. | |||
6657 | if (!S->isClassScope()) | |||
6658 | Results.AddResult(CodeCompletionResult("namespace")); | |||
6659 | ||||
6660 | // After "using", we can see anything that would start a | |||
6661 | // nested-name-specifier. | |||
6662 | CodeCompletionDeclConsumer Consumer(Results, CurContext); | |||
6663 | LookupVisibleDecls(S, LookupOrdinaryName, Consumer, | |||
6664 | CodeCompleter->includeGlobals(), | |||
6665 | CodeCompleter->loadExternal()); | |||
6666 | Results.ExitScope(); | |||
6667 | ||||
6668 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
6669 | Results.data(), Results.size()); | |||
6670 | } | |||
6671 | ||||
6672 | void Sema::CodeCompleteUsingDirective(Scope *S) { | |||
6673 | if (!CodeCompleter) | |||
6674 | return; | |||
6675 | ||||
6676 | // After "using namespace", we expect to see a namespace name or namespace | |||
6677 | // alias. | |||
6678 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
6679 | CodeCompleter->getCodeCompletionTUInfo(), | |||
6680 | CodeCompletionContext::CCC_Namespace, | |||
6681 | &ResultBuilder::IsNamespaceOrAlias); | |||
6682 | Results.EnterNewScope(); | |||
6683 | CodeCompletionDeclConsumer Consumer(Results, CurContext); | |||
6684 | LookupVisibleDecls(S, LookupOrdinaryName, Consumer, | |||
6685 | CodeCompleter->includeGlobals(), | |||
6686 | CodeCompleter->loadExternal()); | |||
6687 | Results.ExitScope(); | |||
6688 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
6689 | Results.data(), Results.size()); | |||
6690 | } | |||
6691 | ||||
6692 | void Sema::CodeCompleteNamespaceDecl(Scope *S) { | |||
6693 | if (!CodeCompleter) | |||
6694 | return; | |||
6695 | ||||
6696 | DeclContext *Ctx = S->getEntity(); | |||
6697 | if (!S->getParent()) | |||
6698 | Ctx = Context.getTranslationUnitDecl(); | |||
6699 | ||||
6700 | bool SuppressedGlobalResults = | |||
6701 | Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx); | |||
6702 | ||||
6703 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
6704 | CodeCompleter->getCodeCompletionTUInfo(), | |||
6705 | SuppressedGlobalResults | |||
6706 | ? CodeCompletionContext::CCC_Namespace | |||
6707 | : CodeCompletionContext::CCC_Other, | |||
6708 | &ResultBuilder::IsNamespace); | |||
6709 | ||||
6710 | if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) { | |||
6711 | // We only want to see those namespaces that have already been defined | |||
6712 | // within this scope, because its likely that the user is creating an | |||
6713 | // extended namespace declaration. Keep track of the most recent | |||
6714 | // definition of each namespace. | |||
6715 | std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest; | |||
6716 | for (DeclContext::specific_decl_iterator<NamespaceDecl> | |||
6717 | NS(Ctx->decls_begin()), | |||
6718 | NSEnd(Ctx->decls_end()); | |||
6719 | NS != NSEnd; ++NS) | |||
6720 | OrigToLatest[NS->getOriginalNamespace()] = *NS; | |||
6721 | ||||
6722 | // Add the most recent definition (or extended definition) of each | |||
6723 | // namespace to the list of results. | |||
6724 | Results.EnterNewScope(); | |||
6725 | for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator | |||
6726 | NS = OrigToLatest.begin(), | |||
6727 | NSEnd = OrigToLatest.end(); | |||
6728 | NS != NSEnd; ++NS) | |||
6729 | Results.AddResult( | |||
6730 | CodeCompletionResult(NS->second, Results.getBasePriority(NS->second), | |||
6731 | nullptr), | |||
6732 | CurContext, nullptr, false); | |||
6733 | Results.ExitScope(); | |||
6734 | } | |||
6735 | ||||
6736 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
6737 | Results.data(), Results.size()); | |||
6738 | } | |||
6739 | ||||
6740 | void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) { | |||
6741 | if (!CodeCompleter) | |||
6742 | return; | |||
6743 | ||||
6744 | // After "namespace", we expect to see a namespace or alias. | |||
6745 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
6746 | CodeCompleter->getCodeCompletionTUInfo(), | |||
6747 | CodeCompletionContext::CCC_Namespace, | |||
6748 | &ResultBuilder::IsNamespaceOrAlias); | |||
6749 | CodeCompletionDeclConsumer Consumer(Results, CurContext); | |||
6750 | LookupVisibleDecls(S, LookupOrdinaryName, Consumer, | |||
6751 | CodeCompleter->includeGlobals(), | |||
6752 | CodeCompleter->loadExternal()); | |||
6753 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
6754 | Results.data(), Results.size()); | |||
6755 | } | |||
6756 | ||||
6757 | void Sema::CodeCompleteOperatorName(Scope *S) { | |||
6758 | if (!CodeCompleter) | |||
6759 | return; | |||
6760 | ||||
6761 | typedef CodeCompletionResult Result; | |||
6762 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
6763 | CodeCompleter->getCodeCompletionTUInfo(), | |||
6764 | CodeCompletionContext::CCC_Type, | |||
6765 | &ResultBuilder::IsType); | |||
6766 | Results.EnterNewScope(); | |||
6767 | ||||
6768 | // Add the names of overloadable operators. Note that OO_Conditional is not | |||
6769 | // actually overloadable. | |||
6770 | #define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \ | |||
6771 | if (OO_##Name != OO_Conditional) \ | |||
6772 | Results.AddResult(Result(Spelling)); | |||
6773 | #include "clang/Basic/OperatorKinds.def" | |||
6774 | ||||
6775 | // Add any type names visible from the current scope | |||
6776 | Results.allowNestedNameSpecifiers(); | |||
6777 | CodeCompletionDeclConsumer Consumer(Results, CurContext); | |||
6778 | LookupVisibleDecls(S, LookupOrdinaryName, Consumer, | |||
6779 | CodeCompleter->includeGlobals(), | |||
6780 | CodeCompleter->loadExternal()); | |||
6781 | ||||
6782 | // Add any type specifiers | |||
6783 | AddTypeSpecifierResults(getLangOpts(), Results); | |||
6784 | Results.ExitScope(); | |||
6785 | ||||
6786 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
6787 | Results.data(), Results.size()); | |||
6788 | } | |||
6789 | ||||
6790 | void Sema::CodeCompleteConstructorInitializer( | |||
6791 | Decl *ConstructorD, ArrayRef<CXXCtorInitializer *> Initializers) { | |||
6792 | if (!ConstructorD) | |||
6793 | return; | |||
6794 | ||||
6795 | AdjustDeclIfTemplate(ConstructorD); | |||
6796 | ||||
6797 | auto *Constructor = dyn_cast<CXXConstructorDecl>(ConstructorD); | |||
6798 | if (!Constructor) | |||
6799 | return; | |||
6800 | ||||
6801 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
6802 | CodeCompleter->getCodeCompletionTUInfo(), | |||
6803 | CodeCompletionContext::CCC_Symbol); | |||
6804 | Results.EnterNewScope(); | |||
6805 | ||||
6806 | // Fill in any already-initialized fields or base classes. | |||
6807 | llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields; | |||
6808 | llvm::SmallPtrSet<CanQualType, 4> InitializedBases; | |||
6809 | for (unsigned I = 0, E = Initializers.size(); I != E; ++I) { | |||
6810 | if (Initializers[I]->isBaseInitializer()) | |||
6811 | InitializedBases.insert(Context.getCanonicalType( | |||
6812 | QualType(Initializers[I]->getBaseClass(), 0))); | |||
6813 | else | |||
6814 | InitializedFields.insert( | |||
6815 | cast<FieldDecl>(Initializers[I]->getAnyMember())); | |||
6816 | } | |||
6817 | ||||
6818 | // Add completions for base classes. | |||
6819 | PrintingPolicy Policy = getCompletionPrintingPolicy(*this); | |||
6820 | bool SawLastInitializer = Initializers.empty(); | |||
6821 | CXXRecordDecl *ClassDecl = Constructor->getParent(); | |||
6822 | ||||
6823 | auto GenerateCCS = [&](const NamedDecl *ND, const char *Name) { | |||
6824 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
6825 | Results.getCodeCompletionTUInfo()); | |||
6826 | Builder.AddTypedTextChunk(Name); | |||
6827 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
6828 | if (const auto *Function = dyn_cast<FunctionDecl>(ND)) | |||
6829 | AddFunctionParameterChunks(PP, Policy, Function, Builder); | |||
6830 | else if (const auto *FunTemplDecl = dyn_cast<FunctionTemplateDecl>(ND)) | |||
6831 | AddFunctionParameterChunks(PP, Policy, FunTemplDecl->getTemplatedDecl(), | |||
6832 | Builder); | |||
6833 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
6834 | return Builder.TakeString(); | |||
6835 | }; | |||
6836 | auto AddDefaultCtorInit = [&](const char *Name, const char *Type, | |||
6837 | const NamedDecl *ND) { | |||
6838 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
6839 | Results.getCodeCompletionTUInfo()); | |||
6840 | Builder.AddTypedTextChunk(Name); | |||
6841 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
6842 | Builder.AddPlaceholderChunk(Type); | |||
6843 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
6844 | if (ND) { | |||
6845 | auto CCR = CodeCompletionResult( | |||
6846 | Builder.TakeString(), ND, | |||
6847 | SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration); | |||
6848 | if (isa<FieldDecl>(ND)) | |||
6849 | CCR.CursorKind = CXCursor_MemberRef; | |||
6850 | return Results.AddResult(CCR); | |||
6851 | } | |||
6852 | return Results.AddResult(CodeCompletionResult( | |||
6853 | Builder.TakeString(), | |||
6854 | SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration)); | |||
6855 | }; | |||
6856 | auto AddCtorsWithName = [&](const CXXRecordDecl *RD, unsigned int Priority, | |||
6857 | const char *Name, const FieldDecl *FD) { | |||
6858 | if (!RD) | |||
6859 | return AddDefaultCtorInit(Name, | |||
6860 | FD ? Results.getAllocator().CopyString( | |||
6861 | FD->getType().getAsString(Policy)) | |||
6862 | : Name, | |||
6863 | FD); | |||
6864 | auto Ctors = getConstructors(Context, RD); | |||
6865 | if (Ctors.begin() == Ctors.end()) | |||
6866 | return AddDefaultCtorInit(Name, Name, RD); | |||
6867 | for (const NamedDecl *Ctor : Ctors) { | |||
6868 | auto CCR = CodeCompletionResult(GenerateCCS(Ctor, Name), RD, Priority); | |||
6869 | CCR.CursorKind = getCursorKindForDecl(Ctor); | |||
6870 | Results.AddResult(CCR); | |||
6871 | } | |||
6872 | }; | |||
6873 | auto AddBase = [&](const CXXBaseSpecifier &Base) { | |||
6874 | const char *BaseName = | |||
6875 | Results.getAllocator().CopyString(Base.getType().getAsString(Policy)); | |||
6876 | const auto *RD = Base.getType()->getAsCXXRecordDecl(); | |||
6877 | AddCtorsWithName( | |||
6878 | RD, SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration, | |||
6879 | BaseName, nullptr); | |||
6880 | }; | |||
6881 | auto AddField = [&](const FieldDecl *FD) { | |||
6882 | const char *FieldName = | |||
6883 | Results.getAllocator().CopyString(FD->getIdentifier()->getName()); | |||
6884 | const CXXRecordDecl *RD = FD->getType()->getAsCXXRecordDecl(); | |||
6885 | AddCtorsWithName( | |||
6886 | RD, SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration, | |||
6887 | FieldName, FD); | |||
6888 | }; | |||
6889 | ||||
6890 | for (const auto &Base : ClassDecl->bases()) { | |||
6891 | if (!InitializedBases.insert(Context.getCanonicalType(Base.getType())) | |||
6892 | .second) { | |||
6893 | SawLastInitializer = | |||
6894 | !Initializers.empty() && Initializers.back()->isBaseInitializer() && | |||
6895 | Context.hasSameUnqualifiedType( | |||
6896 | Base.getType(), QualType(Initializers.back()->getBaseClass(), 0)); | |||
6897 | continue; | |||
6898 | } | |||
6899 | ||||
6900 | AddBase(Base); | |||
6901 | SawLastInitializer = false; | |||
6902 | } | |||
6903 | ||||
6904 | // Add completions for virtual base classes. | |||
6905 | for (const auto &Base : ClassDecl->vbases()) { | |||
6906 | if (!InitializedBases.insert(Context.getCanonicalType(Base.getType())) | |||
6907 | .second) { | |||
6908 | SawLastInitializer = | |||
6909 | !Initializers.empty() && Initializers.back()->isBaseInitializer() && | |||
6910 | Context.hasSameUnqualifiedType( | |||
6911 | Base.getType(), QualType(Initializers.back()->getBaseClass(), 0)); | |||
6912 | continue; | |||
6913 | } | |||
6914 | ||||
6915 | AddBase(Base); | |||
6916 | SawLastInitializer = false; | |||
6917 | } | |||
6918 | ||||
6919 | // Add completions for members. | |||
6920 | for (auto *Field : ClassDecl->fields()) { | |||
6921 | if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl())) | |||
6922 | .second) { | |||
6923 | SawLastInitializer = !Initializers.empty() && | |||
6924 | Initializers.back()->isAnyMemberInitializer() && | |||
6925 | Initializers.back()->getAnyMember() == Field; | |||
6926 | continue; | |||
6927 | } | |||
6928 | ||||
6929 | if (!Field->getDeclName()) | |||
6930 | continue; | |||
6931 | ||||
6932 | AddField(Field); | |||
6933 | SawLastInitializer = false; | |||
6934 | } | |||
6935 | Results.ExitScope(); | |||
6936 | ||||
6937 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
6938 | Results.data(), Results.size()); | |||
6939 | } | |||
6940 | ||||
6941 | /// Determine whether this scope denotes a namespace. | |||
6942 | static bool isNamespaceScope(Scope *S) { | |||
6943 | DeclContext *DC = S->getEntity(); | |||
6944 | if (!DC) | |||
6945 | return false; | |||
6946 | ||||
6947 | return DC->isFileContext(); | |||
6948 | } | |||
6949 | ||||
6950 | void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro, | |||
6951 | bool AfterAmpersand) { | |||
6952 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
6953 | CodeCompleter->getCodeCompletionTUInfo(), | |||
6954 | CodeCompletionContext::CCC_Other); | |||
6955 | Results.EnterNewScope(); | |||
6956 | ||||
6957 | // Note what has already been captured. | |||
6958 | llvm::SmallPtrSet<IdentifierInfo *, 4> Known; | |||
6959 | bool IncludedThis = false; | |||
6960 | for (const auto &C : Intro.Captures) { | |||
6961 | if (C.Kind == LCK_This) { | |||
6962 | IncludedThis = true; | |||
6963 | continue; | |||
6964 | } | |||
6965 | ||||
6966 | Known.insert(C.Id); | |||
6967 | } | |||
6968 | ||||
6969 | // Look for other capturable variables. | |||
6970 | for (; S && !isNamespaceScope(S); S = S->getParent()) { | |||
6971 | for (const auto *D : S->decls()) { | |||
6972 | const auto *Var = dyn_cast<VarDecl>(D); | |||
6973 | if (!Var || !Var->hasLocalStorage() || Var->hasAttr<BlocksAttr>()) | |||
6974 | continue; | |||
6975 | ||||
6976 | if (Known.insert(Var->getIdentifier()).second) | |||
6977 | Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration), | |||
6978 | CurContext, nullptr, false); | |||
6979 | } | |||
6980 | } | |||
6981 | ||||
6982 | // Add 'this', if it would be valid. | |||
6983 | if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy) | |||
6984 | addThisCompletion(*this, Results); | |||
6985 | ||||
6986 | Results.ExitScope(); | |||
6987 | ||||
6988 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
6989 | Results.data(), Results.size()); | |||
6990 | } | |||
6991 | ||||
6992 | void Sema::CodeCompleteAfterFunctionEquals(Declarator &D) { | |||
6993 | if (!LangOpts.CPlusPlus11) | |||
6994 | return; | |||
6995 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
6996 | CodeCompleter->getCodeCompletionTUInfo(), | |||
6997 | CodeCompletionContext::CCC_Other); | |||
6998 | auto ShouldAddDefault = [&D, this]() { | |||
6999 | if (!D.isFunctionDeclarator()) | |||
7000 | return false; | |||
7001 | auto &Id = D.getName(); | |||
7002 | if (Id.getKind() == UnqualifiedIdKind::IK_DestructorName) | |||
7003 | return true; | |||
7004 | // FIXME(liuhui): Ideally, we should check the constructor parameter list to | |||
7005 | // verify that it is the default, copy or move constructor? | |||
7006 | if (Id.getKind() == UnqualifiedIdKind::IK_ConstructorName && | |||
7007 | D.getFunctionTypeInfo().NumParams <= 1) | |||
7008 | return true; | |||
7009 | if (Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId) { | |||
7010 | auto Op = Id.OperatorFunctionId.Operator; | |||
7011 | // FIXME(liuhui): Ideally, we should check the function parameter list to | |||
7012 | // verify that it is the copy or move assignment? | |||
7013 | if (Op == OverloadedOperatorKind::OO_Equal) | |||
7014 | return true; | |||
7015 | if (LangOpts.CPlusPlus20 && | |||
7016 | (Op == OverloadedOperatorKind::OO_EqualEqual || | |||
7017 | Op == OverloadedOperatorKind::OO_ExclaimEqual || | |||
7018 | Op == OverloadedOperatorKind::OO_Less || | |||
7019 | Op == OverloadedOperatorKind::OO_LessEqual || | |||
7020 | Op == OverloadedOperatorKind::OO_Greater || | |||
7021 | Op == OverloadedOperatorKind::OO_GreaterEqual || | |||
7022 | Op == OverloadedOperatorKind::OO_Spaceship)) | |||
7023 | return true; | |||
7024 | } | |||
7025 | return false; | |||
7026 | }; | |||
7027 | ||||
7028 | Results.EnterNewScope(); | |||
7029 | if (ShouldAddDefault()) | |||
7030 | Results.AddResult("default"); | |||
7031 | // FIXME(liuhui): Ideally, we should only provide `delete` completion for the | |||
7032 | // first function declaration. | |||
7033 | Results.AddResult("delete"); | |||
7034 | Results.ExitScope(); | |||
7035 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
7036 | Results.data(), Results.size()); | |||
7037 | } | |||
7038 | ||||
7039 | /// Macro that optionally prepends an "@" to the string literal passed in via | |||
7040 | /// Keyword, depending on whether NeedAt is true or false. | |||
7041 | #define OBJC_AT_KEYWORD_NAME(NeedAt, Keyword)((NeedAt) ? "@" Keyword : Keyword) ((NeedAt) ? "@" Keyword : Keyword) | |||
7042 | ||||
7043 | static void AddObjCImplementationResults(const LangOptions &LangOpts, | |||
7044 | ResultBuilder &Results, bool NeedAt) { | |||
7045 | typedef CodeCompletionResult Result; | |||
7046 | // Since we have an implementation, we can end it. | |||
7047 | Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "end")((NeedAt) ? "@" "end" : "end"))); | |||
7048 | ||||
7049 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
7050 | Results.getCodeCompletionTUInfo()); | |||
7051 | if (LangOpts.ObjC) { | |||
7052 | // @dynamic | |||
7053 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "dynamic")((NeedAt) ? "@" "dynamic" : "dynamic")); | |||
7054 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
7055 | Builder.AddPlaceholderChunk("property"); | |||
7056 | Results.AddResult(Result(Builder.TakeString())); | |||
7057 | ||||
7058 | // @synthesize | |||
7059 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "synthesize")((NeedAt) ? "@" "synthesize" : "synthesize")); | |||
7060 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
7061 | Builder.AddPlaceholderChunk("property"); | |||
7062 | Results.AddResult(Result(Builder.TakeString())); | |||
7063 | } | |||
7064 | } | |||
7065 | ||||
7066 | static void AddObjCInterfaceResults(const LangOptions &LangOpts, | |||
7067 | ResultBuilder &Results, bool NeedAt) { | |||
7068 | typedef CodeCompletionResult Result; | |||
7069 | ||||
7070 | // Since we have an interface or protocol, we can end it. | |||
7071 | Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "end")((NeedAt) ? "@" "end" : "end"))); | |||
7072 | ||||
7073 | if (LangOpts.ObjC) { | |||
7074 | // @property | |||
7075 | Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "property")((NeedAt) ? "@" "property" : "property"))); | |||
7076 | ||||
7077 | // @required | |||
7078 | Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "required")((NeedAt) ? "@" "required" : "required"))); | |||
7079 | ||||
7080 | // @optional | |||
7081 | Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "optional")((NeedAt) ? "@" "optional" : "optional"))); | |||
7082 | } | |||
7083 | } | |||
7084 | ||||
7085 | static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) { | |||
7086 | typedef CodeCompletionResult Result; | |||
7087 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
7088 | Results.getCodeCompletionTUInfo()); | |||
7089 | ||||
7090 | // @class name ; | |||
7091 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "class")((NeedAt) ? "@" "class" : "class")); | |||
7092 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
7093 | Builder.AddPlaceholderChunk("name"); | |||
7094 | Results.AddResult(Result(Builder.TakeString())); | |||
7095 | ||||
7096 | if (Results.includeCodePatterns()) { | |||
7097 | // @interface name | |||
7098 | // FIXME: Could introduce the whole pattern, including superclasses and | |||
7099 | // such. | |||
7100 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "interface")((NeedAt) ? "@" "interface" : "interface")); | |||
7101 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
7102 | Builder.AddPlaceholderChunk("class"); | |||
7103 | Results.AddResult(Result(Builder.TakeString())); | |||
7104 | ||||
7105 | // @protocol name | |||
7106 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "protocol")((NeedAt) ? "@" "protocol" : "protocol")); | |||
7107 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
7108 | Builder.AddPlaceholderChunk("protocol"); | |||
7109 | Results.AddResult(Result(Builder.TakeString())); | |||
7110 | ||||
7111 | // @implementation name | |||
7112 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "implementation")((NeedAt) ? "@" "implementation" : "implementation")); | |||
7113 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
7114 | Builder.AddPlaceholderChunk("class"); | |||
7115 | Results.AddResult(Result(Builder.TakeString())); | |||
7116 | } | |||
7117 | ||||
7118 | // @compatibility_alias name | |||
7119 | Builder.AddTypedTextChunk( | |||
7120 | OBJC_AT_KEYWORD_NAME(NeedAt, "compatibility_alias")((NeedAt) ? "@" "compatibility_alias" : "compatibility_alias" )); | |||
7121 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
7122 | Builder.AddPlaceholderChunk("alias"); | |||
7123 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
7124 | Builder.AddPlaceholderChunk("class"); | |||
7125 | Results.AddResult(Result(Builder.TakeString())); | |||
7126 | ||||
7127 | if (Results.getSema().getLangOpts().Modules) { | |||
7128 | // @import name | |||
7129 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import")((NeedAt) ? "@" "import" : "import")); | |||
7130 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
7131 | Builder.AddPlaceholderChunk("module"); | |||
7132 | Results.AddResult(Result(Builder.TakeString())); | |||
7133 | } | |||
7134 | } | |||
7135 | ||||
7136 | void Sema::CodeCompleteObjCAtDirective(Scope *S) { | |||
7137 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
7138 | CodeCompleter->getCodeCompletionTUInfo(), | |||
7139 | CodeCompletionContext::CCC_Other); | |||
7140 | Results.EnterNewScope(); | |||
7141 | if (isa<ObjCImplDecl>(CurContext)) | |||
7142 | AddObjCImplementationResults(getLangOpts(), Results, false); | |||
7143 | else if (CurContext->isObjCContainer()) | |||
7144 | AddObjCInterfaceResults(getLangOpts(), Results, false); | |||
7145 | else | |||
7146 | AddObjCTopLevelResults(Results, false); | |||
7147 | Results.ExitScope(); | |||
7148 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
7149 | Results.data(), Results.size()); | |||
7150 | } | |||
7151 | ||||
7152 | static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) { | |||
7153 | typedef CodeCompletionResult Result; | |||
7154 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
7155 | Results.getCodeCompletionTUInfo()); | |||
7156 | ||||
7157 | // @encode ( type-name ) | |||
7158 | const char *EncodeType = "char[]"; | |||
7159 | if (Results.getSema().getLangOpts().CPlusPlus || | |||
7160 | Results.getSema().getLangOpts().ConstStrings) | |||
7161 | EncodeType = "const char[]"; | |||
7162 | Builder.AddResultTypeChunk(EncodeType); | |||
7163 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "encode")((NeedAt) ? "@" "encode" : "encode")); | |||
7164 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
7165 | Builder.AddPlaceholderChunk("type-name"); | |||
7166 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
7167 | Results.AddResult(Result(Builder.TakeString())); | |||
7168 | ||||
7169 | // @protocol ( protocol-name ) | |||
7170 | Builder.AddResultTypeChunk("Protocol *"); | |||
7171 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "protocol")((NeedAt) ? "@" "protocol" : "protocol")); | |||
7172 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
7173 | Builder.AddPlaceholderChunk("protocol-name"); | |||
7174 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
7175 | Results.AddResult(Result(Builder.TakeString())); | |||
7176 | ||||
7177 | // @selector ( selector ) | |||
7178 | Builder.AddResultTypeChunk("SEL"); | |||
7179 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "selector")((NeedAt) ? "@" "selector" : "selector")); | |||
7180 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
7181 | Builder.AddPlaceholderChunk("selector"); | |||
7182 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
7183 | Results.AddResult(Result(Builder.TakeString())); | |||
7184 | ||||
7185 | // @"string" | |||
7186 | Builder.AddResultTypeChunk("NSString *"); | |||
7187 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "\"")((NeedAt) ? "@" "\"" : "\"")); | |||
7188 | Builder.AddPlaceholderChunk("string"); | |||
7189 | Builder.AddTextChunk("\""); | |||
7190 | Results.AddResult(Result(Builder.TakeString())); | |||
7191 | ||||
7192 | // @[objects, ...] | |||
7193 | Builder.AddResultTypeChunk("NSArray *"); | |||
7194 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "[")((NeedAt) ? "@" "[" : "[")); | |||
7195 | Builder.AddPlaceholderChunk("objects, ..."); | |||
7196 | Builder.AddChunk(CodeCompletionString::CK_RightBracket); | |||
7197 | Results.AddResult(Result(Builder.TakeString())); | |||
7198 | ||||
7199 | // @{key : object, ...} | |||
7200 | Builder.AddResultTypeChunk("NSDictionary *"); | |||
7201 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "{")((NeedAt) ? "@" "{" : "{")); | |||
7202 | Builder.AddPlaceholderChunk("key"); | |||
7203 | Builder.AddChunk(CodeCompletionString::CK_Colon); | |||
7204 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
7205 | Builder.AddPlaceholderChunk("object, ..."); | |||
7206 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
7207 | Results.AddResult(Result(Builder.TakeString())); | |||
7208 | ||||
7209 | // @(expression) | |||
7210 | Builder.AddResultTypeChunk("id"); | |||
7211 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "(")((NeedAt) ? "@" "(" : "(")); | |||
7212 | Builder.AddPlaceholderChunk("expression"); | |||
7213 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
7214 | Results.AddResult(Result(Builder.TakeString())); | |||
7215 | } | |||
7216 | ||||
7217 | static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) { | |||
7218 | typedef CodeCompletionResult Result; | |||
7219 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
7220 | Results.getCodeCompletionTUInfo()); | |||
7221 | ||||
7222 | if (Results.includeCodePatterns()) { | |||
7223 | // @try { statements } @catch ( declaration ) { statements } @finally | |||
7224 | // { statements } | |||
7225 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "try")((NeedAt) ? "@" "try" : "try")); | |||
7226 | Builder.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
7227 | Builder.AddPlaceholderChunk("statements"); | |||
7228 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
7229 | Builder.AddTextChunk("@catch"); | |||
7230 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
7231 | Builder.AddPlaceholderChunk("parameter"); | |||
7232 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
7233 | Builder.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
7234 | Builder.AddPlaceholderChunk("statements"); | |||
7235 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
7236 | Builder.AddTextChunk("@finally"); | |||
7237 | Builder.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
7238 | Builder.AddPlaceholderChunk("statements"); | |||
7239 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
7240 | Results.AddResult(Result(Builder.TakeString())); | |||
7241 | } | |||
7242 | ||||
7243 | // @throw | |||
7244 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "throw")((NeedAt) ? "@" "throw" : "throw")); | |||
7245 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
7246 | Builder.AddPlaceholderChunk("expression"); | |||
7247 | Results.AddResult(Result(Builder.TakeString())); | |||
7248 | ||||
7249 | if (Results.includeCodePatterns()) { | |||
7250 | // @synchronized ( expression ) { statements } | |||
7251 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "synchronized")((NeedAt) ? "@" "synchronized" : "synchronized")); | |||
7252 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
7253 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
7254 | Builder.AddPlaceholderChunk("expression"); | |||
7255 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
7256 | Builder.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
7257 | Builder.AddPlaceholderChunk("statements"); | |||
7258 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
7259 | Results.AddResult(Result(Builder.TakeString())); | |||
7260 | } | |||
7261 | } | |||
7262 | ||||
7263 | static void AddObjCVisibilityResults(const LangOptions &LangOpts, | |||
7264 | ResultBuilder &Results, bool NeedAt) { | |||
7265 | typedef CodeCompletionResult Result; | |||
7266 | Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "private")((NeedAt) ? "@" "private" : "private"))); | |||
7267 | Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "protected")((NeedAt) ? "@" "protected" : "protected"))); | |||
7268 | Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "public")((NeedAt) ? "@" "public" : "public"))); | |||
7269 | if (LangOpts.ObjC) | |||
7270 | Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "package")((NeedAt) ? "@" "package" : "package"))); | |||
7271 | } | |||
7272 | ||||
7273 | void Sema::CodeCompleteObjCAtVisibility(Scope *S) { | |||
7274 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
7275 | CodeCompleter->getCodeCompletionTUInfo(), | |||
7276 | CodeCompletionContext::CCC_Other); | |||
7277 | Results.EnterNewScope(); | |||
7278 | AddObjCVisibilityResults(getLangOpts(), Results, false); | |||
7279 | Results.ExitScope(); | |||
7280 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
7281 | Results.data(), Results.size()); | |||
7282 | } | |||
7283 | ||||
7284 | void Sema::CodeCompleteObjCAtStatement(Scope *S) { | |||
7285 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
7286 | CodeCompleter->getCodeCompletionTUInfo(), | |||
7287 | CodeCompletionContext::CCC_Other); | |||
7288 | Results.EnterNewScope(); | |||
7289 | AddObjCStatementResults(Results, false); | |||
7290 | AddObjCExpressionResults(Results, false); | |||
7291 | Results.ExitScope(); | |||
7292 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
7293 | Results.data(), Results.size()); | |||
7294 | } | |||
7295 | ||||
7296 | void Sema::CodeCompleteObjCAtExpression(Scope *S) { | |||
7297 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
7298 | CodeCompleter->getCodeCompletionTUInfo(), | |||
7299 | CodeCompletionContext::CCC_Other); | |||
7300 | Results.EnterNewScope(); | |||
7301 | AddObjCExpressionResults(Results, false); | |||
7302 | Results.ExitScope(); | |||
7303 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
7304 | Results.data(), Results.size()); | |||
7305 | } | |||
7306 | ||||
7307 | /// Determine whether the addition of the given flag to an Objective-C | |||
7308 | /// property's attributes will cause a conflict. | |||
7309 | static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) { | |||
7310 | // Check if we've already added this flag. | |||
7311 | if (Attributes & NewFlag) | |||
7312 | return true; | |||
7313 | ||||
7314 | Attributes |= NewFlag; | |||
7315 | ||||
7316 | // Check for collisions with "readonly". | |||
7317 | if ((Attributes & ObjCPropertyAttribute::kind_readonly) && | |||
7318 | (Attributes & ObjCPropertyAttribute::kind_readwrite)) | |||
7319 | return true; | |||
7320 | ||||
7321 | // Check for more than one of { assign, copy, retain, strong, weak }. | |||
7322 | unsigned AssignCopyRetMask = | |||
7323 | Attributes & | |||
7324 | (ObjCPropertyAttribute::kind_assign | | |||
7325 | ObjCPropertyAttribute::kind_unsafe_unretained | | |||
7326 | ObjCPropertyAttribute::kind_copy | ObjCPropertyAttribute::kind_retain | | |||
7327 | ObjCPropertyAttribute::kind_strong | ObjCPropertyAttribute::kind_weak); | |||
7328 | if (AssignCopyRetMask && | |||
7329 | AssignCopyRetMask != ObjCPropertyAttribute::kind_assign && | |||
7330 | AssignCopyRetMask != ObjCPropertyAttribute::kind_unsafe_unretained && | |||
7331 | AssignCopyRetMask != ObjCPropertyAttribute::kind_copy && | |||
7332 | AssignCopyRetMask != ObjCPropertyAttribute::kind_retain && | |||
7333 | AssignCopyRetMask != ObjCPropertyAttribute::kind_strong && | |||
7334 | AssignCopyRetMask != ObjCPropertyAttribute::kind_weak) | |||
7335 | return true; | |||
7336 | ||||
7337 | return false; | |||
7338 | } | |||
7339 | ||||
7340 | void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) { | |||
7341 | if (!CodeCompleter) | |||
7342 | return; | |||
7343 | ||||
7344 | unsigned Attributes = ODS.getPropertyAttributes(); | |||
7345 | ||||
7346 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
7347 | CodeCompleter->getCodeCompletionTUInfo(), | |||
7348 | CodeCompletionContext::CCC_Other); | |||
7349 | Results.EnterNewScope(); | |||
7350 | if (!ObjCPropertyFlagConflicts(Attributes, | |||
7351 | ObjCPropertyAttribute::kind_readonly)) | |||
7352 | Results.AddResult(CodeCompletionResult("readonly")); | |||
7353 | if (!ObjCPropertyFlagConflicts(Attributes, | |||
7354 | ObjCPropertyAttribute::kind_assign)) | |||
7355 | Results.AddResult(CodeCompletionResult("assign")); | |||
7356 | if (!ObjCPropertyFlagConflicts(Attributes, | |||
7357 | ObjCPropertyAttribute::kind_unsafe_unretained)) | |||
7358 | Results.AddResult(CodeCompletionResult("unsafe_unretained")); | |||
7359 | if (!ObjCPropertyFlagConflicts(Attributes, | |||
7360 | ObjCPropertyAttribute::kind_readwrite)) | |||
7361 | Results.AddResult(CodeCompletionResult("readwrite")); | |||
7362 | if (!ObjCPropertyFlagConflicts(Attributes, | |||
7363 | ObjCPropertyAttribute::kind_retain)) | |||
7364 | Results.AddResult(CodeCompletionResult("retain")); | |||
7365 | if (!ObjCPropertyFlagConflicts(Attributes, | |||
7366 | ObjCPropertyAttribute::kind_strong)) | |||
7367 | Results.AddResult(CodeCompletionResult("strong")); | |||
7368 | if (!ObjCPropertyFlagConflicts(Attributes, ObjCPropertyAttribute::kind_copy)) | |||
7369 | Results.AddResult(CodeCompletionResult("copy")); | |||
7370 | if (!ObjCPropertyFlagConflicts(Attributes, | |||
7371 | ObjCPropertyAttribute::kind_nonatomic)) | |||
7372 | Results.AddResult(CodeCompletionResult("nonatomic")); | |||
7373 | if (!ObjCPropertyFlagConflicts(Attributes, | |||
7374 | ObjCPropertyAttribute::kind_atomic)) | |||
7375 | Results.AddResult(CodeCompletionResult("atomic")); | |||
7376 | ||||
7377 | // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC. | |||
7378 | if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC) | |||
7379 | if (!ObjCPropertyFlagConflicts(Attributes, | |||
7380 | ObjCPropertyAttribute::kind_weak)) | |||
7381 | Results.AddResult(CodeCompletionResult("weak")); | |||
7382 | ||||
7383 | if (!ObjCPropertyFlagConflicts(Attributes, | |||
7384 | ObjCPropertyAttribute::kind_setter)) { | |||
7385 | CodeCompletionBuilder Setter(Results.getAllocator(), | |||
7386 | Results.getCodeCompletionTUInfo()); | |||
7387 | Setter.AddTypedTextChunk("setter"); | |||
7388 | Setter.AddTextChunk("="); | |||
7389 | Setter.AddPlaceholderChunk("method"); | |||
7390 | Results.AddResult(CodeCompletionResult(Setter.TakeString())); | |||
7391 | } | |||
7392 | if (!ObjCPropertyFlagConflicts(Attributes, | |||
7393 | ObjCPropertyAttribute::kind_getter)) { | |||
7394 | CodeCompletionBuilder Getter(Results.getAllocator(), | |||
7395 | Results.getCodeCompletionTUInfo()); | |||
7396 | Getter.AddTypedTextChunk("getter"); | |||
7397 | Getter.AddTextChunk("="); | |||
7398 | Getter.AddPlaceholderChunk("method"); | |||
7399 | Results.AddResult(CodeCompletionResult(Getter.TakeString())); | |||
7400 | } | |||
7401 | if (!ObjCPropertyFlagConflicts(Attributes, | |||
7402 | ObjCPropertyAttribute::kind_nullability)) { | |||
7403 | Results.AddResult(CodeCompletionResult("nonnull")); | |||
7404 | Results.AddResult(CodeCompletionResult("nullable")); | |||
7405 | Results.AddResult(CodeCompletionResult("null_unspecified")); | |||
7406 | Results.AddResult(CodeCompletionResult("null_resettable")); | |||
7407 | } | |||
7408 | Results.ExitScope(); | |||
7409 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
7410 | Results.data(), Results.size()); | |||
7411 | } | |||
7412 | ||||
7413 | /// Describes the kind of Objective-C method that we want to find | |||
7414 | /// via code completion. | |||
7415 | enum ObjCMethodKind { | |||
7416 | MK_Any, ///< Any kind of method, provided it means other specified criteria. | |||
7417 | MK_ZeroArgSelector, ///< Zero-argument (unary) selector. | |||
7418 | MK_OneArgSelector ///< One-argument selector. | |||
7419 | }; | |||
7420 | ||||
7421 | static bool isAcceptableObjCSelector(Selector Sel, ObjCMethodKind WantKind, | |||
7422 | ArrayRef<IdentifierInfo *> SelIdents, | |||
7423 | bool AllowSameLength = true) { | |||
7424 | unsigned NumSelIdents = SelIdents.size(); | |||
7425 | if (NumSelIdents > Sel.getNumArgs()) | |||
7426 | return false; | |||
7427 | ||||
7428 | switch (WantKind) { | |||
7429 | case MK_Any: | |||
7430 | break; | |||
7431 | case MK_ZeroArgSelector: | |||
7432 | return Sel.isUnarySelector(); | |||
7433 | case MK_OneArgSelector: | |||
7434 | return Sel.getNumArgs() == 1; | |||
7435 | } | |||
7436 | ||||
7437 | if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs()) | |||
7438 | return false; | |||
7439 | ||||
7440 | for (unsigned I = 0; I != NumSelIdents; ++I) | |||
7441 | if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I)) | |||
7442 | return false; | |||
7443 | ||||
7444 | return true; | |||
7445 | } | |||
7446 | ||||
7447 | static bool isAcceptableObjCMethod(ObjCMethodDecl *Method, | |||
7448 | ObjCMethodKind WantKind, | |||
7449 | ArrayRef<IdentifierInfo *> SelIdents, | |||
7450 | bool AllowSameLength = true) { | |||
7451 | return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents, | |||
7452 | AllowSameLength); | |||
7453 | } | |||
7454 | ||||
7455 | /// A set of selectors, which is used to avoid introducing multiple | |||
7456 | /// completions with the same selector into the result set. | |||
7457 | typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet; | |||
7458 | ||||
7459 | /// Add all of the Objective-C methods in the given Objective-C | |||
7460 | /// container to the set of results. | |||
7461 | /// | |||
7462 | /// The container will be a class, protocol, category, or implementation of | |||
7463 | /// any of the above. This mether will recurse to include methods from | |||
7464 | /// the superclasses of classes along with their categories, protocols, and | |||
7465 | /// implementations. | |||
7466 | /// | |||
7467 | /// \param Container the container in which we'll look to find methods. | |||
7468 | /// | |||
7469 | /// \param WantInstanceMethods Whether to add instance methods (only); if | |||
7470 | /// false, this routine will add factory methods (only). | |||
7471 | /// | |||
7472 | /// \param CurContext the context in which we're performing the lookup that | |||
7473 | /// finds methods. | |||
7474 | /// | |||
7475 | /// \param AllowSameLength Whether we allow a method to be added to the list | |||
7476 | /// when it has the same number of parameters as we have selector identifiers. | |||
7477 | /// | |||
7478 | /// \param Results the structure into which we'll add results. | |||
7479 | static void AddObjCMethods(ObjCContainerDecl *Container, | |||
7480 | bool WantInstanceMethods, ObjCMethodKind WantKind, | |||
7481 | ArrayRef<IdentifierInfo *> SelIdents, | |||
7482 | DeclContext *CurContext, | |||
7483 | VisitedSelectorSet &Selectors, bool AllowSameLength, | |||
7484 | ResultBuilder &Results, bool InOriginalClass = true, | |||
7485 | bool IsRootClass = false) { | |||
7486 | typedef CodeCompletionResult Result; | |||
7487 | Container = getContainerDef(Container); | |||
7488 | ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container); | |||
7489 | IsRootClass = IsRootClass || (IFace && !IFace->getSuperClass()); | |||
7490 | for (ObjCMethodDecl *M : Container->methods()) { | |||
7491 | // The instance methods on the root class can be messaged via the | |||
7492 | // metaclass. | |||
7493 | if (M->isInstanceMethod() == WantInstanceMethods || | |||
7494 | (IsRootClass && !WantInstanceMethods)) { | |||
7495 | // Check whether the selector identifiers we've been given are a | |||
7496 | // subset of the identifiers for this particular method. | |||
7497 | if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength)) | |||
7498 | continue; | |||
7499 | ||||
7500 | if (!Selectors.insert(M->getSelector()).second) | |||
7501 | continue; | |||
7502 | ||||
7503 | Result R = Result(M, Results.getBasePriority(M), nullptr); | |||
7504 | R.StartParameter = SelIdents.size(); | |||
7505 | R.AllParametersAreInformative = (WantKind != MK_Any); | |||
7506 | if (!InOriginalClass) | |||
7507 | setInBaseClass(R); | |||
7508 | Results.MaybeAddResult(R, CurContext); | |||
7509 | } | |||
7510 | } | |||
7511 | ||||
7512 | // Visit the protocols of protocols. | |||
7513 | if (const auto *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { | |||
7514 | if (Protocol->hasDefinition()) { | |||
7515 | const ObjCList<ObjCProtocolDecl> &Protocols = | |||
7516 | Protocol->getReferencedProtocols(); | |||
7517 | for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), | |||
7518 | E = Protocols.end(); | |||
7519 | I != E; ++I) | |||
7520 | AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext, | |||
7521 | Selectors, AllowSameLength, Results, false, IsRootClass); | |||
7522 | } | |||
7523 | } | |||
7524 | ||||
7525 | if (!IFace || !IFace->hasDefinition()) | |||
7526 | return; | |||
7527 | ||||
7528 | // Add methods in protocols. | |||
7529 | for (ObjCProtocolDecl *I : IFace->protocols()) | |||
7530 | AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents, CurContext, | |||
7531 | Selectors, AllowSameLength, Results, false, IsRootClass); | |||
7532 | ||||
7533 | // Add methods in categories. | |||
7534 | for (ObjCCategoryDecl *CatDecl : IFace->known_categories()) { | |||
7535 | AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents, | |||
7536 | CurContext, Selectors, AllowSameLength, Results, | |||
7537 | InOriginalClass, IsRootClass); | |||
7538 | ||||
7539 | // Add a categories protocol methods. | |||
7540 | const ObjCList<ObjCProtocolDecl> &Protocols = | |||
7541 | CatDecl->getReferencedProtocols(); | |||
7542 | for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), | |||
7543 | E = Protocols.end(); | |||
7544 | I != E; ++I) | |||
7545 | AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext, | |||
7546 | Selectors, AllowSameLength, Results, false, IsRootClass); | |||
7547 | ||||
7548 | // Add methods in category implementations. | |||
7549 | if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation()) | |||
7550 | AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext, | |||
7551 | Selectors, AllowSameLength, Results, InOriginalClass, | |||
7552 | IsRootClass); | |||
7553 | } | |||
7554 | ||||
7555 | // Add methods in superclass. | |||
7556 | // Avoid passing in IsRootClass since root classes won't have super classes. | |||
7557 | if (IFace->getSuperClass()) | |||
7558 | AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind, | |||
7559 | SelIdents, CurContext, Selectors, AllowSameLength, Results, | |||
7560 | /*IsRootClass=*/false); | |||
7561 | ||||
7562 | // Add methods in our implementation, if any. | |||
7563 | if (ObjCImplementationDecl *Impl = IFace->getImplementation()) | |||
7564 | AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext, | |||
7565 | Selectors, AllowSameLength, Results, InOriginalClass, | |||
7566 | IsRootClass); | |||
7567 | } | |||
7568 | ||||
7569 | void Sema::CodeCompleteObjCPropertyGetter(Scope *S) { | |||
7570 | // Try to find the interface where getters might live. | |||
7571 | ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext); | |||
7572 | if (!Class) { | |||
7573 | if (ObjCCategoryDecl *Category = | |||
7574 | dyn_cast_or_null<ObjCCategoryDecl>(CurContext)) | |||
7575 | Class = Category->getClassInterface(); | |||
7576 | ||||
7577 | if (!Class) | |||
7578 | return; | |||
7579 | } | |||
7580 | ||||
7581 | // Find all of the potential getters. | |||
7582 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
7583 | CodeCompleter->getCodeCompletionTUInfo(), | |||
7584 | CodeCompletionContext::CCC_Other); | |||
7585 | Results.EnterNewScope(); | |||
7586 | ||||
7587 | VisitedSelectorSet Selectors; | |||
7588 | AddObjCMethods(Class, true, MK_ZeroArgSelector, std::nullopt, CurContext, | |||
7589 | Selectors, | |||
7590 | /*AllowSameLength=*/true, Results); | |||
7591 | Results.ExitScope(); | |||
7592 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
7593 | Results.data(), Results.size()); | |||
7594 | } | |||
7595 | ||||
7596 | void Sema::CodeCompleteObjCPropertySetter(Scope *S) { | |||
7597 | // Try to find the interface where setters might live. | |||
7598 | ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext); | |||
7599 | if (!Class) { | |||
7600 | if (ObjCCategoryDecl *Category = | |||
7601 | dyn_cast_or_null<ObjCCategoryDecl>(CurContext)) | |||
7602 | Class = Category->getClassInterface(); | |||
7603 | ||||
7604 | if (!Class) | |||
7605 | return; | |||
7606 | } | |||
7607 | ||||
7608 | // Find all of the potential getters. | |||
7609 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
7610 | CodeCompleter->getCodeCompletionTUInfo(), | |||
7611 | CodeCompletionContext::CCC_Other); | |||
7612 | Results.EnterNewScope(); | |||
7613 | ||||
7614 | VisitedSelectorSet Selectors; | |||
7615 | AddObjCMethods(Class, true, MK_OneArgSelector, std::nullopt, CurContext, | |||
7616 | Selectors, | |||
7617 | /*AllowSameLength=*/true, Results); | |||
7618 | ||||
7619 | Results.ExitScope(); | |||
7620 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
7621 | Results.data(), Results.size()); | |||
7622 | } | |||
7623 | ||||
7624 | void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS, | |||
7625 | bool IsParameter) { | |||
7626 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
7627 | CodeCompleter->getCodeCompletionTUInfo(), | |||
7628 | CodeCompletionContext::CCC_Type); | |||
7629 | Results.EnterNewScope(); | |||
7630 | ||||
7631 | // Add context-sensitive, Objective-C parameter-passing keywords. | |||
7632 | bool AddedInOut = false; | |||
7633 | if ((DS.getObjCDeclQualifier() & | |||
7634 | (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) { | |||
7635 | Results.AddResult("in"); | |||
7636 | Results.AddResult("inout"); | |||
7637 | AddedInOut = true; | |||
7638 | } | |||
7639 | if ((DS.getObjCDeclQualifier() & | |||
7640 | (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) { | |||
7641 | Results.AddResult("out"); | |||
7642 | if (!AddedInOut) | |||
7643 | Results.AddResult("inout"); | |||
7644 | } | |||
7645 | if ((DS.getObjCDeclQualifier() & | |||
7646 | (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref | | |||
7647 | ObjCDeclSpec::DQ_Oneway)) == 0) { | |||
7648 | Results.AddResult("bycopy"); | |||
7649 | Results.AddResult("byref"); | |||
7650 | Results.AddResult("oneway"); | |||
7651 | } | |||
7652 | if ((DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) == 0) { | |||
7653 | Results.AddResult("nonnull"); | |||
7654 | Results.AddResult("nullable"); | |||
7655 | Results.AddResult("null_unspecified"); | |||
7656 | } | |||
7657 | ||||
7658 | // If we're completing the return type of an Objective-C method and the | |||
7659 | // identifier IBAction refers to a macro, provide a completion item for | |||
7660 | // an action, e.g., | |||
7661 | // IBAction)<#selector#>:(id)sender | |||
7662 | if (DS.getObjCDeclQualifier() == 0 && !IsParameter && | |||
7663 | PP.isMacroDefined("IBAction")) { | |||
7664 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
7665 | Results.getCodeCompletionTUInfo(), | |||
7666 | CCP_CodePattern, CXAvailability_Available); | |||
7667 | Builder.AddTypedTextChunk("IBAction"); | |||
7668 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
7669 | Builder.AddPlaceholderChunk("selector"); | |||
7670 | Builder.AddChunk(CodeCompletionString::CK_Colon); | |||
7671 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
7672 | Builder.AddTextChunk("id"); | |||
7673 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
7674 | Builder.AddTextChunk("sender"); | |||
7675 | Results.AddResult(CodeCompletionResult(Builder.TakeString())); | |||
7676 | } | |||
7677 | ||||
7678 | // If we're completing the return type, provide 'instancetype'. | |||
7679 | if (!IsParameter) { | |||
7680 | Results.AddResult(CodeCompletionResult("instancetype")); | |||
7681 | } | |||
7682 | ||||
7683 | // Add various builtin type names and specifiers. | |||
7684 | AddOrdinaryNameResults(PCC_Type, S, *this, Results); | |||
7685 | Results.ExitScope(); | |||
7686 | ||||
7687 | // Add the various type names | |||
7688 | Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName); | |||
7689 | CodeCompletionDeclConsumer Consumer(Results, CurContext); | |||
7690 | LookupVisibleDecls(S, LookupOrdinaryName, Consumer, | |||
7691 | CodeCompleter->includeGlobals(), | |||
7692 | CodeCompleter->loadExternal()); | |||
7693 | ||||
7694 | if (CodeCompleter->includeMacros()) | |||
7695 | AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false); | |||
7696 | ||||
7697 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
7698 | Results.data(), Results.size()); | |||
7699 | } | |||
7700 | ||||
7701 | /// When we have an expression with type "id", we may assume | |||
7702 | /// that it has some more-specific class type based on knowledge of | |||
7703 | /// common uses of Objective-C. This routine returns that class type, | |||
7704 | /// or NULL if no better result could be determined. | |||
7705 | static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) { | |||
7706 | auto *Msg = dyn_cast_or_null<ObjCMessageExpr>(E); | |||
7707 | if (!Msg) | |||
7708 | return nullptr; | |||
7709 | ||||
7710 | Selector Sel = Msg->getSelector(); | |||
7711 | if (Sel.isNull()) | |||
7712 | return nullptr; | |||
7713 | ||||
7714 | IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0); | |||
7715 | if (!Id) | |||
7716 | return nullptr; | |||
7717 | ||||
7718 | ObjCMethodDecl *Method = Msg->getMethodDecl(); | |||
7719 | if (!Method) | |||
7720 | return nullptr; | |||
7721 | ||||
7722 | // Determine the class that we're sending the message to. | |||
7723 | ObjCInterfaceDecl *IFace = nullptr; | |||
7724 | switch (Msg->getReceiverKind()) { | |||
7725 | case ObjCMessageExpr::Class: | |||
7726 | if (const ObjCObjectType *ObjType = | |||
7727 | Msg->getClassReceiver()->getAs<ObjCObjectType>()) | |||
7728 | IFace = ObjType->getInterface(); | |||
7729 | break; | |||
7730 | ||||
7731 | case ObjCMessageExpr::Instance: { | |||
7732 | QualType T = Msg->getInstanceReceiver()->getType(); | |||
7733 | if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>()) | |||
7734 | IFace = Ptr->getInterfaceDecl(); | |||
7735 | break; | |||
7736 | } | |||
7737 | ||||
7738 | case ObjCMessageExpr::SuperInstance: | |||
7739 | case ObjCMessageExpr::SuperClass: | |||
7740 | break; | |||
7741 | } | |||
7742 | ||||
7743 | if (!IFace) | |||
7744 | return nullptr; | |||
7745 | ||||
7746 | ObjCInterfaceDecl *Super = IFace->getSuperClass(); | |||
7747 | if (Method->isInstanceMethod()) | |||
7748 | return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName()) | |||
7749 | .Case("retain", IFace) | |||
7750 | .Case("strong", IFace) | |||
7751 | .Case("autorelease", IFace) | |||
7752 | .Case("copy", IFace) | |||
7753 | .Case("copyWithZone", IFace) | |||
7754 | .Case("mutableCopy", IFace) | |||
7755 | .Case("mutableCopyWithZone", IFace) | |||
7756 | .Case("awakeFromCoder", IFace) | |||
7757 | .Case("replacementObjectFromCoder", IFace) | |||
7758 | .Case("class", IFace) | |||
7759 | .Case("classForCoder", IFace) | |||
7760 | .Case("superclass", Super) | |||
7761 | .Default(nullptr); | |||
7762 | ||||
7763 | return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName()) | |||
7764 | .Case("new", IFace) | |||
7765 | .Case("alloc", IFace) | |||
7766 | .Case("allocWithZone", IFace) | |||
7767 | .Case("class", IFace) | |||
7768 | .Case("superclass", Super) | |||
7769 | .Default(nullptr); | |||
7770 | } | |||
7771 | ||||
7772 | // Add a special completion for a message send to "super", which fills in the | |||
7773 | // most likely case of forwarding all of our arguments to the superclass | |||
7774 | // function. | |||
7775 | /// | |||
7776 | /// \param S The semantic analysis object. | |||
7777 | /// | |||
7778 | /// \param NeedSuperKeyword Whether we need to prefix this completion with | |||
7779 | /// the "super" keyword. Otherwise, we just need to provide the arguments. | |||
7780 | /// | |||
7781 | /// \param SelIdents The identifiers in the selector that have already been | |||
7782 | /// provided as arguments for a send to "super". | |||
7783 | /// | |||
7784 | /// \param Results The set of results to augment. | |||
7785 | /// | |||
7786 | /// \returns the Objective-C method declaration that would be invoked by | |||
7787 | /// this "super" completion. If NULL, no completion was added. | |||
7788 | static ObjCMethodDecl * | |||
7789 | AddSuperSendCompletion(Sema &S, bool NeedSuperKeyword, | |||
7790 | ArrayRef<IdentifierInfo *> SelIdents, | |||
7791 | ResultBuilder &Results) { | |||
7792 | ObjCMethodDecl *CurMethod = S.getCurMethodDecl(); | |||
7793 | if (!CurMethod) | |||
7794 | return nullptr; | |||
7795 | ||||
7796 | ObjCInterfaceDecl *Class = CurMethod->getClassInterface(); | |||
7797 | if (!Class) | |||
7798 | return nullptr; | |||
7799 | ||||
7800 | // Try to find a superclass method with the same selector. | |||
7801 | ObjCMethodDecl *SuperMethod = nullptr; | |||
7802 | while ((Class = Class->getSuperClass()) && !SuperMethod) { | |||
7803 | // Check in the class | |||
7804 | SuperMethod = Class->getMethod(CurMethod->getSelector(), | |||
7805 | CurMethod->isInstanceMethod()); | |||
7806 | ||||
7807 | // Check in categories or class extensions. | |||
7808 | if (!SuperMethod) { | |||
7809 | for (const auto *Cat : Class->known_categories()) { | |||
7810 | if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(), | |||
7811 | CurMethod->isInstanceMethod()))) | |||
7812 | break; | |||
7813 | } | |||
7814 | } | |||
7815 | } | |||
7816 | ||||
7817 | if (!SuperMethod) | |||
7818 | return nullptr; | |||
7819 | ||||
7820 | // Check whether the superclass method has the same signature. | |||
7821 | if (CurMethod->param_size() != SuperMethod->param_size() || | |||
7822 | CurMethod->isVariadic() != SuperMethod->isVariadic()) | |||
7823 | return nullptr; | |||
7824 | ||||
7825 | for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(), | |||
7826 | CurPEnd = CurMethod->param_end(), | |||
7827 | SuperP = SuperMethod->param_begin(); | |||
7828 | CurP != CurPEnd; ++CurP, ++SuperP) { | |||
7829 | // Make sure the parameter types are compatible. | |||
7830 | if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(), | |||
7831 | (*SuperP)->getType())) | |||
7832 | return nullptr; | |||
7833 | ||||
7834 | // Make sure we have a parameter name to forward! | |||
7835 | if (!(*CurP)->getIdentifier()) | |||
7836 | return nullptr; | |||
7837 | } | |||
7838 | ||||
7839 | // We have a superclass method. Now, form the send-to-super completion. | |||
7840 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
7841 | Results.getCodeCompletionTUInfo()); | |||
7842 | ||||
7843 | // Give this completion a return type. | |||
7844 | AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod, | |||
7845 | Results.getCompletionContext().getBaseType(), Builder); | |||
7846 | ||||
7847 | // If we need the "super" keyword, add it (plus some spacing). | |||
7848 | if (NeedSuperKeyword) { | |||
7849 | Builder.AddTypedTextChunk("super"); | |||
7850 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
7851 | } | |||
7852 | ||||
7853 | Selector Sel = CurMethod->getSelector(); | |||
7854 | if (Sel.isUnarySelector()) { | |||
7855 | if (NeedSuperKeyword) | |||
7856 | Builder.AddTextChunk( | |||
7857 | Builder.getAllocator().CopyString(Sel.getNameForSlot(0))); | |||
7858 | else | |||
7859 | Builder.AddTypedTextChunk( | |||
7860 | Builder.getAllocator().CopyString(Sel.getNameForSlot(0))); | |||
7861 | } else { | |||
7862 | ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(); | |||
7863 | for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) { | |||
7864 | if (I > SelIdents.size()) | |||
7865 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
7866 | ||||
7867 | if (I < SelIdents.size()) | |||
7868 | Builder.AddInformativeChunk( | |||
7869 | Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":")); | |||
7870 | else if (NeedSuperKeyword || I > SelIdents.size()) { | |||
7871 | Builder.AddTextChunk( | |||
7872 | Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":")); | |||
7873 | Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString( | |||
7874 | (*CurP)->getIdentifier()->getName())); | |||
7875 | } else { | |||
7876 | Builder.AddTypedTextChunk( | |||
7877 | Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":")); | |||
7878 | Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString( | |||
7879 | (*CurP)->getIdentifier()->getName())); | |||
7880 | } | |||
7881 | } | |||
7882 | } | |||
7883 | ||||
7884 | Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod, | |||
7885 | CCP_SuperCompletion)); | |||
7886 | return SuperMethod; | |||
7887 | } | |||
7888 | ||||
7889 | void Sema::CodeCompleteObjCMessageReceiver(Scope *S) { | |||
7890 | typedef CodeCompletionResult Result; | |||
7891 | ResultBuilder Results( | |||
7892 | *this, CodeCompleter->getAllocator(), | |||
7893 | CodeCompleter->getCodeCompletionTUInfo(), | |||
7894 | CodeCompletionContext::CCC_ObjCMessageReceiver, | |||
7895 | getLangOpts().CPlusPlus11 | |||
7896 | ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture | |||
7897 | : &ResultBuilder::IsObjCMessageReceiver); | |||
7898 | ||||
7899 | CodeCompletionDeclConsumer Consumer(Results, CurContext); | |||
7900 | Results.EnterNewScope(); | |||
7901 | LookupVisibleDecls(S, LookupOrdinaryName, Consumer, | |||
7902 | CodeCompleter->includeGlobals(), | |||
7903 | CodeCompleter->loadExternal()); | |||
7904 | ||||
7905 | // If we are in an Objective-C method inside a class that has a superclass, | |||
7906 | // add "super" as an option. | |||
7907 | if (ObjCMethodDecl *Method = getCurMethodDecl()) | |||
7908 | if (ObjCInterfaceDecl *Iface = Method->getClassInterface()) | |||
7909 | if (Iface->getSuperClass()) { | |||
7910 | Results.AddResult(Result("super")); | |||
7911 | ||||
7912 | AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, std::nullopt, | |||
7913 | Results); | |||
7914 | } | |||
7915 | ||||
7916 | if (getLangOpts().CPlusPlus11) | |||
7917 | addThisCompletion(*this, Results); | |||
7918 | ||||
7919 | Results.ExitScope(); | |||
7920 | ||||
7921 | if (CodeCompleter->includeMacros()) | |||
7922 | AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false); | |||
7923 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
7924 | Results.data(), Results.size()); | |||
7925 | } | |||
7926 | ||||
7927 | void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc, | |||
7928 | ArrayRef<IdentifierInfo *> SelIdents, | |||
7929 | bool AtArgumentExpression) { | |||
7930 | ObjCInterfaceDecl *CDecl = nullptr; | |||
7931 | if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) { | |||
7932 | // Figure out which interface we're in. | |||
7933 | CDecl = CurMethod->getClassInterface(); | |||
7934 | if (!CDecl) | |||
7935 | return; | |||
7936 | ||||
7937 | // Find the superclass of this class. | |||
7938 | CDecl = CDecl->getSuperClass(); | |||
7939 | if (!CDecl) | |||
7940 | return; | |||
7941 | ||||
7942 | if (CurMethod->isInstanceMethod()) { | |||
7943 | // We are inside an instance method, which means that the message | |||
7944 | // send [super ...] is actually calling an instance method on the | |||
7945 | // current object. | |||
7946 | return CodeCompleteObjCInstanceMessage(S, nullptr, SelIdents, | |||
7947 | AtArgumentExpression, CDecl); | |||
7948 | } | |||
7949 | ||||
7950 | // Fall through to send to the superclass in CDecl. | |||
7951 | } else { | |||
7952 | // "super" may be the name of a type or variable. Figure out which | |||
7953 | // it is. | |||
7954 | IdentifierInfo *Super = getSuperIdentifier(); | |||
7955 | NamedDecl *ND = LookupSingleName(S, Super, SuperLoc, LookupOrdinaryName); | |||
7956 | if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) { | |||
7957 | // "super" names an interface. Use it. | |||
7958 | } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) { | |||
7959 | if (const ObjCObjectType *Iface = | |||
7960 | Context.getTypeDeclType(TD)->getAs<ObjCObjectType>()) | |||
7961 | CDecl = Iface->getInterface(); | |||
7962 | } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) { | |||
7963 | // "super" names an unresolved type; we can't be more specific. | |||
7964 | } else { | |||
7965 | // Assume that "super" names some kind of value and parse that way. | |||
7966 | CXXScopeSpec SS; | |||
7967 | SourceLocation TemplateKWLoc; | |||
7968 | UnqualifiedId id; | |||
7969 | id.setIdentifier(Super, SuperLoc); | |||
7970 | ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id, | |||
7971 | /*HasTrailingLParen=*/false, | |||
7972 | /*IsAddressOfOperand=*/false); | |||
7973 | return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(), | |||
7974 | SelIdents, AtArgumentExpression); | |||
7975 | } | |||
7976 | ||||
7977 | // Fall through | |||
7978 | } | |||
7979 | ||||
7980 | ParsedType Receiver; | |||
7981 | if (CDecl) | |||
7982 | Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl)); | |||
7983 | return CodeCompleteObjCClassMessage(S, Receiver, SelIdents, | |||
7984 | AtArgumentExpression, | |||
7985 | /*IsSuper=*/true); | |||
7986 | } | |||
7987 | ||||
7988 | /// Given a set of code-completion results for the argument of a message | |||
7989 | /// send, determine the preferred type (if any) for that argument expression. | |||
7990 | static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results, | |||
7991 | unsigned NumSelIdents) { | |||
7992 | typedef CodeCompletionResult Result; | |||
7993 | ASTContext &Context = Results.getSema().Context; | |||
7994 | ||||
7995 | QualType PreferredType; | |||
7996 | unsigned BestPriority = CCP_Unlikely * 2; | |||
7997 | Result *ResultsData = Results.data(); | |||
7998 | for (unsigned I = 0, N = Results.size(); I != N; ++I) { | |||
7999 | Result &R = ResultsData[I]; | |||
8000 | if (R.Kind == Result::RK_Declaration && | |||
8001 | isa<ObjCMethodDecl>(R.Declaration)) { | |||
8002 | if (R.Priority <= BestPriority) { | |||
8003 | const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration); | |||
8004 | if (NumSelIdents <= Method->param_size()) { | |||
8005 | QualType MyPreferredType = | |||
8006 | Method->parameters()[NumSelIdents - 1]->getType(); | |||
8007 | if (R.Priority < BestPriority || PreferredType.isNull()) { | |||
8008 | BestPriority = R.Priority; | |||
8009 | PreferredType = MyPreferredType; | |||
8010 | } else if (!Context.hasSameUnqualifiedType(PreferredType, | |||
8011 | MyPreferredType)) { | |||
8012 | PreferredType = QualType(); | |||
8013 | } | |||
8014 | } | |||
8015 | } | |||
8016 | } | |||
8017 | } | |||
8018 | ||||
8019 | return PreferredType; | |||
8020 | } | |||
8021 | ||||
8022 | static void AddClassMessageCompletions(Sema &SemaRef, Scope *S, | |||
8023 | ParsedType Receiver, | |||
8024 | ArrayRef<IdentifierInfo *> SelIdents, | |||
8025 | bool AtArgumentExpression, bool IsSuper, | |||
8026 | ResultBuilder &Results) { | |||
8027 | typedef CodeCompletionResult Result; | |||
8028 | ObjCInterfaceDecl *CDecl = nullptr; | |||
8029 | ||||
8030 | // If the given name refers to an interface type, retrieve the | |||
8031 | // corresponding declaration. | |||
8032 | if (Receiver) { | |||
8033 | QualType T = SemaRef.GetTypeFromParser(Receiver, nullptr); | |||
8034 | if (!T.isNull()) | |||
8035 | if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>()) | |||
8036 | CDecl = Interface->getInterface(); | |||
8037 | } | |||
8038 | ||||
8039 | // Add all of the factory methods in this Objective-C class, its protocols, | |||
8040 | // superclasses, categories, implementation, etc. | |||
8041 | Results.EnterNewScope(); | |||
8042 | ||||
8043 | // If this is a send-to-super, try to add the special "super" send | |||
8044 | // completion. | |||
8045 | if (IsSuper) { | |||
8046 | if (ObjCMethodDecl *SuperMethod = | |||
8047 | AddSuperSendCompletion(SemaRef, false, SelIdents, Results)) | |||
8048 | Results.Ignore(SuperMethod); | |||
8049 | } | |||
8050 | ||||
8051 | // If we're inside an Objective-C method definition, prefer its selector to | |||
8052 | // others. | |||
8053 | if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl()) | |||
8054 | Results.setPreferredSelector(CurMethod->getSelector()); | |||
8055 | ||||
8056 | VisitedSelectorSet Selectors; | |||
8057 | if (CDecl) | |||
8058 | AddObjCMethods(CDecl, false, MK_Any, SelIdents, SemaRef.CurContext, | |||
8059 | Selectors, AtArgumentExpression, Results); | |||
8060 | else { | |||
8061 | // We're messaging "id" as a type; provide all class/factory methods. | |||
8062 | ||||
8063 | // If we have an external source, load the entire class method | |||
8064 | // pool from the AST file. | |||
8065 | if (SemaRef.getExternalSource()) { | |||
8066 | for (uint32_t I = 0, | |||
8067 | N = SemaRef.getExternalSource()->GetNumExternalSelectors(); | |||
8068 | I != N; ++I) { | |||
8069 | Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I); | |||
8070 | if (Sel.isNull() || SemaRef.MethodPool.count(Sel)) | |||
8071 | continue; | |||
8072 | ||||
8073 | SemaRef.ReadMethodPool(Sel); | |||
8074 | } | |||
8075 | } | |||
8076 | ||||
8077 | for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(), | |||
8078 | MEnd = SemaRef.MethodPool.end(); | |||
8079 | M != MEnd; ++M) { | |||
8080 | for (ObjCMethodList *MethList = &M->second.second; | |||
8081 | MethList && MethList->getMethod(); MethList = MethList->getNext()) { | |||
8082 | if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents)) | |||
8083 | continue; | |||
8084 | ||||
8085 | Result R(MethList->getMethod(), | |||
8086 | Results.getBasePriority(MethList->getMethod()), nullptr); | |||
8087 | R.StartParameter = SelIdents.size(); | |||
8088 | R.AllParametersAreInformative = false; | |||
8089 | Results.MaybeAddResult(R, SemaRef.CurContext); | |||
8090 | } | |||
8091 | } | |||
8092 | } | |||
8093 | ||||
8094 | Results.ExitScope(); | |||
8095 | } | |||
8096 | ||||
8097 | void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver, | |||
8098 | ArrayRef<IdentifierInfo *> SelIdents, | |||
8099 | bool AtArgumentExpression, | |||
8100 | bool IsSuper) { | |||
8101 | ||||
8102 | QualType T = this->GetTypeFromParser(Receiver); | |||
8103 | ||||
8104 | ResultBuilder Results( | |||
8105 | *this, CodeCompleter->getAllocator(), | |||
8106 | CodeCompleter->getCodeCompletionTUInfo(), | |||
8107 | CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage, T, | |||
8108 | SelIdents)); | |||
8109 | ||||
8110 | AddClassMessageCompletions(*this, S, Receiver, SelIdents, | |||
8111 | AtArgumentExpression, IsSuper, Results); | |||
8112 | ||||
8113 | // If we're actually at the argument expression (rather than prior to the | |||
8114 | // selector), we're actually performing code completion for an expression. | |||
8115 | // Determine whether we have a single, best method. If so, we can | |||
8116 | // code-complete the expression using the corresponding parameter type as | |||
8117 | // our preferred type, improving completion results. | |||
8118 | if (AtArgumentExpression) { | |||
8119 | QualType PreferredType = | |||
8120 | getPreferredArgumentTypeForMessageSend(Results, SelIdents.size()); | |||
8121 | if (PreferredType.isNull()) | |||
8122 | CodeCompleteOrdinaryName(S, PCC_Expression); | |||
8123 | else | |||
8124 | CodeCompleteExpression(S, PreferredType); | |||
8125 | return; | |||
8126 | } | |||
8127 | ||||
8128 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
8129 | Results.data(), Results.size()); | |||
8130 | } | |||
8131 | ||||
8132 | void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver, | |||
8133 | ArrayRef<IdentifierInfo *> SelIdents, | |||
8134 | bool AtArgumentExpression, | |||
8135 | ObjCInterfaceDecl *Super) { | |||
8136 | typedef CodeCompletionResult Result; | |||
8137 | ||||
8138 | Expr *RecExpr = static_cast<Expr *>(Receiver); | |||
8139 | ||||
8140 | // If necessary, apply function/array conversion to the receiver. | |||
8141 | // C99 6.7.5.3p[7,8]. | |||
8142 | if (RecExpr) { | |||
8143 | ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr); | |||
8144 | if (Conv.isInvalid()) // conversion failed. bail. | |||
8145 | return; | |||
8146 | RecExpr = Conv.get(); | |||
8147 | } | |||
8148 | QualType ReceiverType = RecExpr | |||
8149 | ? RecExpr->getType() | |||
8150 | : Super ? Context.getObjCObjectPointerType( | |||
8151 | Context.getObjCInterfaceType(Super)) | |||
8152 | : Context.getObjCIdType(); | |||
8153 | ||||
8154 | // If we're messaging an expression with type "id" or "Class", check | |||
8155 | // whether we know something special about the receiver that allows | |||
8156 | // us to assume a more-specific receiver type. | |||
8157 | if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) { | |||
8158 | if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) { | |||
8159 | if (ReceiverType->isObjCClassType()) | |||
8160 | return CodeCompleteObjCClassMessage( | |||
8161 | S, ParsedType::make(Context.getObjCInterfaceType(IFace)), SelIdents, | |||
8162 | AtArgumentExpression, Super); | |||
8163 | ||||
8164 | ReceiverType = | |||
8165 | Context.getObjCObjectPointerType(Context.getObjCInterfaceType(IFace)); | |||
8166 | } | |||
8167 | } else if (RecExpr && getLangOpts().CPlusPlus) { | |||
8168 | ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr); | |||
8169 | if (Conv.isUsable()) { | |||
8170 | RecExpr = Conv.get(); | |||
8171 | ReceiverType = RecExpr->getType(); | |||
8172 | } | |||
8173 | } | |||
8174 | ||||
8175 | // Build the set of methods we can see. | |||
8176 | ResultBuilder Results( | |||
8177 | *this, CodeCompleter->getAllocator(), | |||
8178 | CodeCompleter->getCodeCompletionTUInfo(), | |||
8179 | CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage, | |||
8180 | ReceiverType, SelIdents)); | |||
8181 | ||||
8182 | Results.EnterNewScope(); | |||
8183 | ||||
8184 | // If this is a send-to-super, try to add the special "super" send | |||
8185 | // completion. | |||
8186 | if (Super) { | |||
8187 | if (ObjCMethodDecl *SuperMethod = | |||
8188 | AddSuperSendCompletion(*this, false, SelIdents, Results)) | |||
8189 | Results.Ignore(SuperMethod); | |||
8190 | } | |||
8191 | ||||
8192 | // If we're inside an Objective-C method definition, prefer its selector to | |||
8193 | // others. | |||
8194 | if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) | |||
8195 | Results.setPreferredSelector(CurMethod->getSelector()); | |||
8196 | ||||
8197 | // Keep track of the selectors we've already added. | |||
8198 | VisitedSelectorSet Selectors; | |||
8199 | ||||
8200 | // Handle messages to Class. This really isn't a message to an instance | |||
8201 | // method, so we treat it the same way we would treat a message send to a | |||
8202 | // class method. | |||
8203 | if (ReceiverType->isObjCClassType() || | |||
8204 | ReceiverType->isObjCQualifiedClassType()) { | |||
8205 | if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) { | |||
8206 | if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface()) | |||
8207 | AddObjCMethods(ClassDecl, false, MK_Any, SelIdents, CurContext, | |||
8208 | Selectors, AtArgumentExpression, Results); | |||
8209 | } | |||
8210 | } | |||
8211 | // Handle messages to a qualified ID ("id<foo>"). | |||
8212 | else if (const ObjCObjectPointerType *QualID = | |||
8213 | ReceiverType->getAsObjCQualifiedIdType()) { | |||
8214 | // Search protocols for instance methods. | |||
8215 | for (auto *I : QualID->quals()) | |||
8216 | AddObjCMethods(I, true, MK_Any, SelIdents, CurContext, Selectors, | |||
8217 | AtArgumentExpression, Results); | |||
8218 | } | |||
8219 | // Handle messages to a pointer to interface type. | |||
8220 | else if (const ObjCObjectPointerType *IFacePtr = | |||
8221 | ReceiverType->getAsObjCInterfacePointerType()) { | |||
8222 | // Search the class, its superclasses, etc., for instance methods. | |||
8223 | AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents, | |||
8224 | CurContext, Selectors, AtArgumentExpression, Results); | |||
8225 | ||||
8226 | // Search protocols for instance methods. | |||
8227 | for (auto *I : IFacePtr->quals()) | |||
8228 | AddObjCMethods(I, true, MK_Any, SelIdents, CurContext, Selectors, | |||
8229 | AtArgumentExpression, Results); | |||
8230 | } | |||
8231 | // Handle messages to "id". | |||
8232 | else if (ReceiverType->isObjCIdType()) { | |||
8233 | // We're messaging "id", so provide all instance methods we know | |||
8234 | // about as code-completion results. | |||
8235 | ||||
8236 | // If we have an external source, load the entire class method | |||
8237 | // pool from the AST file. | |||
8238 | if (ExternalSource) { | |||
8239 | for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); | |||
8240 | I != N; ++I) { | |||
8241 | Selector Sel = ExternalSource->GetExternalSelector(I); | |||
8242 | if (Sel.isNull() || MethodPool.count(Sel)) | |||
8243 | continue; | |||
8244 | ||||
8245 | ReadMethodPool(Sel); | |||
8246 | } | |||
8247 | } | |||
8248 | ||||
8249 | for (GlobalMethodPool::iterator M = MethodPool.begin(), | |||
8250 | MEnd = MethodPool.end(); | |||
8251 | M != MEnd; ++M) { | |||
8252 | for (ObjCMethodList *MethList = &M->second.first; | |||
8253 | MethList && MethList->getMethod(); MethList = MethList->getNext()) { | |||
8254 | if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents)) | |||
8255 | continue; | |||
8256 | ||||
8257 | if (!Selectors.insert(MethList->getMethod()->getSelector()).second) | |||
8258 | continue; | |||
8259 | ||||
8260 | Result R(MethList->getMethod(), | |||
8261 | Results.getBasePriority(MethList->getMethod()), nullptr); | |||
8262 | R.StartParameter = SelIdents.size(); | |||
8263 | R.AllParametersAreInformative = false; | |||
8264 | Results.MaybeAddResult(R, CurContext); | |||
8265 | } | |||
8266 | } | |||
8267 | } | |||
8268 | Results.ExitScope(); | |||
8269 | ||||
8270 | // If we're actually at the argument expression (rather than prior to the | |||
8271 | // selector), we're actually performing code completion for an expression. | |||
8272 | // Determine whether we have a single, best method. If so, we can | |||
8273 | // code-complete the expression using the corresponding parameter type as | |||
8274 | // our preferred type, improving completion results. | |||
8275 | if (AtArgumentExpression) { | |||
8276 | QualType PreferredType = | |||
8277 | getPreferredArgumentTypeForMessageSend(Results, SelIdents.size()); | |||
8278 | if (PreferredType.isNull()) | |||
8279 | CodeCompleteOrdinaryName(S, PCC_Expression); | |||
8280 | else | |||
8281 | CodeCompleteExpression(S, PreferredType); | |||
8282 | return; | |||
8283 | } | |||
8284 | ||||
8285 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
8286 | Results.data(), Results.size()); | |||
8287 | } | |||
8288 | ||||
8289 | void Sema::CodeCompleteObjCForCollection(Scope *S, | |||
8290 | DeclGroupPtrTy IterationVar) { | |||
8291 | CodeCompleteExpressionData Data; | |||
8292 | Data.ObjCCollection = true; | |||
8293 | ||||
8294 | if (IterationVar.getAsOpaquePtr()) { | |||
8295 | DeclGroupRef DG = IterationVar.get(); | |||
8296 | for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) { | |||
8297 | if (*I) | |||
8298 | Data.IgnoreDecls.push_back(*I); | |||
8299 | } | |||
8300 | } | |||
8301 | ||||
8302 | CodeCompleteExpression(S, Data); | |||
8303 | } | |||
8304 | ||||
8305 | void Sema::CodeCompleteObjCSelector(Scope *S, | |||
8306 | ArrayRef<IdentifierInfo *> SelIdents) { | |||
8307 | // If we have an external source, load the entire class method | |||
8308 | // pool from the AST file. | |||
8309 | if (ExternalSource) { | |||
8310 | for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); I != N; | |||
8311 | ++I) { | |||
8312 | Selector Sel = ExternalSource->GetExternalSelector(I); | |||
8313 | if (Sel.isNull() || MethodPool.count(Sel)) | |||
8314 | continue; | |||
8315 | ||||
8316 | ReadMethodPool(Sel); | |||
8317 | } | |||
8318 | } | |||
8319 | ||||
8320 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
8321 | CodeCompleter->getCodeCompletionTUInfo(), | |||
8322 | CodeCompletionContext::CCC_SelectorName); | |||
8323 | Results.EnterNewScope(); | |||
8324 | for (GlobalMethodPool::iterator M = MethodPool.begin(), | |||
8325 | MEnd = MethodPool.end(); | |||
8326 | M != MEnd; ++M) { | |||
8327 | ||||
8328 | Selector Sel = M->first; | |||
8329 | if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents)) | |||
8330 | continue; | |||
8331 | ||||
8332 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
8333 | Results.getCodeCompletionTUInfo()); | |||
8334 | if (Sel.isUnarySelector()) { | |||
8335 | Builder.AddTypedTextChunk( | |||
8336 | Builder.getAllocator().CopyString(Sel.getNameForSlot(0))); | |||
8337 | Results.AddResult(Builder.TakeString()); | |||
8338 | continue; | |||
8339 | } | |||
8340 | ||||
8341 | std::string Accumulator; | |||
8342 | for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) { | |||
8343 | if (I == SelIdents.size()) { | |||
8344 | if (!Accumulator.empty()) { | |||
8345 | Builder.AddInformativeChunk( | |||
8346 | Builder.getAllocator().CopyString(Accumulator)); | |||
8347 | Accumulator.clear(); | |||
8348 | } | |||
8349 | } | |||
8350 | ||||
8351 | Accumulator += Sel.getNameForSlot(I); | |||
8352 | Accumulator += ':'; | |||
8353 | } | |||
8354 | Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(Accumulator)); | |||
8355 | Results.AddResult(Builder.TakeString()); | |||
8356 | } | |||
8357 | Results.ExitScope(); | |||
8358 | ||||
8359 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
8360 | Results.data(), Results.size()); | |||
8361 | } | |||
8362 | ||||
8363 | /// Add all of the protocol declarations that we find in the given | |||
8364 | /// (translation unit) context. | |||
8365 | static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext, | |||
8366 | bool OnlyForwardDeclarations, | |||
8367 | ResultBuilder &Results) { | |||
8368 | typedef CodeCompletionResult Result; | |||
8369 | ||||
8370 | for (const auto *D : Ctx->decls()) { | |||
8371 | // Record any protocols we find. | |||
8372 | if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(D)) | |||
8373 | if (!OnlyForwardDeclarations || !Proto->hasDefinition()) | |||
8374 | Results.AddResult( | |||
8375 | Result(Proto, Results.getBasePriority(Proto), nullptr), CurContext, | |||
8376 | nullptr, false); | |||
8377 | } | |||
8378 | } | |||
8379 | ||||
8380 | void Sema::CodeCompleteObjCProtocolReferences( | |||
8381 | ArrayRef<IdentifierLocPair> Protocols) { | |||
8382 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
8383 | CodeCompleter->getCodeCompletionTUInfo(), | |||
8384 | CodeCompletionContext::CCC_ObjCProtocolName); | |||
8385 | ||||
8386 | if (CodeCompleter->includeGlobals()) { | |||
8387 | Results.EnterNewScope(); | |||
8388 | ||||
8389 | // Tell the result set to ignore all of the protocols we have | |||
8390 | // already seen. | |||
8391 | // FIXME: This doesn't work when caching code-completion results. | |||
8392 | for (const IdentifierLocPair &Pair : Protocols) | |||
8393 | if (ObjCProtocolDecl *Protocol = LookupProtocol(Pair.first, Pair.second)) | |||
8394 | Results.Ignore(Protocol); | |||
8395 | ||||
8396 | // Add all protocols. | |||
8397 | AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false, | |||
8398 | Results); | |||
8399 | ||||
8400 | Results.ExitScope(); | |||
8401 | } | |||
8402 | ||||
8403 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
8404 | Results.data(), Results.size()); | |||
8405 | } | |||
8406 | ||||
8407 | void Sema::CodeCompleteObjCProtocolDecl(Scope *) { | |||
8408 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
8409 | CodeCompleter->getCodeCompletionTUInfo(), | |||
8410 | CodeCompletionContext::CCC_ObjCProtocolName); | |||
8411 | ||||
8412 | if (CodeCompleter->includeGlobals()) { | |||
8413 | Results.EnterNewScope(); | |||
8414 | ||||
8415 | // Add all protocols. | |||
8416 | AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true, | |||
8417 | Results); | |||
8418 | ||||
8419 | Results.ExitScope(); | |||
8420 | } | |||
8421 | ||||
8422 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
8423 | Results.data(), Results.size()); | |||
8424 | } | |||
8425 | ||||
8426 | /// Add all of the Objective-C interface declarations that we find in | |||
8427 | /// the given (translation unit) context. | |||
8428 | static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext, | |||
8429 | bool OnlyForwardDeclarations, | |||
8430 | bool OnlyUnimplemented, | |||
8431 | ResultBuilder &Results) { | |||
8432 | typedef CodeCompletionResult Result; | |||
8433 | ||||
8434 | for (const auto *D : Ctx->decls()) { | |||
8435 | // Record any interfaces we find. | |||
8436 | if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(D)) | |||
8437 | if ((!OnlyForwardDeclarations || !Class->hasDefinition()) && | |||
8438 | (!OnlyUnimplemented || !Class->getImplementation())) | |||
8439 | Results.AddResult( | |||
8440 | Result(Class, Results.getBasePriority(Class), nullptr), CurContext, | |||
8441 | nullptr, false); | |||
8442 | } | |||
8443 | } | |||
8444 | ||||
8445 | void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) { | |||
8446 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
8447 | CodeCompleter->getCodeCompletionTUInfo(), | |||
8448 | CodeCompletionContext::CCC_ObjCInterfaceName); | |||
8449 | Results.EnterNewScope(); | |||
8450 | ||||
8451 | if (CodeCompleter->includeGlobals()) { | |||
8452 | // Add all classes. | |||
8453 | AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false, | |||
8454 | false, Results); | |||
8455 | } | |||
8456 | ||||
8457 | Results.ExitScope(); | |||
8458 | ||||
8459 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
8460 | Results.data(), Results.size()); | |||
8461 | } | |||
8462 | ||||
8463 | void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName, | |||
8464 | SourceLocation ClassNameLoc) { | |||
8465 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
8466 | CodeCompleter->getCodeCompletionTUInfo(), | |||
8467 | CodeCompletionContext::CCC_ObjCInterfaceName); | |||
8468 | Results.EnterNewScope(); | |||
8469 | ||||
8470 | // Make sure that we ignore the class we're currently defining. | |||
8471 | NamedDecl *CurClass = | |||
8472 | LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName); | |||
8473 | if (CurClass && isa<ObjCInterfaceDecl>(CurClass)) | |||
8474 | Results.Ignore(CurClass); | |||
8475 | ||||
8476 | if (CodeCompleter->includeGlobals()) { | |||
8477 | // Add all classes. | |||
8478 | AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false, | |||
8479 | false, Results); | |||
8480 | } | |||
8481 | ||||
8482 | Results.ExitScope(); | |||
8483 | ||||
8484 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
8485 | Results.data(), Results.size()); | |||
8486 | } | |||
8487 | ||||
8488 | void Sema::CodeCompleteObjCImplementationDecl(Scope *S) { | |||
8489 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
8490 | CodeCompleter->getCodeCompletionTUInfo(), | |||
8491 | CodeCompletionContext::CCC_ObjCImplementation); | |||
8492 | Results.EnterNewScope(); | |||
8493 | ||||
8494 | if (CodeCompleter->includeGlobals()) { | |||
8495 | // Add all unimplemented classes. | |||
8496 | AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false, | |||
8497 | true, Results); | |||
8498 | } | |||
8499 | ||||
8500 | Results.ExitScope(); | |||
8501 | ||||
8502 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
8503 | Results.data(), Results.size()); | |||
8504 | } | |||
8505 | ||||
8506 | void Sema::CodeCompleteObjCInterfaceCategory(Scope *S, | |||
8507 | IdentifierInfo *ClassName, | |||
8508 | SourceLocation ClassNameLoc) { | |||
8509 | typedef CodeCompletionResult Result; | |||
8510 | ||||
8511 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
8512 | CodeCompleter->getCodeCompletionTUInfo(), | |||
8513 | CodeCompletionContext::CCC_ObjCCategoryName); | |||
8514 | ||||
8515 | // Ignore any categories we find that have already been implemented by this | |||
8516 | // interface. | |||
8517 | llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames; | |||
8518 | NamedDecl *CurClass = | |||
8519 | LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName); | |||
8520 | if (ObjCInterfaceDecl *Class = | |||
8521 | dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)) { | |||
8522 | for (const auto *Cat : Class->visible_categories()) | |||
8523 | CategoryNames.insert(Cat->getIdentifier()); | |||
8524 | } | |||
8525 | ||||
8526 | // Add all of the categories we know about. | |||
8527 | Results.EnterNewScope(); | |||
8528 | TranslationUnitDecl *TU = Context.getTranslationUnitDecl(); | |||
8529 | for (const auto *D : TU->decls()) | |||
8530 | if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D)) | |||
8531 | if (CategoryNames.insert(Category->getIdentifier()).second) | |||
8532 | Results.AddResult( | |||
8533 | Result(Category, Results.getBasePriority(Category), nullptr), | |||
8534 | CurContext, nullptr, false); | |||
8535 | Results.ExitScope(); | |||
8536 | ||||
8537 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
8538 | Results.data(), Results.size()); | |||
8539 | } | |||
8540 | ||||
8541 | void Sema::CodeCompleteObjCImplementationCategory(Scope *S, | |||
8542 | IdentifierInfo *ClassName, | |||
8543 | SourceLocation ClassNameLoc) { | |||
8544 | typedef CodeCompletionResult Result; | |||
8545 | ||||
8546 | // Find the corresponding interface. If we couldn't find the interface, the | |||
8547 | // program itself is ill-formed. However, we'll try to be helpful still by | |||
8548 | // providing the list of all of the categories we know about. | |||
8549 | NamedDecl *CurClass = | |||
8550 | LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName); | |||
8551 | ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass); | |||
8552 | if (!Class) | |||
8553 | return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc); | |||
8554 | ||||
8555 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
8556 | CodeCompleter->getCodeCompletionTUInfo(), | |||
8557 | CodeCompletionContext::CCC_ObjCCategoryName); | |||
8558 | ||||
8559 | // Add all of the categories that have corresponding interface | |||
8560 | // declarations in this class and any of its superclasses, except for | |||
8561 | // already-implemented categories in the class itself. | |||
8562 | llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames; | |||
8563 | Results.EnterNewScope(); | |||
8564 | bool IgnoreImplemented = true; | |||
8565 | while (Class) { | |||
8566 | for (const auto *Cat : Class->visible_categories()) { | |||
8567 | if ((!IgnoreImplemented || !Cat->getImplementation()) && | |||
8568 | CategoryNames.insert(Cat->getIdentifier()).second) | |||
8569 | Results.AddResult(Result(Cat, Results.getBasePriority(Cat), nullptr), | |||
8570 | CurContext, nullptr, false); | |||
8571 | } | |||
8572 | ||||
8573 | Class = Class->getSuperClass(); | |||
8574 | IgnoreImplemented = false; | |||
8575 | } | |||
8576 | Results.ExitScope(); | |||
8577 | ||||
8578 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
8579 | Results.data(), Results.size()); | |||
8580 | } | |||
8581 | ||||
8582 | void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) { | |||
8583 | CodeCompletionContext CCContext(CodeCompletionContext::CCC_Other); | |||
8584 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
8585 | CodeCompleter->getCodeCompletionTUInfo(), CCContext); | |||
8586 | ||||
8587 | // Figure out where this @synthesize lives. | |||
8588 | ObjCContainerDecl *Container = | |||
8589 | dyn_cast_or_null<ObjCContainerDecl>(CurContext); | |||
8590 | if (!Container || (!isa<ObjCImplementationDecl>(Container) && | |||
8591 | !isa<ObjCCategoryImplDecl>(Container))) | |||
8592 | return; | |||
8593 | ||||
8594 | // Ignore any properties that have already been implemented. | |||
8595 | Container = getContainerDef(Container); | |||
8596 | for (const auto *D : Container->decls()) | |||
8597 | if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D)) | |||
8598 | Results.Ignore(PropertyImpl->getPropertyDecl()); | |||
8599 | ||||
8600 | // Add any properties that we find. | |||
8601 | AddedPropertiesSet AddedProperties; | |||
8602 | Results.EnterNewScope(); | |||
8603 | if (ObjCImplementationDecl *ClassImpl = | |||
8604 | dyn_cast<ObjCImplementationDecl>(Container)) | |||
8605 | AddObjCProperties(CCContext, ClassImpl->getClassInterface(), false, | |||
8606 | /*AllowNullaryMethods=*/false, CurContext, | |||
8607 | AddedProperties, Results); | |||
8608 | else | |||
8609 | AddObjCProperties(CCContext, | |||
8610 | cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(), | |||
8611 | false, /*AllowNullaryMethods=*/false, CurContext, | |||
8612 | AddedProperties, Results); | |||
8613 | Results.ExitScope(); | |||
8614 | ||||
8615 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
8616 | Results.data(), Results.size()); | |||
8617 | } | |||
8618 | ||||
8619 | void Sema::CodeCompleteObjCPropertySynthesizeIvar( | |||
8620 | Scope *S, IdentifierInfo *PropertyName) { | |||
8621 | typedef CodeCompletionResult Result; | |||
8622 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
8623 | CodeCompleter->getCodeCompletionTUInfo(), | |||
8624 | CodeCompletionContext::CCC_Other); | |||
8625 | ||||
8626 | // Figure out where this @synthesize lives. | |||
8627 | ObjCContainerDecl *Container = | |||
8628 | dyn_cast_or_null<ObjCContainerDecl>(CurContext); | |||
8629 | if (!Container || (!isa<ObjCImplementationDecl>(Container) && | |||
8630 | !isa<ObjCCategoryImplDecl>(Container))) | |||
8631 | return; | |||
8632 | ||||
8633 | // Figure out which interface we're looking into. | |||
8634 | ObjCInterfaceDecl *Class = nullptr; | |||
8635 | if (ObjCImplementationDecl *ClassImpl = | |||
8636 | dyn_cast<ObjCImplementationDecl>(Container)) | |||
8637 | Class = ClassImpl->getClassInterface(); | |||
8638 | else | |||
8639 | Class = cast<ObjCCategoryImplDecl>(Container) | |||
8640 | ->getCategoryDecl() | |||
8641 | ->getClassInterface(); | |||
8642 | ||||
8643 | // Determine the type of the property we're synthesizing. | |||
8644 | QualType PropertyType = Context.getObjCIdType(); | |||
8645 | if (Class) { | |||
8646 | if (ObjCPropertyDecl *Property = Class->FindPropertyDeclaration( | |||
8647 | PropertyName, ObjCPropertyQueryKind::OBJC_PR_query_instance)) { | |||
8648 | PropertyType = | |||
8649 | Property->getType().getNonReferenceType().getUnqualifiedType(); | |||
8650 | ||||
8651 | // Give preference to ivars | |||
8652 | Results.setPreferredType(PropertyType); | |||
8653 | } | |||
8654 | } | |||
8655 | ||||
8656 | // Add all of the instance variables in this class and its superclasses. | |||
8657 | Results.EnterNewScope(); | |||
8658 | bool SawSimilarlyNamedIvar = false; | |||
8659 | std::string NameWithPrefix; | |||
8660 | NameWithPrefix += '_'; | |||
8661 | NameWithPrefix += PropertyName->getName(); | |||
8662 | std::string NameWithSuffix = PropertyName->getName().str(); | |||
8663 | NameWithSuffix += '_'; | |||
8664 | for (; Class; Class = Class->getSuperClass()) { | |||
8665 | for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar; | |||
8666 | Ivar = Ivar->getNextIvar()) { | |||
8667 | Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), nullptr), | |||
8668 | CurContext, nullptr, false); | |||
8669 | ||||
8670 | // Determine whether we've seen an ivar with a name similar to the | |||
8671 | // property. | |||
8672 | if ((PropertyName == Ivar->getIdentifier() || | |||
8673 | NameWithPrefix == Ivar->getName() || | |||
8674 | NameWithSuffix == Ivar->getName())) { | |||
8675 | SawSimilarlyNamedIvar = true; | |||
8676 | ||||
8677 | // Reduce the priority of this result by one, to give it a slight | |||
8678 | // advantage over other results whose names don't match so closely. | |||
8679 | if (Results.size() && | |||
8680 | Results.data()[Results.size() - 1].Kind == | |||
8681 | CodeCompletionResult::RK_Declaration && | |||
8682 | Results.data()[Results.size() - 1].Declaration == Ivar) | |||
8683 | Results.data()[Results.size() - 1].Priority--; | |||
8684 | } | |||
8685 | } | |||
8686 | } | |||
8687 | ||||
8688 | if (!SawSimilarlyNamedIvar) { | |||
8689 | // Create ivar result _propName, that the user can use to synthesize | |||
8690 | // an ivar of the appropriate type. | |||
8691 | unsigned Priority = CCP_MemberDeclaration + 1; | |||
8692 | typedef CodeCompletionResult Result; | |||
8693 | CodeCompletionAllocator &Allocator = Results.getAllocator(); | |||
8694 | CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(), | |||
8695 | Priority, CXAvailability_Available); | |||
8696 | ||||
8697 | PrintingPolicy Policy = getCompletionPrintingPolicy(*this); | |||
8698 | Builder.AddResultTypeChunk( | |||
8699 | GetCompletionTypeString(PropertyType, Context, Policy, Allocator)); | |||
8700 | Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix)); | |||
8701 | Results.AddResult( | |||
8702 | Result(Builder.TakeString(), Priority, CXCursor_ObjCIvarDecl)); | |||
8703 | } | |||
8704 | ||||
8705 | Results.ExitScope(); | |||
8706 | ||||
8707 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
8708 | Results.data(), Results.size()); | |||
8709 | } | |||
8710 | ||||
8711 | // Mapping from selectors to the methods that implement that selector, along | |||
8712 | // with the "in original class" flag. | |||
8713 | typedef llvm::DenseMap<Selector, | |||
8714 | llvm::PointerIntPair<ObjCMethodDecl *, 1, bool>> | |||
8715 | KnownMethodsMap; | |||
8716 | ||||
8717 | /// Find all of the methods that reside in the given container | |||
8718 | /// (and its superclasses, protocols, etc.) that meet the given | |||
8719 | /// criteria. Insert those methods into the map of known methods, | |||
8720 | /// indexed by selector so they can be easily found. | |||
8721 | static void FindImplementableMethods(ASTContext &Context, | |||
8722 | ObjCContainerDecl *Container, | |||
8723 | std::optional<bool> WantInstanceMethods, | |||
8724 | QualType ReturnType, | |||
8725 | KnownMethodsMap &KnownMethods, | |||
8726 | bool InOriginalClass = true) { | |||
8727 | if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) { | |||
8728 | // Make sure we have a definition; that's what we'll walk. | |||
8729 | if (!IFace->hasDefinition()) | |||
8730 | return; | |||
8731 | ||||
8732 | IFace = IFace->getDefinition(); | |||
8733 | Container = IFace; | |||
8734 | ||||
8735 | const ObjCList<ObjCProtocolDecl> &Protocols = | |||
8736 | IFace->getReferencedProtocols(); | |||
8737 | for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), | |||
8738 | E = Protocols.end(); | |||
8739 | I != E; ++I) | |||
8740 | FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType, | |||
8741 | KnownMethods, InOriginalClass); | |||
8742 | ||||
8743 | // Add methods from any class extensions and categories. | |||
8744 | for (auto *Cat : IFace->visible_categories()) { | |||
8745 | FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType, | |||
8746 | KnownMethods, false); | |||
8747 | } | |||
8748 | ||||
8749 | // Visit the superclass. | |||
8750 | if (IFace->getSuperClass()) | |||
8751 | FindImplementableMethods(Context, IFace->getSuperClass(), | |||
8752 | WantInstanceMethods, ReturnType, KnownMethods, | |||
8753 | false); | |||
8754 | } | |||
8755 | ||||
8756 | if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) { | |||
8757 | // Recurse into protocols. | |||
8758 | const ObjCList<ObjCProtocolDecl> &Protocols = | |||
8759 | Category->getReferencedProtocols(); | |||
8760 | for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), | |||
8761 | E = Protocols.end(); | |||
8762 | I != E; ++I) | |||
8763 | FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType, | |||
8764 | KnownMethods, InOriginalClass); | |||
8765 | ||||
8766 | // If this category is the original class, jump to the interface. | |||
8767 | if (InOriginalClass && Category->getClassInterface()) | |||
8768 | FindImplementableMethods(Context, Category->getClassInterface(), | |||
8769 | WantInstanceMethods, ReturnType, KnownMethods, | |||
8770 | false); | |||
8771 | } | |||
8772 | ||||
8773 | if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { | |||
8774 | // Make sure we have a definition; that's what we'll walk. | |||
8775 | if (!Protocol->hasDefinition()) | |||
8776 | return; | |||
8777 | Protocol = Protocol->getDefinition(); | |||
8778 | Container = Protocol; | |||
8779 | ||||
8780 | // Recurse into protocols. | |||
8781 | const ObjCList<ObjCProtocolDecl> &Protocols = | |||
8782 | Protocol->getReferencedProtocols(); | |||
8783 | for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), | |||
8784 | E = Protocols.end(); | |||
8785 | I != E; ++I) | |||
8786 | FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType, | |||
8787 | KnownMethods, false); | |||
8788 | } | |||
8789 | ||||
8790 | // Add methods in this container. This operation occurs last because | |||
8791 | // we want the methods from this container to override any methods | |||
8792 | // we've previously seen with the same selector. | |||
8793 | for (auto *M : Container->methods()) { | |||
8794 | if (!WantInstanceMethods || M->isInstanceMethod() == *WantInstanceMethods) { | |||
8795 | if (!ReturnType.isNull() && | |||
8796 | !Context.hasSameUnqualifiedType(ReturnType, M->getReturnType())) | |||
8797 | continue; | |||
8798 | ||||
8799 | KnownMethods[M->getSelector()] = | |||
8800 | KnownMethodsMap::mapped_type(M, InOriginalClass); | |||
8801 | } | |||
8802 | } | |||
8803 | } | |||
8804 | ||||
8805 | /// Add the parenthesized return or parameter type chunk to a code | |||
8806 | /// completion string. | |||
8807 | static void AddObjCPassingTypeChunk(QualType Type, unsigned ObjCDeclQuals, | |||
8808 | ASTContext &Context, | |||
8809 | const PrintingPolicy &Policy, | |||
8810 | CodeCompletionBuilder &Builder) { | |||
8811 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
8812 | std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals, Type); | |||
8813 | if (!Quals.empty()) | |||
8814 | Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals)); | |||
8815 | Builder.AddTextChunk( | |||
8816 | GetCompletionTypeString(Type, Context, Policy, Builder.getAllocator())); | |||
8817 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
8818 | } | |||
8819 | ||||
8820 | /// Determine whether the given class is or inherits from a class by | |||
8821 | /// the given name. | |||
8822 | static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class, StringRef Name) { | |||
8823 | if (!Class) | |||
8824 | return false; | |||
8825 | ||||
8826 | if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name) | |||
8827 | return true; | |||
8828 | ||||
8829 | return InheritsFromClassNamed(Class->getSuperClass(), Name); | |||
8830 | } | |||
8831 | ||||
8832 | /// Add code completions for Objective-C Key-Value Coding (KVC) and | |||
8833 | /// Key-Value Observing (KVO). | |||
8834 | static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property, | |||
8835 | bool IsInstanceMethod, | |||
8836 | QualType ReturnType, ASTContext &Context, | |||
8837 | VisitedSelectorSet &KnownSelectors, | |||
8838 | ResultBuilder &Results) { | |||
8839 | IdentifierInfo *PropName = Property->getIdentifier(); | |||
8840 | if (!PropName || PropName->getLength() == 0) | |||
8841 | return; | |||
8842 | ||||
8843 | PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema()); | |||
8844 | ||||
8845 | // Builder that will create each code completion. | |||
8846 | typedef CodeCompletionResult Result; | |||
8847 | CodeCompletionAllocator &Allocator = Results.getAllocator(); | |||
8848 | CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo()); | |||
8849 | ||||
8850 | // The selector table. | |||
8851 | SelectorTable &Selectors = Context.Selectors; | |||
8852 | ||||
8853 | // The property name, copied into the code completion allocation region | |||
8854 | // on demand. | |||
8855 | struct KeyHolder { | |||
8856 | CodeCompletionAllocator &Allocator; | |||
8857 | StringRef Key; | |||
8858 | const char *CopiedKey; | |||
8859 | ||||
8860 | KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key) | |||
8861 | : Allocator(Allocator), Key(Key), CopiedKey(nullptr) {} | |||
8862 | ||||
8863 | operator const char *() { | |||
8864 | if (CopiedKey) | |||
8865 | return CopiedKey; | |||
8866 | ||||
8867 | return CopiedKey = Allocator.CopyString(Key); | |||
8868 | } | |||
8869 | } Key(Allocator, PropName->getName()); | |||
8870 | ||||
8871 | // The uppercased name of the property name. | |||
8872 | std::string UpperKey = std::string(PropName->getName()); | |||
8873 | if (!UpperKey.empty()) | |||
8874 | UpperKey[0] = toUppercase(UpperKey[0]); | |||
8875 | ||||
8876 | bool ReturnTypeMatchesProperty = | |||
8877 | ReturnType.isNull() || | |||
8878 | Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(), | |||
8879 | Property->getType()); | |||
8880 | bool ReturnTypeMatchesVoid = ReturnType.isNull() || ReturnType->isVoidType(); | |||
8881 | ||||
8882 | // Add the normal accessor -(type)key. | |||
8883 | if (IsInstanceMethod && | |||
8884 | KnownSelectors.insert(Selectors.getNullarySelector(PropName)).second && | |||
8885 | ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) { | |||
8886 | if (ReturnType.isNull()) | |||
8887 | AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0, Context, Policy, | |||
8888 | Builder); | |||
8889 | ||||
8890 | Builder.AddTypedTextChunk(Key); | |||
8891 | Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern, | |||
8892 | CXCursor_ObjCInstanceMethodDecl)); | |||
8893 | } | |||
8894 | ||||
8895 | // If we have an integral or boolean property (or the user has provided | |||
8896 | // an integral or boolean return type), add the accessor -(type)isKey. | |||
8897 | if (IsInstanceMethod && | |||
8898 | ((!ReturnType.isNull() && | |||
8899 | (ReturnType->isIntegerType() || ReturnType->isBooleanType())) || | |||
8900 | (ReturnType.isNull() && (Property->getType()->isIntegerType() || | |||
8901 | Property->getType()->isBooleanType())))) { | |||
8902 | std::string SelectorName = (Twine("is") + UpperKey).str(); | |||
8903 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
8904 | if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId)) | |||
8905 | .second) { | |||
8906 | if (ReturnType.isNull()) { | |||
8907 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
8908 | Builder.AddTextChunk("BOOL"); | |||
8909 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
8910 | } | |||
8911 | ||||
8912 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorId->getName())); | |||
8913 | Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern, | |||
8914 | CXCursor_ObjCInstanceMethodDecl)); | |||
8915 | } | |||
8916 | } | |||
8917 | ||||
8918 | // Add the normal mutator. | |||
8919 | if (IsInstanceMethod && ReturnTypeMatchesVoid && | |||
8920 | !Property->getSetterMethodDecl()) { | |||
8921 | std::string SelectorName = (Twine("set") + UpperKey).str(); | |||
8922 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
8923 | if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { | |||
8924 | if (ReturnType.isNull()) { | |||
8925 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
8926 | Builder.AddTextChunk("void"); | |||
8927 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
8928 | } | |||
8929 | ||||
8930 | Builder.AddTypedTextChunk( | |||
8931 | Allocator.CopyString(SelectorId->getName() + ":")); | |||
8932 | AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0, Context, Policy, | |||
8933 | Builder); | |||
8934 | Builder.AddTextChunk(Key); | |||
8935 | Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern, | |||
8936 | CXCursor_ObjCInstanceMethodDecl)); | |||
8937 | } | |||
8938 | } | |||
8939 | ||||
8940 | // Indexed and unordered accessors | |||
8941 | unsigned IndexedGetterPriority = CCP_CodePattern; | |||
8942 | unsigned IndexedSetterPriority = CCP_CodePattern; | |||
8943 | unsigned UnorderedGetterPriority = CCP_CodePattern; | |||
8944 | unsigned UnorderedSetterPriority = CCP_CodePattern; | |||
8945 | if (const auto *ObjCPointer = | |||
8946 | Property->getType()->getAs<ObjCObjectPointerType>()) { | |||
8947 | if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) { | |||
8948 | // If this interface type is not provably derived from a known | |||
8949 | // collection, penalize the corresponding completions. | |||
8950 | if (!InheritsFromClassNamed(IFace, "NSMutableArray")) { | |||
8951 | IndexedSetterPriority += CCD_ProbablyNotObjCCollection; | |||
8952 | if (!InheritsFromClassNamed(IFace, "NSArray")) | |||
8953 | IndexedGetterPriority += CCD_ProbablyNotObjCCollection; | |||
8954 | } | |||
8955 | ||||
8956 | if (!InheritsFromClassNamed(IFace, "NSMutableSet")) { | |||
8957 | UnorderedSetterPriority += CCD_ProbablyNotObjCCollection; | |||
8958 | if (!InheritsFromClassNamed(IFace, "NSSet")) | |||
8959 | UnorderedGetterPriority += CCD_ProbablyNotObjCCollection; | |||
8960 | } | |||
8961 | } | |||
8962 | } else { | |||
8963 | IndexedGetterPriority += CCD_ProbablyNotObjCCollection; | |||
8964 | IndexedSetterPriority += CCD_ProbablyNotObjCCollection; | |||
8965 | UnorderedGetterPriority += CCD_ProbablyNotObjCCollection; | |||
8966 | UnorderedSetterPriority += CCD_ProbablyNotObjCCollection; | |||
8967 | } | |||
8968 | ||||
8969 | // Add -(NSUInteger)countOf<key> | |||
8970 | if (IsInstanceMethod && | |||
8971 | (ReturnType.isNull() || ReturnType->isIntegerType())) { | |||
8972 | std::string SelectorName = (Twine("countOf") + UpperKey).str(); | |||
8973 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
8974 | if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId)) | |||
8975 | .second) { | |||
8976 | if (ReturnType.isNull()) { | |||
8977 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
8978 | Builder.AddTextChunk("NSUInteger"); | |||
8979 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
8980 | } | |||
8981 | ||||
8982 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorId->getName())); | |||
8983 | Results.AddResult( | |||
8984 | Result(Builder.TakeString(), | |||
8985 | std::min(IndexedGetterPriority, UnorderedGetterPriority), | |||
8986 | CXCursor_ObjCInstanceMethodDecl)); | |||
8987 | } | |||
8988 | } | |||
8989 | ||||
8990 | // Indexed getters | |||
8991 | // Add -(id)objectInKeyAtIndex:(NSUInteger)index | |||
8992 | if (IsInstanceMethod && | |||
8993 | (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) { | |||
8994 | std::string SelectorName = (Twine("objectIn") + UpperKey + "AtIndex").str(); | |||
8995 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
8996 | if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { | |||
8997 | if (ReturnType.isNull()) { | |||
8998 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
8999 | Builder.AddTextChunk("id"); | |||
9000 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9001 | } | |||
9002 | ||||
9003 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); | |||
9004 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9005 | Builder.AddTextChunk("NSUInteger"); | |||
9006 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9007 | Builder.AddTextChunk("index"); | |||
9008 | Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority, | |||
9009 | CXCursor_ObjCInstanceMethodDecl)); | |||
9010 | } | |||
9011 | } | |||
9012 | ||||
9013 | // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes | |||
9014 | if (IsInstanceMethod && | |||
9015 | (ReturnType.isNull() || | |||
9016 | (ReturnType->isObjCObjectPointerType() && | |||
9017 | ReturnType->castAs<ObjCObjectPointerType>()->getInterfaceDecl() && | |||
9018 | ReturnType->castAs<ObjCObjectPointerType>() | |||
9019 | ->getInterfaceDecl() | |||
9020 | ->getName() == "NSArray"))) { | |||
9021 | std::string SelectorName = (Twine(Property->getName()) + "AtIndexes").str(); | |||
9022 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
9023 | if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { | |||
9024 | if (ReturnType.isNull()) { | |||
9025 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9026 | Builder.AddTextChunk("NSArray *"); | |||
9027 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9028 | } | |||
9029 | ||||
9030 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); | |||
9031 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9032 | Builder.AddTextChunk("NSIndexSet *"); | |||
9033 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9034 | Builder.AddTextChunk("indexes"); | |||
9035 | Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority, | |||
9036 | CXCursor_ObjCInstanceMethodDecl)); | |||
9037 | } | |||
9038 | } | |||
9039 | ||||
9040 | // Add -(void)getKey:(type **)buffer range:(NSRange)inRange | |||
9041 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { | |||
9042 | std::string SelectorName = (Twine("get") + UpperKey).str(); | |||
9043 | IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName), | |||
9044 | &Context.Idents.get("range")}; | |||
9045 | ||||
9046 | if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) { | |||
9047 | if (ReturnType.isNull()) { | |||
9048 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9049 | Builder.AddTextChunk("void"); | |||
9050 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9051 | } | |||
9052 | ||||
9053 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); | |||
9054 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9055 | Builder.AddPlaceholderChunk("object-type"); | |||
9056 | Builder.AddTextChunk(" **"); | |||
9057 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9058 | Builder.AddTextChunk("buffer"); | |||
9059 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9060 | Builder.AddTypedTextChunk("range:"); | |||
9061 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9062 | Builder.AddTextChunk("NSRange"); | |||
9063 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9064 | Builder.AddTextChunk("inRange"); | |||
9065 | Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority, | |||
9066 | CXCursor_ObjCInstanceMethodDecl)); | |||
9067 | } | |||
9068 | } | |||
9069 | ||||
9070 | // Mutable indexed accessors | |||
9071 | ||||
9072 | // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index | |||
9073 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { | |||
9074 | std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str(); | |||
9075 | IdentifierInfo *SelectorIds[2] = {&Context.Idents.get("insertObject"), | |||
9076 | &Context.Idents.get(SelectorName)}; | |||
9077 | ||||
9078 | if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) { | |||
9079 | if (ReturnType.isNull()) { | |||
9080 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9081 | Builder.AddTextChunk("void"); | |||
9082 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9083 | } | |||
9084 | ||||
9085 | Builder.AddTypedTextChunk("insertObject:"); | |||
9086 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9087 | Builder.AddPlaceholderChunk("object-type"); | |||
9088 | Builder.AddTextChunk(" *"); | |||
9089 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9090 | Builder.AddTextChunk("object"); | |||
9091 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9092 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); | |||
9093 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9094 | Builder.AddPlaceholderChunk("NSUInteger"); | |||
9095 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9096 | Builder.AddTextChunk("index"); | |||
9097 | Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority, | |||
9098 | CXCursor_ObjCInstanceMethodDecl)); | |||
9099 | } | |||
9100 | } | |||
9101 | ||||
9102 | // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes | |||
9103 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { | |||
9104 | std::string SelectorName = (Twine("insert") + UpperKey).str(); | |||
9105 | IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName), | |||
9106 | &Context.Idents.get("atIndexes")}; | |||
9107 | ||||
9108 | if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) { | |||
9109 | if (ReturnType.isNull()) { | |||
9110 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9111 | Builder.AddTextChunk("void"); | |||
9112 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9113 | } | |||
9114 | ||||
9115 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); | |||
9116 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9117 | Builder.AddTextChunk("NSArray *"); | |||
9118 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9119 | Builder.AddTextChunk("array"); | |||
9120 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9121 | Builder.AddTypedTextChunk("atIndexes:"); | |||
9122 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9123 | Builder.AddPlaceholderChunk("NSIndexSet *"); | |||
9124 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9125 | Builder.AddTextChunk("indexes"); | |||
9126 | Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority, | |||
9127 | CXCursor_ObjCInstanceMethodDecl)); | |||
9128 | } | |||
9129 | } | |||
9130 | ||||
9131 | // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index | |||
9132 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { | |||
9133 | std::string SelectorName = | |||
9134 | (Twine("removeObjectFrom") + UpperKey + "AtIndex").str(); | |||
9135 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
9136 | if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { | |||
9137 | if (ReturnType.isNull()) { | |||
9138 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9139 | Builder.AddTextChunk("void"); | |||
9140 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9141 | } | |||
9142 | ||||
9143 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); | |||
9144 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9145 | Builder.AddTextChunk("NSUInteger"); | |||
9146 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9147 | Builder.AddTextChunk("index"); | |||
9148 | Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority, | |||
9149 | CXCursor_ObjCInstanceMethodDecl)); | |||
9150 | } | |||
9151 | } | |||
9152 | ||||
9153 | // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes | |||
9154 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { | |||
9155 | std::string SelectorName = (Twine("remove") + UpperKey + "AtIndexes").str(); | |||
9156 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
9157 | if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { | |||
9158 | if (ReturnType.isNull()) { | |||
9159 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9160 | Builder.AddTextChunk("void"); | |||
9161 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9162 | } | |||
9163 | ||||
9164 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); | |||
9165 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9166 | Builder.AddTextChunk("NSIndexSet *"); | |||
9167 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9168 | Builder.AddTextChunk("indexes"); | |||
9169 | Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority, | |||
9170 | CXCursor_ObjCInstanceMethodDecl)); | |||
9171 | } | |||
9172 | } | |||
9173 | ||||
9174 | // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object | |||
9175 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { | |||
9176 | std::string SelectorName = | |||
9177 | (Twine("replaceObjectIn") + UpperKey + "AtIndex").str(); | |||
9178 | IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName), | |||
9179 | &Context.Idents.get("withObject")}; | |||
9180 | ||||
9181 | if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) { | |||
9182 | if (ReturnType.isNull()) { | |||
9183 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9184 | Builder.AddTextChunk("void"); | |||
9185 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9186 | } | |||
9187 | ||||
9188 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); | |||
9189 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9190 | Builder.AddPlaceholderChunk("NSUInteger"); | |||
9191 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9192 | Builder.AddTextChunk("index"); | |||
9193 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9194 | Builder.AddTypedTextChunk("withObject:"); | |||
9195 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9196 | Builder.AddTextChunk("id"); | |||
9197 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9198 | Builder.AddTextChunk("object"); | |||
9199 | Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority, | |||
9200 | CXCursor_ObjCInstanceMethodDecl)); | |||
9201 | } | |||
9202 | } | |||
9203 | ||||
9204 | // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array | |||
9205 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { | |||
9206 | std::string SelectorName1 = | |||
9207 | (Twine("replace") + UpperKey + "AtIndexes").str(); | |||
9208 | std::string SelectorName2 = (Twine("with") + UpperKey).str(); | |||
9209 | IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName1), | |||
9210 | &Context.Idents.get(SelectorName2)}; | |||
9211 | ||||
9212 | if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) { | |||
9213 | if (ReturnType.isNull()) { | |||
9214 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9215 | Builder.AddTextChunk("void"); | |||
9216 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9217 | } | |||
9218 | ||||
9219 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":")); | |||
9220 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9221 | Builder.AddPlaceholderChunk("NSIndexSet *"); | |||
9222 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9223 | Builder.AddTextChunk("indexes"); | |||
9224 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9225 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":")); | |||
9226 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9227 | Builder.AddTextChunk("NSArray *"); | |||
9228 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9229 | Builder.AddTextChunk("array"); | |||
9230 | Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority, | |||
9231 | CXCursor_ObjCInstanceMethodDecl)); | |||
9232 | } | |||
9233 | } | |||
9234 | ||||
9235 | // Unordered getters | |||
9236 | // - (NSEnumerator *)enumeratorOfKey | |||
9237 | if (IsInstanceMethod && | |||
9238 | (ReturnType.isNull() || | |||
9239 | (ReturnType->isObjCObjectPointerType() && | |||
9240 | ReturnType->castAs<ObjCObjectPointerType>()->getInterfaceDecl() && | |||
9241 | ReturnType->castAs<ObjCObjectPointerType>() | |||
9242 | ->getInterfaceDecl() | |||
9243 | ->getName() == "NSEnumerator"))) { | |||
9244 | std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str(); | |||
9245 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
9246 | if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId)) | |||
9247 | .second) { | |||
9248 | if (ReturnType.isNull()) { | |||
9249 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9250 | Builder.AddTextChunk("NSEnumerator *"); | |||
9251 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9252 | } | |||
9253 | ||||
9254 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName)); | |||
9255 | Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority, | |||
9256 | CXCursor_ObjCInstanceMethodDecl)); | |||
9257 | } | |||
9258 | } | |||
9259 | ||||
9260 | // - (type *)memberOfKey:(type *)object | |||
9261 | if (IsInstanceMethod && | |||
9262 | (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) { | |||
9263 | std::string SelectorName = (Twine("memberOf") + UpperKey).str(); | |||
9264 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
9265 | if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { | |||
9266 | if (ReturnType.isNull()) { | |||
9267 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9268 | Builder.AddPlaceholderChunk("object-type"); | |||
9269 | Builder.AddTextChunk(" *"); | |||
9270 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9271 | } | |||
9272 | ||||
9273 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); | |||
9274 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9275 | if (ReturnType.isNull()) { | |||
9276 | Builder.AddPlaceholderChunk("object-type"); | |||
9277 | Builder.AddTextChunk(" *"); | |||
9278 | } else { | |||
9279 | Builder.AddTextChunk(GetCompletionTypeString( | |||
9280 | ReturnType, Context, Policy, Builder.getAllocator())); | |||
9281 | } | |||
9282 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9283 | Builder.AddTextChunk("object"); | |||
9284 | Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority, | |||
9285 | CXCursor_ObjCInstanceMethodDecl)); | |||
9286 | } | |||
9287 | } | |||
9288 | ||||
9289 | // Mutable unordered accessors | |||
9290 | // - (void)addKeyObject:(type *)object | |||
9291 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { | |||
9292 | std::string SelectorName = | |||
9293 | (Twine("add") + UpperKey + Twine("Object")).str(); | |||
9294 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
9295 | if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { | |||
9296 | if (ReturnType.isNull()) { | |||
9297 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9298 | Builder.AddTextChunk("void"); | |||
9299 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9300 | } | |||
9301 | ||||
9302 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); | |||
9303 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9304 | Builder.AddPlaceholderChunk("object-type"); | |||
9305 | Builder.AddTextChunk(" *"); | |||
9306 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9307 | Builder.AddTextChunk("object"); | |||
9308 | Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority, | |||
9309 | CXCursor_ObjCInstanceMethodDecl)); | |||
9310 | } | |||
9311 | } | |||
9312 | ||||
9313 | // - (void)addKey:(NSSet *)objects | |||
9314 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { | |||
9315 | std::string SelectorName = (Twine("add") + UpperKey).str(); | |||
9316 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
9317 | if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { | |||
9318 | if (ReturnType.isNull()) { | |||
9319 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9320 | Builder.AddTextChunk("void"); | |||
9321 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9322 | } | |||
9323 | ||||
9324 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); | |||
9325 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9326 | Builder.AddTextChunk("NSSet *"); | |||
9327 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9328 | Builder.AddTextChunk("objects"); | |||
9329 | Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority, | |||
9330 | CXCursor_ObjCInstanceMethodDecl)); | |||
9331 | } | |||
9332 | } | |||
9333 | ||||
9334 | // - (void)removeKeyObject:(type *)object | |||
9335 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { | |||
9336 | std::string SelectorName = | |||
9337 | (Twine("remove") + UpperKey + Twine("Object")).str(); | |||
9338 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
9339 | if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { | |||
9340 | if (ReturnType.isNull()) { | |||
9341 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9342 | Builder.AddTextChunk("void"); | |||
9343 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9344 | } | |||
9345 | ||||
9346 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); | |||
9347 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9348 | Builder.AddPlaceholderChunk("object-type"); | |||
9349 | Builder.AddTextChunk(" *"); | |||
9350 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9351 | Builder.AddTextChunk("object"); | |||
9352 | Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority, | |||
9353 | CXCursor_ObjCInstanceMethodDecl)); | |||
9354 | } | |||
9355 | } | |||
9356 | ||||
9357 | // - (void)removeKey:(NSSet *)objects | |||
9358 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { | |||
9359 | std::string SelectorName = (Twine("remove") + UpperKey).str(); | |||
9360 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
9361 | if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { | |||
9362 | if (ReturnType.isNull()) { | |||
9363 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9364 | Builder.AddTextChunk("void"); | |||
9365 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9366 | } | |||
9367 | ||||
9368 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); | |||
9369 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9370 | Builder.AddTextChunk("NSSet *"); | |||
9371 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9372 | Builder.AddTextChunk("objects"); | |||
9373 | Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority, | |||
9374 | CXCursor_ObjCInstanceMethodDecl)); | |||
9375 | } | |||
9376 | } | |||
9377 | ||||
9378 | // - (void)intersectKey:(NSSet *)objects | |||
9379 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { | |||
9380 | std::string SelectorName = (Twine("intersect") + UpperKey).str(); | |||
9381 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
9382 | if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { | |||
9383 | if (ReturnType.isNull()) { | |||
9384 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9385 | Builder.AddTextChunk("void"); | |||
9386 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9387 | } | |||
9388 | ||||
9389 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); | |||
9390 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9391 | Builder.AddTextChunk("NSSet *"); | |||
9392 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9393 | Builder.AddTextChunk("objects"); | |||
9394 | Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority, | |||
9395 | CXCursor_ObjCInstanceMethodDecl)); | |||
9396 | } | |||
9397 | } | |||
9398 | ||||
9399 | // Key-Value Observing | |||
9400 | // + (NSSet *)keyPathsForValuesAffectingKey | |||
9401 | if (!IsInstanceMethod && | |||
9402 | (ReturnType.isNull() || | |||
9403 | (ReturnType->isObjCObjectPointerType() && | |||
9404 | ReturnType->castAs<ObjCObjectPointerType>()->getInterfaceDecl() && | |||
9405 | ReturnType->castAs<ObjCObjectPointerType>() | |||
9406 | ->getInterfaceDecl() | |||
9407 | ->getName() == "NSSet"))) { | |||
9408 | std::string SelectorName = | |||
9409 | (Twine("keyPathsForValuesAffecting") + UpperKey).str(); | |||
9410 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
9411 | if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId)) | |||
9412 | .second) { | |||
9413 | if (ReturnType.isNull()) { | |||
9414 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9415 | Builder.AddTextChunk("NSSet<NSString *> *"); | |||
9416 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9417 | } | |||
9418 | ||||
9419 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName)); | |||
9420 | Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern, | |||
9421 | CXCursor_ObjCClassMethodDecl)); | |||
9422 | } | |||
9423 | } | |||
9424 | ||||
9425 | // + (BOOL)automaticallyNotifiesObserversForKey | |||
9426 | if (!IsInstanceMethod && | |||
9427 | (ReturnType.isNull() || ReturnType->isIntegerType() || | |||
9428 | ReturnType->isBooleanType())) { | |||
9429 | std::string SelectorName = | |||
9430 | (Twine("automaticallyNotifiesObserversOf") + UpperKey).str(); | |||
9431 | IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); | |||
9432 | if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId)) | |||
9433 | .second) { | |||
9434 | if (ReturnType.isNull()) { | |||
9435 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9436 | Builder.AddTextChunk("BOOL"); | |||
9437 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9438 | } | |||
9439 | ||||
9440 | Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName)); | |||
9441 | Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern, | |||
9442 | CXCursor_ObjCClassMethodDecl)); | |||
9443 | } | |||
9444 | } | |||
9445 | } | |||
9446 | ||||
9447 | void Sema::CodeCompleteObjCMethodDecl(Scope *S, | |||
9448 | std::optional<bool> IsInstanceMethod, | |||
9449 | ParsedType ReturnTy) { | |||
9450 | // Determine the return type of the method we're declaring, if | |||
9451 | // provided. | |||
9452 | QualType ReturnType = GetTypeFromParser(ReturnTy); | |||
9453 | Decl *IDecl = nullptr; | |||
9454 | if (CurContext->isObjCContainer()) { | |||
9455 | ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext); | |||
9456 | IDecl = OCD; | |||
9457 | } | |||
9458 | // Determine where we should start searching for methods. | |||
9459 | ObjCContainerDecl *SearchDecl = nullptr; | |||
9460 | bool IsInImplementation = false; | |||
9461 | if (Decl *D = IDecl) { | |||
9462 | if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) { | |||
9463 | SearchDecl = Impl->getClassInterface(); | |||
9464 | IsInImplementation = true; | |||
9465 | } else if (ObjCCategoryImplDecl *CatImpl = | |||
9466 | dyn_cast<ObjCCategoryImplDecl>(D)) { | |||
9467 | SearchDecl = CatImpl->getCategoryDecl(); | |||
9468 | IsInImplementation = true; | |||
9469 | } else | |||
9470 | SearchDecl = dyn_cast<ObjCContainerDecl>(D); | |||
9471 | } | |||
9472 | ||||
9473 | if (!SearchDecl && S) { | |||
9474 | if (DeclContext *DC = S->getEntity()) | |||
9475 | SearchDecl = dyn_cast<ObjCContainerDecl>(DC); | |||
9476 | } | |||
9477 | ||||
9478 | if (!SearchDecl) { | |||
9479 | HandleCodeCompleteResults(this, CodeCompleter, | |||
9480 | CodeCompletionContext::CCC_Other, nullptr, 0); | |||
9481 | return; | |||
9482 | } | |||
9483 | ||||
9484 | // Find all of the methods that we could declare/implement here. | |||
9485 | KnownMethodsMap KnownMethods; | |||
9486 | FindImplementableMethods(Context, SearchDecl, IsInstanceMethod, ReturnType, | |||
9487 | KnownMethods); | |||
9488 | ||||
9489 | // Add declarations or definitions for each of the known methods. | |||
9490 | typedef CodeCompletionResult Result; | |||
9491 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
9492 | CodeCompleter->getCodeCompletionTUInfo(), | |||
9493 | CodeCompletionContext::CCC_Other); | |||
9494 | Results.EnterNewScope(); | |||
9495 | PrintingPolicy Policy = getCompletionPrintingPolicy(*this); | |||
9496 | for (KnownMethodsMap::iterator M = KnownMethods.begin(), | |||
9497 | MEnd = KnownMethods.end(); | |||
9498 | M != MEnd; ++M) { | |||
9499 | ObjCMethodDecl *Method = M->second.getPointer(); | |||
9500 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
9501 | Results.getCodeCompletionTUInfo()); | |||
9502 | ||||
9503 | // Add the '-'/'+' prefix if it wasn't provided yet. | |||
9504 | if (!IsInstanceMethod) { | |||
9505 | Builder.AddTextChunk(Method->isInstanceMethod() ? "-" : "+"); | |||
9506 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9507 | } | |||
9508 | ||||
9509 | // If the result type was not already provided, add it to the | |||
9510 | // pattern as (type). | |||
9511 | if (ReturnType.isNull()) { | |||
9512 | QualType ResTy = Method->getSendResultType().stripObjCKindOfType(Context); | |||
9513 | AttributedType::stripOuterNullability(ResTy); | |||
9514 | AddObjCPassingTypeChunk(ResTy, Method->getObjCDeclQualifier(), Context, | |||
9515 | Policy, Builder); | |||
9516 | } | |||
9517 | ||||
9518 | Selector Sel = Method->getSelector(); | |||
9519 | ||||
9520 | if (Sel.isUnarySelector()) { | |||
9521 | // Unary selectors have no arguments. | |||
9522 | Builder.AddTypedTextChunk( | |||
9523 | Builder.getAllocator().CopyString(Sel.getNameForSlot(0))); | |||
9524 | } else { | |||
9525 | // Add all parameters to the pattern. | |||
9526 | unsigned I = 0; | |||
9527 | for (ObjCMethodDecl::param_iterator P = Method->param_begin(), | |||
9528 | PEnd = Method->param_end(); | |||
9529 | P != PEnd; (void)++P, ++I) { | |||
9530 | // Add the part of the selector name. | |||
9531 | if (I == 0) | |||
9532 | Builder.AddTypedTextChunk( | |||
9533 | Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":")); | |||
9534 | else if (I < Sel.getNumArgs()) { | |||
9535 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9536 | Builder.AddTypedTextChunk( | |||
9537 | Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":")); | |||
9538 | } else | |||
9539 | break; | |||
9540 | ||||
9541 | // Add the parameter type. | |||
9542 | QualType ParamType; | |||
9543 | if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) | |||
9544 | ParamType = (*P)->getType(); | |||
9545 | else | |||
9546 | ParamType = (*P)->getOriginalType(); | |||
9547 | ParamType = ParamType.substObjCTypeArgs( | |||
9548 | Context, {}, ObjCSubstitutionContext::Parameter); | |||
9549 | AttributedType::stripOuterNullability(ParamType); | |||
9550 | AddObjCPassingTypeChunk(ParamType, (*P)->getObjCDeclQualifier(), | |||
9551 | Context, Policy, Builder); | |||
9552 | ||||
9553 | if (IdentifierInfo *Id = (*P)->getIdentifier()) | |||
9554 | Builder.AddTextChunk( | |||
9555 | Builder.getAllocator().CopyString(Id->getName())); | |||
9556 | } | |||
9557 | } | |||
9558 | ||||
9559 | if (Method->isVariadic()) { | |||
9560 | if (Method->param_size() > 0) | |||
9561 | Builder.AddChunk(CodeCompletionString::CK_Comma); | |||
9562 | Builder.AddTextChunk("..."); | |||
9563 | } | |||
9564 | ||||
9565 | if (IsInImplementation && Results.includeCodePatterns()) { | |||
9566 | // We will be defining the method here, so add a compound statement. | |||
9567 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9568 | Builder.AddChunk(CodeCompletionString::CK_LeftBrace); | |||
9569 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
9570 | if (!Method->getReturnType()->isVoidType()) { | |||
9571 | // If the result type is not void, add a return clause. | |||
9572 | Builder.AddTextChunk("return"); | |||
9573 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9574 | Builder.AddPlaceholderChunk("expression"); | |||
9575 | Builder.AddChunk(CodeCompletionString::CK_SemiColon); | |||
9576 | } else | |||
9577 | Builder.AddPlaceholderChunk("statements"); | |||
9578 | ||||
9579 | Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); | |||
9580 | Builder.AddChunk(CodeCompletionString::CK_RightBrace); | |||
9581 | } | |||
9582 | ||||
9583 | unsigned Priority = CCP_CodePattern; | |||
9584 | auto R = Result(Builder.TakeString(), Method, Priority); | |||
9585 | if (!M->second.getInt()) | |||
9586 | setInBaseClass(R); | |||
9587 | Results.AddResult(std::move(R)); | |||
9588 | } | |||
9589 | ||||
9590 | // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of | |||
9591 | // the properties in this class and its categories. | |||
9592 | if (Context.getLangOpts().ObjC) { | |||
9593 | SmallVector<ObjCContainerDecl *, 4> Containers; | |||
9594 | Containers.push_back(SearchDecl); | |||
9595 | ||||
9596 | VisitedSelectorSet KnownSelectors; | |||
9597 | for (KnownMethodsMap::iterator M = KnownMethods.begin(), | |||
9598 | MEnd = KnownMethods.end(); | |||
9599 | M != MEnd; ++M) | |||
9600 | KnownSelectors.insert(M->first); | |||
9601 | ||||
9602 | ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl); | |||
9603 | if (!IFace) | |||
9604 | if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl)) | |||
9605 | IFace = Category->getClassInterface(); | |||
9606 | ||||
9607 | if (IFace) | |||
9608 | llvm::append_range(Containers, IFace->visible_categories()); | |||
9609 | ||||
9610 | if (IsInstanceMethod) { | |||
9611 | for (unsigned I = 0, N = Containers.size(); I != N; ++I) | |||
9612 | for (auto *P : Containers[I]->instance_properties()) | |||
9613 | AddObjCKeyValueCompletions(P, *IsInstanceMethod, ReturnType, Context, | |||
9614 | KnownSelectors, Results); | |||
9615 | } | |||
9616 | } | |||
9617 | ||||
9618 | Results.ExitScope(); | |||
9619 | ||||
9620 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
9621 | Results.data(), Results.size()); | |||
9622 | } | |||
9623 | ||||
9624 | void Sema::CodeCompleteObjCMethodDeclSelector( | |||
9625 | Scope *S, bool IsInstanceMethod, bool AtParameterName, ParsedType ReturnTy, | |||
9626 | ArrayRef<IdentifierInfo *> SelIdents) { | |||
9627 | // If we have an external source, load the entire class method | |||
9628 | // pool from the AST file. | |||
9629 | if (ExternalSource) { | |||
9630 | for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); I != N; | |||
9631 | ++I) { | |||
9632 | Selector Sel = ExternalSource->GetExternalSelector(I); | |||
9633 | if (Sel.isNull() || MethodPool.count(Sel)) | |||
9634 | continue; | |||
9635 | ||||
9636 | ReadMethodPool(Sel); | |||
9637 | } | |||
9638 | } | |||
9639 | ||||
9640 | // Build the set of methods we can see. | |||
9641 | typedef CodeCompletionResult Result; | |||
9642 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
9643 | CodeCompleter->getCodeCompletionTUInfo(), | |||
9644 | CodeCompletionContext::CCC_Other); | |||
9645 | ||||
9646 | if (ReturnTy) | |||
9647 | Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType()); | |||
9648 | ||||
9649 | Results.EnterNewScope(); | |||
9650 | for (GlobalMethodPool::iterator M = MethodPool.begin(), | |||
9651 | MEnd = MethodPool.end(); | |||
9652 | M != MEnd; ++M) { | |||
9653 | for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first | |||
9654 | : &M->second.second; | |||
9655 | MethList && MethList->getMethod(); MethList = MethList->getNext()) { | |||
9656 | if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents)) | |||
9657 | continue; | |||
9658 | ||||
9659 | if (AtParameterName) { | |||
9660 | // Suggest parameter names we've seen before. | |||
9661 | unsigned NumSelIdents = SelIdents.size(); | |||
9662 | if (NumSelIdents && | |||
9663 | NumSelIdents <= MethList->getMethod()->param_size()) { | |||
9664 | ParmVarDecl *Param = | |||
9665 | MethList->getMethod()->parameters()[NumSelIdents - 1]; | |||
9666 | if (Param->getIdentifier()) { | |||
9667 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
9668 | Results.getCodeCompletionTUInfo()); | |||
9669 | Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( | |||
9670 | Param->getIdentifier()->getName())); | |||
9671 | Results.AddResult(Builder.TakeString()); | |||
9672 | } | |||
9673 | } | |||
9674 | ||||
9675 | continue; | |||
9676 | } | |||
9677 | ||||
9678 | Result R(MethList->getMethod(), | |||
9679 | Results.getBasePriority(MethList->getMethod()), nullptr); | |||
9680 | R.StartParameter = SelIdents.size(); | |||
9681 | R.AllParametersAreInformative = false; | |||
9682 | R.DeclaringEntity = true; | |||
9683 | Results.MaybeAddResult(R, CurContext); | |||
9684 | } | |||
9685 | } | |||
9686 | ||||
9687 | Results.ExitScope(); | |||
9688 | ||||
9689 | if (!AtParameterName && !SelIdents.empty() && | |||
9690 | SelIdents.front()->getName().startswith("init")) { | |||
9691 | for (const auto &M : PP.macros()) { | |||
9692 | if (M.first->getName() != "NS_DESIGNATED_INITIALIZER") | |||
9693 | continue; | |||
9694 | Results.EnterNewScope(); | |||
9695 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
9696 | Results.getCodeCompletionTUInfo()); | |||
9697 | Builder.AddTypedTextChunk( | |||
9698 | Builder.getAllocator().CopyString(M.first->getName())); | |||
9699 | Results.AddResult(CodeCompletionResult(Builder.TakeString(), CCP_Macro, | |||
9700 | CXCursor_MacroDefinition)); | |||
9701 | Results.ExitScope(); | |||
9702 | } | |||
9703 | } | |||
9704 | ||||
9705 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
9706 | Results.data(), Results.size()); | |||
9707 | } | |||
9708 | ||||
9709 | void Sema::CodeCompletePreprocessorDirective(bool InConditional) { | |||
9710 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
9711 | CodeCompleter->getCodeCompletionTUInfo(), | |||
9712 | CodeCompletionContext::CCC_PreprocessorDirective); | |||
9713 | Results.EnterNewScope(); | |||
9714 | ||||
9715 | // #if <condition> | |||
9716 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
9717 | Results.getCodeCompletionTUInfo()); | |||
9718 | Builder.AddTypedTextChunk("if"); | |||
9719 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9720 | Builder.AddPlaceholderChunk("condition"); | |||
9721 | Results.AddResult(Builder.TakeString()); | |||
9722 | ||||
9723 | // #ifdef <macro> | |||
9724 | Builder.AddTypedTextChunk("ifdef"); | |||
9725 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9726 | Builder.AddPlaceholderChunk("macro"); | |||
9727 | Results.AddResult(Builder.TakeString()); | |||
9728 | ||||
9729 | // #ifndef <macro> | |||
9730 | Builder.AddTypedTextChunk("ifndef"); | |||
9731 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9732 | Builder.AddPlaceholderChunk("macro"); | |||
9733 | Results.AddResult(Builder.TakeString()); | |||
9734 | ||||
9735 | if (InConditional) { | |||
9736 | // #elif <condition> | |||
9737 | Builder.AddTypedTextChunk("elif"); | |||
9738 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9739 | Builder.AddPlaceholderChunk("condition"); | |||
9740 | Results.AddResult(Builder.TakeString()); | |||
9741 | ||||
9742 | // #elifdef <macro> | |||
9743 | Builder.AddTypedTextChunk("elifdef"); | |||
9744 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9745 | Builder.AddPlaceholderChunk("macro"); | |||
9746 | Results.AddResult(Builder.TakeString()); | |||
9747 | ||||
9748 | // #elifndef <macro> | |||
9749 | Builder.AddTypedTextChunk("elifndef"); | |||
9750 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9751 | Builder.AddPlaceholderChunk("macro"); | |||
9752 | Results.AddResult(Builder.TakeString()); | |||
9753 | ||||
9754 | // #else | |||
9755 | Builder.AddTypedTextChunk("else"); | |||
9756 | Results.AddResult(Builder.TakeString()); | |||
9757 | ||||
9758 | // #endif | |||
9759 | Builder.AddTypedTextChunk("endif"); | |||
9760 | Results.AddResult(Builder.TakeString()); | |||
9761 | } | |||
9762 | ||||
9763 | // #include "header" | |||
9764 | Builder.AddTypedTextChunk("include"); | |||
9765 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9766 | Builder.AddTextChunk("\""); | |||
9767 | Builder.AddPlaceholderChunk("header"); | |||
9768 | Builder.AddTextChunk("\""); | |||
9769 | Results.AddResult(Builder.TakeString()); | |||
9770 | ||||
9771 | // #include <header> | |||
9772 | Builder.AddTypedTextChunk("include"); | |||
9773 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9774 | Builder.AddTextChunk("<"); | |||
9775 | Builder.AddPlaceholderChunk("header"); | |||
9776 | Builder.AddTextChunk(">"); | |||
9777 | Results.AddResult(Builder.TakeString()); | |||
9778 | ||||
9779 | // #define <macro> | |||
9780 | Builder.AddTypedTextChunk("define"); | |||
9781 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9782 | Builder.AddPlaceholderChunk("macro"); | |||
9783 | Results.AddResult(Builder.TakeString()); | |||
9784 | ||||
9785 | // #define <macro>(<args>) | |||
9786 | Builder.AddTypedTextChunk("define"); | |||
9787 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9788 | Builder.AddPlaceholderChunk("macro"); | |||
9789 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9790 | Builder.AddPlaceholderChunk("args"); | |||
9791 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9792 | Results.AddResult(Builder.TakeString()); | |||
9793 | ||||
9794 | // #undef <macro> | |||
9795 | Builder.AddTypedTextChunk("undef"); | |||
9796 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9797 | Builder.AddPlaceholderChunk("macro"); | |||
9798 | Results.AddResult(Builder.TakeString()); | |||
9799 | ||||
9800 | // #line <number> | |||
9801 | Builder.AddTypedTextChunk("line"); | |||
9802 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9803 | Builder.AddPlaceholderChunk("number"); | |||
9804 | Results.AddResult(Builder.TakeString()); | |||
9805 | ||||
9806 | // #line <number> "filename" | |||
9807 | Builder.AddTypedTextChunk("line"); | |||
9808 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9809 | Builder.AddPlaceholderChunk("number"); | |||
9810 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9811 | Builder.AddTextChunk("\""); | |||
9812 | Builder.AddPlaceholderChunk("filename"); | |||
9813 | Builder.AddTextChunk("\""); | |||
9814 | Results.AddResult(Builder.TakeString()); | |||
9815 | ||||
9816 | // #error <message> | |||
9817 | Builder.AddTypedTextChunk("error"); | |||
9818 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9819 | Builder.AddPlaceholderChunk("message"); | |||
9820 | Results.AddResult(Builder.TakeString()); | |||
9821 | ||||
9822 | // #pragma <arguments> | |||
9823 | Builder.AddTypedTextChunk("pragma"); | |||
9824 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9825 | Builder.AddPlaceholderChunk("arguments"); | |||
9826 | Results.AddResult(Builder.TakeString()); | |||
9827 | ||||
9828 | if (getLangOpts().ObjC) { | |||
9829 | // #import "header" | |||
9830 | Builder.AddTypedTextChunk("import"); | |||
9831 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9832 | Builder.AddTextChunk("\""); | |||
9833 | Builder.AddPlaceholderChunk("header"); | |||
9834 | Builder.AddTextChunk("\""); | |||
9835 | Results.AddResult(Builder.TakeString()); | |||
9836 | ||||
9837 | // #import <header> | |||
9838 | Builder.AddTypedTextChunk("import"); | |||
9839 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9840 | Builder.AddTextChunk("<"); | |||
9841 | Builder.AddPlaceholderChunk("header"); | |||
9842 | Builder.AddTextChunk(">"); | |||
9843 | Results.AddResult(Builder.TakeString()); | |||
9844 | } | |||
9845 | ||||
9846 | // #include_next "header" | |||
9847 | Builder.AddTypedTextChunk("include_next"); | |||
9848 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9849 | Builder.AddTextChunk("\""); | |||
9850 | Builder.AddPlaceholderChunk("header"); | |||
9851 | Builder.AddTextChunk("\""); | |||
9852 | Results.AddResult(Builder.TakeString()); | |||
9853 | ||||
9854 | // #include_next <header> | |||
9855 | Builder.AddTypedTextChunk("include_next"); | |||
9856 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9857 | Builder.AddTextChunk("<"); | |||
9858 | Builder.AddPlaceholderChunk("header"); | |||
9859 | Builder.AddTextChunk(">"); | |||
9860 | Results.AddResult(Builder.TakeString()); | |||
9861 | ||||
9862 | // #warning <message> | |||
9863 | Builder.AddTypedTextChunk("warning"); | |||
9864 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9865 | Builder.AddPlaceholderChunk("message"); | |||
9866 | Results.AddResult(Builder.TakeString()); | |||
9867 | ||||
9868 | // Note: #ident and #sccs are such crazy anachronisms that we don't provide | |||
9869 | // completions for them. And __include_macros is a Clang-internal extension | |||
9870 | // that we don't want to encourage anyone to use. | |||
9871 | ||||
9872 | // FIXME: we don't support #assert or #unassert, so don't suggest them. | |||
9873 | Results.ExitScope(); | |||
9874 | ||||
9875 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
9876 | Results.data(), Results.size()); | |||
9877 | } | |||
9878 | ||||
9879 | void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) { | |||
9880 | CodeCompleteOrdinaryName(S, S->getFnParent() ? Sema::PCC_RecoveryInFunction | |||
9881 | : Sema::PCC_Namespace); | |||
9882 | } | |||
9883 | ||||
9884 | void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) { | |||
9885 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
9886 | CodeCompleter->getCodeCompletionTUInfo(), | |||
9887 | IsDefinition ? CodeCompletionContext::CCC_MacroName | |||
9888 | : CodeCompletionContext::CCC_MacroNameUse); | |||
9889 | if (!IsDefinition && CodeCompleter->includeMacros()) { | |||
9890 | // Add just the names of macros, not their arguments. | |||
9891 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
9892 | Results.getCodeCompletionTUInfo()); | |||
9893 | Results.EnterNewScope(); | |||
9894 | for (Preprocessor::macro_iterator M = PP.macro_begin(), | |||
9895 | MEnd = PP.macro_end(); | |||
9896 | M != MEnd; ++M) { | |||
9897 | Builder.AddTypedTextChunk( | |||
9898 | Builder.getAllocator().CopyString(M->first->getName())); | |||
9899 | Results.AddResult(CodeCompletionResult( | |||
9900 | Builder.TakeString(), CCP_CodePattern, CXCursor_MacroDefinition)); | |||
9901 | } | |||
9902 | Results.ExitScope(); | |||
9903 | } else if (IsDefinition) { | |||
9904 | // FIXME: Can we detect when the user just wrote an include guard above? | |||
9905 | } | |||
9906 | ||||
9907 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
9908 | Results.data(), Results.size()); | |||
9909 | } | |||
9910 | ||||
9911 | void Sema::CodeCompletePreprocessorExpression() { | |||
9912 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
9913 | CodeCompleter->getCodeCompletionTUInfo(), | |||
9914 | CodeCompletionContext::CCC_PreprocessorExpression); | |||
9915 | ||||
9916 | if (CodeCompleter->includeMacros()) | |||
9917 | AddMacroResults(PP, Results, CodeCompleter->loadExternal(), true); | |||
9918 | ||||
9919 | // defined (<macro>) | |||
9920 | Results.EnterNewScope(); | |||
9921 | CodeCompletionBuilder Builder(Results.getAllocator(), | |||
9922 | Results.getCodeCompletionTUInfo()); | |||
9923 | Builder.AddTypedTextChunk("defined"); | |||
9924 | Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); | |||
9925 | Builder.AddChunk(CodeCompletionString::CK_LeftParen); | |||
9926 | Builder.AddPlaceholderChunk("macro"); | |||
9927 | Builder.AddChunk(CodeCompletionString::CK_RightParen); | |||
9928 | Results.AddResult(Builder.TakeString()); | |||
9929 | Results.ExitScope(); | |||
9930 | ||||
9931 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
9932 | Results.data(), Results.size()); | |||
9933 | } | |||
9934 | ||||
9935 | void Sema::CodeCompletePreprocessorMacroArgument(Scope *S, | |||
9936 | IdentifierInfo *Macro, | |||
9937 | MacroInfo *MacroInfo, | |||
9938 | unsigned Argument) { | |||
9939 | // FIXME: In the future, we could provide "overload" results, much like we | |||
9940 | // do for function calls. | |||
9941 | ||||
9942 | // Now just ignore this. There will be another code-completion callback | |||
9943 | // for the expanded tokens. | |||
9944 | } | |||
9945 | ||||
9946 | // This handles completion inside an #include filename, e.g. #include <foo/ba | |||
9947 | // We look for the directory "foo" under each directory on the include path, | |||
9948 | // list its files, and reassemble the appropriate #include. | |||
9949 | void Sema::CodeCompleteIncludedFile(llvm::StringRef Dir, bool Angled) { | |||
9950 | // RelDir should use /, but unescaped \ is possible on windows! | |||
9951 | // Our completions will normalize to / for simplicity, this case is rare. | |||
9952 | std::string RelDir = llvm::sys::path::convert_to_slash(Dir); | |||
9953 | // We need the native slashes for the actual file system interactions. | |||
9954 | SmallString<128> NativeRelDir = StringRef(RelDir); | |||
9955 | llvm::sys::path::native(NativeRelDir); | |||
9956 | llvm::vfs::FileSystem &FS = | |||
9957 | getSourceManager().getFileManager().getVirtualFileSystem(); | |||
9958 | ||||
9959 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
9960 | CodeCompleter->getCodeCompletionTUInfo(), | |||
9961 | CodeCompletionContext::CCC_IncludedFile); | |||
9962 | llvm::DenseSet<StringRef> SeenResults; // To deduplicate results. | |||
9963 | ||||
9964 | // Helper: adds one file or directory completion result. | |||
9965 | auto AddCompletion = [&](StringRef Filename, bool IsDirectory) { | |||
9966 | SmallString<64> TypedChunk = Filename; | |||
9967 | // Directory completion is up to the slash, e.g. <sys/ | |||
9968 | TypedChunk.push_back(IsDirectory ? '/' : Angled ? '>' : '"'); | |||
9969 | auto R = SeenResults.insert(TypedChunk); | |||
9970 | if (R.second) { // New completion | |||
9971 | const char *InternedTyped = Results.getAllocator().CopyString(TypedChunk); | |||
9972 | *R.first = InternedTyped; // Avoid dangling StringRef. | |||
9973 | CodeCompletionBuilder Builder(CodeCompleter->getAllocator(), | |||
9974 | CodeCompleter->getCodeCompletionTUInfo()); | |||
9975 | Builder.AddTypedTextChunk(InternedTyped); | |||
9976 | // The result is a "Pattern", which is pretty opaque. | |||
9977 | // We may want to include the real filename to allow smart ranking. | |||
9978 | Results.AddResult(CodeCompletionResult(Builder.TakeString())); | |||
9979 | } | |||
9980 | }; | |||
9981 | ||||
9982 | // Helper: scans IncludeDir for nice files, and adds results for each. | |||
9983 | auto AddFilesFromIncludeDir = [&](StringRef IncludeDir, | |||
9984 | bool IsSystem, | |||
9985 | DirectoryLookup::LookupType_t LookupType) { | |||
9986 | llvm::SmallString<128> Dir = IncludeDir; | |||
9987 | if (!NativeRelDir.empty()) { | |||
9988 | if (LookupType == DirectoryLookup::LT_Framework) { | |||
9989 | // For a framework dir, #include <Foo/Bar/> actually maps to | |||
9990 | // a path of Foo.framework/Headers/Bar/. | |||
9991 | auto Begin = llvm::sys::path::begin(NativeRelDir); | |||
9992 | auto End = llvm::sys::path::end(NativeRelDir); | |||
9993 | ||||
9994 | llvm::sys::path::append(Dir, *Begin + ".framework", "Headers"); | |||
9995 | llvm::sys::path::append(Dir, ++Begin, End); | |||
9996 | } else { | |||
9997 | llvm::sys::path::append(Dir, NativeRelDir); | |||
9998 | } | |||
9999 | } | |||
10000 | ||||
10001 | const StringRef &Dirname = llvm::sys::path::filename(Dir); | |||
10002 | const bool isQt = Dirname.startswith("Qt") || Dirname == "ActiveQt"; | |||
10003 | const bool ExtensionlessHeaders = | |||
10004 | IsSystem || isQt || Dir.endswith(".framework/Headers"); | |||
10005 | std::error_code EC; | |||
10006 | unsigned Count = 0; | |||
10007 | for (auto It = FS.dir_begin(Dir, EC); | |||
10008 | !EC && It != llvm::vfs::directory_iterator(); It.increment(EC)) { | |||
10009 | if (++Count == 2500) // If we happen to hit a huge directory, | |||
10010 | break; // bail out early so we're not too slow. | |||
10011 | StringRef Filename = llvm::sys::path::filename(It->path()); | |||
10012 | ||||
10013 | // To know whether a symlink should be treated as file or a directory, we | |||
10014 | // have to stat it. This should be cheap enough as there shouldn't be many | |||
10015 | // symlinks. | |||
10016 | llvm::sys::fs::file_type Type = It->type(); | |||
10017 | if (Type == llvm::sys::fs::file_type::symlink_file) { | |||
10018 | if (auto FileStatus = FS.status(It->path())) | |||
10019 | Type = FileStatus->getType(); | |||
10020 | } | |||
10021 | switch (Type) { | |||
10022 | case llvm::sys::fs::file_type::directory_file: | |||
10023 | // All entries in a framework directory must have a ".framework" suffix, | |||
10024 | // but the suffix does not appear in the source code's include/import. | |||
10025 | if (LookupType == DirectoryLookup::LT_Framework && | |||
10026 | NativeRelDir.empty() && !Filename.consume_back(".framework")) | |||
10027 | break; | |||
10028 | ||||
10029 | AddCompletion(Filename, /*IsDirectory=*/true); | |||
10030 | break; | |||
10031 | case llvm::sys::fs::file_type::regular_file: { | |||
10032 | // Only files that really look like headers. (Except in special dirs). | |||
10033 | const bool IsHeader = Filename.endswith_insensitive(".h") || | |||
10034 | Filename.endswith_insensitive(".hh") || | |||
10035 | Filename.endswith_insensitive(".hpp") || | |||
10036 | Filename.endswith_insensitive(".hxx") || | |||
10037 | Filename.endswith_insensitive(".inc") || | |||
10038 | (ExtensionlessHeaders && !Filename.contains('.')); | |||
10039 | if (!IsHeader) | |||
10040 | break; | |||
10041 | AddCompletion(Filename, /*IsDirectory=*/false); | |||
10042 | break; | |||
10043 | } | |||
10044 | default: | |||
10045 | break; | |||
10046 | } | |||
10047 | } | |||
10048 | }; | |||
10049 | ||||
10050 | // Helper: adds results relative to IncludeDir, if possible. | |||
10051 | auto AddFilesFromDirLookup = [&](const DirectoryLookup &IncludeDir, | |||
10052 | bool IsSystem) { | |||
10053 | switch (IncludeDir.getLookupType()) { | |||
10054 | case DirectoryLookup::LT_HeaderMap: | |||
10055 | // header maps are not (currently) enumerable. | |||
10056 | break; | |||
10057 | case DirectoryLookup::LT_NormalDir: | |||
10058 | AddFilesFromIncludeDir(IncludeDir.getDir()->getName(), IsSystem, | |||
10059 | DirectoryLookup::LT_NormalDir); | |||
10060 | break; | |||
10061 | case DirectoryLookup::LT_Framework: | |||
10062 | AddFilesFromIncludeDir(IncludeDir.getFrameworkDir()->getName(), IsSystem, | |||
10063 | DirectoryLookup::LT_Framework); | |||
10064 | break; | |||
10065 | } | |||
10066 | }; | |||
10067 | ||||
10068 | // Finally with all our helpers, we can scan the include path. | |||
10069 | // Do this in standard order so deduplication keeps the right file. | |||
10070 | // (In case we decide to add more details to the results later). | |||
10071 | const auto &S = PP.getHeaderSearchInfo(); | |||
10072 | using llvm::make_range; | |||
10073 | if (!Angled) { | |||
10074 | // The current directory is on the include path for "quoted" includes. | |||
10075 | const FileEntry *CurFile = PP.getCurrentFileLexer()->getFileEntry(); | |||
10076 | if (CurFile && CurFile->getDir()) | |||
10077 | AddFilesFromIncludeDir(CurFile->getDir()->getName(), false, | |||
10078 | DirectoryLookup::LT_NormalDir); | |||
10079 | for (const auto &D : make_range(S.quoted_dir_begin(), S.quoted_dir_end())) | |||
10080 | AddFilesFromDirLookup(D, false); | |||
10081 | } | |||
10082 | for (const auto &D : make_range(S.angled_dir_begin(), S.angled_dir_end())) | |||
10083 | AddFilesFromDirLookup(D, false); | |||
10084 | for (const auto &D : make_range(S.system_dir_begin(), S.system_dir_end())) | |||
10085 | AddFilesFromDirLookup(D, true); | |||
10086 | ||||
10087 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
10088 | Results.data(), Results.size()); | |||
10089 | } | |||
10090 | ||||
10091 | void Sema::CodeCompleteNaturalLanguage() { | |||
10092 | HandleCodeCompleteResults(this, CodeCompleter, | |||
10093 | CodeCompletionContext::CCC_NaturalLanguage, nullptr, | |||
10094 | 0); | |||
10095 | } | |||
10096 | ||||
10097 | void Sema::CodeCompleteAvailabilityPlatformName() { | |||
10098 | ResultBuilder Results(*this, CodeCompleter->getAllocator(), | |||
10099 | CodeCompleter->getCodeCompletionTUInfo(), | |||
10100 | CodeCompletionContext::CCC_Other); | |||
10101 | Results.EnterNewScope(); | |||
10102 | static const char *Platforms[] = {"macOS", "iOS", "watchOS", "tvOS"}; | |||
10103 | for (const char *Platform : llvm::ArrayRef(Platforms)) { | |||
10104 | Results.AddResult(CodeCompletionResult(Platform)); | |||
10105 | Results.AddResult(CodeCompletionResult(Results.getAllocator().CopyString( | |||
10106 | Twine(Platform) + "ApplicationExtension"))); | |||
10107 | } | |||
10108 | Results.ExitScope(); | |||
10109 | HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), | |||
10110 | Results.data(), Results.size()); | |||
10111 | } | |||
10112 | ||||
10113 | void Sema::GatherGlobalCodeCompletions( | |||
10114 | CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo, | |||
10115 | SmallVectorImpl<CodeCompletionResult> &Results) { | |||
10116 | ResultBuilder Builder(*this, Allocator, CCTUInfo, | |||
10117 | CodeCompletionContext::CCC_Recovery); | |||
10118 | if (!CodeCompleter || CodeCompleter->includeGlobals()) { | |||
10119 | CodeCompletionDeclConsumer Consumer(Builder, | |||
10120 | Context.getTranslationUnitDecl()); | |||
10121 | LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName, | |||
10122 | Consumer, | |||
10123 | !CodeCompleter || CodeCompleter->loadExternal()); | |||
10124 | } | |||
10125 | ||||
10126 | if (!CodeCompleter || CodeCompleter->includeMacros()) | |||
10127 | AddMacroResults(PP, Builder, | |||
10128 | !CodeCompleter || CodeCompleter->loadExternal(), true); | |||
10129 | ||||
10130 | Results.clear(); | |||
10131 | Results.insert(Results.end(), Builder.data(), | |||
10132 | Builder.data() + Builder.size()); | |||
10133 | } |