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/DynamicRecursiveASTVisitor.h" |
19 | #include "clang/AST/Expr.h" |
20 | #include "clang/AST/ExprCXX.h" |
21 | #include "clang/AST/ExprConcepts.h" |
22 | #include "clang/AST/ExprObjC.h" |
23 | #include "clang/AST/NestedNameSpecifier.h" |
24 | #include "clang/AST/OperationKinds.h" |
25 | #include "clang/AST/QualTypeNames.h" |
26 | #include "clang/AST/Type.h" |
27 | #include "clang/Basic/AttributeCommonInfo.h" |
28 | #include "clang/Basic/CharInfo.h" |
29 | #include "clang/Basic/OperatorKinds.h" |
30 | #include "clang/Basic/Specifiers.h" |
31 | #include "clang/Lex/HeaderSearch.h" |
32 | #include "clang/Lex/MacroInfo.h" |
33 | #include "clang/Lex/Preprocessor.h" |
34 | #include "clang/Sema/CodeCompleteConsumer.h" |
35 | #include "clang/Sema/DeclSpec.h" |
36 | #include "clang/Sema/Designator.h" |
37 | #include "clang/Sema/HeuristicResolver.h" |
38 | #include "clang/Sema/Lookup.h" |
39 | #include "clang/Sema/Overload.h" |
40 | #include "clang/Sema/ParsedAttr.h" |
41 | #include "clang/Sema/ParsedTemplate.h" |
42 | #include "clang/Sema/Scope.h" |
43 | #include "clang/Sema/ScopeInfo.h" |
44 | #include "clang/Sema/Sema.h" |
45 | #include "clang/Sema/SemaCodeCompletion.h" |
46 | #include "clang/Sema/SemaObjC.h" |
47 | #include "llvm/ADT/ArrayRef.h" |
48 | #include "llvm/ADT/DenseSet.h" |
49 | #include "llvm/ADT/SmallBitVector.h" |
50 | #include "llvm/ADT/SmallPtrSet.h" |
51 | #include "llvm/ADT/SmallString.h" |
52 | #include "llvm/ADT/StringSwitch.h" |
53 | #include "llvm/ADT/Twine.h" |
54 | #include "llvm/ADT/iterator_range.h" |
55 | #include "llvm/Support/Casting.h" |
56 | #include "llvm/Support/Path.h" |
57 | #include "llvm/Support/raw_ostream.h" |
58 | |
59 | #include <list> |
60 | #include <map> |
61 | #include <optional> |
62 | #include <string> |
63 | #include <vector> |
64 | |
65 | using namespace clang; |
66 | using namespace sema; |
67 | |
68 | namespace { |
69 | /// A container of code-completion results. |
70 | class ResultBuilder { |
71 | public: |
72 | /// The type of a name-lookup filter, which can be provided to the |
73 | /// name-lookup routines to specify which declarations should be included in |
74 | /// the result set (when it returns true) and which declarations should be |
75 | /// filtered out (returns false). |
76 | typedef bool (ResultBuilder::*LookupFilter)(const NamedDecl *) const; |
77 | |
78 | typedef CodeCompletionResult Result; |
79 | |
80 | private: |
81 | /// The actual results we have found. |
82 | std::vector<Result> Results; |
83 | |
84 | /// A record of all of the declarations we have found and placed |
85 | /// into the result set, used to ensure that no declaration ever gets into |
86 | /// the result set twice. |
87 | llvm::SmallPtrSet<const Decl *, 16> AllDeclsFound; |
88 | |
89 | typedef std::pair<const NamedDecl *, unsigned> DeclIndexPair; |
90 | |
91 | /// An entry in the shadow map, which is optimized to store |
92 | /// a single (declaration, index) mapping (the common case) but |
93 | /// can also store a list of (declaration, index) mappings. |
94 | class ShadowMapEntry { |
95 | typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector; |
96 | |
97 | /// Contains either the solitary NamedDecl * or a vector |
98 | /// of (declaration, index) pairs. |
99 | llvm::PointerUnion<const NamedDecl *, DeclIndexPairVector *> DeclOrVector; |
100 | |
101 | /// When the entry contains a single declaration, this is |
102 | /// the index associated with that entry. |
103 | unsigned SingleDeclIndex = 0; |
104 | |
105 | public: |
106 | ShadowMapEntry() = default; |
107 | ShadowMapEntry(const ShadowMapEntry &) = delete; |
108 | ShadowMapEntry(ShadowMapEntry &&Move) { *this = std::move(Move); } |
109 | ShadowMapEntry &operator=(const ShadowMapEntry &) = delete; |
110 | ShadowMapEntry &operator=(ShadowMapEntry &&Move) { |
111 | SingleDeclIndex = Move.SingleDeclIndex; |
112 | DeclOrVector = Move.DeclOrVector; |
113 | Move.DeclOrVector = nullptr; |
114 | return *this; |
115 | } |
116 | |
117 | void Add(const NamedDecl *ND, unsigned Index) { |
118 | if (DeclOrVector.isNull()) { |
119 | // 0 - > 1 elements: just set the single element information. |
120 | DeclOrVector = ND; |
121 | SingleDeclIndex = Index; |
122 | return; |
123 | } |
124 | |
125 | if (const NamedDecl *PrevND = dyn_cast<const NamedDecl *>(Val&: DeclOrVector)) { |
126 | // 1 -> 2 elements: create the vector of results and push in the |
127 | // existing declaration. |
128 | DeclIndexPairVector *Vec = new DeclIndexPairVector; |
129 | Vec->push_back(Elt: DeclIndexPair(PrevND, SingleDeclIndex)); |
130 | DeclOrVector = Vec; |
131 | } |
132 | |
133 | // Add the new element to the end of the vector. |
134 | cast<DeclIndexPairVector *>(Val&: DeclOrVector) |
135 | ->push_back(Elt: DeclIndexPair(ND, Index)); |
136 | } |
137 | |
138 | ~ShadowMapEntry() { |
139 | if (DeclIndexPairVector *Vec = |
140 | dyn_cast_if_present<DeclIndexPairVector *>(Val&: DeclOrVector)) { |
141 | delete Vec; |
142 | DeclOrVector = ((NamedDecl *)nullptr); |
143 | } |
144 | } |
145 | |
146 | // Iteration. |
147 | class iterator; |
148 | iterator begin() const; |
149 | iterator end() const; |
150 | }; |
151 | |
152 | /// A mapping from declaration names to the declarations that have |
153 | /// this name within a particular scope and their index within the list of |
154 | /// results. |
155 | typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap; |
156 | |
157 | /// The semantic analysis object for which results are being |
158 | /// produced. |
159 | Sema &SemaRef; |
160 | |
161 | /// The allocator used to allocate new code-completion strings. |
162 | CodeCompletionAllocator &Allocator; |
163 | |
164 | CodeCompletionTUInfo &CCTUInfo; |
165 | |
166 | /// If non-NULL, a filter function used to remove any code-completion |
167 | /// results that are not desirable. |
168 | LookupFilter Filter; |
169 | |
170 | /// Whether we should allow declarations as |
171 | /// nested-name-specifiers that would otherwise be filtered out. |
172 | bool AllowNestedNameSpecifiers; |
173 | |
174 | /// If set, the type that we would prefer our resulting value |
175 | /// declarations to have. |
176 | /// |
177 | /// Closely matching the preferred type gives a boost to a result's |
178 | /// priority. |
179 | CanQualType PreferredType; |
180 | |
181 | /// A list of shadow maps, which is used to model name hiding at |
182 | /// different levels of, e.g., the inheritance hierarchy. |
183 | std::list<ShadowMap> ShadowMaps; |
184 | |
185 | /// Overloaded C++ member functions found by SemaLookup. |
186 | /// Used to determine when one overload is dominated by another. |
187 | llvm::DenseMap<std::pair<DeclContext *, /*Name*/uintptr_t>, ShadowMapEntry> |
188 | OverloadMap; |
189 | |
190 | /// If we're potentially referring to a C++ member function, the set |
191 | /// of qualifiers applied to the object type. |
192 | Qualifiers ObjectTypeQualifiers; |
193 | /// The kind of the object expression, for rvalue/lvalue overloads. |
194 | ExprValueKind ObjectKind; |
195 | |
196 | /// Whether the \p ObjectTypeQualifiers field is active. |
197 | bool HasObjectTypeQualifiers; |
198 | |
199 | /// The selector that we prefer. |
200 | Selector PreferredSelector; |
201 | |
202 | /// The completion context in which we are gathering results. |
203 | CodeCompletionContext CompletionContext; |
204 | |
205 | /// If we are in an instance method definition, the \@implementation |
206 | /// object. |
207 | ObjCImplementationDecl *ObjCImplementation; |
208 | |
209 | void AdjustResultPriorityForDecl(Result &R); |
210 | |
211 | void MaybeAddConstructorResults(Result R); |
212 | |
213 | public: |
214 | explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator, |
215 | CodeCompletionTUInfo &CCTUInfo, |
216 | const CodeCompletionContext &CompletionContext, |
217 | LookupFilter Filter = nullptr) |
218 | : SemaRef(SemaRef), Allocator(Allocator), CCTUInfo(CCTUInfo), |
219 | Filter(Filter), AllowNestedNameSpecifiers(false), |
220 | HasObjectTypeQualifiers(false), CompletionContext(CompletionContext), |
221 | ObjCImplementation(nullptr) { |
222 | // If this is an Objective-C instance method definition, dig out the |
223 | // corresponding implementation. |
224 | switch (CompletionContext.getKind()) { |
225 | case CodeCompletionContext::CCC_Expression: |
226 | case CodeCompletionContext::CCC_ObjCMessageReceiver: |
227 | case CodeCompletionContext::CCC_ParenthesizedExpression: |
228 | case CodeCompletionContext::CCC_Statement: |
229 | case CodeCompletionContext::CCC_TopLevelOrExpression: |
230 | case CodeCompletionContext::CCC_Recovery: |
231 | if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) |
232 | if (Method->isInstanceMethod()) |
233 | if (ObjCInterfaceDecl *Interface = Method->getClassInterface()) |
234 | ObjCImplementation = Interface->getImplementation(); |
235 | break; |
236 | |
237 | default: |
238 | break; |
239 | } |
240 | } |
241 | |
242 | /// Determine the priority for a reference to the given declaration. |
243 | unsigned getBasePriority(const NamedDecl *D); |
244 | |
245 | /// Whether we should include code patterns in the completion |
246 | /// results. |
247 | bool includeCodePatterns() const { |
248 | return SemaRef.CodeCompletion().CodeCompleter && |
249 | SemaRef.CodeCompletion().CodeCompleter->includeCodePatterns(); |
250 | } |
251 | |
252 | /// Set the filter used for code-completion results. |
253 | void setFilter(LookupFilter Filter) { this->Filter = Filter; } |
254 | |
255 | Result *data() { return Results.empty() ? nullptr : &Results.front(); } |
256 | unsigned size() const { return Results.size(); } |
257 | bool empty() const { return Results.empty(); } |
258 | |
259 | /// Specify the preferred type. |
260 | void setPreferredType(QualType T) { |
261 | PreferredType = SemaRef.Context.getCanonicalType(T); |
262 | } |
263 | |
264 | /// Set the cv-qualifiers on the object type, for us in filtering |
265 | /// calls to member functions. |
266 | /// |
267 | /// When there are qualifiers in this set, they will be used to filter |
268 | /// out member functions that aren't available (because there will be a |
269 | /// cv-qualifier mismatch) or prefer functions with an exact qualifier |
270 | /// match. |
271 | void setObjectTypeQualifiers(Qualifiers Quals, ExprValueKind Kind) { |
272 | ObjectTypeQualifiers = Quals; |
273 | ObjectKind = Kind; |
274 | HasObjectTypeQualifiers = true; |
275 | } |
276 | |
277 | /// Set the preferred selector. |
278 | /// |
279 | /// When an Objective-C method declaration result is added, and that |
280 | /// method's selector matches this preferred selector, we give that method |
281 | /// a slight priority boost. |
282 | void setPreferredSelector(Selector Sel) { PreferredSelector = Sel; } |
283 | |
284 | /// Retrieve the code-completion context for which results are |
285 | /// being collected. |
286 | const CodeCompletionContext &getCompletionContext() const { |
287 | return CompletionContext; |
288 | } |
289 | |
290 | /// Specify whether nested-name-specifiers are allowed. |
291 | void allowNestedNameSpecifiers(bool Allow = true) { |
292 | AllowNestedNameSpecifiers = Allow; |
293 | } |
294 | |
295 | /// Return the semantic analysis object for which we are collecting |
296 | /// code completion results. |
297 | Sema &getSema() const { return SemaRef; } |
298 | |
299 | /// Retrieve the allocator used to allocate code completion strings. |
300 | CodeCompletionAllocator &getAllocator() const { return Allocator; } |
301 | |
302 | CodeCompletionTUInfo &getCodeCompletionTUInfo() const { return CCTUInfo; } |
303 | |
304 | /// Determine whether the given declaration is at all interesting |
305 | /// as a code-completion result. |
306 | /// |
307 | /// \param ND the declaration that we are inspecting. |
308 | /// |
309 | /// \param AsNestedNameSpecifier will be set true if this declaration is |
310 | /// only interesting when it is a nested-name-specifier. |
311 | bool isInterestingDecl(const NamedDecl *ND, |
312 | bool &AsNestedNameSpecifier) const; |
313 | |
314 | /// Decide whether or not a use of function Decl can be a call. |
315 | /// |
316 | /// \param ND the function declaration. |
317 | /// |
318 | /// \param BaseExprType the object type in a member access expression, |
319 | /// if any. |
320 | bool canFunctionBeCalled(const NamedDecl *ND, QualType BaseExprType) const; |
321 | |
322 | /// Decide whether or not a use of member function Decl can be a call. |
323 | /// |
324 | /// \param Method the function declaration. |
325 | /// |
326 | /// \param BaseExprType the object type in a member access expression, |
327 | /// if any. |
328 | bool canCxxMethodBeCalled(const CXXMethodDecl *Method, |
329 | QualType BaseExprType) const; |
330 | |
331 | /// Check whether the result is hidden by the Hiding declaration. |
332 | /// |
333 | /// \returns true if the result is hidden and cannot be found, false if |
334 | /// the hidden result could still be found. When false, \p R may be |
335 | /// modified to describe how the result can be found (e.g., via extra |
336 | /// qualification). |
337 | bool CheckHiddenResult(Result &R, DeclContext *CurContext, |
338 | const NamedDecl *Hiding); |
339 | |
340 | /// Add a new result to this result set (if it isn't already in one |
341 | /// of the shadow maps), or replace an existing result (for, e.g., a |
342 | /// redeclaration). |
343 | /// |
344 | /// \param R the result to add (if it is unique). |
345 | /// |
346 | /// \param CurContext the context in which this result will be named. |
347 | void MaybeAddResult(Result R, DeclContext *CurContext = nullptr); |
348 | |
349 | /// Add a new result to this result set, where we already know |
350 | /// the hiding declaration (if any). |
351 | /// |
352 | /// \param R the result to add (if it is unique). |
353 | /// |
354 | /// \param CurContext the context in which this result will be named. |
355 | /// |
356 | /// \param Hiding the declaration that hides the result. |
357 | /// |
358 | /// \param InBaseClass whether the result was found in a base |
359 | /// class of the searched context. |
360 | /// |
361 | /// \param BaseExprType the type of expression that precedes the "." or "->" |
362 | /// in a member access expression. |
363 | void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding, |
364 | bool InBaseClass, QualType BaseExprType); |
365 | |
366 | /// Add a new non-declaration result to this result set. |
367 | void AddResult(Result R); |
368 | |
369 | /// Enter into a new scope. |
370 | void EnterNewScope(); |
371 | |
372 | /// Exit from the current scope. |
373 | void ExitScope(); |
374 | |
375 | /// Ignore this declaration, if it is seen again. |
376 | void Ignore(const Decl *D) { AllDeclsFound.insert(Ptr: D->getCanonicalDecl()); } |
377 | |
378 | /// Add a visited context. |
379 | void addVisitedContext(DeclContext *Ctx) { |
380 | CompletionContext.addVisitedContext(Ctx); |
381 | } |
382 | |
383 | /// \name Name lookup predicates |
384 | /// |
385 | /// These predicates can be passed to the name lookup functions to filter the |
386 | /// results of name lookup. All of the predicates have the same type, so that |
387 | /// |
388 | //@{ |
389 | bool IsOrdinaryName(const NamedDecl *ND) const; |
390 | bool IsOrdinaryNonTypeName(const NamedDecl *ND) const; |
391 | bool IsIntegralConstantValue(const NamedDecl *ND) const; |
392 | bool IsOrdinaryNonValueName(const NamedDecl *ND) const; |
393 | bool IsNestedNameSpecifier(const NamedDecl *ND) const; |
394 | bool IsEnum(const NamedDecl *ND) const; |
395 | bool IsClassOrStruct(const NamedDecl *ND) const; |
396 | bool IsUnion(const NamedDecl *ND) const; |
397 | bool IsNamespace(const NamedDecl *ND) const; |
398 | bool IsNamespaceOrAlias(const NamedDecl *ND) const; |
399 | bool IsType(const NamedDecl *ND) const; |
400 | bool IsMember(const NamedDecl *ND) const; |
401 | bool IsObjCIvar(const NamedDecl *ND) const; |
402 | bool IsObjCMessageReceiver(const NamedDecl *ND) const; |
403 | bool IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const; |
404 | bool IsObjCCollection(const NamedDecl *ND) const; |
405 | bool IsImpossibleToSatisfy(const NamedDecl *ND) const; |
406 | //@} |
407 | }; |
408 | } // namespace |
409 | |
410 | void PreferredTypeBuilder::enterReturn(Sema &S, SourceLocation Tok) { |
411 | if (!Enabled) |
412 | return; |
413 | if (isa<BlockDecl>(Val: S.CurContext)) { |
414 | if (sema::BlockScopeInfo *BSI = S.getCurBlock()) { |
415 | ComputeType = nullptr; |
416 | Type = BSI->ReturnType; |
417 | ExpectedLoc = Tok; |
418 | } |
419 | } else if (const auto *Function = dyn_cast<FunctionDecl>(Val: S.CurContext)) { |
420 | ComputeType = nullptr; |
421 | Type = Function->getReturnType(); |
422 | ExpectedLoc = Tok; |
423 | } else if (const auto *Method = dyn_cast<ObjCMethodDecl>(Val: S.CurContext)) { |
424 | ComputeType = nullptr; |
425 | Type = Method->getReturnType(); |
426 | ExpectedLoc = Tok; |
427 | } |
428 | } |
429 | |
430 | void PreferredTypeBuilder::enterVariableInit(SourceLocation Tok, Decl *D) { |
431 | if (!Enabled) |
432 | return; |
433 | auto *VD = llvm::dyn_cast_or_null<ValueDecl>(Val: D); |
434 | ComputeType = nullptr; |
435 | Type = VD ? VD->getType() : QualType(); |
436 | ExpectedLoc = Tok; |
437 | } |
438 | |
439 | static QualType getDesignatedType(QualType BaseType, const Designation &Desig, |
440 | HeuristicResolver &Resolver); |
441 | |
442 | void PreferredTypeBuilder::enterDesignatedInitializer(SourceLocation Tok, |
443 | QualType BaseType, |
444 | const Designation &D) { |
445 | if (!Enabled) |
446 | return; |
447 | ComputeType = nullptr; |
448 | HeuristicResolver Resolver(*Ctx); |
449 | Type = getDesignatedType(BaseType, D, Resolver); |
450 | ExpectedLoc = Tok; |
451 | } |
452 | |
453 | void PreferredTypeBuilder::enterFunctionArgument( |
454 | SourceLocation Tok, llvm::function_ref<QualType()> ComputeType) { |
455 | if (!Enabled) |
456 | return; |
457 | this->ComputeType = ComputeType; |
458 | Type = QualType(); |
459 | ExpectedLoc = Tok; |
460 | } |
461 | |
462 | void PreferredTypeBuilder::enterParenExpr(SourceLocation Tok, |
463 | SourceLocation LParLoc) { |
464 | if (!Enabled) |
465 | return; |
466 | // expected type for parenthesized expression does not change. |
467 | if (ExpectedLoc == LParLoc) |
468 | ExpectedLoc = Tok; |
469 | } |
470 | |
471 | static QualType getPreferredTypeOfBinaryRHS(Sema &S, Expr *LHS, |
472 | tok::TokenKind Op) { |
473 | if (!LHS) |
474 | return QualType(); |
475 | |
476 | QualType LHSType = LHS->getType(); |
477 | if (LHSType->isPointerType()) { |
478 | if (Op == tok::plus || Op == tok::plusequal || Op == tok::minusequal) |
479 | return S.getASTContext().getPointerDiffType(); |
480 | // Pointer difference is more common than subtracting an int from a pointer. |
481 | if (Op == tok::minus) |
482 | return LHSType; |
483 | } |
484 | |
485 | switch (Op) { |
486 | // No way to infer the type of RHS from LHS. |
487 | case tok::comma: |
488 | return QualType(); |
489 | // Prefer the type of the left operand for all of these. |
490 | // Arithmetic operations. |
491 | case tok::plus: |
492 | case tok::plusequal: |
493 | case tok::minus: |
494 | case tok::minusequal: |
495 | case tok::percent: |
496 | case tok::percentequal: |
497 | case tok::slash: |
498 | case tok::slashequal: |
499 | case tok::star: |
500 | case tok::starequal: |
501 | // Assignment. |
502 | case tok::equal: |
503 | // Comparison operators. |
504 | case tok::equalequal: |
505 | case tok::exclaimequal: |
506 | case tok::less: |
507 | case tok::lessequal: |
508 | case tok::greater: |
509 | case tok::greaterequal: |
510 | case tok::spaceship: |
511 | return LHS->getType(); |
512 | // Binary shifts are often overloaded, so don't try to guess those. |
513 | case tok::greatergreater: |
514 | case tok::greatergreaterequal: |
515 | case tok::lessless: |
516 | case tok::lesslessequal: |
517 | if (LHSType->isIntegralOrEnumerationType()) |
518 | return S.getASTContext().IntTy; |
519 | return QualType(); |
520 | // Logical operators, assume we want bool. |
521 | case tok::ampamp: |
522 | case tok::pipepipe: |
523 | return S.getASTContext().BoolTy; |
524 | // Operators often used for bit manipulation are typically used with the type |
525 | // of the left argument. |
526 | case tok::pipe: |
527 | case tok::pipeequal: |
528 | case tok::caret: |
529 | case tok::caretequal: |
530 | case tok::amp: |
531 | case tok::ampequal: |
532 | if (LHSType->isIntegralOrEnumerationType()) |
533 | return LHSType; |
534 | return QualType(); |
535 | // RHS should be a pointer to a member of the 'LHS' type, but we can't give |
536 | // any particular type here. |
537 | case tok::periodstar: |
538 | case tok::arrowstar: |
539 | return QualType(); |
540 | default: |
541 | // FIXME(ibiryukov): handle the missing op, re-add the assertion. |
542 | // assert(false && "unhandled binary op"); |
543 | return QualType(); |
544 | } |
545 | } |
546 | |
547 | /// Get preferred type for an argument of an unary expression. \p ContextType is |
548 | /// preferred type of the whole unary expression. |
549 | static QualType getPreferredTypeOfUnaryArg(Sema &S, QualType ContextType, |
550 | tok::TokenKind Op) { |
551 | switch (Op) { |
552 | case tok::exclaim: |
553 | return S.getASTContext().BoolTy; |
554 | case tok::amp: |
555 | if (!ContextType.isNull() && ContextType->isPointerType()) |
556 | return ContextType->getPointeeType(); |
557 | return QualType(); |
558 | case tok::star: |
559 | if (ContextType.isNull()) |
560 | return QualType(); |
561 | return S.getASTContext().getPointerType(T: ContextType.getNonReferenceType()); |
562 | case tok::plus: |
563 | case tok::minus: |
564 | case tok::tilde: |
565 | case tok::minusminus: |
566 | case tok::plusplus: |
567 | if (ContextType.isNull()) |
568 | return S.getASTContext().IntTy; |
569 | // leave as is, these operators typically return the same type. |
570 | return ContextType; |
571 | case tok::kw___real: |
572 | case tok::kw___imag: |
573 | return QualType(); |
574 | default: |
575 | assert(false && "unhandled unary op"); |
576 | return QualType(); |
577 | } |
578 | } |
579 | |
580 | void PreferredTypeBuilder::enterBinary(Sema &S, SourceLocation Tok, Expr *LHS, |
581 | tok::TokenKind Op) { |
582 | if (!Enabled) |
583 | return; |
584 | ComputeType = nullptr; |
585 | Type = getPreferredTypeOfBinaryRHS(S, LHS, Op); |
586 | ExpectedLoc = Tok; |
587 | } |
588 | |
589 | void PreferredTypeBuilder::enterMemAccess(Sema &S, SourceLocation Tok, |
590 | Expr *Base) { |
591 | if (!Enabled || !Base) |
592 | return; |
593 | // Do we have expected type for Base? |
594 | if (ExpectedLoc != Base->getBeginLoc()) |
595 | return; |
596 | // Keep the expected type, only update the location. |
597 | ExpectedLoc = Tok; |
598 | } |
599 | |
600 | void PreferredTypeBuilder::enterUnary(Sema &S, SourceLocation Tok, |
601 | tok::TokenKind OpKind, |
602 | SourceLocation OpLoc) { |
603 | if (!Enabled) |
604 | return; |
605 | ComputeType = nullptr; |
606 | Type = getPreferredTypeOfUnaryArg(S, this->get(OpLoc), OpKind); |
607 | ExpectedLoc = Tok; |
608 | } |
609 | |
610 | void PreferredTypeBuilder::enterSubscript(Sema &S, SourceLocation Tok, |
611 | Expr *LHS) { |
612 | if (!Enabled) |
613 | return; |
614 | ComputeType = nullptr; |
615 | Type = S.getASTContext().IntTy; |
616 | ExpectedLoc = Tok; |
617 | } |
618 | |
619 | void PreferredTypeBuilder::enterTypeCast(SourceLocation Tok, |
620 | QualType CastType) { |
621 | if (!Enabled) |
622 | return; |
623 | ComputeType = nullptr; |
624 | Type = !CastType.isNull() ? CastType.getCanonicalType() : QualType(); |
625 | ExpectedLoc = Tok; |
626 | } |
627 | |
628 | void PreferredTypeBuilder::enterCondition(Sema &S, SourceLocation Tok) { |
629 | if (!Enabled) |
630 | return; |
631 | ComputeType = nullptr; |
632 | Type = S.getASTContext().BoolTy; |
633 | ExpectedLoc = Tok; |
634 | } |
635 | |
636 | class ResultBuilder::ShadowMapEntry::iterator { |
637 | llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator; |
638 | unsigned SingleDeclIndex; |
639 | |
640 | public: |
641 | typedef DeclIndexPair value_type; |
642 | typedef value_type reference; |
643 | typedef std::ptrdiff_t difference_type; |
644 | typedef std::input_iterator_tag iterator_category; |
645 | |
646 | class pointer { |
647 | DeclIndexPair Value; |
648 | |
649 | public: |
650 | pointer(const DeclIndexPair &Value) : Value(Value) {} |
651 | |
652 | const DeclIndexPair *operator->() const { return &Value; } |
653 | }; |
654 | |
655 | iterator() : DeclOrIterator((NamedDecl *)nullptr), SingleDeclIndex(0) {} |
656 | |
657 | iterator(const NamedDecl *SingleDecl, unsigned Index) |
658 | : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) {} |
659 | |
660 | iterator(const DeclIndexPair *Iterator) |
661 | : DeclOrIterator(Iterator), SingleDeclIndex(0) {} |
662 | |
663 | iterator &operator++() { |
664 | if (isa<const NamedDecl *>(Val: DeclOrIterator)) { |
665 | DeclOrIterator = (NamedDecl *)nullptr; |
666 | SingleDeclIndex = 0; |
667 | return *this; |
668 | } |
669 | |
670 | const DeclIndexPair *I = cast<const DeclIndexPair *>(Val&: DeclOrIterator); |
671 | ++I; |
672 | DeclOrIterator = I; |
673 | return *this; |
674 | } |
675 | |
676 | /*iterator operator++(int) { |
677 | iterator tmp(*this); |
678 | ++(*this); |
679 | return tmp; |
680 | }*/ |
681 | |
682 | reference operator*() const { |
683 | if (const NamedDecl *ND = dyn_cast<const NamedDecl *>(Val: DeclOrIterator)) |
684 | return reference(ND, SingleDeclIndex); |
685 | |
686 | return *cast<const DeclIndexPair *>(Val: DeclOrIterator); |
687 | } |
688 | |
689 | pointer operator->() const { return pointer(**this); } |
690 | |
691 | friend bool operator==(const iterator &X, const iterator &Y) { |
692 | return X.DeclOrIterator.getOpaqueValue() == |
693 | Y.DeclOrIterator.getOpaqueValue() && |
694 | X.SingleDeclIndex == Y.SingleDeclIndex; |
695 | } |
696 | |
697 | friend bool operator!=(const iterator &X, const iterator &Y) { |
698 | return !(X == Y); |
699 | } |
700 | }; |
701 | |
702 | ResultBuilder::ShadowMapEntry::iterator |
703 | ResultBuilder::ShadowMapEntry::begin() const { |
704 | if (DeclOrVector.isNull()) |
705 | return iterator(); |
706 | |
707 | if (const NamedDecl *ND = dyn_cast<const NamedDecl *>(Val: DeclOrVector)) |
708 | return iterator(ND, SingleDeclIndex); |
709 | |
710 | return iterator(cast<DeclIndexPairVector *>(Val: DeclOrVector)->begin()); |
711 | } |
712 | |
713 | ResultBuilder::ShadowMapEntry::iterator |
714 | ResultBuilder::ShadowMapEntry::end() const { |
715 | if (isa<const NamedDecl *>(Val: DeclOrVector) || DeclOrVector.isNull()) |
716 | return iterator(); |
717 | |
718 | return iterator(cast<DeclIndexPairVector *>(Val: DeclOrVector)->end()); |
719 | } |
720 | |
721 | /// Compute the qualification required to get from the current context |
722 | /// (\p CurContext) to the target context (\p TargetContext). |
723 | /// |
724 | /// \param Context the AST context in which the qualification will be used. |
725 | /// |
726 | /// \param CurContext the context where an entity is being named, which is |
727 | /// typically based on the current scope. |
728 | /// |
729 | /// \param TargetContext the context in which the named entity actually |
730 | /// resides. |
731 | /// |
732 | /// \returns a nested name specifier that refers into the target context, or |
733 | /// NULL if no qualification is needed. |
734 | static NestedNameSpecifier * |
735 | getRequiredQualification(ASTContext &Context, const DeclContext *CurContext, |
736 | const DeclContext *TargetContext) { |
737 | SmallVector<const DeclContext *, 4> TargetParents; |
738 | |
739 | for (const DeclContext *CommonAncestor = TargetContext; |
740 | CommonAncestor && !CommonAncestor->Encloses(DC: CurContext); |
741 | CommonAncestor = CommonAncestor->getLookupParent()) { |
742 | if (CommonAncestor->isTransparentContext() || |
743 | CommonAncestor->isFunctionOrMethod()) |
744 | continue; |
745 | |
746 | TargetParents.push_back(Elt: CommonAncestor); |
747 | } |
748 | |
749 | NestedNameSpecifier *Result = nullptr; |
750 | while (!TargetParents.empty()) { |
751 | const DeclContext *Parent = TargetParents.pop_back_val(); |
752 | |
753 | if (const auto *Namespace = dyn_cast<NamespaceDecl>(Val: Parent)) { |
754 | if (!Namespace->getIdentifier()) |
755 | continue; |
756 | |
757 | Result = NestedNameSpecifier::Create(Context, Prefix: Result, NS: Namespace); |
758 | } else if (const auto *TD = dyn_cast<TagDecl>(Val: Parent)) |
759 | Result = NestedNameSpecifier::Create( |
760 | Context, Prefix: Result, T: Context.getTypeDeclType(TD).getTypePtr()); |
761 | } |
762 | return Result; |
763 | } |
764 | |
765 | // Some declarations have reserved names that we don't want to ever show. |
766 | // Filter out names reserved for the implementation if they come from a |
767 | // system header. |
768 | static bool shouldIgnoreDueToReservedName(const NamedDecl *ND, Sema &SemaRef) { |
769 | // Debuggers want access to all identifiers, including reserved ones. |
770 | if (SemaRef.getLangOpts().DebuggerSupport) |
771 | return false; |
772 | |
773 | ReservedIdentifierStatus Status = ND->isReserved(LangOpts: SemaRef.getLangOpts()); |
774 | // Ignore reserved names for compiler provided decls. |
775 | if (isReservedInAllContexts(Status) && ND->getLocation().isInvalid()) |
776 | return true; |
777 | |
778 | // For system headers ignore only double-underscore names. |
779 | // This allows for system headers providing private symbols with a single |
780 | // underscore. |
781 | if (Status == ReservedIdentifierStatus::StartsWithDoubleUnderscore && |
782 | SemaRef.SourceMgr.isInSystemHeader( |
783 | Loc: SemaRef.SourceMgr.getSpellingLoc(Loc: ND->getLocation()))) |
784 | return true; |
785 | |
786 | return false; |
787 | } |
788 | |
789 | bool ResultBuilder::isInterestingDecl(const NamedDecl *ND, |
790 | bool &AsNestedNameSpecifier) const { |
791 | AsNestedNameSpecifier = false; |
792 | |
793 | auto *Named = ND; |
794 | ND = ND->getUnderlyingDecl(); |
795 | |
796 | // Skip unnamed entities. |
797 | if (!ND->getDeclName()) |
798 | return false; |
799 | |
800 | // Friend declarations and declarations introduced due to friends are never |
801 | // added as results. |
802 | if (ND->getFriendObjectKind() == Decl::FOK_Undeclared) |
803 | return false; |
804 | |
805 | // Class template (partial) specializations are never added as results. |
806 | if (isa<ClassTemplateSpecializationDecl>(Val: ND) || |
807 | isa<ClassTemplatePartialSpecializationDecl>(Val: ND)) |
808 | return false; |
809 | |
810 | // Using declarations themselves are never added as results. |
811 | if (isa<UsingDecl>(Val: ND)) |
812 | return false; |
813 | |
814 | if (shouldIgnoreDueToReservedName(ND, SemaRef)) |
815 | return false; |
816 | |
817 | if (Filter == &ResultBuilder::IsNestedNameSpecifier || |
818 | (isa<NamespaceDecl>(Val: ND) && Filter != &ResultBuilder::IsNamespace && |
819 | Filter != &ResultBuilder::IsNamespaceOrAlias && Filter != nullptr)) |
820 | AsNestedNameSpecifier = true; |
821 | |
822 | // Filter out any unwanted results. |
823 | if (Filter && !(this->*Filter)(Named)) { |
824 | // Check whether it is interesting as a nested-name-specifier. |
825 | if (AllowNestedNameSpecifiers && SemaRef.getLangOpts().CPlusPlus && |
826 | IsNestedNameSpecifier(ND) && |
827 | (Filter != &ResultBuilder::IsMember || |
828 | (isa<CXXRecordDecl>(Val: ND) && |
829 | cast<CXXRecordDecl>(Val: ND)->isInjectedClassName()))) { |
830 | AsNestedNameSpecifier = true; |
831 | return true; |
832 | } |
833 | |
834 | return false; |
835 | } |
836 | // ... then it must be interesting! |
837 | return true; |
838 | } |
839 | |
840 | bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext, |
841 | const NamedDecl *Hiding) { |
842 | // In C, there is no way to refer to a hidden name. |
843 | // FIXME: This isn't true; we can find a tag name hidden by an ordinary |
844 | // name if we introduce the tag type. |
845 | if (!SemaRef.getLangOpts().CPlusPlus) |
846 | return true; |
847 | |
848 | const DeclContext *HiddenCtx = |
849 | R.Declaration->getDeclContext()->getRedeclContext(); |
850 | |
851 | // There is no way to qualify a name declared in a function or method. |
852 | if (HiddenCtx->isFunctionOrMethod()) |
853 | return true; |
854 | |
855 | if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext()) |
856 | return true; |
857 | |
858 | // We can refer to the result with the appropriate qualification. Do it. |
859 | R.Hidden = true; |
860 | R.QualifierIsInformative = false; |
861 | |
862 | if (!R.Qualifier) |
863 | R.Qualifier = getRequiredQualification(SemaRef.Context, CurContext, |
864 | R.Declaration->getDeclContext()); |
865 | return false; |
866 | } |
867 | |
868 | /// A simplified classification of types used to determine whether two |
869 | /// types are "similar enough" when adjusting priorities. |
870 | SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) { |
871 | switch (T->getTypeClass()) { |
872 | case Type::Builtin: |
873 | switch (cast<BuiltinType>(Val&: T)->getKind()) { |
874 | case BuiltinType::Void: |
875 | return STC_Void; |
876 | |
877 | case BuiltinType::NullPtr: |
878 | return STC_Pointer; |
879 | |
880 | case BuiltinType::Overload: |
881 | case BuiltinType::Dependent: |
882 | return STC_Other; |
883 | |
884 | case BuiltinType::ObjCId: |
885 | case BuiltinType::ObjCClass: |
886 | case BuiltinType::ObjCSel: |
887 | return STC_ObjectiveC; |
888 | |
889 | default: |
890 | return STC_Arithmetic; |
891 | } |
892 | |
893 | case Type::Complex: |
894 | return STC_Arithmetic; |
895 | |
896 | case Type::Pointer: |
897 | return STC_Pointer; |
898 | |
899 | case Type::BlockPointer: |
900 | return STC_Block; |
901 | |
902 | case Type::LValueReference: |
903 | case Type::RValueReference: |
904 | return getSimplifiedTypeClass(T->getAs<ReferenceType>()->getPointeeType()); |
905 | |
906 | case Type::ConstantArray: |
907 | case Type::IncompleteArray: |
908 | case Type::VariableArray: |
909 | case Type::DependentSizedArray: |
910 | return STC_Array; |
911 | |
912 | case Type::DependentSizedExtVector: |
913 | case Type::Vector: |
914 | case Type::ExtVector: |
915 | return STC_Arithmetic; |
916 | |
917 | case Type::FunctionProto: |
918 | case Type::FunctionNoProto: |
919 | return STC_Function; |
920 | |
921 | case Type::Record: |
922 | return STC_Record; |
923 | |
924 | case Type::Enum: |
925 | return STC_Arithmetic; |
926 | |
927 | case Type::ObjCObject: |
928 | case Type::ObjCInterface: |
929 | case Type::ObjCObjectPointer: |
930 | return STC_ObjectiveC; |
931 | |
932 | default: |
933 | return STC_Other; |
934 | } |
935 | } |
936 | |
937 | /// Get the type that a given expression will have if this declaration |
938 | /// is used as an expression in its "typical" code-completion form. |
939 | QualType clang::getDeclUsageType(ASTContext &C, const NamedDecl *ND) { |
940 | ND = ND->getUnderlyingDecl(); |
941 | |
942 | if (const auto *Type = dyn_cast<TypeDecl>(Val: ND)) |
943 | return C.getTypeDeclType(Decl: Type); |
944 | if (const auto *Iface = dyn_cast<ObjCInterfaceDecl>(Val: ND)) |
945 | return C.getObjCInterfaceType(Decl: Iface); |
946 | |
947 | QualType T; |
948 | if (const FunctionDecl *Function = ND->getAsFunction()) |
949 | T = Function->getCallResultType(); |
950 | else if (const auto *Method = dyn_cast<ObjCMethodDecl>(Val: ND)) |
951 | T = Method->getSendResultType(); |
952 | else if (const auto *Enumerator = dyn_cast<EnumConstantDecl>(Val: ND)) |
953 | T = C.getTypeDeclType(Decl: cast<EnumDecl>(Enumerator->getDeclContext())); |
954 | else if (const auto *Property = dyn_cast<ObjCPropertyDecl>(Val: ND)) |
955 | T = Property->getType(); |
956 | else if (const auto *Value = dyn_cast<ValueDecl>(Val: ND)) |
957 | T = Value->getType(); |
958 | |
959 | if (T.isNull()) |
960 | return QualType(); |
961 | |
962 | // Dig through references, function pointers, and block pointers to |
963 | // get down to the likely type of an expression when the entity is |
964 | // used. |
965 | do { |
966 | if (const auto *Ref = T->getAs<ReferenceType>()) { |
967 | T = Ref->getPointeeType(); |
968 | continue; |
969 | } |
970 | |
971 | if (const auto *Pointer = T->getAs<PointerType>()) { |
972 | if (Pointer->getPointeeType()->isFunctionType()) { |
973 | T = Pointer->getPointeeType(); |
974 | continue; |
975 | } |
976 | |
977 | break; |
978 | } |
979 | |
980 | if (const auto *Block = T->getAs<BlockPointerType>()) { |
981 | T = Block->getPointeeType(); |
982 | continue; |
983 | } |
984 | |
985 | if (const auto *Function = T->getAs<FunctionType>()) { |
986 | T = Function->getReturnType(); |
987 | continue; |
988 | } |
989 | |
990 | break; |
991 | } while (true); |
992 | |
993 | return T; |
994 | } |
995 | |
996 | unsigned ResultBuilder::getBasePriority(const NamedDecl *ND) { |
997 | if (!ND) |
998 | return CCP_Unlikely; |
999 | |
1000 | // Context-based decisions. |
1001 | const DeclContext *LexicalDC = ND->getLexicalDeclContext(); |
1002 | if (LexicalDC->isFunctionOrMethod()) { |
1003 | // _cmd is relatively rare |
1004 | if (const auto *ImplicitParam = dyn_cast<ImplicitParamDecl>(Val: ND)) |
1005 | if (ImplicitParam->getIdentifier() && |
1006 | ImplicitParam->getIdentifier()->isStr("_cmd")) |
1007 | return CCP_ObjC_cmd; |
1008 | |
1009 | return CCP_LocalDeclaration; |
1010 | } |
1011 | |
1012 | const DeclContext *DC = ND->getDeclContext()->getRedeclContext(); |
1013 | if (DC->isRecord() || isa<ObjCContainerDecl>(Val: DC)) { |
1014 | // Explicit destructor calls are very rare. |
1015 | if (isa<CXXDestructorDecl>(Val: ND)) |
1016 | return CCP_Unlikely; |
1017 | // Explicit operator and conversion function calls are also very rare. |
1018 | auto DeclNameKind = ND->getDeclName().getNameKind(); |
1019 | if (DeclNameKind == DeclarationName::CXXOperatorName || |
1020 | DeclNameKind == DeclarationName::CXXLiteralOperatorName || |
1021 | DeclNameKind == DeclarationName::CXXConversionFunctionName) |
1022 | return CCP_Unlikely; |
1023 | return CCP_MemberDeclaration; |
1024 | } |
1025 | |
1026 | // Content-based decisions. |
1027 | if (isa<EnumConstantDecl>(Val: ND)) |
1028 | return CCP_Constant; |
1029 | |
1030 | // Use CCP_Type for type declarations unless we're in a statement, Objective-C |
1031 | // message receiver, or parenthesized expression context. There, it's as |
1032 | // likely that the user will want to write a type as other declarations. |
1033 | if ((isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) && |
1034 | !(CompletionContext.getKind() == CodeCompletionContext::CCC_Statement || |
1035 | CompletionContext.getKind() == |
1036 | CodeCompletionContext::CCC_ObjCMessageReceiver || |
1037 | CompletionContext.getKind() == |
1038 | CodeCompletionContext::CCC_ParenthesizedExpression)) |
1039 | return CCP_Type; |
1040 | |
1041 | return CCP_Declaration; |
1042 | } |
1043 | |
1044 | void ResultBuilder::AdjustResultPriorityForDecl(Result &R) { |
1045 | // If this is an Objective-C method declaration whose selector matches our |
1046 | // preferred selector, give it a priority boost. |
1047 | if (!PreferredSelector.isNull()) |
1048 | if (const auto *Method = dyn_cast<ObjCMethodDecl>(Val: R.Declaration)) |
1049 | if (PreferredSelector == Method->getSelector()) |
1050 | R.Priority += CCD_SelectorMatch; |
1051 | |
1052 | // If we have a preferred type, adjust the priority for results with exactly- |
1053 | // matching or nearly-matching types. |
1054 | if (!PreferredType.isNull()) { |
1055 | QualType T = getDeclUsageType(C&: SemaRef.Context, ND: R.Declaration); |
1056 | if (!T.isNull()) { |
1057 | CanQualType TC = SemaRef.Context.getCanonicalType(T); |
1058 | // Check for exactly-matching types (modulo qualifiers). |
1059 | if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC)) |
1060 | R.Priority /= CCF_ExactTypeMatch; |
1061 | // Check for nearly-matching types, based on classification of each. |
1062 | else if ((getSimplifiedTypeClass(PreferredType) == |
1063 | getSimplifiedTypeClass(TC)) && |
1064 | !(PreferredType->isEnumeralType() && TC->isEnumeralType())) |
1065 | R.Priority /= CCF_SimilarTypeMatch; |
1066 | } |
1067 | } |
1068 | } |
1069 | |
1070 | static DeclContext::lookup_result getConstructors(ASTContext &Context, |
1071 | const CXXRecordDecl *Record) { |
1072 | QualType RecordTy = Context.getTypeDeclType(Record); |
1073 | DeclarationName ConstructorName = |
1074 | Context.DeclarationNames.getCXXConstructorName( |
1075 | Ty: Context.getCanonicalType(T: RecordTy)); |
1076 | return Record->lookup(ConstructorName); |
1077 | } |
1078 | |
1079 | void ResultBuilder::MaybeAddConstructorResults(Result R) { |
1080 | if (!SemaRef.getLangOpts().CPlusPlus || !R.Declaration || |
1081 | !CompletionContext.wantConstructorResults()) |
1082 | return; |
1083 | |
1084 | const NamedDecl *D = R.Declaration; |
1085 | const CXXRecordDecl *Record = nullptr; |
1086 | if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(Val: D)) |
1087 | Record = ClassTemplate->getTemplatedDecl(); |
1088 | else if ((Record = dyn_cast<CXXRecordDecl>(Val: D))) { |
1089 | // Skip specializations and partial specializations. |
1090 | if (isa<ClassTemplateSpecializationDecl>(Val: Record)) |
1091 | return; |
1092 | } else { |
1093 | // There are no constructors here. |
1094 | return; |
1095 | } |
1096 | |
1097 | Record = Record->getDefinition(); |
1098 | if (!Record) |
1099 | return; |
1100 | |
1101 | for (NamedDecl *Ctor : getConstructors(Context&: SemaRef.Context, Record)) { |
1102 | R.Declaration = Ctor; |
1103 | R.CursorKind = getCursorKindForDecl(R.Declaration); |
1104 | Results.push_back(x: R); |
1105 | } |
1106 | } |
1107 | |
1108 | static bool isConstructor(const Decl *ND) { |
1109 | if (const auto *Tmpl = dyn_cast<FunctionTemplateDecl>(Val: ND)) |
1110 | ND = Tmpl->getTemplatedDecl(); |
1111 | return isa<CXXConstructorDecl>(Val: ND); |
1112 | } |
1113 | |
1114 | void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) { |
1115 | assert(!ShadowMaps.empty() && "Must enter into a results scope"); |
1116 | |
1117 | if (R.Kind != Result::RK_Declaration) { |
1118 | // For non-declaration results, just add the result. |
1119 | Results.push_back(x: R); |
1120 | return; |
1121 | } |
1122 | |
1123 | // Look through using declarations. |
1124 | if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(Val: R.Declaration)) { |
1125 | CodeCompletionResult Result(Using->getTargetDecl(), |
1126 | getBasePriority(ND: Using->getTargetDecl()), |
1127 | R.Qualifier, false, |
1128 | (R.Availability == CXAvailability_Available || |
1129 | R.Availability == CXAvailability_Deprecated), |
1130 | std::move(R.FixIts)); |
1131 | Result.ShadowDecl = Using; |
1132 | MaybeAddResult(R: Result, CurContext); |
1133 | return; |
1134 | } |
1135 | |
1136 | const Decl *CanonDecl = R.Declaration->getCanonicalDecl(); |
1137 | unsigned IDNS = CanonDecl->getIdentifierNamespace(); |
1138 | |
1139 | bool AsNestedNameSpecifier = false; |
1140 | if (!isInterestingDecl(ND: R.Declaration, AsNestedNameSpecifier)) |
1141 | return; |
1142 | |
1143 | // C++ constructors are never found by name lookup. |
1144 | if (isConstructor(R.Declaration)) |
1145 | return; |
1146 | |
1147 | ShadowMap &SMap = ShadowMaps.back(); |
1148 | ShadowMapEntry::iterator I, IEnd; |
1149 | ShadowMap::iterator NamePos = SMap.find(Val: R.Declaration->getDeclName()); |
1150 | if (NamePos != SMap.end()) { |
1151 | I = NamePos->second.begin(); |
1152 | IEnd = NamePos->second.end(); |
1153 | } |
1154 | |
1155 | for (; I != IEnd; ++I) { |
1156 | const NamedDecl *ND = I->first; |
1157 | unsigned Index = I->second; |
1158 | if (ND->getCanonicalDecl() == CanonDecl) { |
1159 | // This is a redeclaration. Always pick the newer declaration. |
1160 | Results[Index].Declaration = R.Declaration; |
1161 | |
1162 | // We're done. |
1163 | return; |
1164 | } |
1165 | } |
1166 | |
1167 | // This is a new declaration in this scope. However, check whether this |
1168 | // declaration name is hidden by a similarly-named declaration in an outer |
1169 | // scope. |
1170 | std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end(); |
1171 | --SMEnd; |
1172 | for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) { |
1173 | ShadowMapEntry::iterator I, IEnd; |
1174 | ShadowMap::iterator NamePos = SM->find(Val: R.Declaration->getDeclName()); |
1175 | if (NamePos != SM->end()) { |
1176 | I = NamePos->second.begin(); |
1177 | IEnd = NamePos->second.end(); |
1178 | } |
1179 | for (; I != IEnd; ++I) { |
1180 | // A tag declaration does not hide a non-tag declaration. |
1181 | if (I->first->hasTagIdentifierNamespace() && |
1182 | (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary | |
1183 | Decl::IDNS_LocalExtern | Decl::IDNS_ObjCProtocol))) |
1184 | continue; |
1185 | |
1186 | // Protocols are in distinct namespaces from everything else. |
1187 | if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol) || |
1188 | (IDNS & Decl::IDNS_ObjCProtocol)) && |
1189 | I->first->getIdentifierNamespace() != IDNS) |
1190 | continue; |
1191 | |
1192 | // The newly-added result is hidden by an entry in the shadow map. |
1193 | if (CheckHiddenResult(R, CurContext, Hiding: I->first)) |
1194 | return; |
1195 | |
1196 | break; |
1197 | } |
1198 | } |
1199 | |
1200 | // Make sure that any given declaration only shows up in the result set once. |
1201 | if (!AllDeclsFound.insert(Ptr: CanonDecl).second) |
1202 | return; |
1203 | |
1204 | // If the filter is for nested-name-specifiers, then this result starts a |
1205 | // nested-name-specifier. |
1206 | if (AsNestedNameSpecifier) { |
1207 | R.StartsNestedNameSpecifier = true; |
1208 | R.Priority = CCP_NestedNameSpecifier; |
1209 | } else |
1210 | AdjustResultPriorityForDecl(R); |
1211 | |
1212 | // If this result is supposed to have an informative qualifier, add one. |
1213 | if (R.QualifierIsInformative && !R.Qualifier && |
1214 | !R.StartsNestedNameSpecifier) { |
1215 | const DeclContext *Ctx = R.Declaration->getDeclContext(); |
1216 | if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Val: Ctx)) |
1217 | R.Qualifier = |
1218 | NestedNameSpecifier::Create(Context: SemaRef.Context, Prefix: nullptr, NS: Namespace); |
1219 | else if (const TagDecl *Tag = dyn_cast<TagDecl>(Val: Ctx)) |
1220 | R.Qualifier = NestedNameSpecifier::Create( |
1221 | Context: SemaRef.Context, Prefix: nullptr, |
1222 | T: SemaRef.Context.getTypeDeclType(Tag).getTypePtr()); |
1223 | else |
1224 | R.QualifierIsInformative = false; |
1225 | } |
1226 | |
1227 | // Insert this result into the set of results and into the current shadow |
1228 | // map. |
1229 | SMap[R.Declaration->getDeclName()].Add(ND: R.Declaration, Index: Results.size()); |
1230 | Results.push_back(x: R); |
1231 | |
1232 | if (!AsNestedNameSpecifier) |
1233 | MaybeAddConstructorResults(R); |
1234 | } |
1235 | |
1236 | static void setInBaseClass(ResultBuilder::Result &R) { |
1237 | R.Priority += CCD_InBaseClass; |
1238 | R.InBaseClass = true; |
1239 | } |
1240 | |
1241 | enum class OverloadCompare { BothViable, Dominates, Dominated }; |
1242 | // Will Candidate ever be called on the object, when overloaded with Incumbent? |
1243 | // Returns Dominates if Candidate is always called, Dominated if Incumbent is |
1244 | // always called, BothViable if either may be called depending on arguments. |
1245 | // Precondition: must actually be overloads! |
1246 | static OverloadCompare compareOverloads(const CXXMethodDecl &Candidate, |
1247 | const CXXMethodDecl &Incumbent, |
1248 | const Qualifiers &ObjectQuals, |
1249 | ExprValueKind ObjectKind, |
1250 | const ASTContext &Ctx) { |
1251 | // Base/derived shadowing is handled elsewhere. |
1252 | if (Candidate.getDeclContext() != Incumbent.getDeclContext()) |
1253 | return OverloadCompare::BothViable; |
1254 | if (Candidate.isVariadic() != Incumbent.isVariadic() || |
1255 | Candidate.getNumParams() != Incumbent.getNumParams() || |
1256 | Candidate.getMinRequiredArguments() != |
1257 | Incumbent.getMinRequiredArguments()) |
1258 | return OverloadCompare::BothViable; |
1259 | for (unsigned I = 0, E = Candidate.getNumParams(); I != E; ++I) |
1260 | if (Candidate.parameters()[I]->getType().getCanonicalType() != |
1261 | Incumbent.parameters()[I]->getType().getCanonicalType()) |
1262 | return OverloadCompare::BothViable; |
1263 | if (!Candidate.specific_attrs<EnableIfAttr>().empty() || |
1264 | !Incumbent.specific_attrs<EnableIfAttr>().empty()) |
1265 | return OverloadCompare::BothViable; |
1266 | // At this point, we know calls can't pick one or the other based on |
1267 | // arguments, so one of the two must win. (Or both fail, handled elsewhere). |
1268 | RefQualifierKind CandidateRef = Candidate.getRefQualifier(); |
1269 | RefQualifierKind IncumbentRef = Incumbent.getRefQualifier(); |
1270 | if (CandidateRef != IncumbentRef) { |
1271 | // If the object kind is LValue/RValue, there's one acceptable ref-qualifier |
1272 | // and it can't be mixed with ref-unqualified overloads (in valid code). |
1273 | |
1274 | // For xvalue objects, we prefer the rvalue overload even if we have to |
1275 | // add qualifiers (which is rare, because const&& is rare). |
1276 | if (ObjectKind == clang::VK_XValue) |
1277 | return CandidateRef == RQ_RValue ? OverloadCompare::Dominates |
1278 | : OverloadCompare::Dominated; |
1279 | } |
1280 | // Now the ref qualifiers are the same (or we're in some invalid state). |
1281 | // So make some decision based on the qualifiers. |
1282 | Qualifiers CandidateQual = Candidate.getMethodQualifiers(); |
1283 | Qualifiers IncumbentQual = Incumbent.getMethodQualifiers(); |
1284 | bool CandidateSuperset = CandidateQual.compatiblyIncludes(other: IncumbentQual, Ctx); |
1285 | bool IncumbentSuperset = IncumbentQual.compatiblyIncludes(other: CandidateQual, Ctx); |
1286 | if (CandidateSuperset == IncumbentSuperset) |
1287 | return OverloadCompare::BothViable; |
1288 | return IncumbentSuperset ? OverloadCompare::Dominates |
1289 | : OverloadCompare::Dominated; |
1290 | } |
1291 | |
1292 | bool ResultBuilder::canCxxMethodBeCalled(const CXXMethodDecl *Method, |
1293 | QualType BaseExprType) const { |
1294 | // Find the class scope that we're currently in. |
1295 | // We could e.g. be inside a lambda, so walk up the DeclContext until we |
1296 | // find a CXXMethodDecl. |
1297 | DeclContext *CurContext = SemaRef.CurContext; |
1298 | const auto *CurrentClassScope = [&]() -> const CXXRecordDecl * { |
1299 | for (DeclContext *Ctx = CurContext; Ctx; Ctx = Ctx->getParent()) { |
1300 | const auto *CtxMethod = llvm::dyn_cast<CXXMethodDecl>(Val: Ctx); |
1301 | if (CtxMethod && !CtxMethod->getParent()->isLambda()) { |
1302 | return CtxMethod->getParent(); |
1303 | } |
1304 | } |
1305 | return nullptr; |
1306 | }(); |
1307 | |
1308 | // If we're not inside the scope of the method's class, it can't be a call. |
1309 | bool FunctionCanBeCall = |
1310 | CurrentClassScope && |
1311 | (CurrentClassScope == Method->getParent() || |
1312 | CurrentClassScope->isDerivedFrom(Base: Method->getParent())); |
1313 | |
1314 | // We skip the following calculation for exceptions if it's already true. |
1315 | if (FunctionCanBeCall) |
1316 | return true; |
1317 | |
1318 | // Exception: foo->FooBase::bar() or foo->Foo::bar() *is* a call. |
1319 | if (const CXXRecordDecl *MaybeDerived = |
1320 | BaseExprType.isNull() ? nullptr |
1321 | : BaseExprType->getAsCXXRecordDecl()) { |
1322 | auto *MaybeBase = Method->getParent(); |
1323 | FunctionCanBeCall = |
1324 | MaybeDerived == MaybeBase || MaybeDerived->isDerivedFrom(Base: MaybeBase); |
1325 | } |
1326 | |
1327 | return FunctionCanBeCall; |
1328 | } |
1329 | |
1330 | bool ResultBuilder::canFunctionBeCalled(const NamedDecl *ND, |
1331 | QualType BaseExprType) const { |
1332 | // We apply heuristics only to CCC_Symbol: |
1333 | // * CCC_{Arrow,Dot}MemberAccess reflect member access expressions: |
1334 | // f.method() and f->method(). These are always calls. |
1335 | // * A qualified name to a member function may *not* be a call. We have to |
1336 | // subdivide the cases: For example, f.Base::method(), which is regarded as |
1337 | // CCC_Symbol, should be a call. |
1338 | // * Non-member functions and static member functions are always considered |
1339 | // calls. |
1340 | if (CompletionContext.getKind() == clang::CodeCompletionContext::CCC_Symbol) { |
1341 | if (const auto *FuncTmpl = dyn_cast<FunctionTemplateDecl>(Val: ND)) { |
1342 | ND = FuncTmpl->getTemplatedDecl(); |
1343 | } |
1344 | const auto *Method = dyn_cast<CXXMethodDecl>(Val: ND); |
1345 | if (Method && !Method->isStatic()) { |
1346 | return canCxxMethodBeCalled(Method, BaseExprType); |
1347 | } |
1348 | } |
1349 | return true; |
1350 | } |
1351 | |
1352 | void ResultBuilder::AddResult(Result R, DeclContext *CurContext, |
1353 | NamedDecl *Hiding, bool InBaseClass = false, |
1354 | QualType BaseExprType = QualType()) { |
1355 | if (R.Kind != Result::RK_Declaration) { |
1356 | // For non-declaration results, just add the result. |
1357 | Results.push_back(x: R); |
1358 | return; |
1359 | } |
1360 | |
1361 | // Look through using declarations. |
1362 | if (const auto *Using = dyn_cast<UsingShadowDecl>(Val: R.Declaration)) { |
1363 | CodeCompletionResult Result(Using->getTargetDecl(), |
1364 | getBasePriority(ND: Using->getTargetDecl()), |
1365 | R.Qualifier, false, |
1366 | (R.Availability == CXAvailability_Available || |
1367 | R.Availability == CXAvailability_Deprecated), |
1368 | std::move(R.FixIts)); |
1369 | Result.ShadowDecl = Using; |
1370 | AddResult(R: Result, CurContext, Hiding, /*InBaseClass=*/false, |
1371 | /*BaseExprType=*/BaseExprType); |
1372 | return; |
1373 | } |
1374 | |
1375 | bool AsNestedNameSpecifier = false; |
1376 | if (!isInterestingDecl(ND: R.Declaration, AsNestedNameSpecifier)) |
1377 | return; |
1378 | |
1379 | // C++ constructors are never found by name lookup. |
1380 | if (isConstructor(R.Declaration)) |
1381 | return; |
1382 | |
1383 | if (Hiding && CheckHiddenResult(R, CurContext, Hiding)) |
1384 | return; |
1385 | |
1386 | // Make sure that any given declaration only shows up in the result set once. |
1387 | if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()).second) |
1388 | return; |
1389 | |
1390 | // If the filter is for nested-name-specifiers, then this result starts a |
1391 | // nested-name-specifier. |
1392 | if (AsNestedNameSpecifier) { |
1393 | R.StartsNestedNameSpecifier = true; |
1394 | R.Priority = CCP_NestedNameSpecifier; |
1395 | } else if (Filter == &ResultBuilder::IsMember && !R.Qualifier && |
1396 | InBaseClass && |
1397 | isa<CXXRecordDecl>( |
1398 | R.Declaration->getDeclContext()->getRedeclContext())) |
1399 | R.QualifierIsInformative = true; |
1400 | |
1401 | // If this result is supposed to have an informative qualifier, add one. |
1402 | if (R.QualifierIsInformative && !R.Qualifier && |
1403 | !R.StartsNestedNameSpecifier) { |
1404 | const DeclContext *Ctx = R.Declaration->getDeclContext(); |
1405 | if (const auto *Namespace = dyn_cast<NamespaceDecl>(Ctx)) |
1406 | R.Qualifier = |
1407 | NestedNameSpecifier::Create(SemaRef.Context, nullptr, Namespace); |
1408 | else if (const auto *Tag = dyn_cast<TagDecl>(Ctx)) |
1409 | R.Qualifier = NestedNameSpecifier::Create( |
1410 | SemaRef.Context, nullptr, |
1411 | SemaRef.Context.getTypeDeclType(Decl: Tag).getTypePtr()); |
1412 | else |
1413 | R.QualifierIsInformative = false; |
1414 | } |
1415 | |
1416 | // Adjust the priority if this result comes from a base class. |
1417 | if (InBaseClass) |
1418 | setInBaseClass(R); |
1419 | |
1420 | AdjustResultPriorityForDecl(R); |
1421 | |
1422 | if (HasObjectTypeQualifiers) |
1423 | if (const auto *Method = dyn_cast<CXXMethodDecl>(Val: R.Declaration)) |
1424 | if (Method->isInstance()) { |
1425 | Qualifiers MethodQuals = Method->getMethodQualifiers(); |
1426 | if (ObjectTypeQualifiers == MethodQuals) |
1427 | R.Priority += CCD_ObjectQualifierMatch; |
1428 | else if (ObjectTypeQualifiers - MethodQuals) { |
1429 | // The method cannot be invoked, because doing so would drop |
1430 | // qualifiers. |
1431 | return; |
1432 | } |
1433 | // Detect cases where a ref-qualified method cannot be invoked. |
1434 | switch (Method->getRefQualifier()) { |
1435 | case RQ_LValue: |
1436 | if (ObjectKind != VK_LValue && !MethodQuals.hasConst()) |
1437 | return; |
1438 | break; |
1439 | case RQ_RValue: |
1440 | if (ObjectKind == VK_LValue) |
1441 | return; |
1442 | break; |
1443 | case RQ_None: |
1444 | break; |
1445 | } |
1446 | |
1447 | /// Check whether this dominates another overloaded method, which should |
1448 | /// be suppressed (or vice versa). |
1449 | /// Motivating case is const_iterator begin() const vs iterator begin(). |
1450 | auto &OverloadSet = OverloadMap[std::make_pair( |
1451 | CurContext, Method->getDeclName().getAsOpaqueInteger())]; |
1452 | for (const DeclIndexPair Entry : OverloadSet) { |
1453 | Result &Incumbent = Results[Entry.second]; |
1454 | switch (compareOverloads(*Method, |
1455 | *cast<CXXMethodDecl>(Incumbent.Declaration), |
1456 | ObjectTypeQualifiers, ObjectKind, |
1457 | CurContext->getParentASTContext())) { |
1458 | case OverloadCompare::Dominates: |
1459 | // Replace the dominated overload with this one. |
1460 | // FIXME: if the overload dominates multiple incumbents then we |
1461 | // should remove all. But two overloads is by far the common case. |
1462 | Incumbent = std::move(R); |
1463 | return; |
1464 | case OverloadCompare::Dominated: |
1465 | // This overload can't be called, drop it. |
1466 | return; |
1467 | case OverloadCompare::BothViable: |
1468 | break; |
1469 | } |
1470 | } |
1471 | OverloadSet.Add(Method, Results.size()); |
1472 | } |
1473 | |
1474 | R.FunctionCanBeCall = canFunctionBeCalled(ND: R.getDeclaration(), BaseExprType); |
1475 | |
1476 | // Insert this result into the set of results. |
1477 | Results.push_back(x: R); |
1478 | |
1479 | if (!AsNestedNameSpecifier) |
1480 | MaybeAddConstructorResults(R); |
1481 | } |
1482 | |
1483 | void ResultBuilder::AddResult(Result R) { |
1484 | assert(R.Kind != Result::RK_Declaration && |
1485 | "Declaration results need more context"); |
1486 | Results.push_back(x: R); |
1487 | } |
1488 | |
1489 | /// Enter into a new scope. |
1490 | void ResultBuilder::EnterNewScope() { ShadowMaps.emplace_back(); } |
1491 | |
1492 | /// Exit from the current scope. |
1493 | void ResultBuilder::ExitScope() { |
1494 | ShadowMaps.pop_back(); |
1495 | } |
1496 | |
1497 | /// Determines whether this given declaration will be found by |
1498 | /// ordinary name lookup. |
1499 | bool ResultBuilder::IsOrdinaryName(const NamedDecl *ND) const { |
1500 | ND = ND->getUnderlyingDecl(); |
1501 | |
1502 | // If name lookup finds a local extern declaration, then we are in a |
1503 | // context where it behaves like an ordinary name. |
1504 | unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern; |
1505 | if (SemaRef.getLangOpts().CPlusPlus) |
1506 | IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member; |
1507 | else if (SemaRef.getLangOpts().ObjC) { |
1508 | if (isa<ObjCIvarDecl>(Val: ND)) |
1509 | return true; |
1510 | } |
1511 | |
1512 | return ND->getIdentifierNamespace() & IDNS; |
1513 | } |
1514 | |
1515 | /// Determines whether this given declaration will be found by |
1516 | /// ordinary name lookup but is not a type name. |
1517 | bool ResultBuilder::IsOrdinaryNonTypeName(const NamedDecl *ND) const { |
1518 | ND = ND->getUnderlyingDecl(); |
1519 | if (isa<TypeDecl>(Val: ND)) |
1520 | return false; |
1521 | // Objective-C interfaces names are not filtered by this method because they |
1522 | // can be used in a class property expression. We can still filter out |
1523 | // @class declarations though. |
1524 | if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(Val: ND)) { |
1525 | if (!ID->getDefinition()) |
1526 | return false; |
1527 | } |
1528 | |
1529 | unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern; |
1530 | if (SemaRef.getLangOpts().CPlusPlus) |
1531 | IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member; |
1532 | else if (SemaRef.getLangOpts().ObjC) { |
1533 | if (isa<ObjCIvarDecl>(Val: ND)) |
1534 | return true; |
1535 | } |
1536 | |
1537 | return ND->getIdentifierNamespace() & IDNS; |
1538 | } |
1539 | |
1540 | bool ResultBuilder::IsIntegralConstantValue(const NamedDecl *ND) const { |
1541 | if (!IsOrdinaryNonTypeName(ND)) |
1542 | return false; |
1543 | |
1544 | if (const auto *VD = dyn_cast<ValueDecl>(Val: ND->getUnderlyingDecl())) |
1545 | if (VD->getType()->isIntegralOrEnumerationType()) |
1546 | return true; |
1547 | |
1548 | return false; |
1549 | } |
1550 | |
1551 | /// Determines whether this given declaration will be found by |
1552 | /// ordinary name lookup. |
1553 | bool ResultBuilder::IsOrdinaryNonValueName(const NamedDecl *ND) const { |
1554 | ND = ND->getUnderlyingDecl(); |
1555 | |
1556 | unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern; |
1557 | if (SemaRef.getLangOpts().CPlusPlus) |
1558 | IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace; |
1559 | |
1560 | return (ND->getIdentifierNamespace() & IDNS) && !isa<ValueDecl>(Val: ND) && |
1561 | !isa<FunctionTemplateDecl>(Val: ND) && !isa<ObjCPropertyDecl>(Val: ND); |
1562 | } |
1563 | |
1564 | /// Determines whether the given declaration is suitable as the |
1565 | /// start of a C++ nested-name-specifier, e.g., a class or namespace. |
1566 | bool ResultBuilder::IsNestedNameSpecifier(const NamedDecl *ND) const { |
1567 | // Allow us to find class templates, too. |
1568 | if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(Val: ND)) |
1569 | ND = ClassTemplate->getTemplatedDecl(); |
1570 | |
1571 | return SemaRef.isAcceptableNestedNameSpecifier(SD: ND); |
1572 | } |
1573 | |
1574 | /// Determines whether the given declaration is an enumeration. |
1575 | bool ResultBuilder::IsEnum(const NamedDecl *ND) const { |
1576 | return isa<EnumDecl>(Val: ND); |
1577 | } |
1578 | |
1579 | /// Determines whether the given declaration is a class or struct. |
1580 | bool ResultBuilder::IsClassOrStruct(const NamedDecl *ND) const { |
1581 | // Allow us to find class templates, too. |
1582 | if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(Val: ND)) |
1583 | ND = ClassTemplate->getTemplatedDecl(); |
1584 | |
1585 | // For purposes of this check, interfaces match too. |
1586 | if (const auto *RD = dyn_cast<RecordDecl>(Val: ND)) |
1587 | return RD->getTagKind() == TagTypeKind::Class || |
1588 | RD->getTagKind() == TagTypeKind::Struct || |
1589 | RD->getTagKind() == TagTypeKind::Interface; |
1590 | |
1591 | return false; |
1592 | } |
1593 | |
1594 | /// Determines whether the given declaration is a union. |
1595 | bool ResultBuilder::IsUnion(const NamedDecl *ND) const { |
1596 | // Allow us to find class templates, too. |
1597 | if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(Val: ND)) |
1598 | ND = ClassTemplate->getTemplatedDecl(); |
1599 | |
1600 | if (const auto *RD = dyn_cast<RecordDecl>(Val: ND)) |
1601 | return RD->getTagKind() == TagTypeKind::Union; |
1602 | |
1603 | return false; |
1604 | } |
1605 | |
1606 | /// Determines whether the given declaration is a namespace. |
1607 | bool ResultBuilder::IsNamespace(const NamedDecl *ND) const { |
1608 | return isa<NamespaceDecl>(Val: ND); |
1609 | } |
1610 | |
1611 | /// Determines whether the given declaration is a namespace or |
1612 | /// namespace alias. |
1613 | bool ResultBuilder::IsNamespaceOrAlias(const NamedDecl *ND) const { |
1614 | return isa<NamespaceDecl>(Val: ND->getUnderlyingDecl()); |
1615 | } |
1616 | |
1617 | /// Determines whether the given declaration is a type. |
1618 | bool ResultBuilder::IsType(const NamedDecl *ND) const { |
1619 | ND = ND->getUnderlyingDecl(); |
1620 | return isa<TypeDecl>(Val: ND) || isa<ObjCInterfaceDecl>(Val: ND); |
1621 | } |
1622 | |
1623 | /// Determines which members of a class should be visible via |
1624 | /// "." or "->". Only value declarations, nested name specifiers, and |
1625 | /// using declarations thereof should show up. |
1626 | bool ResultBuilder::IsMember(const NamedDecl *ND) const { |
1627 | ND = ND->getUnderlyingDecl(); |
1628 | return isa<ValueDecl>(Val: ND) || isa<FunctionTemplateDecl>(Val: ND) || |
1629 | isa<ObjCPropertyDecl>(Val: ND); |
1630 | } |
1631 | |
1632 | static bool isObjCReceiverType(ASTContext &C, QualType T) { |
1633 | T = C.getCanonicalType(T); |
1634 | switch (T->getTypeClass()) { |
1635 | case Type::ObjCObject: |
1636 | case Type::ObjCInterface: |
1637 | case Type::ObjCObjectPointer: |
1638 | return true; |
1639 | |
1640 | case Type::Builtin: |
1641 | switch (cast<BuiltinType>(Val&: T)->getKind()) { |
1642 | case BuiltinType::ObjCId: |
1643 | case BuiltinType::ObjCClass: |
1644 | case BuiltinType::ObjCSel: |
1645 | return true; |
1646 | |
1647 | default: |
1648 | break; |
1649 | } |
1650 | return false; |
1651 | |
1652 | default: |
1653 | break; |
1654 | } |
1655 | |
1656 | if (!C.getLangOpts().CPlusPlus) |
1657 | return false; |
1658 | |
1659 | // FIXME: We could perform more analysis here to determine whether a |
1660 | // particular class type has any conversions to Objective-C types. For now, |
1661 | // just accept all class types. |
1662 | return T->isDependentType() || T->isRecordType(); |
1663 | } |
1664 | |
1665 | bool ResultBuilder::IsObjCMessageReceiver(const NamedDecl *ND) const { |
1666 | QualType T = getDeclUsageType(C&: SemaRef.Context, ND); |
1667 | if (T.isNull()) |
1668 | return false; |
1669 | |
1670 | T = SemaRef.Context.getBaseElementType(QT: T); |
1671 | return isObjCReceiverType(C&: SemaRef.Context, T); |
1672 | } |
1673 | |
1674 | bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture( |
1675 | const NamedDecl *ND) const { |
1676 | if (IsObjCMessageReceiver(ND)) |
1677 | return true; |
1678 | |
1679 | const auto *Var = dyn_cast<VarDecl>(Val: ND); |
1680 | if (!Var) |
1681 | return false; |
1682 | |
1683 | return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>(); |
1684 | } |
1685 | |
1686 | bool ResultBuilder::IsObjCCollection(const NamedDecl *ND) const { |
1687 | if ((SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) || |
1688 | (!SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND))) |
1689 | return false; |
1690 | |
1691 | QualType T = getDeclUsageType(C&: SemaRef.Context, ND); |
1692 | if (T.isNull()) |
1693 | return false; |
1694 | |
1695 | T = SemaRef.Context.getBaseElementType(QT: T); |
1696 | return T->isObjCObjectType() || T->isObjCObjectPointerType() || |
1697 | T->isObjCIdType() || |
1698 | (SemaRef.getLangOpts().CPlusPlus && T->isRecordType()); |
1699 | } |
1700 | |
1701 | bool ResultBuilder::IsImpossibleToSatisfy(const NamedDecl *ND) const { |
1702 | return false; |
1703 | } |
1704 | |
1705 | /// Determines whether the given declaration is an Objective-C |
1706 | /// instance variable. |
1707 | bool ResultBuilder::IsObjCIvar(const NamedDecl *ND) const { |
1708 | return isa<ObjCIvarDecl>(Val: ND); |
1709 | } |
1710 | |
1711 | namespace { |
1712 | |
1713 | /// Visible declaration consumer that adds a code-completion result |
1714 | /// for each visible declaration. |
1715 | class CodeCompletionDeclConsumer : public VisibleDeclConsumer { |
1716 | ResultBuilder &Results; |
1717 | DeclContext *InitialLookupCtx; |
1718 | // NamingClass and BaseType are used for access-checking. See |
1719 | // Sema::IsSimplyAccessible for details. |
1720 | CXXRecordDecl *NamingClass; |
1721 | QualType BaseType; |
1722 | std::vector<FixItHint> FixIts; |
1723 | |
1724 | public: |
1725 | CodeCompletionDeclConsumer( |
1726 | ResultBuilder &Results, DeclContext *InitialLookupCtx, |
1727 | QualType BaseType = QualType(), |
1728 | std::vector<FixItHint> FixIts = std::vector<FixItHint>()) |
1729 | : Results(Results), InitialLookupCtx(InitialLookupCtx), |
1730 | FixIts(std::move(FixIts)) { |
1731 | NamingClass = llvm::dyn_cast<CXXRecordDecl>(Val: InitialLookupCtx); |
1732 | // If BaseType was not provided explicitly, emulate implicit 'this->'. |
1733 | if (BaseType.isNull()) { |
1734 | auto ThisType = Results.getSema().getCurrentThisType(); |
1735 | if (!ThisType.isNull()) { |
1736 | assert(ThisType->isPointerType()); |
1737 | BaseType = ThisType->getPointeeType(); |
1738 | if (!NamingClass) |
1739 | NamingClass = BaseType->getAsCXXRecordDecl(); |
1740 | } |
1741 | } |
1742 | this->BaseType = BaseType; |
1743 | } |
1744 | |
1745 | void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx, |
1746 | bool InBaseClass) override { |
1747 | ResultBuilder::Result Result(ND, Results.getBasePriority(ND), nullptr, |
1748 | false, IsAccessible(ND, Ctx), FixIts); |
1749 | Results.AddResult(Result, InitialLookupCtx, Hiding, InBaseClass, BaseType); |
1750 | } |
1751 | |
1752 | void EnteredContext(DeclContext *Ctx) override { |
1753 | Results.addVisitedContext(Ctx); |
1754 | } |
1755 | |
1756 | private: |
1757 | bool IsAccessible(NamedDecl *ND, DeclContext *Ctx) { |
1758 | // Naming class to use for access check. In most cases it was provided |
1759 | // explicitly (e.g. member access (lhs.foo) or qualified lookup (X::)), |
1760 | // for unqualified lookup we fallback to the \p Ctx in which we found the |
1761 | // member. |
1762 | auto *NamingClass = this->NamingClass; |
1763 | QualType BaseType = this->BaseType; |
1764 | if (auto *Cls = llvm::dyn_cast_or_null<CXXRecordDecl>(Val: Ctx)) { |
1765 | if (!NamingClass) |
1766 | NamingClass = Cls; |
1767 | // When we emulate implicit 'this->' in an unqualified lookup, we might |
1768 | // end up with an invalid naming class. In that case, we avoid emulating |
1769 | // 'this->' qualifier to satisfy preconditions of the access checking. |
1770 | if (NamingClass->getCanonicalDecl() != Cls->getCanonicalDecl() && |
1771 | !NamingClass->isDerivedFrom(Base: Cls)) { |
1772 | NamingClass = Cls; |
1773 | BaseType = QualType(); |
1774 | } |
1775 | } else { |
1776 | // The decl was found outside the C++ class, so only ObjC access checks |
1777 | // apply. Those do not rely on NamingClass and BaseType, so we clear them |
1778 | // out. |
1779 | NamingClass = nullptr; |
1780 | BaseType = QualType(); |
1781 | } |
1782 | return Results.getSema().IsSimplyAccessible(Decl: ND, NamingClass, BaseType); |
1783 | } |
1784 | }; |
1785 | } // namespace |
1786 | |
1787 | /// Add type specifiers for the current language as keyword results. |
1788 | static void AddTypeSpecifierResults(const LangOptions &LangOpts, |
1789 | ResultBuilder &Results) { |
1790 | typedef CodeCompletionResult Result; |
1791 | Results.AddResult(R: Result("short", CCP_Type)); |
1792 | Results.AddResult(R: Result("long", CCP_Type)); |
1793 | Results.AddResult(R: Result("signed", CCP_Type)); |
1794 | Results.AddResult(R: Result("unsigned", CCP_Type)); |
1795 | Results.AddResult(R: Result("void", CCP_Type)); |
1796 | Results.AddResult(R: Result("char", CCP_Type)); |
1797 | Results.AddResult(R: Result("int", CCP_Type)); |
1798 | Results.AddResult(R: Result("float", CCP_Type)); |
1799 | Results.AddResult(R: Result("double", CCP_Type)); |
1800 | Results.AddResult(R: Result("enum", CCP_Type)); |
1801 | Results.AddResult(R: Result("struct", CCP_Type)); |
1802 | Results.AddResult(R: Result("union", CCP_Type)); |
1803 | Results.AddResult(R: Result("const", CCP_Type)); |
1804 | Results.AddResult(R: Result("volatile", CCP_Type)); |
1805 | |
1806 | if (LangOpts.C99) { |
1807 | // C99-specific |
1808 | Results.AddResult(R: Result("_Complex", CCP_Type)); |
1809 | if (!LangOpts.C2y) |
1810 | Results.AddResult(R: Result("_Imaginary", CCP_Type)); |
1811 | Results.AddResult(R: Result("_Bool", CCP_Type)); |
1812 | Results.AddResult(R: Result("restrict", CCP_Type)); |
1813 | } |
1814 | |
1815 | CodeCompletionBuilder Builder(Results.getAllocator(), |
1816 | Results.getCodeCompletionTUInfo()); |
1817 | if (LangOpts.CPlusPlus) { |
1818 | // C++-specific |
1819 | Results.AddResult( |
1820 | R: Result("bool", CCP_Type + (LangOpts.ObjC ? CCD_bool_in_ObjC : 0))); |
1821 | Results.AddResult(R: Result("class", CCP_Type)); |
1822 | Results.AddResult(R: Result("wchar_t", CCP_Type)); |
1823 | |
1824 | // typename name |
1825 | Builder.AddTypedTextChunk(Text: "typename"); |
1826 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
1827 | Builder.AddPlaceholderChunk(Placeholder: "name"); |
1828 | Results.AddResult(R: Result(Builder.TakeString())); |
1829 | |
1830 | if (LangOpts.CPlusPlus11) { |
1831 | Results.AddResult(R: Result("auto", CCP_Type)); |
1832 | Results.AddResult(R: Result("char16_t", CCP_Type)); |
1833 | Results.AddResult(R: Result("char32_t", CCP_Type)); |
1834 | |
1835 | Builder.AddTypedTextChunk(Text: "decltype"); |
1836 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
1837 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
1838 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
1839 | Results.AddResult(R: Result(Builder.TakeString())); |
1840 | } |
1841 | |
1842 | if (LangOpts.Char8 || LangOpts.CPlusPlus20) |
1843 | Results.AddResult(R: Result("char8_t", CCP_Type)); |
1844 | } else |
1845 | Results.AddResult(R: Result("__auto_type", CCP_Type)); |
1846 | |
1847 | // GNU keywords |
1848 | if (LangOpts.GNUKeywords) { |
1849 | // FIXME: Enable when we actually support decimal floating point. |
1850 | // Results.AddResult(Result("_Decimal32")); |
1851 | // Results.AddResult(Result("_Decimal64")); |
1852 | // Results.AddResult(Result("_Decimal128")); |
1853 | |
1854 | Builder.AddTypedTextChunk(Text: "typeof"); |
1855 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
1856 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
1857 | Results.AddResult(R: Result(Builder.TakeString())); |
1858 | |
1859 | Builder.AddTypedTextChunk(Text: "typeof"); |
1860 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
1861 | Builder.AddPlaceholderChunk(Placeholder: "type"); |
1862 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
1863 | Results.AddResult(R: Result(Builder.TakeString())); |
1864 | } |
1865 | |
1866 | // Nullability |
1867 | Results.AddResult(R: Result("_Nonnull", CCP_Type)); |
1868 | Results.AddResult(R: Result("_Null_unspecified", CCP_Type)); |
1869 | Results.AddResult(R: Result("_Nullable", CCP_Type)); |
1870 | } |
1871 | |
1872 | static void |
1873 | AddStorageSpecifiers(SemaCodeCompletion::ParserCompletionContext CCC, |
1874 | const LangOptions &LangOpts, ResultBuilder &Results) { |
1875 | typedef CodeCompletionResult Result; |
1876 | // Note: we don't suggest either "auto" or "register", because both |
1877 | // are pointless as storage specifiers. Elsewhere, we suggest "auto" |
1878 | // in C++0x as a type specifier. |
1879 | Results.AddResult(R: Result("extern")); |
1880 | Results.AddResult(R: Result("static")); |
1881 | |
1882 | if (LangOpts.CPlusPlus11) { |
1883 | CodeCompletionAllocator &Allocator = Results.getAllocator(); |
1884 | CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo()); |
1885 | |
1886 | // alignas |
1887 | Builder.AddTypedTextChunk(Text: "alignas"); |
1888 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
1889 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
1890 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
1891 | Results.AddResult(R: Result(Builder.TakeString())); |
1892 | |
1893 | Results.AddResult(R: Result("constexpr")); |
1894 | Results.AddResult(R: Result("thread_local")); |
1895 | } |
1896 | |
1897 | if (LangOpts.CPlusPlus20) |
1898 | Results.AddResult(R: Result("constinit")); |
1899 | } |
1900 | |
1901 | static void |
1902 | AddFunctionSpecifiers(SemaCodeCompletion::ParserCompletionContext CCC, |
1903 | const LangOptions &LangOpts, ResultBuilder &Results) { |
1904 | typedef CodeCompletionResult Result; |
1905 | switch (CCC) { |
1906 | case SemaCodeCompletion::PCC_Class: |
1907 | case SemaCodeCompletion::PCC_MemberTemplate: |
1908 | if (LangOpts.CPlusPlus) { |
1909 | Results.AddResult(R: Result("explicit")); |
1910 | Results.AddResult(R: Result("friend")); |
1911 | Results.AddResult(R: Result("mutable")); |
1912 | Results.AddResult(R: Result("virtual")); |
1913 | } |
1914 | [[fallthrough]]; |
1915 | |
1916 | case SemaCodeCompletion::PCC_ObjCInterface: |
1917 | case SemaCodeCompletion::PCC_ObjCImplementation: |
1918 | case SemaCodeCompletion::PCC_Namespace: |
1919 | case SemaCodeCompletion::PCC_Template: |
1920 | if (LangOpts.CPlusPlus || LangOpts.C99) |
1921 | Results.AddResult(R: Result("inline")); |
1922 | |
1923 | if (LangOpts.CPlusPlus20) |
1924 | Results.AddResult(R: Result("consteval")); |
1925 | break; |
1926 | |
1927 | case SemaCodeCompletion::PCC_ObjCInstanceVariableList: |
1928 | case SemaCodeCompletion::PCC_Expression: |
1929 | case SemaCodeCompletion::PCC_Statement: |
1930 | case SemaCodeCompletion::PCC_TopLevelOrExpression: |
1931 | case SemaCodeCompletion::PCC_ForInit: |
1932 | case SemaCodeCompletion::PCC_Condition: |
1933 | case SemaCodeCompletion::PCC_RecoveryInFunction: |
1934 | case SemaCodeCompletion::PCC_Type: |
1935 | case SemaCodeCompletion::PCC_ParenthesizedExpression: |
1936 | case SemaCodeCompletion::PCC_LocalDeclarationSpecifiers: |
1937 | break; |
1938 | } |
1939 | } |
1940 | |
1941 | static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt); |
1942 | static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt); |
1943 | static void AddObjCVisibilityResults(const LangOptions &LangOpts, |
1944 | ResultBuilder &Results, bool NeedAt); |
1945 | static void AddObjCImplementationResults(const LangOptions &LangOpts, |
1946 | ResultBuilder &Results, bool NeedAt); |
1947 | static void AddObjCInterfaceResults(const LangOptions &LangOpts, |
1948 | ResultBuilder &Results, bool NeedAt); |
1949 | static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt); |
1950 | |
1951 | static void AddTypedefResult(ResultBuilder &Results) { |
1952 | CodeCompletionBuilder Builder(Results.getAllocator(), |
1953 | Results.getCodeCompletionTUInfo()); |
1954 | Builder.AddTypedTextChunk(Text: "typedef"); |
1955 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
1956 | Builder.AddPlaceholderChunk(Placeholder: "type"); |
1957 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
1958 | Builder.AddPlaceholderChunk(Placeholder: "name"); |
1959 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
1960 | Results.AddResult(R: CodeCompletionResult(Builder.TakeString())); |
1961 | } |
1962 | |
1963 | // using name = type |
1964 | static void AddUsingAliasResult(CodeCompletionBuilder &Builder, |
1965 | ResultBuilder &Results) { |
1966 | Builder.AddTypedTextChunk(Text: "using"); |
1967 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
1968 | Builder.AddPlaceholderChunk(Placeholder: "name"); |
1969 | Builder.AddChunk(CK: CodeCompletionString::CK_Equal); |
1970 | Builder.AddPlaceholderChunk(Placeholder: "type"); |
1971 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
1972 | Results.AddResult(R: CodeCompletionResult(Builder.TakeString())); |
1973 | } |
1974 | |
1975 | static bool WantTypesInContext(SemaCodeCompletion::ParserCompletionContext CCC, |
1976 | const LangOptions &LangOpts) { |
1977 | switch (CCC) { |
1978 | case SemaCodeCompletion::PCC_Namespace: |
1979 | case SemaCodeCompletion::PCC_Class: |
1980 | case SemaCodeCompletion::PCC_ObjCInstanceVariableList: |
1981 | case SemaCodeCompletion::PCC_Template: |
1982 | case SemaCodeCompletion::PCC_MemberTemplate: |
1983 | case SemaCodeCompletion::PCC_Statement: |
1984 | case SemaCodeCompletion::PCC_RecoveryInFunction: |
1985 | case SemaCodeCompletion::PCC_Type: |
1986 | case SemaCodeCompletion::PCC_ParenthesizedExpression: |
1987 | case SemaCodeCompletion::PCC_LocalDeclarationSpecifiers: |
1988 | case SemaCodeCompletion::PCC_TopLevelOrExpression: |
1989 | return true; |
1990 | |
1991 | case SemaCodeCompletion::PCC_Expression: |
1992 | case SemaCodeCompletion::PCC_Condition: |
1993 | return LangOpts.CPlusPlus; |
1994 | |
1995 | case SemaCodeCompletion::PCC_ObjCInterface: |
1996 | case SemaCodeCompletion::PCC_ObjCImplementation: |
1997 | return false; |
1998 | |
1999 | case SemaCodeCompletion::PCC_ForInit: |
2000 | return LangOpts.CPlusPlus || LangOpts.ObjC || LangOpts.C99; |
2001 | } |
2002 | |
2003 | llvm_unreachable("Invalid ParserCompletionContext!"); |
2004 | } |
2005 | |
2006 | static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context, |
2007 | const Preprocessor &PP) { |
2008 | PrintingPolicy Policy = Sema::getPrintingPolicy(Ctx: Context, PP); |
2009 | Policy.AnonymousTagLocations = false; |
2010 | Policy.SuppressStrongLifetime = true; |
2011 | Policy.SuppressUnwrittenScope = true; |
2012 | Policy.SuppressScope = true; |
2013 | Policy.CleanUglifiedParameters = true; |
2014 | return Policy; |
2015 | } |
2016 | |
2017 | /// Retrieve a printing policy suitable for code completion. |
2018 | static PrintingPolicy getCompletionPrintingPolicy(Sema &S) { |
2019 | return getCompletionPrintingPolicy(Context: S.Context, PP: S.PP); |
2020 | } |
2021 | |
2022 | /// Retrieve the string representation of the given type as a string |
2023 | /// that has the appropriate lifetime for code completion. |
2024 | /// |
2025 | /// This routine provides a fast path where we provide constant strings for |
2026 | /// common type names. |
2027 | static const char *GetCompletionTypeString(QualType T, ASTContext &Context, |
2028 | const PrintingPolicy &Policy, |
2029 | CodeCompletionAllocator &Allocator) { |
2030 | if (!T.getLocalQualifiers()) { |
2031 | // Built-in type names are constant strings. |
2032 | if (const BuiltinType *BT = dyn_cast<BuiltinType>(Val&: T)) |
2033 | return BT->getNameAsCString(Policy); |
2034 | |
2035 | // Anonymous tag types are constant strings. |
2036 | if (const TagType *TagT = dyn_cast<TagType>(Val&: T)) |
2037 | if (TagDecl *Tag = TagT->getDecl()) |
2038 | if (!Tag->hasNameForLinkage()) { |
2039 | switch (Tag->getTagKind()) { |
2040 | case TagTypeKind::Struct: |
2041 | return "struct <anonymous>"; |
2042 | case TagTypeKind::Interface: |
2043 | return "__interface <anonymous>"; |
2044 | case TagTypeKind::Class: |
2045 | return "class <anonymous>"; |
2046 | case TagTypeKind::Union: |
2047 | return "union <anonymous>"; |
2048 | case TagTypeKind::Enum: |
2049 | return "enum <anonymous>"; |
2050 | } |
2051 | } |
2052 | } |
2053 | |
2054 | // Slow path: format the type as a string. |
2055 | std::string Result; |
2056 | T.getAsStringInternal(Str&: Result, Policy); |
2057 | return Allocator.CopyString(String: Result); |
2058 | } |
2059 | |
2060 | /// Add a completion for "this", if we're in a member function. |
2061 | static void addThisCompletion(Sema &S, ResultBuilder &Results) { |
2062 | QualType ThisTy = S.getCurrentThisType(); |
2063 | if (ThisTy.isNull()) |
2064 | return; |
2065 | |
2066 | CodeCompletionAllocator &Allocator = Results.getAllocator(); |
2067 | CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo()); |
2068 | PrintingPolicy Policy = getCompletionPrintingPolicy(S); |
2069 | Builder.AddResultTypeChunk( |
2070 | ResultType: GetCompletionTypeString(T: ThisTy, Context&: S.Context, Policy, Allocator)); |
2071 | Builder.AddTypedTextChunk(Text: "this"); |
2072 | Results.AddResult(R: CodeCompletionResult(Builder.TakeString())); |
2073 | } |
2074 | |
2075 | static void AddStaticAssertResult(CodeCompletionBuilder &Builder, |
2076 | ResultBuilder &Results, |
2077 | const LangOptions &LangOpts) { |
2078 | if (!LangOpts.CPlusPlus11) |
2079 | return; |
2080 | |
2081 | Builder.AddTypedTextChunk(Text: "static_assert"); |
2082 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2083 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2084 | Builder.AddChunk(CK: CodeCompletionString::CK_Comma); |
2085 | Builder.AddPlaceholderChunk(Placeholder: "message"); |
2086 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2087 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2088 | Results.AddResult(R: CodeCompletionResult(Builder.TakeString())); |
2089 | } |
2090 | |
2091 | static void AddOverrideResults(ResultBuilder &Results, |
2092 | const CodeCompletionContext &CCContext, |
2093 | CodeCompletionBuilder &Builder) { |
2094 | Sema &S = Results.getSema(); |
2095 | const auto *CR = llvm::dyn_cast<CXXRecordDecl>(Val: S.CurContext); |
2096 | // If not inside a class/struct/union return empty. |
2097 | if (!CR) |
2098 | return; |
2099 | // First store overrides within current class. |
2100 | // These are stored by name to make querying fast in the later step. |
2101 | llvm::StringMap<std::vector<FunctionDecl *>> Overrides; |
2102 | for (auto *Method : CR->methods()) { |
2103 | if (!Method->isVirtual() || !Method->getIdentifier()) |
2104 | continue; |
2105 | Overrides[Method->getName()].push_back(Method); |
2106 | } |
2107 | |
2108 | for (const auto &Base : CR->bases()) { |
2109 | const auto *BR = Base.getType().getTypePtr()->getAsCXXRecordDecl(); |
2110 | if (!BR) |
2111 | continue; |
2112 | for (auto *Method : BR->methods()) { |
2113 | if (!Method->isVirtual() || !Method->getIdentifier()) |
2114 | continue; |
2115 | const auto it = Overrides.find(Method->getName()); |
2116 | bool IsOverriden = false; |
2117 | if (it != Overrides.end()) { |
2118 | for (auto *MD : it->second) { |
2119 | // If the method in current body is not an overload of this virtual |
2120 | // function, then it overrides this one. |
2121 | if (!S.IsOverload(MD, Method, false)) { |
2122 | IsOverriden = true; |
2123 | break; |
2124 | } |
2125 | } |
2126 | } |
2127 | if (!IsOverriden) { |
2128 | // Generates a new CodeCompletionResult by taking this function and |
2129 | // converting it into an override declaration with only one chunk in the |
2130 | // final CodeCompletionString as a TypedTextChunk. |
2131 | CodeCompletionResult CCR(Method, 0); |
2132 | PrintingPolicy Policy = |
2133 | getCompletionPrintingPolicy(Context: S.getASTContext(), PP: S.getPreprocessor()); |
2134 | auto *CCS = CCR.createCodeCompletionStringForOverride( |
2135 | PP&: S.getPreprocessor(), Ctx&: S.getASTContext(), Result&: Builder, |
2136 | /*IncludeBriefComments=*/false, CCContext, Policy); |
2137 | Results.AddResult(R: CodeCompletionResult(CCS, Method, CCP_CodePattern)); |
2138 | } |
2139 | } |
2140 | } |
2141 | } |
2142 | |
2143 | /// Add language constructs that show up for "ordinary" names. |
2144 | static void |
2145 | AddOrdinaryNameResults(SemaCodeCompletion::ParserCompletionContext CCC, |
2146 | Scope *S, Sema &SemaRef, ResultBuilder &Results) { |
2147 | CodeCompletionAllocator &Allocator = Results.getAllocator(); |
2148 | CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo()); |
2149 | |
2150 | typedef CodeCompletionResult Result; |
2151 | switch (CCC) { |
2152 | case SemaCodeCompletion::PCC_Namespace: |
2153 | if (SemaRef.getLangOpts().CPlusPlus) { |
2154 | if (Results.includeCodePatterns()) { |
2155 | // namespace <identifier> { declarations } |
2156 | Builder.AddTypedTextChunk(Text: "namespace"); |
2157 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2158 | Builder.AddPlaceholderChunk(Placeholder: "identifier"); |
2159 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2160 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
2161 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2162 | Builder.AddPlaceholderChunk(Placeholder: "declarations"); |
2163 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2164 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
2165 | Results.AddResult(R: Result(Builder.TakeString())); |
2166 | } |
2167 | |
2168 | // namespace identifier = identifier ; |
2169 | Builder.AddTypedTextChunk(Text: "namespace"); |
2170 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2171 | Builder.AddPlaceholderChunk(Placeholder: "name"); |
2172 | Builder.AddChunk(CK: CodeCompletionString::CK_Equal); |
2173 | Builder.AddPlaceholderChunk(Placeholder: "namespace"); |
2174 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2175 | Results.AddResult(R: Result(Builder.TakeString())); |
2176 | |
2177 | // Using directives |
2178 | Builder.AddTypedTextChunk(Text: "using namespace"); |
2179 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2180 | Builder.AddPlaceholderChunk(Placeholder: "identifier"); |
2181 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2182 | Results.AddResult(R: Result(Builder.TakeString())); |
2183 | |
2184 | // asm(string-literal) |
2185 | Builder.AddTypedTextChunk(Text: "asm"); |
2186 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2187 | Builder.AddPlaceholderChunk(Placeholder: "string-literal"); |
2188 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2189 | Results.AddResult(R: Result(Builder.TakeString())); |
2190 | |
2191 | if (Results.includeCodePatterns()) { |
2192 | // Explicit template instantiation |
2193 | Builder.AddTypedTextChunk(Text: "template"); |
2194 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2195 | Builder.AddPlaceholderChunk(Placeholder: "declaration"); |
2196 | Results.AddResult(R: Result(Builder.TakeString())); |
2197 | } else { |
2198 | Results.AddResult(R: Result("template", CodeCompletionResult::RK_Keyword)); |
2199 | } |
2200 | |
2201 | if (SemaRef.getLangOpts().CPlusPlus20 && |
2202 | SemaRef.getLangOpts().CPlusPlusModules) { |
2203 | clang::Module *CurrentModule = SemaRef.getCurrentModule(); |
2204 | if (SemaRef.CurContext->isTranslationUnit()) { |
2205 | /// Global module fragment can only be declared in the beginning of |
2206 | /// the file. CurrentModule should be null in this case. |
2207 | if (!CurrentModule) { |
2208 | // module; |
2209 | Builder.AddTypedTextChunk(Text: "module"); |
2210 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2211 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2212 | Results.AddResult(R: Result(Builder.TakeString())); |
2213 | } |
2214 | |
2215 | /// Named module should be declared in the beginning of the file, |
2216 | /// or after the global module fragment. |
2217 | if (!CurrentModule || |
2218 | CurrentModule->Kind == Module::ExplicitGlobalModuleFragment || |
2219 | CurrentModule->Kind == Module::ImplicitGlobalModuleFragment) { |
2220 | // export module; |
2221 | // module name; |
2222 | Builder.AddTypedTextChunk(Text: "module"); |
2223 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2224 | Builder.AddPlaceholderChunk(Placeholder: "name"); |
2225 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2226 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2227 | Results.AddResult(R: Result(Builder.TakeString())); |
2228 | } |
2229 | |
2230 | /// Import can occur in non module file or after the named module |
2231 | /// declaration. |
2232 | if (!CurrentModule || |
2233 | CurrentModule->Kind == Module::ModuleInterfaceUnit || |
2234 | CurrentModule->Kind == Module::ModulePartitionInterface) { |
2235 | // import name; |
2236 | Builder.AddTypedTextChunk(Text: "import"); |
2237 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2238 | Builder.AddPlaceholderChunk(Placeholder: "name"); |
2239 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2240 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2241 | Results.AddResult(R: Result(Builder.TakeString())); |
2242 | } |
2243 | |
2244 | if (CurrentModule && |
2245 | (CurrentModule->Kind == Module::ModuleInterfaceUnit || |
2246 | CurrentModule->Kind == Module::ModulePartitionInterface)) { |
2247 | // module: private; |
2248 | Builder.AddTypedTextChunk(Text: "module"); |
2249 | Builder.AddChunk(CK: CodeCompletionString::CK_Colon); |
2250 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2251 | Builder.AddTypedTextChunk(Text: "private"); |
2252 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2253 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2254 | Results.AddResult(R: Result(Builder.TakeString())); |
2255 | } |
2256 | } |
2257 | |
2258 | // export |
2259 | if (!CurrentModule || |
2260 | CurrentModule->Kind != Module::ModuleKind::PrivateModuleFragment) |
2261 | Results.AddResult(R: Result("export", CodeCompletionResult::RK_Keyword)); |
2262 | } |
2263 | } |
2264 | |
2265 | if (SemaRef.getLangOpts().ObjC) |
2266 | AddObjCTopLevelResults(Results, NeedAt: true); |
2267 | |
2268 | AddTypedefResult(Results); |
2269 | [[fallthrough]]; |
2270 | |
2271 | case SemaCodeCompletion::PCC_Class: |
2272 | if (SemaRef.getLangOpts().CPlusPlus) { |
2273 | // Using declaration |
2274 | Builder.AddTypedTextChunk(Text: "using"); |
2275 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2276 | Builder.AddPlaceholderChunk(Placeholder: "qualifier"); |
2277 | Builder.AddTextChunk(Text: "::"); |
2278 | Builder.AddPlaceholderChunk(Placeholder: "name"); |
2279 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2280 | Results.AddResult(R: Result(Builder.TakeString())); |
2281 | |
2282 | if (SemaRef.getLangOpts().CPlusPlus11) |
2283 | AddUsingAliasResult(Builder, Results); |
2284 | |
2285 | // using typename qualifier::name (only in a dependent context) |
2286 | if (SemaRef.CurContext->isDependentContext()) { |
2287 | Builder.AddTypedTextChunk(Text: "using typename"); |
2288 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2289 | Builder.AddPlaceholderChunk(Placeholder: "qualifier"); |
2290 | Builder.AddTextChunk(Text: "::"); |
2291 | Builder.AddPlaceholderChunk(Placeholder: "name"); |
2292 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2293 | Results.AddResult(R: Result(Builder.TakeString())); |
2294 | } |
2295 | |
2296 | AddStaticAssertResult(Builder, Results, LangOpts: SemaRef.getLangOpts()); |
2297 | |
2298 | if (CCC == SemaCodeCompletion::PCC_Class) { |
2299 | AddTypedefResult(Results); |
2300 | |
2301 | bool IsNotInheritanceScope = !S->isClassInheritanceScope(); |
2302 | // public: |
2303 | Builder.AddTypedTextChunk(Text: "public"); |
2304 | if (IsNotInheritanceScope && Results.includeCodePatterns()) |
2305 | Builder.AddChunk(CK: CodeCompletionString::CK_Colon); |
2306 | Results.AddResult(R: Result(Builder.TakeString())); |
2307 | |
2308 | // protected: |
2309 | Builder.AddTypedTextChunk(Text: "protected"); |
2310 | if (IsNotInheritanceScope && Results.includeCodePatterns()) |
2311 | Builder.AddChunk(CK: CodeCompletionString::CK_Colon); |
2312 | Results.AddResult(R: Result(Builder.TakeString())); |
2313 | |
2314 | // private: |
2315 | Builder.AddTypedTextChunk(Text: "private"); |
2316 | if (IsNotInheritanceScope && Results.includeCodePatterns()) |
2317 | Builder.AddChunk(CK: CodeCompletionString::CK_Colon); |
2318 | Results.AddResult(R: Result(Builder.TakeString())); |
2319 | |
2320 | // FIXME: This adds override results only if we are at the first word of |
2321 | // the declaration/definition. Also call this from other sides to have |
2322 | // more use-cases. |
2323 | AddOverrideResults(Results, CCContext: CodeCompletionContext::CCC_ClassStructUnion, |
2324 | Builder); |
2325 | } |
2326 | } |
2327 | [[fallthrough]]; |
2328 | |
2329 | case SemaCodeCompletion::PCC_Template: |
2330 | if (SemaRef.getLangOpts().CPlusPlus20 && |
2331 | CCC == SemaCodeCompletion::PCC_Template) |
2332 | Results.AddResult(R: Result("concept", CCP_Keyword)); |
2333 | [[fallthrough]]; |
2334 | |
2335 | case SemaCodeCompletion::PCC_MemberTemplate: |
2336 | if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) { |
2337 | // template < parameters > |
2338 | Builder.AddTypedTextChunk(Text: "template"); |
2339 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftAngle); |
2340 | Builder.AddPlaceholderChunk(Placeholder: "parameters"); |
2341 | Builder.AddChunk(CK: CodeCompletionString::CK_RightAngle); |
2342 | Results.AddResult(R: Result(Builder.TakeString())); |
2343 | } else { |
2344 | Results.AddResult(R: Result("template", CodeCompletionResult::RK_Keyword)); |
2345 | } |
2346 | |
2347 | if (SemaRef.getLangOpts().CPlusPlus20 && |
2348 | (CCC == SemaCodeCompletion::PCC_Template || |
2349 | CCC == SemaCodeCompletion::PCC_MemberTemplate)) |
2350 | Results.AddResult(R: Result("requires", CCP_Keyword)); |
2351 | |
2352 | AddStorageSpecifiers(CCC, LangOpts: SemaRef.getLangOpts(), Results); |
2353 | AddFunctionSpecifiers(CCC, LangOpts: SemaRef.getLangOpts(), Results); |
2354 | break; |
2355 | |
2356 | case SemaCodeCompletion::PCC_ObjCInterface: |
2357 | AddObjCInterfaceResults(LangOpts: SemaRef.getLangOpts(), Results, NeedAt: true); |
2358 | AddStorageSpecifiers(CCC, LangOpts: SemaRef.getLangOpts(), Results); |
2359 | AddFunctionSpecifiers(CCC, LangOpts: SemaRef.getLangOpts(), Results); |
2360 | break; |
2361 | |
2362 | case SemaCodeCompletion::PCC_ObjCImplementation: |
2363 | AddObjCImplementationResults(LangOpts: SemaRef.getLangOpts(), Results, NeedAt: true); |
2364 | AddStorageSpecifiers(CCC, LangOpts: SemaRef.getLangOpts(), Results); |
2365 | AddFunctionSpecifiers(CCC, LangOpts: SemaRef.getLangOpts(), Results); |
2366 | break; |
2367 | |
2368 | case SemaCodeCompletion::PCC_ObjCInstanceVariableList: |
2369 | AddObjCVisibilityResults(LangOpts: SemaRef.getLangOpts(), Results, NeedAt: true); |
2370 | break; |
2371 | |
2372 | case SemaCodeCompletion::PCC_RecoveryInFunction: |
2373 | case SemaCodeCompletion::PCC_TopLevelOrExpression: |
2374 | case SemaCodeCompletion::PCC_Statement: { |
2375 | if (SemaRef.getLangOpts().CPlusPlus11) |
2376 | AddUsingAliasResult(Builder, Results); |
2377 | |
2378 | AddTypedefResult(Results); |
2379 | |
2380 | if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() && |
2381 | SemaRef.getLangOpts().CXXExceptions) { |
2382 | Builder.AddTypedTextChunk(Text: "try"); |
2383 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2384 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
2385 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2386 | Builder.AddPlaceholderChunk(Placeholder: "statements"); |
2387 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2388 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
2389 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2390 | Builder.AddTextChunk(Text: "catch"); |
2391 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2392 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2393 | Builder.AddPlaceholderChunk(Placeholder: "declaration"); |
2394 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2395 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2396 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
2397 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2398 | Builder.AddPlaceholderChunk(Placeholder: "statements"); |
2399 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2400 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
2401 | Results.AddResult(R: Result(Builder.TakeString())); |
2402 | } |
2403 | if (SemaRef.getLangOpts().ObjC) |
2404 | AddObjCStatementResults(Results, NeedAt: true); |
2405 | |
2406 | if (Results.includeCodePatterns()) { |
2407 | // if (condition) { statements } |
2408 | Builder.AddTypedTextChunk(Text: "if"); |
2409 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2410 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2411 | if (SemaRef.getLangOpts().CPlusPlus) |
2412 | Builder.AddPlaceholderChunk(Placeholder: "condition"); |
2413 | else |
2414 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2415 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2416 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2417 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
2418 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2419 | Builder.AddPlaceholderChunk(Placeholder: "statements"); |
2420 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2421 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
2422 | Results.AddResult(R: Result(Builder.TakeString())); |
2423 | |
2424 | // switch (condition) { } |
2425 | Builder.AddTypedTextChunk(Text: "switch"); |
2426 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2427 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2428 | if (SemaRef.getLangOpts().CPlusPlus) |
2429 | Builder.AddPlaceholderChunk(Placeholder: "condition"); |
2430 | else |
2431 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2432 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2433 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2434 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
2435 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2436 | Builder.AddPlaceholderChunk(Placeholder: "cases"); |
2437 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2438 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
2439 | Results.AddResult(R: Result(Builder.TakeString())); |
2440 | } |
2441 | |
2442 | // Switch-specific statements. |
2443 | if (SemaRef.getCurFunction() && |
2444 | !SemaRef.getCurFunction()->SwitchStack.empty()) { |
2445 | // case expression: |
2446 | Builder.AddTypedTextChunk(Text: "case"); |
2447 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2448 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2449 | Builder.AddChunk(CK: CodeCompletionString::CK_Colon); |
2450 | Results.AddResult(R: Result(Builder.TakeString())); |
2451 | |
2452 | // default: |
2453 | Builder.AddTypedTextChunk(Text: "default"); |
2454 | Builder.AddChunk(CK: CodeCompletionString::CK_Colon); |
2455 | Results.AddResult(R: Result(Builder.TakeString())); |
2456 | } |
2457 | |
2458 | if (Results.includeCodePatterns()) { |
2459 | /// while (condition) { statements } |
2460 | Builder.AddTypedTextChunk(Text: "while"); |
2461 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2462 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2463 | if (SemaRef.getLangOpts().CPlusPlus) |
2464 | Builder.AddPlaceholderChunk(Placeholder: "condition"); |
2465 | else |
2466 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2467 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2468 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2469 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
2470 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2471 | Builder.AddPlaceholderChunk(Placeholder: "statements"); |
2472 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2473 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
2474 | Results.AddResult(R: Result(Builder.TakeString())); |
2475 | |
2476 | // do { statements } while ( expression ); |
2477 | Builder.AddTypedTextChunk(Text: "do"); |
2478 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2479 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
2480 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2481 | Builder.AddPlaceholderChunk(Placeholder: "statements"); |
2482 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2483 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
2484 | Builder.AddTextChunk(Text: "while"); |
2485 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2486 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2487 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2488 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2489 | Results.AddResult(R: Result(Builder.TakeString())); |
2490 | |
2491 | // for ( for-init-statement ; condition ; expression ) { statements } |
2492 | Builder.AddTypedTextChunk(Text: "for"); |
2493 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2494 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2495 | if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99) |
2496 | Builder.AddPlaceholderChunk(Placeholder: "init-statement"); |
2497 | else |
2498 | Builder.AddPlaceholderChunk(Placeholder: "init-expression"); |
2499 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2500 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2501 | Builder.AddPlaceholderChunk(Placeholder: "condition"); |
2502 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2503 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2504 | Builder.AddPlaceholderChunk(Placeholder: "inc-expression"); |
2505 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2506 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2507 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
2508 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2509 | Builder.AddPlaceholderChunk(Placeholder: "statements"); |
2510 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2511 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
2512 | Results.AddResult(R: Result(Builder.TakeString())); |
2513 | |
2514 | if (SemaRef.getLangOpts().CPlusPlus11 || SemaRef.getLangOpts().ObjC) { |
2515 | // for ( range_declaration (:|in) range_expression ) { statements } |
2516 | Builder.AddTypedTextChunk(Text: "for"); |
2517 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2518 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2519 | Builder.AddPlaceholderChunk(Placeholder: "range-declaration"); |
2520 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2521 | if (SemaRef.getLangOpts().ObjC) |
2522 | Builder.AddTextChunk(Text: "in"); |
2523 | else |
2524 | Builder.AddChunk(CK: CodeCompletionString::CK_Colon); |
2525 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2526 | Builder.AddPlaceholderChunk(Placeholder: "range-expression"); |
2527 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2528 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2529 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
2530 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2531 | Builder.AddPlaceholderChunk(Placeholder: "statements"); |
2532 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2533 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
2534 | Results.AddResult(R: Result(Builder.TakeString())); |
2535 | } |
2536 | } |
2537 | |
2538 | if (S->getContinueParent()) { |
2539 | // continue ; |
2540 | Builder.AddTypedTextChunk(Text: "continue"); |
2541 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2542 | Results.AddResult(R: Result(Builder.TakeString())); |
2543 | } |
2544 | |
2545 | if (S->getBreakParent()) { |
2546 | // break ; |
2547 | Builder.AddTypedTextChunk(Text: "break"); |
2548 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2549 | Results.AddResult(R: Result(Builder.TakeString())); |
2550 | } |
2551 | |
2552 | // "return expression ;" or "return ;", depending on the return type. |
2553 | QualType ReturnType; |
2554 | if (const auto *Function = dyn_cast<FunctionDecl>(Val: SemaRef.CurContext)) |
2555 | ReturnType = Function->getReturnType(); |
2556 | else if (const auto *Method = dyn_cast<ObjCMethodDecl>(Val: SemaRef.CurContext)) |
2557 | ReturnType = Method->getReturnType(); |
2558 | else if (SemaRef.getCurBlock() && |
2559 | !SemaRef.getCurBlock()->ReturnType.isNull()) |
2560 | ReturnType = SemaRef.getCurBlock()->ReturnType;; |
2561 | if (ReturnType.isNull() || ReturnType->isVoidType()) { |
2562 | Builder.AddTypedTextChunk(Text: "return"); |
2563 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2564 | Results.AddResult(R: Result(Builder.TakeString())); |
2565 | } else { |
2566 | assert(!ReturnType.isNull()); |
2567 | // "return expression ;" |
2568 | Builder.AddTypedTextChunk(Text: "return"); |
2569 | Builder.AddChunk(CK: clang::CodeCompletionString::CK_HorizontalSpace); |
2570 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2571 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2572 | Results.AddResult(R: Result(Builder.TakeString())); |
2573 | // "co_return expression ;" for coroutines(C++20). |
2574 | if (SemaRef.getLangOpts().CPlusPlus20) { |
2575 | Builder.AddTypedTextChunk(Text: "co_return"); |
2576 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2577 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2578 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2579 | Results.AddResult(R: Result(Builder.TakeString())); |
2580 | } |
2581 | // When boolean, also add 'return true;' and 'return false;'. |
2582 | if (ReturnType->isBooleanType()) { |
2583 | Builder.AddTypedTextChunk(Text: "return true"); |
2584 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2585 | Results.AddResult(R: Result(Builder.TakeString())); |
2586 | |
2587 | Builder.AddTypedTextChunk(Text: "return false"); |
2588 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2589 | Results.AddResult(R: Result(Builder.TakeString())); |
2590 | } |
2591 | // For pointers, suggest 'return nullptr' in C++. |
2592 | if (SemaRef.getLangOpts().CPlusPlus11 && |
2593 | (ReturnType->isPointerType() || ReturnType->isMemberPointerType())) { |
2594 | Builder.AddTypedTextChunk(Text: "return nullptr"); |
2595 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2596 | Results.AddResult(R: Result(Builder.TakeString())); |
2597 | } |
2598 | } |
2599 | |
2600 | // goto identifier ; |
2601 | Builder.AddTypedTextChunk(Text: "goto"); |
2602 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2603 | Builder.AddPlaceholderChunk(Placeholder: "label"); |
2604 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2605 | Results.AddResult(R: Result(Builder.TakeString())); |
2606 | |
2607 | // Using directives |
2608 | Builder.AddTypedTextChunk(Text: "using namespace"); |
2609 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2610 | Builder.AddPlaceholderChunk(Placeholder: "identifier"); |
2611 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2612 | Results.AddResult(R: Result(Builder.TakeString())); |
2613 | |
2614 | AddStaticAssertResult(Builder, Results, LangOpts: SemaRef.getLangOpts()); |
2615 | } |
2616 | [[fallthrough]]; |
2617 | |
2618 | // Fall through (for statement expressions). |
2619 | case SemaCodeCompletion::PCC_ForInit: |
2620 | case SemaCodeCompletion::PCC_Condition: |
2621 | AddStorageSpecifiers(CCC, LangOpts: SemaRef.getLangOpts(), Results); |
2622 | // Fall through: conditions and statements can have expressions. |
2623 | [[fallthrough]]; |
2624 | |
2625 | case SemaCodeCompletion::PCC_ParenthesizedExpression: |
2626 | if (SemaRef.getLangOpts().ObjCAutoRefCount && |
2627 | CCC == SemaCodeCompletion::PCC_ParenthesizedExpression) { |
2628 | // (__bridge <type>)<expression> |
2629 | Builder.AddTypedTextChunk(Text: "__bridge"); |
2630 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2631 | Builder.AddPlaceholderChunk(Placeholder: "type"); |
2632 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2633 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2634 | Results.AddResult(R: Result(Builder.TakeString())); |
2635 | |
2636 | // (__bridge_transfer <Objective-C type>)<expression> |
2637 | Builder.AddTypedTextChunk(Text: "__bridge_transfer"); |
2638 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2639 | Builder.AddPlaceholderChunk(Placeholder: "Objective-C type"); |
2640 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2641 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2642 | Results.AddResult(R: Result(Builder.TakeString())); |
2643 | |
2644 | // (__bridge_retained <CF type>)<expression> |
2645 | Builder.AddTypedTextChunk(Text: "__bridge_retained"); |
2646 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2647 | Builder.AddPlaceholderChunk(Placeholder: "CF type"); |
2648 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2649 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2650 | Results.AddResult(R: Result(Builder.TakeString())); |
2651 | } |
2652 | // Fall through |
2653 | [[fallthrough]]; |
2654 | |
2655 | case SemaCodeCompletion::PCC_Expression: { |
2656 | if (SemaRef.getLangOpts().CPlusPlus) { |
2657 | // 'this', if we're in a non-static member function. |
2658 | addThisCompletion(S&: SemaRef, Results); |
2659 | |
2660 | // true |
2661 | Builder.AddResultTypeChunk(ResultType: "bool"); |
2662 | Builder.AddTypedTextChunk(Text: "true"); |
2663 | Results.AddResult(R: Result(Builder.TakeString())); |
2664 | |
2665 | // false |
2666 | Builder.AddResultTypeChunk(ResultType: "bool"); |
2667 | Builder.AddTypedTextChunk(Text: "false"); |
2668 | Results.AddResult(R: Result(Builder.TakeString())); |
2669 | |
2670 | if (SemaRef.getLangOpts().RTTI) { |
2671 | // dynamic_cast < type-id > ( expression ) |
2672 | Builder.AddTypedTextChunk(Text: "dynamic_cast"); |
2673 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftAngle); |
2674 | Builder.AddPlaceholderChunk(Placeholder: "type"); |
2675 | Builder.AddChunk(CK: CodeCompletionString::CK_RightAngle); |
2676 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2677 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2678 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2679 | Results.AddResult(R: Result(Builder.TakeString())); |
2680 | } |
2681 | |
2682 | // static_cast < type-id > ( expression ) |
2683 | Builder.AddTypedTextChunk(Text: "static_cast"); |
2684 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftAngle); |
2685 | Builder.AddPlaceholderChunk(Placeholder: "type"); |
2686 | Builder.AddChunk(CK: CodeCompletionString::CK_RightAngle); |
2687 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2688 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2689 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2690 | Results.AddResult(R: Result(Builder.TakeString())); |
2691 | |
2692 | // reinterpret_cast < type-id > ( expression ) |
2693 | Builder.AddTypedTextChunk(Text: "reinterpret_cast"); |
2694 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftAngle); |
2695 | Builder.AddPlaceholderChunk(Placeholder: "type"); |
2696 | Builder.AddChunk(CK: CodeCompletionString::CK_RightAngle); |
2697 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2698 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2699 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2700 | Results.AddResult(R: Result(Builder.TakeString())); |
2701 | |
2702 | // const_cast < type-id > ( expression ) |
2703 | Builder.AddTypedTextChunk(Text: "const_cast"); |
2704 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftAngle); |
2705 | Builder.AddPlaceholderChunk(Placeholder: "type"); |
2706 | Builder.AddChunk(CK: CodeCompletionString::CK_RightAngle); |
2707 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2708 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2709 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2710 | Results.AddResult(R: Result(Builder.TakeString())); |
2711 | |
2712 | if (SemaRef.getLangOpts().RTTI) { |
2713 | // typeid ( expression-or-type ) |
2714 | Builder.AddResultTypeChunk(ResultType: "std::type_info"); |
2715 | Builder.AddTypedTextChunk(Text: "typeid"); |
2716 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2717 | Builder.AddPlaceholderChunk(Placeholder: "expression-or-type"); |
2718 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2719 | Results.AddResult(R: Result(Builder.TakeString())); |
2720 | } |
2721 | |
2722 | // new T ( ... ) |
2723 | Builder.AddTypedTextChunk(Text: "new"); |
2724 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2725 | Builder.AddPlaceholderChunk(Placeholder: "type"); |
2726 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2727 | Builder.AddPlaceholderChunk(Placeholder: "expressions"); |
2728 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2729 | Results.AddResult(R: Result(Builder.TakeString())); |
2730 | |
2731 | // new T [ ] ( ... ) |
2732 | Builder.AddTypedTextChunk(Text: "new"); |
2733 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2734 | Builder.AddPlaceholderChunk(Placeholder: "type"); |
2735 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBracket); |
2736 | Builder.AddPlaceholderChunk(Placeholder: "size"); |
2737 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBracket); |
2738 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2739 | Builder.AddPlaceholderChunk(Placeholder: "expressions"); |
2740 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2741 | Results.AddResult(R: Result(Builder.TakeString())); |
2742 | |
2743 | // delete expression |
2744 | Builder.AddResultTypeChunk(ResultType: "void"); |
2745 | Builder.AddTypedTextChunk(Text: "delete"); |
2746 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2747 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2748 | Results.AddResult(R: Result(Builder.TakeString())); |
2749 | |
2750 | // delete [] expression |
2751 | Builder.AddResultTypeChunk(ResultType: "void"); |
2752 | Builder.AddTypedTextChunk(Text: "delete"); |
2753 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2754 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBracket); |
2755 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBracket); |
2756 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2757 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2758 | Results.AddResult(R: Result(Builder.TakeString())); |
2759 | |
2760 | if (SemaRef.getLangOpts().CXXExceptions) { |
2761 | // throw expression |
2762 | Builder.AddResultTypeChunk(ResultType: "void"); |
2763 | Builder.AddTypedTextChunk(Text: "throw"); |
2764 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2765 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2766 | Results.AddResult(R: Result(Builder.TakeString())); |
2767 | } |
2768 | |
2769 | // FIXME: Rethrow? |
2770 | |
2771 | if (SemaRef.getLangOpts().CPlusPlus11) { |
2772 | // nullptr |
2773 | Builder.AddResultTypeChunk(ResultType: "std::nullptr_t"); |
2774 | Builder.AddTypedTextChunk(Text: "nullptr"); |
2775 | Results.AddResult(R: Result(Builder.TakeString())); |
2776 | |
2777 | // alignof |
2778 | Builder.AddResultTypeChunk(ResultType: "size_t"); |
2779 | Builder.AddTypedTextChunk(Text: "alignof"); |
2780 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2781 | Builder.AddPlaceholderChunk(Placeholder: "type"); |
2782 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2783 | Results.AddResult(R: Result(Builder.TakeString())); |
2784 | |
2785 | // noexcept |
2786 | Builder.AddResultTypeChunk(ResultType: "bool"); |
2787 | Builder.AddTypedTextChunk(Text: "noexcept"); |
2788 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2789 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2790 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2791 | Results.AddResult(R: Result(Builder.TakeString())); |
2792 | |
2793 | // sizeof... expression |
2794 | Builder.AddResultTypeChunk(ResultType: "size_t"); |
2795 | Builder.AddTypedTextChunk(Text: "sizeof..."); |
2796 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2797 | Builder.AddPlaceholderChunk(Placeholder: "parameter-pack"); |
2798 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2799 | Results.AddResult(R: Result(Builder.TakeString())); |
2800 | } |
2801 | |
2802 | if (SemaRef.getLangOpts().CPlusPlus20) { |
2803 | // co_await expression |
2804 | Builder.AddTypedTextChunk(Text: "co_await"); |
2805 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2806 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2807 | Results.AddResult(R: Result(Builder.TakeString())); |
2808 | |
2809 | // co_yield expression |
2810 | Builder.AddTypedTextChunk(Text: "co_yield"); |
2811 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2812 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2813 | Results.AddResult(R: Result(Builder.TakeString())); |
2814 | |
2815 | // requires (parameters) { requirements } |
2816 | Builder.AddResultTypeChunk(ResultType: "bool"); |
2817 | Builder.AddTypedTextChunk(Text: "requires"); |
2818 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2819 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2820 | Builder.AddPlaceholderChunk(Placeholder: "parameters"); |
2821 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2822 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2823 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
2824 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2825 | Builder.AddPlaceholderChunk(Placeholder: "requirements"); |
2826 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
2827 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
2828 | Results.AddResult(R: Result(Builder.TakeString())); |
2829 | |
2830 | if (SemaRef.CurContext->isRequiresExprBody()) { |
2831 | // requires expression ; |
2832 | Builder.AddTypedTextChunk(Text: "requires"); |
2833 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
2834 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
2835 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
2836 | Results.AddResult(R: Result(Builder.TakeString())); |
2837 | } |
2838 | } |
2839 | } |
2840 | |
2841 | if (SemaRef.getLangOpts().ObjC) { |
2842 | // Add "super", if we're in an Objective-C class with a superclass. |
2843 | if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) { |
2844 | // The interface can be NULL. |
2845 | if (ObjCInterfaceDecl *ID = Method->getClassInterface()) |
2846 | if (ID->getSuperClass()) { |
2847 | std::string SuperType; |
2848 | SuperType = ID->getSuperClass()->getNameAsString(); |
2849 | if (Method->isInstanceMethod()) |
2850 | SuperType += " *"; |
2851 | |
2852 | Builder.AddResultTypeChunk(ResultType: Allocator.CopyString(String: SuperType)); |
2853 | Builder.AddTypedTextChunk(Text: "super"); |
2854 | Results.AddResult(R: Result(Builder.TakeString())); |
2855 | } |
2856 | } |
2857 | |
2858 | AddObjCExpressionResults(Results, NeedAt: true); |
2859 | } |
2860 | |
2861 | if (SemaRef.getLangOpts().C11) { |
2862 | // _Alignof |
2863 | Builder.AddResultTypeChunk(ResultType: "size_t"); |
2864 | if (SemaRef.PP.isMacroDefined(Id: "alignof")) |
2865 | Builder.AddTypedTextChunk(Text: "alignof"); |
2866 | else |
2867 | Builder.AddTypedTextChunk(Text: "_Alignof"); |
2868 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2869 | Builder.AddPlaceholderChunk(Placeholder: "type"); |
2870 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2871 | Results.AddResult(R: Result(Builder.TakeString())); |
2872 | } |
2873 | |
2874 | if (SemaRef.getLangOpts().C23) { |
2875 | // nullptr |
2876 | Builder.AddResultTypeChunk(ResultType: "nullptr_t"); |
2877 | Builder.AddTypedTextChunk(Text: "nullptr"); |
2878 | Results.AddResult(R: Result(Builder.TakeString())); |
2879 | } |
2880 | |
2881 | // sizeof expression |
2882 | Builder.AddResultTypeChunk(ResultType: "size_t"); |
2883 | Builder.AddTypedTextChunk(Text: "sizeof"); |
2884 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
2885 | Builder.AddPlaceholderChunk(Placeholder: "expression-or-type"); |
2886 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
2887 | Results.AddResult(R: Result(Builder.TakeString())); |
2888 | break; |
2889 | } |
2890 | |
2891 | case SemaCodeCompletion::PCC_Type: |
2892 | case SemaCodeCompletion::PCC_LocalDeclarationSpecifiers: |
2893 | break; |
2894 | } |
2895 | |
2896 | if (WantTypesInContext(CCC, LangOpts: SemaRef.getLangOpts())) |
2897 | AddTypeSpecifierResults(LangOpts: SemaRef.getLangOpts(), Results); |
2898 | |
2899 | if (SemaRef.getLangOpts().CPlusPlus && CCC != SemaCodeCompletion::PCC_Type) |
2900 | Results.AddResult(R: Result("operator")); |
2901 | } |
2902 | |
2903 | /// If the given declaration has an associated type, add it as a result |
2904 | /// type chunk. |
2905 | static void AddResultTypeChunk(ASTContext &Context, |
2906 | const PrintingPolicy &Policy, |
2907 | const NamedDecl *ND, QualType BaseType, |
2908 | CodeCompletionBuilder &Result) { |
2909 | if (!ND) |
2910 | return; |
2911 | |
2912 | // Skip constructors and conversion functions, which have their return types |
2913 | // built into their names. |
2914 | if (isConstructor(ND) || isa<CXXConversionDecl>(Val: ND)) |
2915 | return; |
2916 | |
2917 | // Determine the type of the declaration (if it has a type). |
2918 | QualType T; |
2919 | if (const FunctionDecl *Function = ND->getAsFunction()) |
2920 | T = Function->getReturnType(); |
2921 | else if (const auto *Method = dyn_cast<ObjCMethodDecl>(Val: ND)) { |
2922 | if (!BaseType.isNull()) |
2923 | T = Method->getSendResultType(receiverType: BaseType); |
2924 | else |
2925 | T = Method->getReturnType(); |
2926 | } else if (const auto *Enumerator = dyn_cast<EnumConstantDecl>(Val: ND)) { |
2927 | T = Context.getTypeDeclType(Decl: cast<TypeDecl>(Enumerator->getDeclContext())); |
2928 | T = clang::TypeName::getFullyQualifiedType(QT: T, Ctx: Context); |
2929 | } else if (isa<UnresolvedUsingValueDecl>(Val: ND)) { |
2930 | /* Do nothing: ignore unresolved using declarations*/ |
2931 | } else if (const auto *Ivar = dyn_cast<ObjCIvarDecl>(Val: ND)) { |
2932 | if (!BaseType.isNull()) |
2933 | T = Ivar->getUsageType(objectType: BaseType); |
2934 | else |
2935 | T = Ivar->getType(); |
2936 | } else if (const auto *Value = dyn_cast<ValueDecl>(Val: ND)) { |
2937 | T = Value->getType(); |
2938 | } else if (const auto *Property = dyn_cast<ObjCPropertyDecl>(Val: ND)) { |
2939 | if (!BaseType.isNull()) |
2940 | T = Property->getUsageType(objectType: BaseType); |
2941 | else |
2942 | T = Property->getType(); |
2943 | } |
2944 | |
2945 | if (T.isNull() || Context.hasSameType(T, Context.DependentTy)) |
2946 | return; |
2947 | |
2948 | Result.AddResultTypeChunk( |
2949 | ResultType: GetCompletionTypeString(T, Context, Policy, Allocator&: Result.getAllocator())); |
2950 | } |
2951 | |
2952 | static void MaybeAddSentinel(Preprocessor &PP, |
2953 | const NamedDecl *FunctionOrMethod, |
2954 | CodeCompletionBuilder &Result) { |
2955 | if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>()) |
2956 | if (Sentinel->getSentinel() == 0) { |
2957 | if (PP.getLangOpts().ObjC && PP.isMacroDefined(Id: "nil")) |
2958 | Result.AddTextChunk(Text: ", nil"); |
2959 | else if (PP.isMacroDefined(Id: "NULL")) |
2960 | Result.AddTextChunk(Text: ", NULL"); |
2961 | else |
2962 | Result.AddTextChunk(Text: ", (void*)0"); |
2963 | } |
2964 | } |
2965 | |
2966 | static std::string formatObjCParamQualifiers(unsigned ObjCQuals, |
2967 | QualType &Type) { |
2968 | std::string Result; |
2969 | if (ObjCQuals & Decl::OBJC_TQ_In) |
2970 | Result += "in "; |
2971 | else if (ObjCQuals & Decl::OBJC_TQ_Inout) |
2972 | Result += "inout "; |
2973 | else if (ObjCQuals & Decl::OBJC_TQ_Out) |
2974 | Result += "out "; |
2975 | if (ObjCQuals & Decl::OBJC_TQ_Bycopy) |
2976 | Result += "bycopy "; |
2977 | else if (ObjCQuals & Decl::OBJC_TQ_Byref) |
2978 | Result += "byref "; |
2979 | if (ObjCQuals & Decl::OBJC_TQ_Oneway) |
2980 | Result += "oneway "; |
2981 | if (ObjCQuals & Decl::OBJC_TQ_CSNullability) { |
2982 | if (auto nullability = AttributedType::stripOuterNullability(T&: Type)) { |
2983 | switch (*nullability) { |
2984 | case NullabilityKind::NonNull: |
2985 | Result += "nonnull "; |
2986 | break; |
2987 | |
2988 | case NullabilityKind::Nullable: |
2989 | Result += "nullable "; |
2990 | break; |
2991 | |
2992 | case NullabilityKind::Unspecified: |
2993 | Result += "null_unspecified "; |
2994 | break; |
2995 | |
2996 | case NullabilityKind::NullableResult: |
2997 | llvm_unreachable("Not supported as a context-sensitive keyword!"); |
2998 | break; |
2999 | } |
3000 | } |
3001 | } |
3002 | return Result; |
3003 | } |
3004 | |
3005 | /// Tries to find the most appropriate type location for an Objective-C |
3006 | /// block placeholder. |
3007 | /// |
3008 | /// This function ignores things like typedefs and qualifiers in order to |
3009 | /// present the most relevant and accurate block placeholders in code completion |
3010 | /// results. |
3011 | static void findTypeLocationForBlockDecl(const TypeSourceInfo *TSInfo, |
3012 | FunctionTypeLoc &Block, |
3013 | FunctionProtoTypeLoc &BlockProto, |
3014 | bool SuppressBlock = false) { |
3015 | if (!TSInfo) |
3016 | return; |
3017 | TypeLoc TL = TSInfo->getTypeLoc().getUnqualifiedLoc(); |
3018 | while (true) { |
3019 | // Look through typedefs. |
3020 | if (!SuppressBlock) { |
3021 | if (TypedefTypeLoc TypedefTL = TL.getAsAdjusted<TypedefTypeLoc>()) { |
3022 | if (TypeSourceInfo *InnerTSInfo = |
3023 | TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) { |
3024 | TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc(); |
3025 | continue; |
3026 | } |
3027 | } |
3028 | |
3029 | // Look through qualified types |
3030 | if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) { |
3031 | TL = QualifiedTL.getUnqualifiedLoc(); |
3032 | continue; |
3033 | } |
3034 | |
3035 | if (AttributedTypeLoc AttrTL = TL.getAs<AttributedTypeLoc>()) { |
3036 | TL = AttrTL.getModifiedLoc(); |
3037 | continue; |
3038 | } |
3039 | } |
3040 | |
3041 | // Try to get the function prototype behind the block pointer type, |
3042 | // then we're done. |
3043 | if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) { |
3044 | TL = BlockPtr.getPointeeLoc().IgnoreParens(); |
3045 | Block = TL.getAs<FunctionTypeLoc>(); |
3046 | BlockProto = TL.getAs<FunctionProtoTypeLoc>(); |
3047 | } |
3048 | break; |
3049 | } |
3050 | } |
3051 | |
3052 | static std::string formatBlockPlaceholder( |
3053 | const PrintingPolicy &Policy, const NamedDecl *BlockDecl, |
3054 | FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto, |
3055 | bool SuppressBlockName = false, bool SuppressBlock = false, |
3056 | std::optional<ArrayRef<QualType>> ObjCSubsts = std::nullopt); |
3057 | |
3058 | static std::string FormatFunctionParameter( |
3059 | const PrintingPolicy &Policy, const DeclaratorDecl *Param, |
3060 | bool SuppressName = false, bool SuppressBlock = false, |
3061 | std::optional<ArrayRef<QualType>> ObjCSubsts = std::nullopt) { |
3062 | // Params are unavailable in FunctionTypeLoc if the FunctionType is invalid. |
3063 | // It would be better to pass in the param Type, which is usually available. |
3064 | // But this case is rare, so just pretend we fell back to int as elsewhere. |
3065 | if (!Param) |
3066 | return "int"; |
3067 | Decl::ObjCDeclQualifier ObjCQual = Decl::OBJC_TQ_None; |
3068 | if (const auto *PVD = dyn_cast<ParmVarDecl>(Val: Param)) |
3069 | ObjCQual = PVD->getObjCDeclQualifier(); |
3070 | bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext()); |
3071 | if (Param->getType()->isDependentType() || |
3072 | !Param->getType()->isBlockPointerType()) { |
3073 | // The argument for a dependent or non-block parameter is a placeholder |
3074 | // containing that parameter's type. |
3075 | std::string Result; |
3076 | |
3077 | if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName) |
3078 | Result = std::string(Param->getIdentifier()->deuglifiedName()); |
3079 | |
3080 | QualType Type = Param->getType(); |
3081 | if (ObjCSubsts) |
3082 | Type = Type.substObjCTypeArgs(ctx&: Param->getASTContext(), typeArgs: *ObjCSubsts, |
3083 | context: ObjCSubstitutionContext::Parameter); |
3084 | if (ObjCMethodParam) { |
3085 | Result = "("+ formatObjCParamQualifiers(ObjCQuals: ObjCQual, Type); |
3086 | Result += Type.getAsString(Policy) + ")"; |
3087 | if (Param->getIdentifier() && !SuppressName) |
3088 | Result += Param->getIdentifier()->deuglifiedName(); |
3089 | } else { |
3090 | Type.getAsStringInternal(Str&: Result, Policy); |
3091 | } |
3092 | return Result; |
3093 | } |
3094 | |
3095 | // The argument for a block pointer parameter is a block literal with |
3096 | // the appropriate type. |
3097 | FunctionTypeLoc Block; |
3098 | FunctionProtoTypeLoc BlockProto; |
3099 | findTypeLocationForBlockDecl(TSInfo: Param->getTypeSourceInfo(), Block, BlockProto, |
3100 | SuppressBlock); |
3101 | // Try to retrieve the block type information from the property if this is a |
3102 | // parameter in a setter. |
3103 | if (!Block && ObjCMethodParam && |
3104 | cast<ObjCMethodDecl>(Param->getDeclContext())->isPropertyAccessor()) { |
3105 | if (const auto *PD = cast<ObjCMethodDecl>(Param->getDeclContext()) |
3106 | ->findPropertyDecl(/*CheckOverrides=*/false)) |
3107 | findTypeLocationForBlockDecl(PD->getTypeSourceInfo(), Block, BlockProto, |
3108 | SuppressBlock); |
3109 | } |
3110 | |
3111 | if (!Block) { |
3112 | // We were unable to find a FunctionProtoTypeLoc with parameter names |
3113 | // for the block; just use the parameter type as a placeholder. |
3114 | std::string Result; |
3115 | if (!ObjCMethodParam && Param->getIdentifier()) |
3116 | Result = std::string(Param->getIdentifier()->deuglifiedName()); |
3117 | |
3118 | QualType Type = Param->getType().getUnqualifiedType(); |
3119 | |
3120 | if (ObjCMethodParam) { |
3121 | Result = Type.getAsString(Policy); |
3122 | std::string Quals = formatObjCParamQualifiers(ObjCQuals: ObjCQual, Type); |
3123 | if (!Quals.empty()) |
3124 | Result = "("+ Quals + " "+ Result + ")"; |
3125 | if (Result.back() != ')') |
3126 | Result += " "; |
3127 | if (Param->getIdentifier()) |
3128 | Result += Param->getIdentifier()->deuglifiedName(); |
3129 | } else { |
3130 | Type.getAsStringInternal(Str&: Result, Policy); |
3131 | } |
3132 | |
3133 | return Result; |
3134 | } |
3135 | |
3136 | // We have the function prototype behind the block pointer type, as it was |
3137 | // written in the source. |
3138 | return formatBlockPlaceholder(Policy, Param, Block, BlockProto, |
3139 | /*SuppressBlockName=*/false, SuppressBlock, |
3140 | ObjCSubsts); |
3141 | } |
3142 | |
3143 | /// Returns a placeholder string that corresponds to an Objective-C block |
3144 | /// declaration. |
3145 | /// |
3146 | /// \param BlockDecl A declaration with an Objective-C block type. |
3147 | /// |
3148 | /// \param Block The most relevant type location for that block type. |
3149 | /// |
3150 | /// \param SuppressBlockName Determines whether or not the name of the block |
3151 | /// declaration is included in the resulting string. |
3152 | static std::string |
3153 | formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl, |
3154 | FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto, |
3155 | bool SuppressBlockName, bool SuppressBlock, |
3156 | std::optional<ArrayRef<QualType>> ObjCSubsts) { |
3157 | std::string Result; |
3158 | QualType ResultType = Block.getTypePtr()->getReturnType(); |
3159 | if (ObjCSubsts) |
3160 | ResultType = |
3161 | ResultType.substObjCTypeArgs(ctx&: BlockDecl->getASTContext(), typeArgs: *ObjCSubsts, |
3162 | context: ObjCSubstitutionContext::Result); |
3163 | if (!ResultType->isVoidType() || SuppressBlock) |
3164 | ResultType.getAsStringInternal(Str&: Result, Policy); |
3165 | |
3166 | // Format the parameter list. |
3167 | std::string Params; |
3168 | if (!BlockProto || Block.getNumParams() == 0) { |
3169 | if (BlockProto && BlockProto.getTypePtr()->isVariadic()) |
3170 | Params = "(...)"; |
3171 | else |
3172 | Params = "(void)"; |
3173 | } else { |
3174 | Params += "("; |
3175 | for (unsigned I = 0, N = Block.getNumParams(); I != N; ++I) { |
3176 | if (I) |
3177 | Params += ", "; |
3178 | Params += FormatFunctionParameter(Policy, Block.getParam(i: I), |
3179 | /*SuppressName=*/false, |
3180 | /*SuppressBlock=*/true, ObjCSubsts); |
3181 | |
3182 | if (I == N - 1 && BlockProto.getTypePtr()->isVariadic()) |
3183 | Params += ", ..."; |
3184 | } |
3185 | Params += ")"; |
3186 | } |
3187 | |
3188 | if (SuppressBlock) { |
3189 | // Format as a parameter. |
3190 | Result = Result + " (^"; |
3191 | if (!SuppressBlockName && BlockDecl->getIdentifier()) |
3192 | Result += BlockDecl->getIdentifier()->getName(); |
3193 | Result += ")"; |
3194 | Result += Params; |
3195 | } else { |
3196 | // Format as a block literal argument. |
3197 | Result = '^' + Result; |
3198 | Result += Params; |
3199 | |
3200 | if (!SuppressBlockName && BlockDecl->getIdentifier()) |
3201 | Result += BlockDecl->getIdentifier()->getName(); |
3202 | } |
3203 | |
3204 | return Result; |
3205 | } |
3206 | |
3207 | static std::string GetDefaultValueString(const ParmVarDecl *Param, |
3208 | const SourceManager &SM, |
3209 | const LangOptions &LangOpts) { |
3210 | const SourceRange SrcRange = Param->getDefaultArgRange(); |
3211 | CharSourceRange CharSrcRange = CharSourceRange::getTokenRange(R: SrcRange); |
3212 | bool Invalid = CharSrcRange.isInvalid(); |
3213 | if (Invalid) |
3214 | return ""; |
3215 | StringRef srcText = |
3216 | Lexer::getSourceText(Range: CharSrcRange, SM, LangOpts, Invalid: &Invalid); |
3217 | if (Invalid) |
3218 | return ""; |
3219 | |
3220 | if (srcText.empty() || srcText == "=") { |
3221 | // Lexer can't determine the value. |
3222 | // This happens if the code is incorrect (for example class is forward |
3223 | // declared). |
3224 | return ""; |
3225 | } |
3226 | std::string DefValue(srcText.str()); |
3227 | // FIXME: remove this check if the Lexer::getSourceText value is fixed and |
3228 | // this value always has (or always does not have) '=' in front of it |
3229 | if (DefValue.at(n: 0) != '=') { |
3230 | // If we don't have '=' in front of value. |
3231 | // Lexer returns built-in types values without '=' and user-defined types |
3232 | // values with it. |
3233 | return " = "+ DefValue; |
3234 | } |
3235 | return " "+ DefValue; |
3236 | } |
3237 | |
3238 | /// Add function parameter chunks to the given code completion string. |
3239 | static void AddFunctionParameterChunks(Preprocessor &PP, |
3240 | const PrintingPolicy &Policy, |
3241 | const FunctionDecl *Function, |
3242 | CodeCompletionBuilder &Result, |
3243 | unsigned Start = 0, |
3244 | bool InOptional = false) { |
3245 | bool FirstParameter = true; |
3246 | |
3247 | for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) { |
3248 | const ParmVarDecl *Param = Function->getParamDecl(i: P); |
3249 | |
3250 | if (Param->hasDefaultArg() && !InOptional) { |
3251 | // When we see an optional default argument, put that argument and |
3252 | // the remaining default arguments into a new, optional string. |
3253 | CodeCompletionBuilder Opt(Result.getAllocator(), |
3254 | Result.getCodeCompletionTUInfo()); |
3255 | if (!FirstParameter) |
3256 | Opt.AddChunk(CK: CodeCompletionString::CK_Comma); |
3257 | AddFunctionParameterChunks(PP, Policy, Function, Result&: Opt, Start: P, InOptional: true); |
3258 | Result.AddOptionalChunk(Optional: Opt.TakeString()); |
3259 | break; |
3260 | } |
3261 | |
3262 | if (FirstParameter) |
3263 | FirstParameter = false; |
3264 | else |
3265 | Result.AddChunk(CK: CodeCompletionString::CK_Comma); |
3266 | |
3267 | InOptional = false; |
3268 | |
3269 | // Format the placeholder string. |
3270 | std::string PlaceholderStr = FormatFunctionParameter(Policy, Param); |
3271 | if (Param->hasDefaultArg()) |
3272 | PlaceholderStr += |
3273 | GetDefaultValueString(Param, SM: PP.getSourceManager(), LangOpts: PP.getLangOpts()); |
3274 | |
3275 | if (Function->isVariadic() && P == N - 1) |
3276 | PlaceholderStr += ", ..."; |
3277 | |
3278 | // Add the placeholder string. |
3279 | Result.AddPlaceholderChunk( |
3280 | Placeholder: Result.getAllocator().CopyString(String: PlaceholderStr)); |
3281 | } |
3282 | |
3283 | if (const auto *Proto = Function->getType()->getAs<FunctionProtoType>()) |
3284 | if (Proto->isVariadic()) { |
3285 | if (Proto->getNumParams() == 0) |
3286 | Result.AddPlaceholderChunk(Placeholder: "..."); |
3287 | |
3288 | MaybeAddSentinel(PP, Function, Result); |
3289 | } |
3290 | } |
3291 | |
3292 | /// Add template parameter chunks to the given code completion string. |
3293 | static void AddTemplateParameterChunks( |
3294 | ASTContext &Context, const PrintingPolicy &Policy, |
3295 | const TemplateDecl *Template, CodeCompletionBuilder &Result, |
3296 | unsigned MaxParameters = 0, unsigned Start = 0, bool InDefaultArg = false) { |
3297 | bool FirstParameter = true; |
3298 | |
3299 | // Prefer to take the template parameter names from the first declaration of |
3300 | // the template. |
3301 | Template = cast<TemplateDecl>(Template->getCanonicalDecl()); |
3302 | |
3303 | TemplateParameterList *Params = Template->getTemplateParameters(); |
3304 | TemplateParameterList::iterator PEnd = Params->end(); |
3305 | if (MaxParameters) |
3306 | PEnd = Params->begin() + MaxParameters; |
3307 | for (TemplateParameterList::iterator P = Params->begin() + Start; P != PEnd; |
3308 | ++P) { |
3309 | bool HasDefaultArg = false; |
3310 | std::string PlaceholderStr; |
3311 | if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Val: *P)) { |
3312 | if (TTP->wasDeclaredWithTypename()) |
3313 | PlaceholderStr = "typename"; |
3314 | else if (const auto *TC = TTP->getTypeConstraint()) { |
3315 | llvm::raw_string_ostream OS(PlaceholderStr); |
3316 | TC->print(OS, Policy); |
3317 | } else |
3318 | PlaceholderStr = "class"; |
3319 | |
3320 | if (TTP->getIdentifier()) { |
3321 | PlaceholderStr += ' '; |
3322 | PlaceholderStr += TTP->getIdentifier()->deuglifiedName(); |
3323 | } |
3324 | |
3325 | HasDefaultArg = TTP->hasDefaultArgument(); |
3326 | } else if (NonTypeTemplateParmDecl *NTTP = |
3327 | dyn_cast<NonTypeTemplateParmDecl>(Val: *P)) { |
3328 | if (NTTP->getIdentifier()) |
3329 | PlaceholderStr = std::string(NTTP->getIdentifier()->deuglifiedName()); |
3330 | NTTP->getType().getAsStringInternal(PlaceholderStr, Policy); |
3331 | HasDefaultArg = NTTP->hasDefaultArgument(); |
3332 | } else { |
3333 | assert(isa<TemplateTemplateParmDecl>(*P)); |
3334 | TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(Val: *P); |
3335 | |
3336 | // Since putting the template argument list into the placeholder would |
3337 | // be very, very long, we just use an abbreviation. |
3338 | PlaceholderStr = "template<...> class"; |
3339 | if (TTP->getIdentifier()) { |
3340 | PlaceholderStr += ' '; |
3341 | PlaceholderStr += TTP->getIdentifier()->deuglifiedName(); |
3342 | } |
3343 | |
3344 | HasDefaultArg = TTP->hasDefaultArgument(); |
3345 | } |
3346 | |
3347 | if (HasDefaultArg && !InDefaultArg) { |
3348 | // When we see an optional default argument, put that argument and |
3349 | // the remaining default arguments into a new, optional string. |
3350 | CodeCompletionBuilder Opt(Result.getAllocator(), |
3351 | Result.getCodeCompletionTUInfo()); |
3352 | if (!FirstParameter) |
3353 | Opt.AddChunk(CK: CodeCompletionString::CK_Comma); |
3354 | AddTemplateParameterChunks(Context, Policy, Template, Result&: Opt, MaxParameters, |
3355 | Start: P - Params->begin(), InDefaultArg: true); |
3356 | Result.AddOptionalChunk(Optional: Opt.TakeString()); |
3357 | break; |
3358 | } |
3359 | |
3360 | InDefaultArg = false; |
3361 | |
3362 | if (FirstParameter) |
3363 | FirstParameter = false; |
3364 | else |
3365 | Result.AddChunk(CK: CodeCompletionString::CK_Comma); |
3366 | |
3367 | // Add the placeholder string. |
3368 | Result.AddPlaceholderChunk( |
3369 | Placeholder: Result.getAllocator().CopyString(String: PlaceholderStr)); |
3370 | } |
3371 | } |
3372 | |
3373 | /// Add a qualifier to the given code-completion string, if the |
3374 | /// provided nested-name-specifier is non-NULL. |
3375 | static void AddQualifierToCompletionString(CodeCompletionBuilder &Result, |
3376 | NestedNameSpecifier *Qualifier, |
3377 | bool QualifierIsInformative, |
3378 | ASTContext &Context, |
3379 | const PrintingPolicy &Policy) { |
3380 | if (!Qualifier) |
3381 | return; |
3382 | |
3383 | std::string PrintedNNS; |
3384 | { |
3385 | llvm::raw_string_ostream OS(PrintedNNS); |
3386 | Qualifier->print(OS, Policy); |
3387 | } |
3388 | if (QualifierIsInformative) |
3389 | Result.AddInformativeChunk(Text: Result.getAllocator().CopyString(String: PrintedNNS)); |
3390 | else |
3391 | Result.AddTextChunk(Text: Result.getAllocator().CopyString(String: PrintedNNS)); |
3392 | } |
3393 | |
3394 | static void |
3395 | AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result, |
3396 | const FunctionDecl *Function) { |
3397 | const auto *Proto = Function->getType()->getAs<FunctionProtoType>(); |
3398 | if (!Proto || !Proto->getMethodQuals()) |
3399 | return; |
3400 | |
3401 | // FIXME: Add ref-qualifier! |
3402 | |
3403 | // Handle single qualifiers without copying |
3404 | if (Proto->getMethodQuals().hasOnlyConst()) { |
3405 | Result.AddInformativeChunk(Text: " const"); |
3406 | return; |
3407 | } |
3408 | |
3409 | if (Proto->getMethodQuals().hasOnlyVolatile()) { |
3410 | Result.AddInformativeChunk(Text: " volatile"); |
3411 | return; |
3412 | } |
3413 | |
3414 | if (Proto->getMethodQuals().hasOnlyRestrict()) { |
3415 | Result.AddInformativeChunk(Text: " restrict"); |
3416 | return; |
3417 | } |
3418 | |
3419 | // Handle multiple qualifiers. |
3420 | std::string QualsStr; |
3421 | if (Proto->isConst()) |
3422 | QualsStr += " const"; |
3423 | if (Proto->isVolatile()) |
3424 | QualsStr += " volatile"; |
3425 | if (Proto->isRestrict()) |
3426 | QualsStr += " restrict"; |
3427 | Result.AddInformativeChunk(Text: Result.getAllocator().CopyString(String: QualsStr)); |
3428 | } |
3429 | |
3430 | /// Add the name of the given declaration |
3431 | static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy, |
3432 | const NamedDecl *ND, |
3433 | CodeCompletionBuilder &Result) { |
3434 | DeclarationName Name = ND->getDeclName(); |
3435 | if (!Name) |
3436 | return; |
3437 | |
3438 | switch (Name.getNameKind()) { |
3439 | case DeclarationName::CXXOperatorName: { |
3440 | const char *OperatorName = nullptr; |
3441 | switch (Name.getCXXOverloadedOperator()) { |
3442 | case OO_None: |
3443 | case OO_Conditional: |
3444 | case NUM_OVERLOADED_OPERATORS: |
3445 | OperatorName = "operator"; |
3446 | break; |
3447 | |
3448 | #define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \ |
3449 | case OO_##Name: \ |
3450 | OperatorName = "operator" Spelling; \ |
3451 | break; |
3452 | #define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemberOnly) |
3453 | #include "clang/Basic/OperatorKinds.def" |
3454 | |
3455 | case OO_New: |
3456 | OperatorName = "operator new"; |
3457 | break; |
3458 | case OO_Delete: |
3459 | OperatorName = "operator delete"; |
3460 | break; |
3461 | case OO_Array_New: |
3462 | OperatorName = "operator new[]"; |
3463 | break; |
3464 | case OO_Array_Delete: |
3465 | OperatorName = "operator delete[]"; |
3466 | break; |
3467 | case OO_Call: |
3468 | OperatorName = "operator()"; |
3469 | break; |
3470 | case OO_Subscript: |
3471 | OperatorName = "operator[]"; |
3472 | break; |
3473 | } |
3474 | Result.AddTypedTextChunk(Text: OperatorName); |
3475 | break; |
3476 | } |
3477 | |
3478 | case DeclarationName::Identifier: |
3479 | case DeclarationName::CXXConversionFunctionName: |
3480 | case DeclarationName::CXXDestructorName: |
3481 | case DeclarationName::CXXLiteralOperatorName: |
3482 | Result.AddTypedTextChunk( |
3483 | Text: Result.getAllocator().CopyString(String: ND->getNameAsString())); |
3484 | break; |
3485 | |
3486 | case DeclarationName::CXXDeductionGuideName: |
3487 | case DeclarationName::CXXUsingDirective: |
3488 | case DeclarationName::ObjCZeroArgSelector: |
3489 | case DeclarationName::ObjCOneArgSelector: |
3490 | case DeclarationName::ObjCMultiArgSelector: |
3491 | break; |
3492 | |
3493 | case DeclarationName::CXXConstructorName: { |
3494 | CXXRecordDecl *Record = nullptr; |
3495 | QualType Ty = Name.getCXXNameType(); |
3496 | if (const auto *RecordTy = Ty->getAs<RecordType>()) |
3497 | Record = cast<CXXRecordDecl>(Val: RecordTy->getDecl()); |
3498 | else if (const auto *InjectedTy = Ty->getAs<InjectedClassNameType>()) |
3499 | Record = InjectedTy->getDecl(); |
3500 | else { |
3501 | Result.AddTypedTextChunk( |
3502 | Text: Result.getAllocator().CopyString(String: ND->getNameAsString())); |
3503 | break; |
3504 | } |
3505 | |
3506 | Result.AddTypedTextChunk( |
3507 | Text: Result.getAllocator().CopyString(String: Record->getNameAsString())); |
3508 | if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) { |
3509 | Result.AddChunk(CK: CodeCompletionString::CK_LeftAngle); |
3510 | AddTemplateParameterChunks(Context, Policy, Template, Result); |
3511 | Result.AddChunk(CK: CodeCompletionString::CK_RightAngle); |
3512 | } |
3513 | break; |
3514 | } |
3515 | } |
3516 | } |
3517 | |
3518 | CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString( |
3519 | Sema &S, const CodeCompletionContext &CCContext, |
3520 | CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo, |
3521 | bool IncludeBriefComments) { |
3522 | return CreateCodeCompletionString(Ctx&: S.Context, PP&: S.PP, CCContext, Allocator, |
3523 | CCTUInfo, IncludeBriefComments); |
3524 | } |
3525 | |
3526 | CodeCompletionString *CodeCompletionResult::CreateCodeCompletionStringForMacro( |
3527 | Preprocessor &PP, CodeCompletionAllocator &Allocator, |
3528 | CodeCompletionTUInfo &CCTUInfo) { |
3529 | assert(Kind == RK_Macro); |
3530 | CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability); |
3531 | const MacroInfo *MI = PP.getMacroInfo(II: Macro); |
3532 | Result.AddTypedTextChunk(Text: Result.getAllocator().CopyString(String: Macro->getName())); |
3533 | |
3534 | if (!MI || !MI->isFunctionLike()) |
3535 | return Result.TakeString(); |
3536 | |
3537 | // Format a function-like macro with placeholders for the arguments. |
3538 | Result.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
3539 | MacroInfo::param_iterator A = MI->param_begin(), AEnd = MI->param_end(); |
3540 | |
3541 | // C99 variadic macros add __VA_ARGS__ at the end. Skip it. |
3542 | if (MI->isC99Varargs()) { |
3543 | --AEnd; |
3544 | |
3545 | if (A == AEnd) { |
3546 | Result.AddPlaceholderChunk(Placeholder: "..."); |
3547 | } |
3548 | } |
3549 | |
3550 | for (MacroInfo::param_iterator A = MI->param_begin(); A != AEnd; ++A) { |
3551 | if (A != MI->param_begin()) |
3552 | Result.AddChunk(CK: CodeCompletionString::CK_Comma); |
3553 | |
3554 | if (MI->isVariadic() && (A + 1) == AEnd) { |
3555 | SmallString<32> Arg = (*A)->getName(); |
3556 | if (MI->isC99Varargs()) |
3557 | Arg += ", ..."; |
3558 | else |
3559 | Arg += "..."; |
3560 | Result.AddPlaceholderChunk(Placeholder: Result.getAllocator().CopyString(String: Arg)); |
3561 | break; |
3562 | } |
3563 | |
3564 | // Non-variadic macros are simple. |
3565 | Result.AddPlaceholderChunk( |
3566 | Placeholder: Result.getAllocator().CopyString(String: (*A)->getName())); |
3567 | } |
3568 | Result.AddChunk(CK: CodeCompletionString::CK_RightParen); |
3569 | return Result.TakeString(); |
3570 | } |
3571 | |
3572 | /// If possible, create a new code completion string for the given |
3573 | /// result. |
3574 | /// |
3575 | /// \returns Either a new, heap-allocated code completion string describing |
3576 | /// how to use this result, or NULL to indicate that the string or name of the |
3577 | /// result is all that is needed. |
3578 | CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString( |
3579 | ASTContext &Ctx, Preprocessor &PP, const CodeCompletionContext &CCContext, |
3580 | CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo, |
3581 | bool IncludeBriefComments) { |
3582 | if (Kind == RK_Macro) |
3583 | return CreateCodeCompletionStringForMacro(PP, Allocator, CCTUInfo); |
3584 | |
3585 | CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability); |
3586 | |
3587 | PrintingPolicy Policy = getCompletionPrintingPolicy(Context: Ctx, PP); |
3588 | if (Kind == RK_Pattern) { |
3589 | Pattern->Priority = Priority; |
3590 | Pattern->Availability = Availability; |
3591 | |
3592 | if (Declaration) { |
3593 | Result.addParentContext(DC: Declaration->getDeclContext()); |
3594 | Pattern->ParentName = Result.getParentName(); |
3595 | if (const RawComment *RC = |
3596 | getPatternCompletionComment(Ctx, Decl: Declaration)) { |
3597 | Result.addBriefComment(Comment: RC->getBriefText(Context: Ctx)); |
3598 | Pattern->BriefComment = Result.getBriefComment(); |
3599 | } |
3600 | } |
3601 | |
3602 | return Pattern; |
3603 | } |
3604 | |
3605 | if (Kind == RK_Keyword) { |
3606 | Result.AddTypedTextChunk(Text: Keyword); |
3607 | return Result.TakeString(); |
3608 | } |
3609 | assert(Kind == RK_Declaration && "Missed a result kind?"); |
3610 | return createCodeCompletionStringForDecl( |
3611 | PP, Ctx, Result, IncludeBriefComments, CCContext, Policy); |
3612 | } |
3613 | |
3614 | static void printOverrideString(const CodeCompletionString &CCS, |
3615 | std::string &BeforeName, |
3616 | std::string &NameAndSignature) { |
3617 | bool SeenTypedChunk = false; |
3618 | for (auto &Chunk : CCS) { |
3619 | if (Chunk.Kind == CodeCompletionString::CK_Optional) { |
3620 | assert(SeenTypedChunk && "optional parameter before name"); |
3621 | // Note that we put all chunks inside into NameAndSignature. |
3622 | printOverrideString(CCS: *Chunk.Optional, BeforeName&: NameAndSignature, NameAndSignature); |
3623 | continue; |
3624 | } |
3625 | SeenTypedChunk |= Chunk.Kind == CodeCompletionString::CK_TypedText; |
3626 | if (SeenTypedChunk) |
3627 | NameAndSignature += Chunk.Text; |
3628 | else |
3629 | BeforeName += Chunk.Text; |
3630 | } |
3631 | } |
3632 | |
3633 | CodeCompletionString * |
3634 | CodeCompletionResult::createCodeCompletionStringForOverride( |
3635 | Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result, |
3636 | bool IncludeBriefComments, const CodeCompletionContext &CCContext, |
3637 | PrintingPolicy &Policy) { |
3638 | auto *CCS = createCodeCompletionStringForDecl(PP, Ctx, Result, |
3639 | /*IncludeBriefComments=*/false, |
3640 | CCContext, Policy); |
3641 | std::string BeforeName; |
3642 | std::string NameAndSignature; |
3643 | // For overrides all chunks go into the result, none are informative. |
3644 | printOverrideString(CCS: *CCS, BeforeName, NameAndSignature); |
3645 | NameAndSignature += " override"; |
3646 | |
3647 | Result.AddTextChunk(Text: Result.getAllocator().CopyString(String: BeforeName)); |
3648 | Result.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
3649 | Result.AddTypedTextChunk(Text: Result.getAllocator().CopyString(String: NameAndSignature)); |
3650 | return Result.TakeString(); |
3651 | } |
3652 | |
3653 | // FIXME: Right now this works well with lambdas. Add support for other functor |
3654 | // types like std::function. |
3655 | static const NamedDecl *extractFunctorCallOperator(const NamedDecl *ND) { |
3656 | const auto *VD = dyn_cast<VarDecl>(Val: ND); |
3657 | if (!VD) |
3658 | return nullptr; |
3659 | const auto *RecordDecl = VD->getType()->getAsCXXRecordDecl(); |
3660 | if (!RecordDecl || !RecordDecl->isLambda()) |
3661 | return nullptr; |
3662 | return RecordDecl->getLambdaCallOperator(); |
3663 | } |
3664 | |
3665 | CodeCompletionString *CodeCompletionResult::createCodeCompletionStringForDecl( |
3666 | Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result, |
3667 | bool IncludeBriefComments, const CodeCompletionContext &CCContext, |
3668 | PrintingPolicy &Policy) { |
3669 | const NamedDecl *ND = Declaration; |
3670 | Result.addParentContext(DC: ND->getDeclContext()); |
3671 | |
3672 | if (IncludeBriefComments) { |
3673 | // Add documentation comment, if it exists. |
3674 | if (const RawComment *RC = getCompletionComment(Ctx, Decl: Declaration)) { |
3675 | Result.addBriefComment(Comment: RC->getBriefText(Context: Ctx)); |
3676 | } |
3677 | } |
3678 | |
3679 | if (StartsNestedNameSpecifier) { |
3680 | Result.AddTypedTextChunk( |
3681 | Text: Result.getAllocator().CopyString(String: ND->getNameAsString())); |
3682 | Result.AddTextChunk(Text: "::"); |
3683 | return Result.TakeString(); |
3684 | } |
3685 | |
3686 | for (const auto *I : ND->specific_attrs<AnnotateAttr>()) |
3687 | Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation())); |
3688 | |
3689 | auto AddFunctionTypeAndResult = [&](const FunctionDecl *Function) { |
3690 | AddResultTypeChunk(Ctx, Policy, Function, CCContext.getBaseType(), Result); |
3691 | AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, |
3692 | Context&: Ctx, Policy); |
3693 | AddTypedNameChunk(Context&: Ctx, Policy, ND, Result); |
3694 | Result.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
3695 | AddFunctionParameterChunks(PP, Policy, Function, Result); |
3696 | Result.AddChunk(CK: CodeCompletionString::CK_RightParen); |
3697 | AddFunctionTypeQualsToCompletionString(Result, Function); |
3698 | }; |
3699 | |
3700 | if (const auto *Function = dyn_cast<FunctionDecl>(Val: ND)) { |
3701 | AddFunctionTypeAndResult(Function); |
3702 | return Result.TakeString(); |
3703 | } |
3704 | |
3705 | if (const auto *CallOperator = |
3706 | dyn_cast_or_null<FunctionDecl>(Val: extractFunctorCallOperator(ND))) { |
3707 | AddFunctionTypeAndResult(CallOperator); |
3708 | return Result.TakeString(); |
3709 | } |
3710 | |
3711 | AddResultTypeChunk(Context&: Ctx, Policy, ND, BaseType: CCContext.getBaseType(), Result); |
3712 | |
3713 | if (const FunctionTemplateDecl *FunTmpl = |
3714 | dyn_cast<FunctionTemplateDecl>(Val: ND)) { |
3715 | AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, |
3716 | Context&: Ctx, Policy); |
3717 | FunctionDecl *Function = FunTmpl->getTemplatedDecl(); |
3718 | AddTypedNameChunk(Ctx, Policy, Function, Result); |
3719 | |
3720 | // Figure out which template parameters are deduced (or have default |
3721 | // arguments). |
3722 | // Note that we're creating a non-empty bit vector so that we can go |
3723 | // through the loop below to omit default template parameters for non-call |
3724 | // cases. |
3725 | llvm::SmallBitVector Deduced(FunTmpl->getTemplateParameters()->size()); |
3726 | // Avoid running it if this is not a call: We should emit *all* template |
3727 | // parameters. |
3728 | if (FunctionCanBeCall) |
3729 | Sema::MarkDeducedTemplateParameters(Ctx, FunctionTemplate: FunTmpl, Deduced); |
3730 | unsigned LastDeducibleArgument; |
3731 | for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0; |
3732 | --LastDeducibleArgument) { |
3733 | if (!Deduced[LastDeducibleArgument - 1]) { |
3734 | // C++0x: Figure out if the template argument has a default. If so, |
3735 | // the user doesn't need to type this argument. |
3736 | // FIXME: We need to abstract template parameters better! |
3737 | bool HasDefaultArg = false; |
3738 | NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam( |
3739 | LastDeducibleArgument - 1); |
3740 | if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Val: Param)) |
3741 | HasDefaultArg = TTP->hasDefaultArgument(); |
3742 | else if (NonTypeTemplateParmDecl *NTTP = |
3743 | dyn_cast<NonTypeTemplateParmDecl>(Val: Param)) |
3744 | HasDefaultArg = NTTP->hasDefaultArgument(); |
3745 | else { |
3746 | assert(isa<TemplateTemplateParmDecl>(Param)); |
3747 | HasDefaultArg = |
3748 | cast<TemplateTemplateParmDecl>(Val: Param)->hasDefaultArgument(); |
3749 | } |
3750 | |
3751 | if (!HasDefaultArg) |
3752 | break; |
3753 | } |
3754 | } |
3755 | |
3756 | if (LastDeducibleArgument || !FunctionCanBeCall) { |
3757 | // Some of the function template arguments cannot be deduced from a |
3758 | // function call, so we introduce an explicit template argument list |
3759 | // containing all of the arguments up to the first deducible argument. |
3760 | // |
3761 | // Or, if this isn't a call, emit all the template arguments |
3762 | // to disambiguate the (potential) overloads. |
3763 | // |
3764 | // FIXME: Detect cases where the function parameters can be deduced from |
3765 | // the surrounding context, as per [temp.deduct.funcaddr]. |
3766 | // e.g., |
3767 | // template <class T> void foo(T); |
3768 | // void (*f)(int) = foo; |
3769 | Result.AddChunk(CK: CodeCompletionString::CK_LeftAngle); |
3770 | AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result, |
3771 | LastDeducibleArgument); |
3772 | Result.AddChunk(CK: CodeCompletionString::CK_RightAngle); |
3773 | } |
3774 | |
3775 | // Add the function parameters |
3776 | Result.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
3777 | AddFunctionParameterChunks(PP, Policy, Function, Result); |
3778 | Result.AddChunk(CK: CodeCompletionString::CK_RightParen); |
3779 | AddFunctionTypeQualsToCompletionString(Result, Function); |
3780 | return Result.TakeString(); |
3781 | } |
3782 | |
3783 | if (const auto *Template = dyn_cast<TemplateDecl>(Val: ND)) { |
3784 | AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, |
3785 | Context&: Ctx, Policy); |
3786 | Result.AddTypedTextChunk( |
3787 | Text: Result.getAllocator().CopyString(String: Template->getNameAsString())); |
3788 | Result.AddChunk(CK: CodeCompletionString::CK_LeftAngle); |
3789 | AddTemplateParameterChunks(Context&: Ctx, Policy, Template, Result); |
3790 | Result.AddChunk(CK: CodeCompletionString::CK_RightAngle); |
3791 | return Result.TakeString(); |
3792 | } |
3793 | |
3794 | if (const auto *Method = dyn_cast<ObjCMethodDecl>(Val: ND)) { |
3795 | Selector Sel = Method->getSelector(); |
3796 | if (Sel.isUnarySelector()) { |
3797 | Result.AddTypedTextChunk( |
3798 | Text: Result.getAllocator().CopyString(String: Sel.getNameForSlot(argIndex: 0))); |
3799 | return Result.TakeString(); |
3800 | } |
3801 | |
3802 | std::string SelName = Sel.getNameForSlot(argIndex: 0).str(); |
3803 | SelName += ':'; |
3804 | if (StartParameter == 0) |
3805 | Result.AddTypedTextChunk(Text: Result.getAllocator().CopyString(String: SelName)); |
3806 | else { |
3807 | Result.AddInformativeChunk(Text: Result.getAllocator().CopyString(String: SelName)); |
3808 | |
3809 | // If there is only one parameter, and we're past it, add an empty |
3810 | // typed-text chunk since there is nothing to type. |
3811 | if (Method->param_size() == 1) |
3812 | Result.AddTypedTextChunk(Text: ""); |
3813 | } |
3814 | unsigned Idx = 0; |
3815 | // The extra Idx < Sel.getNumArgs() check is needed due to legacy C-style |
3816 | // method parameters. |
3817 | for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(), |
3818 | PEnd = Method->param_end(); |
3819 | P != PEnd && Idx < Sel.getNumArgs(); (void)++P, ++Idx) { |
3820 | if (Idx > 0) { |
3821 | std::string Keyword; |
3822 | if (Idx > StartParameter) |
3823 | Result.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
3824 | if (const IdentifierInfo *II = Sel.getIdentifierInfoForSlot(argIndex: Idx)) |
3825 | Keyword += II->getName(); |
3826 | Keyword += ":"; |
3827 | if (Idx < StartParameter || AllParametersAreInformative) |
3828 | Result.AddInformativeChunk(Text: Result.getAllocator().CopyString(String: Keyword)); |
3829 | else |
3830 | Result.AddTypedTextChunk(Text: Result.getAllocator().CopyString(String: Keyword)); |
3831 | } |
3832 | |
3833 | // If we're before the starting parameter, skip the placeholder. |
3834 | if (Idx < StartParameter) |
3835 | continue; |
3836 | |
3837 | std::string Arg; |
3838 | QualType ParamType = (*P)->getType(); |
3839 | std::optional<ArrayRef<QualType>> ObjCSubsts; |
3840 | if (!CCContext.getBaseType().isNull()) |
3841 | ObjCSubsts = CCContext.getBaseType()->getObjCSubstitutions(Method); |
3842 | |
3843 | if (ParamType->isBlockPointerType() && !DeclaringEntity) |
3844 | Arg = FormatFunctionParameter(Policy, *P, true, |
3845 | /*SuppressBlock=*/false, ObjCSubsts); |
3846 | else { |
3847 | if (ObjCSubsts) |
3848 | ParamType = ParamType.substObjCTypeArgs( |
3849 | ctx&: Ctx, typeArgs: *ObjCSubsts, context: ObjCSubstitutionContext::Parameter); |
3850 | Arg = "("+ formatObjCParamQualifiers(ObjCQuals: (*P)->getObjCDeclQualifier(), |
3851 | Type&: ParamType); |
3852 | Arg += ParamType.getAsString(Policy) + ")"; |
3853 | if (const IdentifierInfo *II = (*P)->getIdentifier()) |
3854 | if (DeclaringEntity || AllParametersAreInformative) |
3855 | Arg += II->getName(); |
3856 | } |
3857 | |
3858 | if (Method->isVariadic() && (P + 1) == PEnd) |
3859 | Arg += ", ..."; |
3860 | |
3861 | if (DeclaringEntity) |
3862 | Result.AddTextChunk(Text: Result.getAllocator().CopyString(String: Arg)); |
3863 | else if (AllParametersAreInformative) |
3864 | Result.AddInformativeChunk(Text: Result.getAllocator().CopyString(String: Arg)); |
3865 | else |
3866 | Result.AddPlaceholderChunk(Placeholder: Result.getAllocator().CopyString(String: Arg)); |
3867 | } |
3868 | |
3869 | if (Method->isVariadic()) { |
3870 | if (Method->param_size() == 0) { |
3871 | if (DeclaringEntity) |
3872 | Result.AddTextChunk(Text: ", ..."); |
3873 | else if (AllParametersAreInformative) |
3874 | Result.AddInformativeChunk(Text: ", ..."); |
3875 | else |
3876 | Result.AddPlaceholderChunk(Placeholder: ", ..."); |
3877 | } |
3878 | |
3879 | MaybeAddSentinel(PP, Method, Result); |
3880 | } |
3881 | |
3882 | return Result.TakeString(); |
3883 | } |
3884 | |
3885 | if (Qualifier) |
3886 | AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, |
3887 | Context&: Ctx, Policy); |
3888 | |
3889 | Result.AddTypedTextChunk( |
3890 | Text: Result.getAllocator().CopyString(String: ND->getNameAsString())); |
3891 | return Result.TakeString(); |
3892 | } |
3893 | |
3894 | const RawComment *clang::getCompletionComment(const ASTContext &Ctx, |
3895 | const NamedDecl *ND) { |
3896 | if (!ND) |
3897 | return nullptr; |
3898 | if (auto *RC = Ctx.getRawCommentForAnyRedecl(ND)) |
3899 | return RC; |
3900 | |
3901 | // Try to find comment from a property for ObjC methods. |
3902 | const auto *M = dyn_cast<ObjCMethodDecl>(Val: ND); |
3903 | if (!M) |
3904 | return nullptr; |
3905 | const ObjCPropertyDecl *PDecl = M->findPropertyDecl(); |
3906 | if (!PDecl) |
3907 | return nullptr; |
3908 | |
3909 | return Ctx.getRawCommentForAnyRedecl(PDecl); |
3910 | } |
3911 | |
3912 | const RawComment *clang::getPatternCompletionComment(const ASTContext &Ctx, |
3913 | const NamedDecl *ND) { |
3914 | const auto *M = dyn_cast_or_null<ObjCMethodDecl>(Val: ND); |
3915 | if (!M || !M->isPropertyAccessor()) |
3916 | return nullptr; |
3917 | |
3918 | // Provide code completion comment for self.GetterName where |
3919 | // GetterName is the getter method for a property with name |
3920 | // different from the property name (declared via a property |
3921 | // getter attribute. |
3922 | const ObjCPropertyDecl *PDecl = M->findPropertyDecl(); |
3923 | if (!PDecl) |
3924 | return nullptr; |
3925 | if (PDecl->getGetterName() == M->getSelector() && |
3926 | PDecl->getIdentifier() != M->getIdentifier()) { |
3927 | if (auto *RC = Ctx.getRawCommentForAnyRedecl(M)) |
3928 | return RC; |
3929 | if (auto *RC = Ctx.getRawCommentForAnyRedecl(PDecl)) |
3930 | return RC; |
3931 | } |
3932 | return nullptr; |
3933 | } |
3934 | |
3935 | const RawComment *clang::getParameterComment( |
3936 | const ASTContext &Ctx, |
3937 | const CodeCompleteConsumer::OverloadCandidate &Result, unsigned ArgIndex) { |
3938 | auto FDecl = Result.getFunction(); |
3939 | if (!FDecl) |
3940 | return nullptr; |
3941 | if (ArgIndex < FDecl->getNumParams()) |
3942 | return Ctx.getRawCommentForAnyRedecl(FDecl->getParamDecl(i: ArgIndex)); |
3943 | return nullptr; |
3944 | } |
3945 | |
3946 | static void AddOverloadAggregateChunks(const RecordDecl *RD, |
3947 | const PrintingPolicy &Policy, |
3948 | CodeCompletionBuilder &Result, |
3949 | unsigned CurrentArg) { |
3950 | unsigned ChunkIndex = 0; |
3951 | auto AddChunk = [&](llvm::StringRef Placeholder) { |
3952 | if (ChunkIndex > 0) |
3953 | Result.AddChunk(CK: CodeCompletionString::CK_Comma); |
3954 | const char *Copy = Result.getAllocator().CopyString(String: Placeholder); |
3955 | if (ChunkIndex == CurrentArg) |
3956 | Result.AddCurrentParameterChunk(CurrentParameter: Copy); |
3957 | else |
3958 | Result.AddPlaceholderChunk(Placeholder: Copy); |
3959 | ++ChunkIndex; |
3960 | }; |
3961 | // Aggregate initialization has all bases followed by all fields. |
3962 | // (Bases are not legal in C++11 but in that case we never get here). |
3963 | if (auto *CRD = llvm::dyn_cast<CXXRecordDecl>(Val: RD)) { |
3964 | for (const auto &Base : CRD->bases()) |
3965 | AddChunk(Base.getType().getAsString(Policy)); |
3966 | } |
3967 | for (const auto &Field : RD->fields()) |
3968 | AddChunk(FormatFunctionParameter(Policy, Field)); |
3969 | } |
3970 | |
3971 | /// Add function overload parameter chunks to the given code completion |
3972 | /// string. |
3973 | static void AddOverloadParameterChunks( |
3974 | ASTContext &Context, const PrintingPolicy &Policy, |
3975 | const FunctionDecl *Function, const FunctionProtoType *Prototype, |
3976 | FunctionProtoTypeLoc PrototypeLoc, CodeCompletionBuilder &Result, |
3977 | unsigned CurrentArg, unsigned Start = 0, bool InOptional = false) { |
3978 | if (!Function && !Prototype) { |
3979 | Result.AddChunk(CK: CodeCompletionString::CK_CurrentParameter, Text: "..."); |
3980 | return; |
3981 | } |
3982 | |
3983 | bool FirstParameter = true; |
3984 | unsigned NumParams = |
3985 | Function ? Function->getNumParams() : Prototype->getNumParams(); |
3986 | |
3987 | for (unsigned P = Start; P != NumParams; ++P) { |
3988 | if (Function && Function->getParamDecl(i: P)->hasDefaultArg() && !InOptional) { |
3989 | // When we see an optional default argument, put that argument and |
3990 | // the remaining default arguments into a new, optional string. |
3991 | CodeCompletionBuilder Opt(Result.getAllocator(), |
3992 | Result.getCodeCompletionTUInfo()); |
3993 | if (!FirstParameter) |
3994 | Opt.AddChunk(CK: CodeCompletionString::CK_Comma); |
3995 | // Optional sections are nested. |
3996 | AddOverloadParameterChunks(Context, Policy, Function, Prototype, |
3997 | PrototypeLoc, Result&: Opt, CurrentArg, Start: P, |
3998 | /*InOptional=*/true); |
3999 | Result.AddOptionalChunk(Optional: Opt.TakeString()); |
4000 | return; |
4001 | } |
4002 | |
4003 | if (FirstParameter) |
4004 | FirstParameter = false; |
4005 | else |
4006 | Result.AddChunk(CK: CodeCompletionString::CK_Comma); |
4007 | |
4008 | InOptional = false; |
4009 | |
4010 | // Format the placeholder string. |
4011 | std::string Placeholder; |
4012 | assert(P < Prototype->getNumParams()); |
4013 | if (Function || PrototypeLoc) { |
4014 | const ParmVarDecl *Param = |
4015 | Function ? Function->getParamDecl(i: P) : PrototypeLoc.getParam(P); |
4016 | Placeholder = FormatFunctionParameter(Policy, Param); |
4017 | if (Param->hasDefaultArg()) |
4018 | Placeholder += GetDefaultValueString(Param, SM: Context.getSourceManager(), |
4019 | LangOpts: Context.getLangOpts()); |
4020 | } else { |
4021 | Placeholder = Prototype->getParamType(i: P).getAsString(Policy); |
4022 | } |
4023 | |
4024 | if (P == CurrentArg) |
4025 | Result.AddCurrentParameterChunk( |
4026 | CurrentParameter: Result.getAllocator().CopyString(String: Placeholder)); |
4027 | else |
4028 | Result.AddPlaceholderChunk(Placeholder: Result.getAllocator().CopyString(String: Placeholder)); |
4029 | } |
4030 | |
4031 | if (Prototype && Prototype->isVariadic()) { |
4032 | CodeCompletionBuilder Opt(Result.getAllocator(), |
4033 | Result.getCodeCompletionTUInfo()); |
4034 | if (!FirstParameter) |
4035 | Opt.AddChunk(CK: CodeCompletionString::CK_Comma); |
4036 | |
4037 | if (CurrentArg < NumParams) |
4038 | Opt.AddPlaceholderChunk(Placeholder: "..."); |
4039 | else |
4040 | Opt.AddCurrentParameterChunk(CurrentParameter: "..."); |
4041 | |
4042 | Result.AddOptionalChunk(Optional: Opt.TakeString()); |
4043 | } |
4044 | } |
4045 | |
4046 | static std::string |
4047 | formatTemplateParameterPlaceholder(const NamedDecl *Param, bool &Optional, |
4048 | const PrintingPolicy &Policy) { |
4049 | if (const auto *Type = dyn_cast<TemplateTypeParmDecl>(Val: Param)) { |
4050 | Optional = Type->hasDefaultArgument(); |
4051 | } else if (const auto *NonType = dyn_cast<NonTypeTemplateParmDecl>(Val: Param)) { |
4052 | Optional = NonType->hasDefaultArgument(); |
4053 | } else if (const auto *Template = dyn_cast<TemplateTemplateParmDecl>(Val: Param)) { |
4054 | Optional = Template->hasDefaultArgument(); |
4055 | } |
4056 | std::string Result; |
4057 | llvm::raw_string_ostream OS(Result); |
4058 | Param->print(OS, Policy); |
4059 | return Result; |
4060 | } |
4061 | |
4062 | static std::string templateResultType(const TemplateDecl *TD, |
4063 | const PrintingPolicy &Policy) { |
4064 | if (const auto *CTD = dyn_cast<ClassTemplateDecl>(Val: TD)) |
4065 | return CTD->getTemplatedDecl()->getKindName().str(); |
4066 | if (const auto *VTD = dyn_cast<VarTemplateDecl>(Val: TD)) |
4067 | return VTD->getTemplatedDecl()->getType().getAsString(Policy); |
4068 | if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(Val: TD)) |
4069 | return FTD->getTemplatedDecl()->getReturnType().getAsString(Policy); |
4070 | if (isa<TypeAliasTemplateDecl>(Val: TD)) |
4071 | return "type"; |
4072 | if (isa<TemplateTemplateParmDecl>(Val: TD)) |
4073 | return "class"; |
4074 | if (isa<ConceptDecl>(Val: TD)) |
4075 | return "concept"; |
4076 | return ""; |
4077 | } |
4078 | |
4079 | static CodeCompletionString *createTemplateSignatureString( |
4080 | const TemplateDecl *TD, CodeCompletionBuilder &Builder, unsigned CurrentArg, |
4081 | const PrintingPolicy &Policy) { |
4082 | llvm::ArrayRef<NamedDecl *> Params = TD->getTemplateParameters()->asArray(); |
4083 | CodeCompletionBuilder OptionalBuilder(Builder.getAllocator(), |
4084 | Builder.getCodeCompletionTUInfo()); |
4085 | std::string ResultType = templateResultType(TD, Policy); |
4086 | if (!ResultType.empty()) |
4087 | Builder.AddResultTypeChunk(ResultType: Builder.getAllocator().CopyString(String: ResultType)); |
4088 | Builder.AddTextChunk( |
4089 | Text: Builder.getAllocator().CopyString(String: TD->getNameAsString())); |
4090 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftAngle); |
4091 | // Initially we're writing into the main string. Once we see an optional arg |
4092 | // (with default), we're writing into the nested optional chunk. |
4093 | CodeCompletionBuilder *Current = &Builder; |
4094 | for (unsigned I = 0; I < Params.size(); ++I) { |
4095 | bool Optional = false; |
4096 | std::string Placeholder = |
4097 | formatTemplateParameterPlaceholder(Param: Params[I], Optional, Policy); |
4098 | if (Optional) |
4099 | Current = &OptionalBuilder; |
4100 | if (I > 0) |
4101 | Current->AddChunk(CK: CodeCompletionString::CK_Comma); |
4102 | Current->AddChunk(CK: I == CurrentArg |
4103 | ? CodeCompletionString::CK_CurrentParameter |
4104 | : CodeCompletionString::CK_Placeholder, |
4105 | Text: Current->getAllocator().CopyString(String: Placeholder)); |
4106 | } |
4107 | // Add the optional chunk to the main string if we ever used it. |
4108 | if (Current == &OptionalBuilder) |
4109 | Builder.AddOptionalChunk(Optional: OptionalBuilder.TakeString()); |
4110 | Builder.AddChunk(CK: CodeCompletionString::CK_RightAngle); |
4111 | // For function templates, ResultType was the function's return type. |
4112 | // Give some clue this is a function. (Don't show the possibly-bulky params). |
4113 | if (isa<FunctionTemplateDecl>(Val: TD)) |
4114 | Builder.AddInformativeChunk(Text: "()"); |
4115 | return Builder.TakeString(); |
4116 | } |
4117 | |
4118 | CodeCompletionString * |
4119 | CodeCompleteConsumer::OverloadCandidate::CreateSignatureString( |
4120 | unsigned CurrentArg, Sema &S, CodeCompletionAllocator &Allocator, |
4121 | CodeCompletionTUInfo &CCTUInfo, bool IncludeBriefComments, |
4122 | bool Braced) const { |
4123 | PrintingPolicy Policy = getCompletionPrintingPolicy(S); |
4124 | // Show signatures of constructors as they are declared: |
4125 | // vector(int n) rather than vector<string>(int n) |
4126 | // This is less noisy without being less clear, and avoids tricky cases. |
4127 | Policy.SuppressTemplateArgsInCXXConstructors = true; |
4128 | |
4129 | // FIXME: Set priority, availability appropriately. |
4130 | CodeCompletionBuilder Result(Allocator, CCTUInfo, 1, |
4131 | CXAvailability_Available); |
4132 | |
4133 | if (getKind() == CK_Template) |
4134 | return createTemplateSignatureString(TD: getTemplate(), Builder&: Result, CurrentArg, |
4135 | Policy); |
4136 | |
4137 | FunctionDecl *FDecl = getFunction(); |
4138 | const FunctionProtoType *Proto = |
4139 | dyn_cast_or_null<FunctionProtoType>(Val: getFunctionType()); |
4140 | |
4141 | // First, the name/type of the callee. |
4142 | if (getKind() == CK_Aggregate) { |
4143 | Result.AddTextChunk( |
4144 | Text: Result.getAllocator().CopyString(String: getAggregate()->getName())); |
4145 | } else if (FDecl) { |
4146 | if (IncludeBriefComments) { |
4147 | if (auto RC = getParameterComment(Ctx: S.getASTContext(), Result: *this, ArgIndex: CurrentArg)) |
4148 | Result.addBriefComment(Comment: RC->getBriefText(Context: S.getASTContext())); |
4149 | } |
4150 | AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result); |
4151 | |
4152 | std::string Name; |
4153 | llvm::raw_string_ostream OS(Name); |
4154 | FDecl->getDeclName().print(OS, Policy); |
4155 | Result.AddTextChunk(Text: Result.getAllocator().CopyString(String: Name)); |
4156 | } else { |
4157 | // Function without a declaration. Just give the return type. |
4158 | Result.AddResultTypeChunk(ResultType: Result.getAllocator().CopyString( |
4159 | String: getFunctionType()->getReturnType().getAsString(Policy))); |
4160 | } |
4161 | |
4162 | // Next, the brackets and parameters. |
4163 | Result.AddChunk(CK: Braced ? CodeCompletionString::CK_LeftBrace |
4164 | : CodeCompletionString::CK_LeftParen); |
4165 | if (getKind() == CK_Aggregate) |
4166 | AddOverloadAggregateChunks(RD: getAggregate(), Policy, Result, CurrentArg); |
4167 | else |
4168 | AddOverloadParameterChunks(Context&: S.getASTContext(), Policy, Function: FDecl, Prototype: Proto, |
4169 | PrototypeLoc: getFunctionProtoTypeLoc(), Result, CurrentArg); |
4170 | Result.AddChunk(CK: Braced ? CodeCompletionString::CK_RightBrace |
4171 | : CodeCompletionString::CK_RightParen); |
4172 | |
4173 | return Result.TakeString(); |
4174 | } |
4175 | |
4176 | unsigned clang::getMacroUsagePriority(StringRef MacroName, |
4177 | const LangOptions &LangOpts, |
4178 | bool PreferredTypeIsPointer) { |
4179 | unsigned Priority = CCP_Macro; |
4180 | |
4181 | // Treat the "nil", "Nil" and "NULL" macros as null pointer constants. |
4182 | if (MacroName == "nil"|| MacroName == "NULL"|| MacroName == "Nil") { |
4183 | Priority = CCP_Constant; |
4184 | if (PreferredTypeIsPointer) |
4185 | Priority = Priority / CCF_SimilarTypeMatch; |
4186 | } |
4187 | // Treat "YES", "NO", "true", and "false" as constants. |
4188 | else if (MacroName == "YES"|| MacroName == "NO"|| MacroName == "true"|| |
4189 | MacroName == "false") |
4190 | Priority = CCP_Constant; |
4191 | // Treat "bool" as a type. |
4192 | else if (MacroName == "bool") |
4193 | Priority = CCP_Type + (LangOpts.ObjC ? CCD_bool_in_ObjC : 0); |
4194 | |
4195 | return Priority; |
4196 | } |
4197 | |
4198 | CXCursorKind clang::getCursorKindForDecl(const Decl *D) { |
4199 | if (!D) |
4200 | return CXCursor_UnexposedDecl; |
4201 | |
4202 | switch (D->getKind()) { |
4203 | case Decl::Enum: |
4204 | return CXCursor_EnumDecl; |
4205 | case Decl::EnumConstant: |
4206 | return CXCursor_EnumConstantDecl; |
4207 | case Decl::Field: |
4208 | return CXCursor_FieldDecl; |
4209 | case Decl::Function: |
4210 | return CXCursor_FunctionDecl; |
4211 | case Decl::ObjCCategory: |
4212 | return CXCursor_ObjCCategoryDecl; |
4213 | case Decl::ObjCCategoryImpl: |
4214 | return CXCursor_ObjCCategoryImplDecl; |
4215 | case Decl::ObjCImplementation: |
4216 | return CXCursor_ObjCImplementationDecl; |
4217 | |
4218 | case Decl::ObjCInterface: |
4219 | return CXCursor_ObjCInterfaceDecl; |
4220 | case Decl::ObjCIvar: |
4221 | return CXCursor_ObjCIvarDecl; |
4222 | case Decl::ObjCMethod: |
4223 | return cast<ObjCMethodDecl>(Val: D)->isInstanceMethod() |
4224 | ? CXCursor_ObjCInstanceMethodDecl |
4225 | : CXCursor_ObjCClassMethodDecl; |
4226 | case Decl::CXXMethod: |
4227 | return CXCursor_CXXMethod; |
4228 | case Decl::CXXConstructor: |
4229 | return CXCursor_Constructor; |
4230 | case Decl::CXXDestructor: |
4231 | return CXCursor_Destructor; |
4232 | case Decl::CXXConversion: |
4233 | return CXCursor_ConversionFunction; |
4234 | case Decl::ObjCProperty: |
4235 | return CXCursor_ObjCPropertyDecl; |
4236 | case Decl::ObjCProtocol: |
4237 | return CXCursor_ObjCProtocolDecl; |
4238 | case Decl::ParmVar: |
4239 | return CXCursor_ParmDecl; |
4240 | case Decl::Typedef: |
4241 | return CXCursor_TypedefDecl; |
4242 | case Decl::TypeAlias: |
4243 | return CXCursor_TypeAliasDecl; |
4244 | case Decl::TypeAliasTemplate: |
4245 | return CXCursor_TypeAliasTemplateDecl; |
4246 | case Decl::Var: |
4247 | return CXCursor_VarDecl; |
4248 | case Decl::Namespace: |
4249 | return CXCursor_Namespace; |
4250 | case Decl::NamespaceAlias: |
4251 | return CXCursor_NamespaceAlias; |
4252 | case Decl::TemplateTypeParm: |
4253 | return CXCursor_TemplateTypeParameter; |
4254 | case Decl::NonTypeTemplateParm: |
4255 | return CXCursor_NonTypeTemplateParameter; |
4256 | case Decl::TemplateTemplateParm: |
4257 | return CXCursor_TemplateTemplateParameter; |
4258 | case Decl::FunctionTemplate: |
4259 | return CXCursor_FunctionTemplate; |
4260 | case Decl::ClassTemplate: |
4261 | return CXCursor_ClassTemplate; |
4262 | case Decl::AccessSpec: |
4263 | return CXCursor_CXXAccessSpecifier; |
4264 | case Decl::ClassTemplatePartialSpecialization: |
4265 | return CXCursor_ClassTemplatePartialSpecialization; |
4266 | case Decl::UsingDirective: |
4267 | return CXCursor_UsingDirective; |
4268 | case Decl::StaticAssert: |
4269 | return CXCursor_StaticAssert; |
4270 | case Decl::Friend: |
4271 | return CXCursor_FriendDecl; |
4272 | case Decl::TranslationUnit: |
4273 | return CXCursor_TranslationUnit; |
4274 | |
4275 | case Decl::Using: |
4276 | case Decl::UnresolvedUsingValue: |
4277 | case Decl::UnresolvedUsingTypename: |
4278 | return CXCursor_UsingDeclaration; |
4279 | |
4280 | case Decl::UsingEnum: |
4281 | return CXCursor_EnumDecl; |
4282 | |
4283 | case Decl::ObjCPropertyImpl: |
4284 | switch (cast<ObjCPropertyImplDecl>(Val: D)->getPropertyImplementation()) { |
4285 | case ObjCPropertyImplDecl::Dynamic: |
4286 | return CXCursor_ObjCDynamicDecl; |
4287 | |
4288 | case ObjCPropertyImplDecl::Synthesize: |
4289 | return CXCursor_ObjCSynthesizeDecl; |
4290 | } |
4291 | llvm_unreachable("Unexpected Kind!"); |
4292 | |
4293 | case Decl::Import: |
4294 | return CXCursor_ModuleImportDecl; |
4295 | |
4296 | case Decl::ObjCTypeParam: |
4297 | return CXCursor_TemplateTypeParameter; |
4298 | |
4299 | case Decl::Concept: |
4300 | return CXCursor_ConceptDecl; |
4301 | |
4302 | case Decl::LinkageSpec: |
4303 | return CXCursor_LinkageSpec; |
4304 | |
4305 | default: |
4306 | if (const auto *TD = dyn_cast<TagDecl>(Val: D)) { |
4307 | switch (TD->getTagKind()) { |
4308 | case TagTypeKind::Interface: // fall through |
4309 | case TagTypeKind::Struct: |
4310 | return CXCursor_StructDecl; |
4311 | case TagTypeKind::Class: |
4312 | return CXCursor_ClassDecl; |
4313 | case TagTypeKind::Union: |
4314 | return CXCursor_UnionDecl; |
4315 | case TagTypeKind::Enum: |
4316 | return CXCursor_EnumDecl; |
4317 | } |
4318 | } |
4319 | } |
4320 | |
4321 | return CXCursor_UnexposedDecl; |
4322 | } |
4323 | |
4324 | static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results, |
4325 | bool LoadExternal, bool IncludeUndefined, |
4326 | bool TargetTypeIsPointer = false) { |
4327 | typedef CodeCompletionResult Result; |
4328 | |
4329 | Results.EnterNewScope(); |
4330 | |
4331 | for (Preprocessor::macro_iterator M = PP.macro_begin(IncludeExternalMacros: LoadExternal), |
4332 | MEnd = PP.macro_end(IncludeExternalMacros: LoadExternal); |
4333 | M != MEnd; ++M) { |
4334 | auto MD = PP.getMacroDefinition(II: M->first); |
4335 | if (IncludeUndefined || MD) { |
4336 | MacroInfo *MI = MD.getMacroInfo(); |
4337 | if (MI && MI->isUsedForHeaderGuard()) |
4338 | continue; |
4339 | |
4340 | Results.AddResult( |
4341 | R: Result(M->first, MI, |
4342 | getMacroUsagePriority(MacroName: M->first->getName(), LangOpts: PP.getLangOpts(), |
4343 | PreferredTypeIsPointer: TargetTypeIsPointer))); |
4344 | } |
4345 | } |
4346 | |
4347 | Results.ExitScope(); |
4348 | } |
4349 | |
4350 | static void AddPrettyFunctionResults(const LangOptions &LangOpts, |
4351 | ResultBuilder &Results) { |
4352 | typedef CodeCompletionResult Result; |
4353 | |
4354 | Results.EnterNewScope(); |
4355 | |
4356 | Results.AddResult(R: Result("__PRETTY_FUNCTION__", CCP_Constant)); |
4357 | Results.AddResult(R: Result("__FUNCTION__", CCP_Constant)); |
4358 | if (LangOpts.C99 || LangOpts.CPlusPlus11) |
4359 | Results.AddResult(R: Result("__func__", CCP_Constant)); |
4360 | Results.ExitScope(); |
4361 | } |
4362 | |
4363 | static void HandleCodeCompleteResults(Sema *S, |
4364 | CodeCompleteConsumer *CodeCompleter, |
4365 | const CodeCompletionContext &Context, |
4366 | CodeCompletionResult *Results, |
4367 | unsigned NumResults) { |
4368 | if (CodeCompleter) |
4369 | CodeCompleter->ProcessCodeCompleteResults(S&: *S, Context, Results, NumResults); |
4370 | } |
4371 | |
4372 | static CodeCompletionContext |
4373 | mapCodeCompletionContext(Sema &S, |
4374 | SemaCodeCompletion::ParserCompletionContext PCC) { |
4375 | switch (PCC) { |
4376 | case SemaCodeCompletion::PCC_Namespace: |
4377 | return CodeCompletionContext::CCC_TopLevel; |
4378 | |
4379 | case SemaCodeCompletion::PCC_Class: |
4380 | return CodeCompletionContext::CCC_ClassStructUnion; |
4381 | |
4382 | case SemaCodeCompletion::PCC_ObjCInterface: |
4383 | return CodeCompletionContext::CCC_ObjCInterface; |
4384 | |
4385 | case SemaCodeCompletion::PCC_ObjCImplementation: |
4386 | return CodeCompletionContext::CCC_ObjCImplementation; |
4387 | |
4388 | case SemaCodeCompletion::PCC_ObjCInstanceVariableList: |
4389 | return CodeCompletionContext::CCC_ObjCIvarList; |
4390 | |
4391 | case SemaCodeCompletion::PCC_Template: |
4392 | case SemaCodeCompletion::PCC_MemberTemplate: |
4393 | if (S.CurContext->isFileContext()) |
4394 | return CodeCompletionContext::CCC_TopLevel; |
4395 | if (S.CurContext->isRecord()) |
4396 | return CodeCompletionContext::CCC_ClassStructUnion; |
4397 | return CodeCompletionContext::CCC_Other; |
4398 | |
4399 | case SemaCodeCompletion::PCC_RecoveryInFunction: |
4400 | return CodeCompletionContext::CCC_Recovery; |
4401 | |
4402 | case SemaCodeCompletion::PCC_ForInit: |
4403 | if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 || |
4404 | S.getLangOpts().ObjC) |
4405 | return CodeCompletionContext::CCC_ParenthesizedExpression; |
4406 | else |
4407 | return CodeCompletionContext::CCC_Expression; |
4408 | |
4409 | case SemaCodeCompletion::PCC_Expression: |
4410 | return CodeCompletionContext::CCC_Expression; |
4411 | case SemaCodeCompletion::PCC_Condition: |
4412 | return CodeCompletionContext(CodeCompletionContext::CCC_Expression, |
4413 | S.getASTContext().BoolTy); |
4414 | |
4415 | case SemaCodeCompletion::PCC_Statement: |
4416 | return CodeCompletionContext::CCC_Statement; |
4417 | |
4418 | case SemaCodeCompletion::PCC_Type: |
4419 | return CodeCompletionContext::CCC_Type; |
4420 | |
4421 | case SemaCodeCompletion::PCC_ParenthesizedExpression: |
4422 | return CodeCompletionContext::CCC_ParenthesizedExpression; |
4423 | |
4424 | case SemaCodeCompletion::PCC_LocalDeclarationSpecifiers: |
4425 | return CodeCompletionContext::CCC_Type; |
4426 | case SemaCodeCompletion::PCC_TopLevelOrExpression: |
4427 | return CodeCompletionContext::CCC_TopLevelOrExpression; |
4428 | } |
4429 | |
4430 | llvm_unreachable("Invalid ParserCompletionContext!"); |
4431 | } |
4432 | |
4433 | /// If we're in a C++ virtual member function, add completion results |
4434 | /// that invoke the functions we override, since it's common to invoke the |
4435 | /// overridden function as well as adding new functionality. |
4436 | /// |
4437 | /// \param S The semantic analysis object for which we are generating results. |
4438 | /// |
4439 | /// \param InContext This context in which the nested-name-specifier preceding |
4440 | /// the code-completion point |
4441 | static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext, |
4442 | ResultBuilder &Results) { |
4443 | // Look through blocks. |
4444 | DeclContext *CurContext = S.CurContext; |
4445 | while (isa<BlockDecl>(Val: CurContext)) |
4446 | CurContext = CurContext->getParent(); |
4447 | |
4448 | CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Val: CurContext); |
4449 | if (!Method || !Method->isVirtual()) |
4450 | return; |
4451 | |
4452 | // We need to have names for all of the parameters, if we're going to |
4453 | // generate a forwarding call. |
4454 | for (auto *P : Method->parameters()) |
4455 | if (!P->getDeclName()) |
4456 | return; |
4457 | |
4458 | PrintingPolicy Policy = getCompletionPrintingPolicy(S); |
4459 | for (const CXXMethodDecl *Overridden : Method->overridden_methods()) { |
4460 | CodeCompletionBuilder Builder(Results.getAllocator(), |
4461 | Results.getCodeCompletionTUInfo()); |
4462 | if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl()) |
4463 | continue; |
4464 | |
4465 | // If we need a nested-name-specifier, add one now. |
4466 | if (!InContext) { |
4467 | NestedNameSpecifier *NNS = getRequiredQualification( |
4468 | S.Context, CurContext, Overridden->getDeclContext()); |
4469 | if (NNS) { |
4470 | std::string Str; |
4471 | llvm::raw_string_ostream OS(Str); |
4472 | NNS->print(OS, Policy); |
4473 | Builder.AddTextChunk(Text: Results.getAllocator().CopyString(String: Str)); |
4474 | } |
4475 | } else if (!InContext->Equals(DC: Overridden->getDeclContext())) |
4476 | continue; |
4477 | |
4478 | Builder.AddTypedTextChunk( |
4479 | Text: Results.getAllocator().CopyString(String: Overridden->getNameAsString())); |
4480 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
4481 | bool FirstParam = true; |
4482 | for (auto *P : Method->parameters()) { |
4483 | if (FirstParam) |
4484 | FirstParam = false; |
4485 | else |
4486 | Builder.AddChunk(CodeCompletionString::CK_Comma); |
4487 | |
4488 | Builder.AddPlaceholderChunk( |
4489 | Results.getAllocator().CopyString(P->getIdentifier()->getName())); |
4490 | } |
4491 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
4492 | Results.AddResult(R: CodeCompletionResult( |
4493 | Builder.TakeString(), CCP_SuperCompletion, CXCursor_CXXMethod, |
4494 | CXAvailability_Available, Overridden)); |
4495 | Results.Ignore(Overridden); |
4496 | } |
4497 | } |
4498 | |
4499 | void SemaCodeCompletion::CodeCompleteModuleImport(SourceLocation ImportLoc, |
4500 | ModuleIdPath Path) { |
4501 | typedef CodeCompletionResult Result; |
4502 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
4503 | CodeCompleter->getCodeCompletionTUInfo(), |
4504 | CodeCompletionContext::CCC_Other); |
4505 | Results.EnterNewScope(); |
4506 | |
4507 | CodeCompletionAllocator &Allocator = Results.getAllocator(); |
4508 | CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo()); |
4509 | typedef CodeCompletionResult Result; |
4510 | if (Path.empty()) { |
4511 | // Enumerate all top-level modules. |
4512 | SmallVector<Module *, 8> Modules; |
4513 | SemaRef.PP.getHeaderSearchInfo().collectAllModules(Modules); |
4514 | for (unsigned I = 0, N = Modules.size(); I != N; ++I) { |
4515 | Builder.AddTypedTextChunk( |
4516 | Text: Builder.getAllocator().CopyString(String: Modules[I]->Name)); |
4517 | Results.AddResult(R: Result( |
4518 | Builder.TakeString(), CCP_Declaration, CXCursor_ModuleImportDecl, |
4519 | Modules[I]->isAvailable() ? CXAvailability_Available |
4520 | : CXAvailability_NotAvailable)); |
4521 | } |
4522 | } else if (getLangOpts().Modules) { |
4523 | // Load the named module. |
4524 | Module *Mod = SemaRef.PP.getModuleLoader().loadModule( |
4525 | ImportLoc, Path, Visibility: Module::AllVisible, |
4526 | /*IsInclusionDirective=*/false); |
4527 | // Enumerate submodules. |
4528 | if (Mod) { |
4529 | for (auto *Submodule : Mod->submodules()) { |
4530 | Builder.AddTypedTextChunk( |
4531 | Text: Builder.getAllocator().CopyString(String: Submodule->Name)); |
4532 | Results.AddResult(R: Result( |
4533 | Builder.TakeString(), CCP_Declaration, CXCursor_ModuleImportDecl, |
4534 | Submodule->isAvailable() ? CXAvailability_Available |
4535 | : CXAvailability_NotAvailable)); |
4536 | } |
4537 | } |
4538 | } |
4539 | Results.ExitScope(); |
4540 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
4541 | Context: Results.getCompletionContext(), Results: Results.data(), |
4542 | NumResults: Results.size()); |
4543 | } |
4544 | |
4545 | void SemaCodeCompletion::CodeCompleteOrdinaryName( |
4546 | Scope *S, SemaCodeCompletion::ParserCompletionContext CompletionContext) { |
4547 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
4548 | CodeCompleter->getCodeCompletionTUInfo(), |
4549 | mapCodeCompletionContext(S&: SemaRef, PCC: CompletionContext)); |
4550 | Results.EnterNewScope(); |
4551 | |
4552 | // Determine how to filter results, e.g., so that the names of |
4553 | // values (functions, enumerators, function templates, etc.) are |
4554 | // only allowed where we can have an expression. |
4555 | switch (CompletionContext) { |
4556 | case PCC_Namespace: |
4557 | case PCC_Class: |
4558 | case PCC_ObjCInterface: |
4559 | case PCC_ObjCImplementation: |
4560 | case PCC_ObjCInstanceVariableList: |
4561 | case PCC_Template: |
4562 | case PCC_MemberTemplate: |
4563 | case PCC_Type: |
4564 | case PCC_LocalDeclarationSpecifiers: |
4565 | Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName); |
4566 | break; |
4567 | |
4568 | case PCC_Statement: |
4569 | case PCC_TopLevelOrExpression: |
4570 | case PCC_ParenthesizedExpression: |
4571 | case PCC_Expression: |
4572 | case PCC_ForInit: |
4573 | case PCC_Condition: |
4574 | if (WantTypesInContext(CCC: CompletionContext, LangOpts: getLangOpts())) |
4575 | Results.setFilter(&ResultBuilder::IsOrdinaryName); |
4576 | else |
4577 | Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName); |
4578 | |
4579 | if (getLangOpts().CPlusPlus) |
4580 | MaybeAddOverrideCalls(S&: SemaRef, /*InContext=*/nullptr, Results); |
4581 | break; |
4582 | |
4583 | case PCC_RecoveryInFunction: |
4584 | // Unfiltered |
4585 | break; |
4586 | } |
4587 | |
4588 | // If we are in a C++ non-static member function, check the qualifiers on |
4589 | // the member function to filter/prioritize the results list. |
4590 | auto ThisType = SemaRef.getCurrentThisType(); |
4591 | if (!ThisType.isNull()) |
4592 | Results.setObjectTypeQualifiers(Quals: ThisType->getPointeeType().getQualifiers(), |
4593 | Kind: VK_LValue); |
4594 | |
4595 | CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext); |
4596 | SemaRef.LookupVisibleDecls(S, SemaRef.LookupOrdinaryName, Consumer, |
4597 | CodeCompleter->includeGlobals(), |
4598 | CodeCompleter->loadExternal()); |
4599 | |
4600 | AddOrdinaryNameResults(CCC: CompletionContext, S, SemaRef, Results); |
4601 | Results.ExitScope(); |
4602 | |
4603 | switch (CompletionContext) { |
4604 | case PCC_ParenthesizedExpression: |
4605 | case PCC_Expression: |
4606 | case PCC_Statement: |
4607 | case PCC_TopLevelOrExpression: |
4608 | case PCC_RecoveryInFunction: |
4609 | if (S->getFnParent()) |
4610 | AddPrettyFunctionResults(LangOpts: getLangOpts(), Results); |
4611 | break; |
4612 | |
4613 | case PCC_Namespace: |
4614 | case PCC_Class: |
4615 | case PCC_ObjCInterface: |
4616 | case PCC_ObjCImplementation: |
4617 | case PCC_ObjCInstanceVariableList: |
4618 | case PCC_Template: |
4619 | case PCC_MemberTemplate: |
4620 | case PCC_ForInit: |
4621 | case PCC_Condition: |
4622 | case PCC_Type: |
4623 | case PCC_LocalDeclarationSpecifiers: |
4624 | break; |
4625 | } |
4626 | |
4627 | if (CodeCompleter->includeMacros()) |
4628 | AddMacroResults(PP&: SemaRef.PP, Results, LoadExternal: CodeCompleter->loadExternal(), IncludeUndefined: false); |
4629 | |
4630 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
4631 | Context: Results.getCompletionContext(), Results: Results.data(), |
4632 | NumResults: Results.size()); |
4633 | } |
4634 | |
4635 | static void |
4636 | AddClassMessageCompletions(Sema &SemaRef, Scope *S, ParsedType Receiver, |
4637 | ArrayRef<const IdentifierInfo *> SelIdents, |
4638 | bool AtArgumentExpression, bool IsSuper, |
4639 | ResultBuilder &Results); |
4640 | |
4641 | void SemaCodeCompletion::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS, |
4642 | bool AllowNonIdentifiers, |
4643 | bool AllowNestedNameSpecifiers) { |
4644 | typedef CodeCompletionResult Result; |
4645 | ResultBuilder Results( |
4646 | SemaRef, CodeCompleter->getAllocator(), |
4647 | CodeCompleter->getCodeCompletionTUInfo(), |
4648 | AllowNestedNameSpecifiers |
4649 | // FIXME: Try to separate codepath leading here to deduce whether we |
4650 | // need an existing symbol or a new one. |
4651 | ? CodeCompletionContext::CCC_SymbolOrNewName |
4652 | : CodeCompletionContext::CCC_NewName); |
4653 | Results.EnterNewScope(); |
4654 | |
4655 | // Type qualifiers can come after names. |
4656 | Results.AddResult(R: Result("const")); |
4657 | Results.AddResult(R: Result("volatile")); |
4658 | if (getLangOpts().C99) |
4659 | Results.AddResult(R: Result("restrict")); |
4660 | |
4661 | if (getLangOpts().CPlusPlus) { |
4662 | if (getLangOpts().CPlusPlus11 && |
4663 | (DS.getTypeSpecType() == DeclSpec::TST_class || |
4664 | DS.getTypeSpecType() == DeclSpec::TST_struct)) |
4665 | Results.AddResult(R: "final"); |
4666 | |
4667 | if (AllowNonIdentifiers) { |
4668 | Results.AddResult(R: Result("operator")); |
4669 | } |
4670 | |
4671 | // Add nested-name-specifiers. |
4672 | if (AllowNestedNameSpecifiers) { |
4673 | Results.allowNestedNameSpecifiers(); |
4674 | Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy); |
4675 | CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext); |
4676 | SemaRef.LookupVisibleDecls(S, Sema::LookupNestedNameSpecifierName, |
4677 | Consumer, CodeCompleter->includeGlobals(), |
4678 | CodeCompleter->loadExternal()); |
4679 | Results.setFilter(nullptr); |
4680 | } |
4681 | } |
4682 | Results.ExitScope(); |
4683 | |
4684 | // If we're in a context where we might have an expression (rather than a |
4685 | // declaration), and what we've seen so far is an Objective-C type that could |
4686 | // be a receiver of a class message, this may be a class message send with |
4687 | // the initial opening bracket '[' missing. Add appropriate completions. |
4688 | if (AllowNonIdentifiers && !AllowNestedNameSpecifiers && |
4689 | DS.getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier && |
4690 | DS.getTypeSpecType() == DeclSpec::TST_typename && |
4691 | DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified && |
4692 | DS.getTypeSpecSign() == TypeSpecifierSign::Unspecified && |
4693 | !DS.isTypeAltiVecVector() && S && |
4694 | (S->getFlags() & Scope::DeclScope) != 0 && |
4695 | (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope | |
4696 | Scope::FunctionPrototypeScope | Scope::AtCatchScope)) == |
4697 | 0) { |
4698 | ParsedType T = DS.getRepAsType(); |
4699 | if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType()) |
4700 | AddClassMessageCompletions(SemaRef, S, Receiver: T, SelIdents: {}, AtArgumentExpression: false, IsSuper: false, Results); |
4701 | } |
4702 | |
4703 | // Note that we intentionally suppress macro results here, since we do not |
4704 | // encourage using macros to produce the names of entities. |
4705 | |
4706 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
4707 | Context: Results.getCompletionContext(), Results: Results.data(), |
4708 | NumResults: Results.size()); |
4709 | } |
4710 | |
4711 | static const char *underscoreAttrScope(llvm::StringRef Scope) { |
4712 | if (Scope == "clang") |
4713 | return "_Clang"; |
4714 | if (Scope == "gnu") |
4715 | return "__gnu__"; |
4716 | return nullptr; |
4717 | } |
4718 | |
4719 | static const char *noUnderscoreAttrScope(llvm::StringRef Scope) { |
4720 | if (Scope == "_Clang") |
4721 | return "clang"; |
4722 | if (Scope == "__gnu__") |
4723 | return "gnu"; |
4724 | return nullptr; |
4725 | } |
4726 | |
4727 | void SemaCodeCompletion::CodeCompleteAttribute( |
4728 | AttributeCommonInfo::Syntax Syntax, AttributeCompletion Completion, |
4729 | const IdentifierInfo *InScope) { |
4730 | if (Completion == AttributeCompletion::None) |
4731 | return; |
4732 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
4733 | CodeCompleter->getCodeCompletionTUInfo(), |
4734 | CodeCompletionContext::CCC_Attribute); |
4735 | |
4736 | // We're going to iterate over the normalized spellings of the attribute. |
4737 | // These don't include "underscore guarding": the normalized spelling is |
4738 | // clang::foo but you can also write _Clang::__foo__. |
4739 | // |
4740 | // (Clang supports a mix like clang::__foo__ but we won't suggest it: either |
4741 | // you care about clashing with macros or you don't). |
4742 | // |
4743 | // So if we're already in a scope, we determine its canonical spellings |
4744 | // (for comparison with normalized attr spelling) and remember whether it was |
4745 | // underscore-guarded (so we know how to spell contained attributes). |
4746 | llvm::StringRef InScopeName; |
4747 | bool InScopeUnderscore = false; |
4748 | if (InScope) { |
4749 | InScopeName = InScope->getName(); |
4750 | if (const char *NoUnderscore = noUnderscoreAttrScope(Scope: InScopeName)) { |
4751 | InScopeName = NoUnderscore; |
4752 | InScopeUnderscore = true; |
4753 | } |
4754 | } |
4755 | bool SyntaxSupportsGuards = Syntax == AttributeCommonInfo::AS_GNU || |
4756 | Syntax == AttributeCommonInfo::AS_CXX11 || |
4757 | Syntax == AttributeCommonInfo::AS_C23; |
4758 | |
4759 | llvm::DenseSet<llvm::StringRef> FoundScopes; |
4760 | auto AddCompletions = [&](const ParsedAttrInfo &A) { |
4761 | if (A.IsTargetSpecific && |
4762 | !A.existsInTarget(Target: getASTContext().getTargetInfo())) |
4763 | return; |
4764 | if (!A.acceptsLangOpts(LO: getLangOpts())) |
4765 | return; |
4766 | for (const auto &S : A.Spellings) { |
4767 | if (S.Syntax != Syntax) |
4768 | continue; |
4769 | llvm::StringRef Name = S.NormalizedFullName; |
4770 | llvm::StringRef Scope; |
4771 | if ((Syntax == AttributeCommonInfo::AS_CXX11 || |
4772 | Syntax == AttributeCommonInfo::AS_C23)) { |
4773 | std::tie(args&: Scope, args&: Name) = Name.split(Separator: "::"); |
4774 | if (Name.empty()) // oops, unscoped |
4775 | std::swap(a&: Name, b&: Scope); |
4776 | } |
4777 | |
4778 | // Do we just want a list of scopes rather than attributes? |
4779 | if (Completion == AttributeCompletion::Scope) { |
4780 | // Make sure to emit each scope only once. |
4781 | if (!Scope.empty() && FoundScopes.insert(V: Scope).second) { |
4782 | Results.AddResult( |
4783 | R: CodeCompletionResult(Results.getAllocator().CopyString(String: Scope))); |
4784 | // Include alternate form (__gnu__ instead of gnu). |
4785 | if (const char *Scope2 = underscoreAttrScope(Scope)) |
4786 | Results.AddResult(R: CodeCompletionResult(Scope2)); |
4787 | } |
4788 | continue; |
4789 | } |
4790 | |
4791 | // If a scope was specified, it must match but we don't need to print it. |
4792 | if (!InScopeName.empty()) { |
4793 | if (Scope != InScopeName) |
4794 | continue; |
4795 | Scope = ""; |
4796 | } |
4797 | |
4798 | auto Add = [&](llvm::StringRef Scope, llvm::StringRef Name, |
4799 | bool Underscores) { |
4800 | CodeCompletionBuilder Builder(Results.getAllocator(), |
4801 | Results.getCodeCompletionTUInfo()); |
4802 | llvm::SmallString<32> Text; |
4803 | if (!Scope.empty()) { |
4804 | Text.append(RHS: Scope); |
4805 | Text.append(RHS: "::"); |
4806 | } |
4807 | if (Underscores) |
4808 | Text.append(RHS: "__"); |
4809 | Text.append(RHS: Name); |
4810 | if (Underscores) |
4811 | Text.append(RHS: "__"); |
4812 | Builder.AddTypedTextChunk(Text: Results.getAllocator().CopyString(String: Text)); |
4813 | |
4814 | if (!A.ArgNames.empty()) { |
4815 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen, Text: "("); |
4816 | bool First = true; |
4817 | for (const char *Arg : A.ArgNames) { |
4818 | if (!First) |
4819 | Builder.AddChunk(CK: CodeCompletionString::CK_Comma, Text: ", "); |
4820 | First = false; |
4821 | Builder.AddPlaceholderChunk(Placeholder: Arg); |
4822 | } |
4823 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen, Text: ")"); |
4824 | } |
4825 | |
4826 | Results.AddResult(R: Builder.TakeString()); |
4827 | }; |
4828 | |
4829 | // Generate the non-underscore-guarded result. |
4830 | // Note this is (a suffix of) the NormalizedFullName, no need to copy. |
4831 | // If an underscore-guarded scope was specified, only the |
4832 | // underscore-guarded attribute name is relevant. |
4833 | if (!InScopeUnderscore) |
4834 | Add(Scope, Name, /*Underscores=*/false); |
4835 | |
4836 | // Generate the underscore-guarded version, for syntaxes that support it. |
4837 | // We skip this if the scope was already spelled and not guarded, or |
4838 | // we must spell it and can't guard it. |
4839 | if (!(InScope && !InScopeUnderscore) && SyntaxSupportsGuards) { |
4840 | if (Scope.empty()) { |
4841 | Add(Scope, Name, /*Underscores=*/true); |
4842 | } else { |
4843 | const char *GuardedScope = underscoreAttrScope(Scope); |
4844 | if (!GuardedScope) |
4845 | continue; |
4846 | Add(GuardedScope, Name, /*Underscores=*/true); |
4847 | } |
4848 | } |
4849 | |
4850 | // It may be nice to include the Kind so we can look up the docs later. |
4851 | } |
4852 | }; |
4853 | |
4854 | for (const auto *A : ParsedAttrInfo::getAllBuiltin()) |
4855 | AddCompletions(*A); |
4856 | for (const auto &Entry : ParsedAttrInfoRegistry::entries()) |
4857 | AddCompletions(*Entry.instantiate()); |
4858 | |
4859 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
4860 | Context: Results.getCompletionContext(), Results: Results.data(), |
4861 | NumResults: Results.size()); |
4862 | } |
4863 | |
4864 | struct SemaCodeCompletion::CodeCompleteExpressionData { |
4865 | CodeCompleteExpressionData(QualType PreferredType = QualType(), |
4866 | bool IsParenthesized = false) |
4867 | : PreferredType(PreferredType), IntegralConstantExpression(false), |
4868 | ObjCCollection(false), IsParenthesized(IsParenthesized) {} |
4869 | |
4870 | QualType PreferredType; |
4871 | bool IntegralConstantExpression; |
4872 | bool ObjCCollection; |
4873 | bool IsParenthesized; |
4874 | SmallVector<Decl *, 4> IgnoreDecls; |
4875 | }; |
4876 | |
4877 | namespace { |
4878 | /// Information that allows to avoid completing redundant enumerators. |
4879 | struct CoveredEnumerators { |
4880 | llvm::SmallPtrSet<EnumConstantDecl *, 8> Seen; |
4881 | NestedNameSpecifier *SuggestedQualifier = nullptr; |
4882 | }; |
4883 | } // namespace |
4884 | |
4885 | static void AddEnumerators(ResultBuilder &Results, ASTContext &Context, |
4886 | EnumDecl *Enum, DeclContext *CurContext, |
4887 | const CoveredEnumerators &Enumerators) { |
4888 | NestedNameSpecifier *Qualifier = Enumerators.SuggestedQualifier; |
4889 | if (Context.getLangOpts().CPlusPlus && !Qualifier && Enumerators.Seen.empty()) { |
4890 | // If there are no prior enumerators in C++, check whether we have to |
4891 | // qualify the names of the enumerators that we suggest, because they |
4892 | // may not be visible in this scope. |
4893 | Qualifier = getRequiredQualification(Context, CurContext, Enum); |
4894 | } |
4895 | |
4896 | Results.EnterNewScope(); |
4897 | for (auto *E : Enum->enumerators()) { |
4898 | if (Enumerators.Seen.count(Ptr: E)) |
4899 | continue; |
4900 | |
4901 | CodeCompletionResult R(E, CCP_EnumInCase, Qualifier); |
4902 | Results.AddResult(R, CurContext, Hiding: nullptr, InBaseClass: false); |
4903 | } |
4904 | Results.ExitScope(); |
4905 | } |
4906 | |
4907 | /// Try to find a corresponding FunctionProtoType for function-like types (e.g. |
4908 | /// function pointers, std::function, etc). |
4909 | static const FunctionProtoType *TryDeconstructFunctionLike(QualType T) { |
4910 | assert(!T.isNull()); |
4911 | // Try to extract first template argument from std::function<> and similar. |
4912 | // Note we only handle the sugared types, they closely match what users wrote. |
4913 | // We explicitly choose to not handle ClassTemplateSpecializationDecl. |
4914 | if (auto *Specialization = T->getAs<TemplateSpecializationType>()) { |
4915 | if (Specialization->template_arguments().size() != 1) |
4916 | return nullptr; |
4917 | const TemplateArgument &Argument = Specialization->template_arguments()[0]; |
4918 | if (Argument.getKind() != TemplateArgument::Type) |
4919 | return nullptr; |
4920 | return Argument.getAsType()->getAs<FunctionProtoType>(); |
4921 | } |
4922 | // Handle other cases. |
4923 | if (T->isPointerType()) |
4924 | T = T->getPointeeType(); |
4925 | return T->getAs<FunctionProtoType>(); |
4926 | } |
4927 | |
4928 | /// Adds a pattern completion for a lambda expression with the specified |
4929 | /// parameter types and placeholders for parameter names. |
4930 | static void AddLambdaCompletion(ResultBuilder &Results, |
4931 | llvm::ArrayRef<QualType> Parameters, |
4932 | const LangOptions &LangOpts) { |
4933 | if (!Results.includeCodePatterns()) |
4934 | return; |
4935 | CodeCompletionBuilder Completion(Results.getAllocator(), |
4936 | Results.getCodeCompletionTUInfo()); |
4937 | // [](<parameters>) {} |
4938 | Completion.AddChunk(CK: CodeCompletionString::CK_LeftBracket); |
4939 | Completion.AddPlaceholderChunk(Placeholder: "="); |
4940 | Completion.AddChunk(CK: CodeCompletionString::CK_RightBracket); |
4941 | if (!Parameters.empty()) { |
4942 | Completion.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
4943 | bool First = true; |
4944 | for (auto Parameter : Parameters) { |
4945 | if (!First) |
4946 | Completion.AddChunk(CK: CodeCompletionString::ChunkKind::CK_Comma); |
4947 | else |
4948 | First = false; |
4949 | |
4950 | constexpr llvm::StringLiteral NamePlaceholder = "!#!NAME_GOES_HERE!#!"; |
4951 | std::string Type = std::string(NamePlaceholder); |
4952 | Parameter.getAsStringInternal(Str&: Type, Policy: PrintingPolicy(LangOpts)); |
4953 | llvm::StringRef Prefix, Suffix; |
4954 | std::tie(args&: Prefix, args&: Suffix) = llvm::StringRef(Type).split(Separator: NamePlaceholder); |
4955 | Prefix = Prefix.rtrim(); |
4956 | Suffix = Suffix.ltrim(); |
4957 | |
4958 | Completion.AddTextChunk(Text: Completion.getAllocator().CopyString(String: Prefix)); |
4959 | Completion.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
4960 | Completion.AddPlaceholderChunk(Placeholder: "parameter"); |
4961 | Completion.AddTextChunk(Text: Completion.getAllocator().CopyString(String: Suffix)); |
4962 | }; |
4963 | Completion.AddChunk(CK: CodeCompletionString::CK_RightParen); |
4964 | } |
4965 | Completion.AddChunk(CK: clang::CodeCompletionString::CK_HorizontalSpace); |
4966 | Completion.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
4967 | Completion.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
4968 | Completion.AddPlaceholderChunk(Placeholder: "body"); |
4969 | Completion.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
4970 | Completion.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
4971 | |
4972 | Results.AddResult(R: Completion.TakeString()); |
4973 | } |
4974 | |
4975 | /// Perform code-completion in an expression context when we know what |
4976 | /// type we're looking for. |
4977 | void SemaCodeCompletion::CodeCompleteExpression( |
4978 | Scope *S, const CodeCompleteExpressionData &Data) { |
4979 | ResultBuilder Results( |
4980 | SemaRef, CodeCompleter->getAllocator(), |
4981 | CodeCompleter->getCodeCompletionTUInfo(), |
4982 | CodeCompletionContext( |
4983 | Data.IsParenthesized |
4984 | ? CodeCompletionContext::CCC_ParenthesizedExpression |
4985 | : CodeCompletionContext::CCC_Expression, |
4986 | Data.PreferredType)); |
4987 | auto PCC = |
4988 | Data.IsParenthesized ? PCC_ParenthesizedExpression : PCC_Expression; |
4989 | if (Data.ObjCCollection) |
4990 | Results.setFilter(&ResultBuilder::IsObjCCollection); |
4991 | else if (Data.IntegralConstantExpression) |
4992 | Results.setFilter(&ResultBuilder::IsIntegralConstantValue); |
4993 | else if (WantTypesInContext(CCC: PCC, LangOpts: getLangOpts())) |
4994 | Results.setFilter(&ResultBuilder::IsOrdinaryName); |
4995 | else |
4996 | Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName); |
4997 | |
4998 | if (!Data.PreferredType.isNull()) |
4999 | Results.setPreferredType(Data.PreferredType.getNonReferenceType()); |
5000 | |
5001 | // Ignore any declarations that we were told that we don't care about. |
5002 | for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I) |
5003 | Results.Ignore(D: Data.IgnoreDecls[I]); |
5004 | |
5005 | CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext); |
5006 | SemaRef.LookupVisibleDecls(S, Sema::LookupOrdinaryName, Consumer, |
5007 | CodeCompleter->includeGlobals(), |
5008 | CodeCompleter->loadExternal()); |
5009 | |
5010 | Results.EnterNewScope(); |
5011 | AddOrdinaryNameResults(CCC: PCC, S, SemaRef, Results); |
5012 | Results.ExitScope(); |
5013 | |
5014 | bool PreferredTypeIsPointer = false; |
5015 | if (!Data.PreferredType.isNull()) { |
5016 | PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType() || |
5017 | Data.PreferredType->isMemberPointerType() || |
5018 | Data.PreferredType->isBlockPointerType(); |
5019 | if (Data.PreferredType->isEnumeralType()) { |
5020 | EnumDecl *Enum = Data.PreferredType->castAs<EnumType>()->getDecl(); |
5021 | if (auto *Def = Enum->getDefinition()) |
5022 | Enum = Def; |
5023 | // FIXME: collect covered enumerators in cases like: |
5024 | // if (x == my_enum::one) { ... } else if (x == ^) {} |
5025 | AddEnumerators(Results, Context&: getASTContext(), Enum, CurContext: SemaRef.CurContext, |
5026 | Enumerators: CoveredEnumerators()); |
5027 | } |
5028 | } |
5029 | |
5030 | if (S->getFnParent() && !Data.ObjCCollection && |
5031 | !Data.IntegralConstantExpression) |
5032 | AddPrettyFunctionResults(LangOpts: getLangOpts(), Results); |
5033 | |
5034 | if (CodeCompleter->includeMacros()) |
5035 | AddMacroResults(PP&: SemaRef.PP, Results, LoadExternal: CodeCompleter->loadExternal(), IncludeUndefined: false, |
5036 | TargetTypeIsPointer: PreferredTypeIsPointer); |
5037 | |
5038 | // Complete a lambda expression when preferred type is a function. |
5039 | if (!Data.PreferredType.isNull() && getLangOpts().CPlusPlus11) { |
5040 | if (const FunctionProtoType *F = |
5041 | TryDeconstructFunctionLike(Data.PreferredType)) |
5042 | AddLambdaCompletion(Results, Parameters: F->getParamTypes(), LangOpts: getLangOpts()); |
5043 | } |
5044 | |
5045 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
5046 | Context: Results.getCompletionContext(), Results: Results.data(), |
5047 | NumResults: Results.size()); |
5048 | } |
5049 | |
5050 | void SemaCodeCompletion::CodeCompleteExpression(Scope *S, |
5051 | QualType PreferredType, |
5052 | bool IsParenthesized) { |
5053 | return CodeCompleteExpression( |
5054 | S, Data: CodeCompleteExpressionData(PreferredType, IsParenthesized)); |
5055 | } |
5056 | |
5057 | void SemaCodeCompletion::CodeCompletePostfixExpression(Scope *S, ExprResult E, |
5058 | QualType PreferredType) { |
5059 | if (E.isInvalid()) |
5060 | CodeCompleteExpression(S, PreferredType); |
5061 | else if (getLangOpts().ObjC) |
5062 | CodeCompleteObjCInstanceMessage(S, Receiver: E.get(), SelIdents: {}, AtArgumentExpression: false); |
5063 | } |
5064 | |
5065 | /// The set of properties that have already been added, referenced by |
5066 | /// property name. |
5067 | typedef llvm::SmallPtrSet<const IdentifierInfo *, 16> AddedPropertiesSet; |
5068 | |
5069 | /// Retrieve the container definition, if any? |
5070 | static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) { |
5071 | if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Val: Container)) { |
5072 | if (Interface->hasDefinition()) |
5073 | return Interface->getDefinition(); |
5074 | |
5075 | return Interface; |
5076 | } |
5077 | |
5078 | if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Val: Container)) { |
5079 | if (Protocol->hasDefinition()) |
5080 | return Protocol->getDefinition(); |
5081 | |
5082 | return Protocol; |
5083 | } |
5084 | return Container; |
5085 | } |
5086 | |
5087 | /// Adds a block invocation code completion result for the given block |
5088 | /// declaration \p BD. |
5089 | static void AddObjCBlockCall(ASTContext &Context, const PrintingPolicy &Policy, |
5090 | CodeCompletionBuilder &Builder, |
5091 | const NamedDecl *BD, |
5092 | const FunctionTypeLoc &BlockLoc, |
5093 | const FunctionProtoTypeLoc &BlockProtoLoc) { |
5094 | Builder.AddResultTypeChunk( |
5095 | ResultType: GetCompletionTypeString(T: BlockLoc.getReturnLoc().getType(), Context, |
5096 | Policy, Allocator&: Builder.getAllocator())); |
5097 | |
5098 | AddTypedNameChunk(Context, Policy, ND: BD, Result&: Builder); |
5099 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
5100 | |
5101 | if (BlockProtoLoc && BlockProtoLoc.getTypePtr()->isVariadic()) { |
5102 | Builder.AddPlaceholderChunk(Placeholder: "..."); |
5103 | } else { |
5104 | for (unsigned I = 0, N = BlockLoc.getNumParams(); I != N; ++I) { |
5105 | if (I) |
5106 | Builder.AddChunk(CK: CodeCompletionString::CK_Comma); |
5107 | |
5108 | // Format the placeholder string. |
5109 | std::string PlaceholderStr = |
5110 | FormatFunctionParameter(Policy, BlockLoc.getParam(i: I)); |
5111 | |
5112 | if (I == N - 1 && BlockProtoLoc && |
5113 | BlockProtoLoc.getTypePtr()->isVariadic()) |
5114 | PlaceholderStr += ", ..."; |
5115 | |
5116 | // Add the placeholder string. |
5117 | Builder.AddPlaceholderChunk( |
5118 | Placeholder: Builder.getAllocator().CopyString(String: PlaceholderStr)); |
5119 | } |
5120 | } |
5121 | |
5122 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
5123 | } |
5124 | |
5125 | static void |
5126 | AddObjCProperties(const CodeCompletionContext &CCContext, |
5127 | ObjCContainerDecl *Container, bool AllowCategories, |
5128 | bool AllowNullaryMethods, DeclContext *CurContext, |
5129 | AddedPropertiesSet &AddedProperties, ResultBuilder &Results, |
5130 | bool IsBaseExprStatement = false, |
5131 | bool IsClassProperty = false, bool InOriginalClass = true) { |
5132 | typedef CodeCompletionResult Result; |
5133 | |
5134 | // Retrieve the definition. |
5135 | Container = getContainerDef(Container); |
5136 | |
5137 | // Add properties in this container. |
5138 | const auto AddProperty = [&](const ObjCPropertyDecl *P) { |
5139 | if (!AddedProperties.insert(P->getIdentifier()).second) |
5140 | return; |
5141 | |
5142 | // FIXME: Provide block invocation completion for non-statement |
5143 | // expressions. |
5144 | if (!P->getType().getTypePtr()->isBlockPointerType() || |
5145 | !IsBaseExprStatement) { |
5146 | Result R = Result(P, Results.getBasePriority(P), nullptr); |
5147 | if (!InOriginalClass) |
5148 | setInBaseClass(R); |
5149 | Results.MaybeAddResult(R, CurContext); |
5150 | return; |
5151 | } |
5152 | |
5153 | // Block setter and invocation completion is provided only when we are able |
5154 | // to find the FunctionProtoTypeLoc with parameter names for the block. |
5155 | FunctionTypeLoc BlockLoc; |
5156 | FunctionProtoTypeLoc BlockProtoLoc; |
5157 | findTypeLocationForBlockDecl(TSInfo: P->getTypeSourceInfo(), Block&: BlockLoc, |
5158 | BlockProto&: BlockProtoLoc); |
5159 | if (!BlockLoc) { |
5160 | Result R = Result(P, Results.getBasePriority(P), nullptr); |
5161 | if (!InOriginalClass) |
5162 | setInBaseClass(R); |
5163 | Results.MaybeAddResult(R, CurContext); |
5164 | return; |
5165 | } |
5166 | |
5167 | // The default completion result for block properties should be the block |
5168 | // invocation completion when the base expression is a statement. |
5169 | CodeCompletionBuilder Builder(Results.getAllocator(), |
5170 | Results.getCodeCompletionTUInfo()); |
5171 | AddObjCBlockCall(Container->getASTContext(), |
5172 | getCompletionPrintingPolicy(S&: Results.getSema()), Builder, P, |
5173 | BlockLoc, BlockProtoLoc); |
5174 | Result R = Result(Builder.TakeString(), P, Results.getBasePriority(P)); |
5175 | if (!InOriginalClass) |
5176 | setInBaseClass(R); |
5177 | Results.MaybeAddResult(R, CurContext); |
5178 | |
5179 | // Provide additional block setter completion iff the base expression is a |
5180 | // statement and the block property is mutable. |
5181 | if (!P->isReadOnly()) { |
5182 | CodeCompletionBuilder Builder(Results.getAllocator(), |
5183 | Results.getCodeCompletionTUInfo()); |
5184 | AddResultTypeChunk(Container->getASTContext(), |
5185 | getCompletionPrintingPolicy(S&: Results.getSema()), P, |
5186 | CCContext.getBaseType(), Builder); |
5187 | Builder.AddTypedTextChunk( |
5188 | Text: Results.getAllocator().CopyString(String: P->getName())); |
5189 | Builder.AddChunk(CK: CodeCompletionString::CK_Equal); |
5190 | |
5191 | std::string PlaceholderStr = formatBlockPlaceholder( |
5192 | getCompletionPrintingPolicy(S&: Results.getSema()), P, BlockLoc, |
5193 | BlockProtoLoc, /*SuppressBlockName=*/true); |
5194 | // Add the placeholder string. |
5195 | Builder.AddPlaceholderChunk( |
5196 | Placeholder: Builder.getAllocator().CopyString(String: PlaceholderStr)); |
5197 | |
5198 | // When completing blocks properties that return void the default |
5199 | // property completion result should show up before the setter, |
5200 | // otherwise the setter completion should show up before the default |
5201 | // property completion, as we normally want to use the result of the |
5202 | // call. |
5203 | Result R = |
5204 | Result(Builder.TakeString(), P, |
5205 | Results.getBasePriority(P) + |
5206 | (BlockLoc.getTypePtr()->getReturnType()->isVoidType() |
5207 | ? CCD_BlockPropertySetter |
5208 | : -CCD_BlockPropertySetter)); |
5209 | if (!InOriginalClass) |
5210 | setInBaseClass(R); |
5211 | Results.MaybeAddResult(R, CurContext); |
5212 | } |
5213 | }; |
5214 | |
5215 | if (IsClassProperty) { |
5216 | for (const auto *P : Container->class_properties()) |
5217 | AddProperty(P); |
5218 | } else { |
5219 | for (const auto *P : Container->instance_properties()) |
5220 | AddProperty(P); |
5221 | } |
5222 | |
5223 | // Add nullary methods or implicit class properties |
5224 | if (AllowNullaryMethods) { |
5225 | ASTContext &Context = Container->getASTContext(); |
5226 | PrintingPolicy Policy = getCompletionPrintingPolicy(S&: Results.getSema()); |
5227 | // Adds a method result |
5228 | const auto AddMethod = [&](const ObjCMethodDecl *M) { |
5229 | const IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(argIndex: 0); |
5230 | if (!Name) |
5231 | return; |
5232 | if (!AddedProperties.insert(Ptr: Name).second) |
5233 | return; |
5234 | CodeCompletionBuilder Builder(Results.getAllocator(), |
5235 | Results.getCodeCompletionTUInfo()); |
5236 | AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(), Builder); |
5237 | Builder.AddTypedTextChunk( |
5238 | Text: Results.getAllocator().CopyString(String: Name->getName())); |
5239 | Result R = Result(Builder.TakeString(), M, |
5240 | CCP_MemberDeclaration + CCD_MethodAsProperty); |
5241 | if (!InOriginalClass) |
5242 | setInBaseClass(R); |
5243 | Results.MaybeAddResult(R, CurContext); |
5244 | }; |
5245 | |
5246 | if (IsClassProperty) { |
5247 | for (const auto *M : Container->methods()) { |
5248 | // Gather the class method that can be used as implicit property |
5249 | // getters. Methods with arguments or methods that return void aren't |
5250 | // added to the results as they can't be used as a getter. |
5251 | if (!M->getSelector().isUnarySelector() || |
5252 | M->getReturnType()->isVoidType() || M->isInstanceMethod()) |
5253 | continue; |
5254 | AddMethod(M); |
5255 | } |
5256 | } else { |
5257 | for (auto *M : Container->methods()) { |
5258 | if (M->getSelector().isUnarySelector()) |
5259 | AddMethod(M); |
5260 | } |
5261 | } |
5262 | } |
5263 | |
5264 | // Add properties in referenced protocols. |
5265 | if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Val: Container)) { |
5266 | for (auto *P : Protocol->protocols()) |
5267 | AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods, |
5268 | CurContext, AddedProperties, Results, |
5269 | IsBaseExprStatement, IsClassProperty, |
5270 | /*InOriginalClass*/ false); |
5271 | } else if (ObjCInterfaceDecl *IFace = |
5272 | dyn_cast<ObjCInterfaceDecl>(Val: Container)) { |
5273 | if (AllowCategories) { |
5274 | // Look through categories. |
5275 | for (auto *Cat : IFace->known_categories()) |
5276 | AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods, |
5277 | CurContext, AddedProperties, Results, |
5278 | IsBaseExprStatement, IsClassProperty, |
5279 | InOriginalClass); |
5280 | } |
5281 | |
5282 | // Look through protocols. |
5283 | for (auto *I : IFace->all_referenced_protocols()) |
5284 | AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods, |
5285 | CurContext, AddedProperties, Results, |
5286 | IsBaseExprStatement, IsClassProperty, |
5287 | /*InOriginalClass*/ false); |
5288 | |
5289 | // Look in the superclass. |
5290 | if (IFace->getSuperClass()) |
5291 | AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories, |
5292 | AllowNullaryMethods, CurContext, AddedProperties, |
5293 | Results, IsBaseExprStatement, IsClassProperty, |
5294 | /*InOriginalClass*/ false); |
5295 | } else if (const auto *Category = |
5296 | dyn_cast<ObjCCategoryDecl>(Val: Container)) { |
5297 | // Look through protocols. |
5298 | for (auto *P : Category->protocols()) |
5299 | AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods, |
5300 | CurContext, AddedProperties, Results, |
5301 | IsBaseExprStatement, IsClassProperty, |
5302 | /*InOriginalClass*/ false); |
5303 | } |
5304 | } |
5305 | |
5306 | static void |
5307 | AddRecordMembersCompletionResults(Sema &SemaRef, ResultBuilder &Results, |
5308 | Scope *S, QualType BaseType, |
5309 | ExprValueKind BaseKind, RecordDecl *RD, |
5310 | std::optional<FixItHint> AccessOpFixIt) { |
5311 | // Indicate that we are performing a member access, and the cv-qualifiers |
5312 | // for the base object type. |
5313 | Results.setObjectTypeQualifiers(Quals: BaseType.getQualifiers(), Kind: BaseKind); |
5314 | |
5315 | // Access to a C/C++ class, struct, or union. |
5316 | Results.allowNestedNameSpecifiers(); |
5317 | std::vector<FixItHint> FixIts; |
5318 | if (AccessOpFixIt) |
5319 | FixIts.emplace_back(args&: *AccessOpFixIt); |
5320 | CodeCompletionDeclConsumer Consumer(Results, RD, BaseType, std::move(FixIts)); |
5321 | SemaRef.LookupVisibleDecls( |
5322 | RD, Sema::LookupMemberName, Consumer, |
5323 | SemaRef.CodeCompletion().CodeCompleter->includeGlobals(), |
5324 | /*IncludeDependentBases=*/true, |
5325 | SemaRef.CodeCompletion().CodeCompleter->loadExternal()); |
5326 | |
5327 | if (SemaRef.getLangOpts().CPlusPlus) { |
5328 | if (!Results.empty()) { |
5329 | // The "template" keyword can follow "->" or "." in the grammar. |
5330 | // However, we only want to suggest the template keyword if something |
5331 | // is dependent. |
5332 | bool IsDependent = BaseType->isDependentType(); |
5333 | if (!IsDependent) { |
5334 | for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent()) |
5335 | if (DeclContext *Ctx = DepScope->getEntity()) { |
5336 | IsDependent = Ctx->isDependentContext(); |
5337 | break; |
5338 | } |
5339 | } |
5340 | |
5341 | if (IsDependent) |
5342 | Results.AddResult(R: CodeCompletionResult("template")); |
5343 | } |
5344 | } |
5345 | } |
5346 | |
5347 | // Returns the RecordDecl inside the BaseType, falling back to primary template |
5348 | // in case of specializations. Since we might not have a decl for the |
5349 | // instantiation/specialization yet, e.g. dependent code. |
5350 | static RecordDecl *getAsRecordDecl(QualType BaseType, |
5351 | HeuristicResolver &Resolver) { |
5352 | BaseType = Resolver.simplifyType(Type: BaseType, E: nullptr, /*UnwrapPointer=*/false); |
5353 | return dyn_cast_if_present<RecordDecl>( |
5354 | Val: Resolver.resolveTypeToTagDecl(T: BaseType)); |
5355 | } |
5356 | |
5357 | namespace { |
5358 | // Collects completion-relevant information about a concept-constrainted type T. |
5359 | // In particular, examines the constraint expressions to find members of T. |
5360 | // |
5361 | // The design is very simple: we walk down each constraint looking for |
5362 | // expressions of the form T.foo(). |
5363 | // If we're extra lucky, the return type is specified. |
5364 | // We don't do any clever handling of && or || in constraint expressions, we |
5365 | // take members from both branches. |
5366 | // |
5367 | // For example, given: |
5368 | // template <class T> concept X = requires (T t, string& s) { t.print(s); }; |
5369 | // template <X U> void foo(U u) { u.^ } |
5370 | // We want to suggest the inferred member function 'print(string)'. |
5371 | // We see that u has type U, so X<U> holds. |
5372 | // X<U> requires t.print(s) to be valid, where t has type U (substituted for T). |
5373 | // By looking at the CallExpr we find the signature of print(). |
5374 | // |
5375 | // While we tend to know in advance which kind of members (access via . -> ::) |
5376 | // we want, it's simpler just to gather them all and post-filter. |
5377 | // |
5378 | // FIXME: some of this machinery could be used for non-concept type-parms too, |
5379 | // enabling completion for type parameters based on other uses of that param. |
5380 | // |
5381 | // FIXME: there are other cases where a type can be constrained by a concept, |
5382 | // e.g. inside `if constexpr(ConceptSpecializationExpr) { ... }` |
5383 | class ConceptInfo { |
5384 | public: |
5385 | // Describes a likely member of a type, inferred by concept constraints. |
5386 | // Offered as a code completion for T. T-> and T:: contexts. |
5387 | struct Member { |
5388 | // Always non-null: we only handle members with ordinary identifier names. |
5389 | const IdentifierInfo *Name = nullptr; |
5390 | // Set for functions we've seen called. |
5391 | // We don't have the declared parameter types, only the actual types of |
5392 | // arguments we've seen. These are still valuable, as it's hard to render |
5393 | // a useful function completion with neither parameter types nor names! |
5394 | std::optional<SmallVector<QualType, 1>> ArgTypes; |
5395 | // Whether this is accessed as T.member, T->member, or T::member. |
5396 | enum AccessOperator { |
5397 | Colons, |
5398 | Arrow, |
5399 | Dot, |
5400 | } Operator = Dot; |
5401 | // What's known about the type of a variable or return type of a function. |
5402 | const TypeConstraint *ResultType = nullptr; |
5403 | // FIXME: also track: |
5404 | // - kind of entity (function/variable/type), to expose structured results |
5405 | // - template args kinds/types, as a proxy for template params |
5406 | |
5407 | // For now we simply return these results as "pattern" strings. |
5408 | CodeCompletionString *render(Sema &S, CodeCompletionAllocator &Alloc, |
5409 | CodeCompletionTUInfo &Info) const { |
5410 | CodeCompletionBuilder B(Alloc, Info); |
5411 | // Result type |
5412 | if (ResultType) { |
5413 | std::string AsString; |
5414 | { |
5415 | llvm::raw_string_ostream OS(AsString); |
5416 | QualType ExactType = deduceType(T: *ResultType); |
5417 | if (!ExactType.isNull()) |
5418 | ExactType.print(OS, Policy: getCompletionPrintingPolicy(S)); |
5419 | else |
5420 | ResultType->print(OS, Policy: getCompletionPrintingPolicy(S)); |
5421 | } |
5422 | B.AddResultTypeChunk(ResultType: Alloc.CopyString(String: AsString)); |
5423 | } |
5424 | // Member name |
5425 | B.AddTypedTextChunk(Text: Alloc.CopyString(String: Name->getName())); |
5426 | // Function argument list |
5427 | if (ArgTypes) { |
5428 | B.AddChunk(CK: clang::CodeCompletionString::CK_LeftParen); |
5429 | bool First = true; |
5430 | for (QualType Arg : *ArgTypes) { |
5431 | if (First) |
5432 | First = false; |
5433 | else { |
5434 | B.AddChunk(CK: clang::CodeCompletionString::CK_Comma); |
5435 | B.AddChunk(CK: clang::CodeCompletionString::CK_HorizontalSpace); |
5436 | } |
5437 | B.AddPlaceholderChunk(Placeholder: Alloc.CopyString( |
5438 | String: Arg.getAsString(Policy: getCompletionPrintingPolicy(S)))); |
5439 | } |
5440 | B.AddChunk(CK: clang::CodeCompletionString::CK_RightParen); |
5441 | } |
5442 | return B.TakeString(); |
5443 | } |
5444 | }; |
5445 | |
5446 | // BaseType is the type parameter T to infer members from. |
5447 | // T must be accessible within S, as we use it to find the template entity |
5448 | // that T is attached to in order to gather the relevant constraints. |
5449 | ConceptInfo(const TemplateTypeParmType &BaseType, Scope *S) { |
5450 | auto *TemplatedEntity = getTemplatedEntity(D: BaseType.getDecl(), S); |
5451 | for (const AssociatedConstraint &AC : |
5452 | constraintsForTemplatedEntity(DC: TemplatedEntity)) |
5453 | believe(E: AC.ConstraintExpr, T: &BaseType); |
5454 | } |
5455 | |
5456 | std::vector<Member> members() { |
5457 | std::vector<Member> Results; |
5458 | for (const auto &E : this->Results) |
5459 | Results.push_back(x: E.second); |
5460 | llvm::sort(C&: Results, Comp: [](const Member &L, const Member &R) { |
5461 | return L.Name->getName() < R.Name->getName(); |
5462 | }); |
5463 | return Results; |
5464 | } |
5465 | |
5466 | private: |
5467 | // Infer members of T, given that the expression E (dependent on T) is true. |
5468 | void believe(const Expr *E, const TemplateTypeParmType *T) { |
5469 | if (!E || !T) |
5470 | return; |
5471 | if (auto *CSE = dyn_cast<ConceptSpecializationExpr>(Val: E)) { |
5472 | // If the concept is |
5473 | // template <class A, class B> concept CD = f<A, B>(); |
5474 | // And the concept specialization is |
5475 | // CD<int, T> |
5476 | // Then we're substituting T for B, so we want to make f<A, B>() true |
5477 | // by adding members to B - i.e. believe(f<A, B>(), B); |
5478 | // |
5479 | // For simplicity: |
5480 | // - we don't attempt to substitute int for A |
5481 | // - when T is used in other ways (like CD<T*>) we ignore it |
5482 | ConceptDecl *CD = CSE->getNamedConcept(); |
5483 | TemplateParameterList *Params = CD->getTemplateParameters(); |
5484 | unsigned Index = 0; |
5485 | for (const auto &Arg : CSE->getTemplateArguments()) { |
5486 | if (Index >= Params->size()) |
5487 | break; // Won't happen in valid code. |
5488 | if (isApprox(Arg, T)) { |
5489 | auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Val: Params->getParam(Idx: Index)); |
5490 | if (!TTPD) |
5491 | continue; |
5492 | // T was used as an argument, and bound to the parameter TT. |
5493 | auto *TT = cast<TemplateTypeParmType>(TTPD->getTypeForDecl()); |
5494 | // So now we know the constraint as a function of TT is true. |
5495 | believe(E: CD->getConstraintExpr(), T: TT); |
5496 | // (concepts themselves have no associated constraints to require) |
5497 | } |
5498 | |
5499 | ++Index; |
5500 | } |
5501 | } else if (auto *BO = dyn_cast<BinaryOperator>(Val: E)) { |
5502 | // For A && B, we can infer members from both branches. |
5503 | // For A || B, the union is still more useful than the intersection. |
5504 | if (BO->getOpcode() == BO_LAnd || BO->getOpcode() == BO_LOr) { |
5505 | believe(E: BO->getLHS(), T); |
5506 | believe(E: BO->getRHS(), T); |
5507 | } |
5508 | } else if (auto *RE = dyn_cast<RequiresExpr>(Val: E)) { |
5509 | // A requires(){...} lets us infer members from each requirement. |
5510 | for (const concepts::Requirement *Req : RE->getRequirements()) { |
5511 | if (!Req->isDependent()) |
5512 | continue; // Can't tell us anything about T. |
5513 | // Now Req cannot a substitution-error: those aren't dependent. |
5514 | |
5515 | if (auto *TR = dyn_cast<concepts::TypeRequirement>(Val: Req)) { |
5516 | // Do a full traversal so we get `foo` from `typename T::foo::bar`. |
5517 | QualType AssertedType = TR->getType()->getType(); |
5518 | ValidVisitor(this, T).TraverseType(AssertedType); |
5519 | } else if (auto *ER = dyn_cast<concepts::ExprRequirement>(Val: Req)) { |
5520 | ValidVisitor Visitor(this, T); |
5521 | // If we have a type constraint on the value of the expression, |
5522 | // AND the whole outer expression describes a member, then we'll |
5523 | // be able to use the constraint to provide the return type. |
5524 | if (ER->getReturnTypeRequirement().isTypeConstraint()) { |
5525 | Visitor.OuterType = |
5526 | ER->getReturnTypeRequirement().getTypeConstraint(); |
5527 | Visitor.OuterExpr = ER->getExpr(); |
5528 | } |
5529 | Visitor.TraverseStmt(ER->getExpr()); |
5530 | } else if (auto *NR = dyn_cast<concepts::NestedRequirement>(Val: Req)) { |
5531 | believe(E: NR->getConstraintExpr(), T); |
5532 | } |
5533 | } |
5534 | } |
5535 | } |
5536 | |
5537 | // This visitor infers members of T based on traversing expressions/types |
5538 | // that involve T. It is invoked with code known to be valid for T. |
5539 | class ValidVisitor : public DynamicRecursiveASTVisitor { |
5540 | ConceptInfo *Outer; |
5541 | const TemplateTypeParmType *T; |
5542 | |
5543 | CallExpr *Caller = nullptr; |
5544 | Expr *Callee = nullptr; |
5545 | |
5546 | public: |
5547 | // If set, OuterExpr is constrained by OuterType. |
5548 | Expr *OuterExpr = nullptr; |
5549 | const TypeConstraint *OuterType = nullptr; |
5550 | |
5551 | ValidVisitor(ConceptInfo *Outer, const TemplateTypeParmType *T) |
5552 | : Outer(Outer), T(T) { |
5553 | assert(T); |
5554 | } |
5555 | |
5556 | // In T.foo or T->foo, `foo` is a member function/variable. |
5557 | bool |
5558 | VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) override { |
5559 | const Type *Base = E->getBaseType().getTypePtr(); |
5560 | bool IsArrow = E->isArrow(); |
5561 | if (Base->isPointerType() && IsArrow) { |
5562 | IsArrow = false; |
5563 | Base = Base->getPointeeType().getTypePtr(); |
5564 | } |
5565 | if (isApprox(Base, T)) |
5566 | addValue(E, E->getMember(), IsArrow ? Member::Arrow : Member::Dot); |
5567 | return true; |
5568 | } |
5569 | |
5570 | // In T::foo, `foo` is a static member function/variable. |
5571 | bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) override { |
5572 | if (E->getQualifier() && isApprox(E->getQualifier()->getAsType(), T)) |
5573 | addValue(E, E->getDeclName(), Member::Colons); |
5574 | return true; |
5575 | } |
5576 | |
5577 | // In T::typename foo, `foo` is a type. |
5578 | bool VisitDependentNameType(DependentNameType *DNT) override { |
5579 | const auto *Q = DNT->getQualifier(); |
5580 | if (Q && isApprox(Q->getAsType(), T)) |
5581 | addType(Name: DNT->getIdentifier()); |
5582 | return true; |
5583 | } |
5584 | |
5585 | // In T::foo::bar, `foo` must be a type. |
5586 | // VisitNNS() doesn't exist, and TraverseNNS isn't always called :-( |
5587 | bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSL) override { |
5588 | if (NNSL) { |
5589 | NestedNameSpecifier *NNS = NNSL.getNestedNameSpecifier(); |
5590 | const auto *Q = NNS->getPrefix(); |
5591 | if (Q && isApprox(Q->getAsType(), T)) |
5592 | addType(Name: NNS->getAsIdentifier()); |
5593 | } |
5594 | // FIXME: also handle T::foo<X>::bar |
5595 | return DynamicRecursiveASTVisitor::TraverseNestedNameSpecifierLoc(NNSL); |
5596 | } |
5597 | |
5598 | // FIXME also handle T::foo<X> |
5599 | |
5600 | // Track the innermost caller/callee relationship so we can tell if a |
5601 | // nested expr is being called as a function. |
5602 | bool VisitCallExpr(CallExpr *CE) override { |
5603 | Caller = CE; |
5604 | Callee = CE->getCallee(); |
5605 | return true; |
5606 | } |
5607 | |
5608 | private: |
5609 | void addResult(Member &&M) { |
5610 | auto R = Outer->Results.try_emplace(Key: M.Name); |
5611 | Member &O = R.first->second; |
5612 | // Overwrite existing if the new member has more info. |
5613 | // The preference of . vs :: vs -> is fairly arbitrary. |
5614 | if (/*Inserted*/ R.second || |
5615 | std::make_tuple(args: M.ArgTypes.has_value(), args: M.ResultType != nullptr, |
5616 | args&: M.Operator) > std::make_tuple(args: O.ArgTypes.has_value(), |
5617 | args: O.ResultType != nullptr, |
5618 | args&: O.Operator)) |
5619 | O = std::move(M); |
5620 | } |
5621 | |
5622 | void addType(const IdentifierInfo *Name) { |
5623 | if (!Name) |
5624 | return; |
5625 | Member M; |
5626 | M.Name = Name; |
5627 | M.Operator = Member::Colons; |
5628 | addResult(M: std::move(M)); |
5629 | } |
5630 | |
5631 | void addValue(Expr *E, DeclarationName Name, |
5632 | Member::AccessOperator Operator) { |
5633 | if (!Name.isIdentifier()) |
5634 | return; |
5635 | Member Result; |
5636 | Result.Name = Name.getAsIdentifierInfo(); |
5637 | Result.Operator = Operator; |
5638 | // If this is the callee of an immediately-enclosing CallExpr, then |
5639 | // treat it as a method, otherwise it's a variable. |
5640 | if (Caller != nullptr && Callee == E) { |
5641 | Result.ArgTypes.emplace(); |
5642 | for (const auto *Arg : Caller->arguments()) |
5643 | Result.ArgTypes->push_back(Elt: Arg->getType()); |
5644 | if (Caller == OuterExpr) { |
5645 | Result.ResultType = OuterType; |
5646 | } |
5647 | } else { |
5648 | if (E == OuterExpr) |
5649 | Result.ResultType = OuterType; |
5650 | } |
5651 | addResult(M: std::move(Result)); |
5652 | } |
5653 | }; |
5654 | |
5655 | static bool isApprox(const TemplateArgument &Arg, const Type *T) { |
5656 | return Arg.getKind() == TemplateArgument::Type && |
5657 | isApprox(T1: Arg.getAsType().getTypePtr(), T2: T); |
5658 | } |
5659 | |
5660 | static bool isApprox(const Type *T1, const Type *T2) { |
5661 | return T1 && T2 && |
5662 | T1->getCanonicalTypeUnqualified() == |
5663 | T2->getCanonicalTypeUnqualified(); |
5664 | } |
5665 | |
5666 | // Returns the DeclContext immediately enclosed by the template parameter |
5667 | // scope. For primary templates, this is the templated (e.g.) CXXRecordDecl. |
5668 | // For specializations, this is e.g. ClassTemplatePartialSpecializationDecl. |
5669 | static DeclContext *getTemplatedEntity(const TemplateTypeParmDecl *D, |
5670 | Scope *S) { |
5671 | if (D == nullptr) |
5672 | return nullptr; |
5673 | Scope *Inner = nullptr; |
5674 | while (S) { |
5675 | if (S->isTemplateParamScope() && S->isDeclScope(D)) |
5676 | return Inner ? Inner->getEntity() : nullptr; |
5677 | Inner = S; |
5678 | S = S->getParent(); |
5679 | } |
5680 | return nullptr; |
5681 | } |
5682 | |
5683 | // Gets all the type constraint expressions that might apply to the type |
5684 | // variables associated with DC (as returned by getTemplatedEntity()). |
5685 | static SmallVector<AssociatedConstraint, 1> |
5686 | constraintsForTemplatedEntity(DeclContext *DC) { |
5687 | SmallVector<AssociatedConstraint, 1> Result; |
5688 | if (DC == nullptr) |
5689 | return Result; |
5690 | // Primary templates can have constraints. |
5691 | if (const auto *TD = cast<Decl>(Val: DC)->getDescribedTemplate()) |
5692 | TD->getAssociatedConstraints(AC&: Result); |
5693 | // Partial specializations may have constraints. |
5694 | if (const auto *CTPSD = |
5695 | dyn_cast<ClassTemplatePartialSpecializationDecl>(Val: DC)) |
5696 | CTPSD->getAssociatedConstraints(AC&: Result); |
5697 | if (const auto *VTPSD = dyn_cast<VarTemplatePartialSpecializationDecl>(Val: DC)) |
5698 | VTPSD->getAssociatedConstraints(AC&: Result); |
5699 | return Result; |
5700 | } |
5701 | |
5702 | // Attempt to find the unique type satisfying a constraint. |
5703 | // This lets us show e.g. `int` instead of `std::same_as<int>`. |
5704 | static QualType deduceType(const TypeConstraint &T) { |
5705 | // Assume a same_as<T> return type constraint is std::same_as or equivalent. |
5706 | // In this case the return type is T. |
5707 | DeclarationName DN = T.getNamedConcept()->getDeclName(); |
5708 | if (DN.isIdentifier() && DN.getAsIdentifierInfo()->isStr(Str: "same_as")) |
5709 | if (const auto *Args = T.getTemplateArgsAsWritten()) |
5710 | if (Args->getNumTemplateArgs() == 1) { |
5711 | const auto &Arg = Args->arguments().front().getArgument(); |
5712 | if (Arg.getKind() == TemplateArgument::Type) |
5713 | return Arg.getAsType(); |
5714 | } |
5715 | return {}; |
5716 | } |
5717 | |
5718 | llvm::DenseMap<const IdentifierInfo *, Member> Results; |
5719 | }; |
5720 | |
5721 | // Returns a type for E that yields acceptable member completions. |
5722 | // In particular, when E->getType() is DependentTy, try to guess a likely type. |
5723 | // We accept some lossiness (like dropping parameters). |
5724 | // We only try to handle common expressions on the LHS of MemberExpr. |
5725 | QualType getApproximateType(const Expr *E, HeuristicResolver &Resolver) { |
5726 | if (E->getType().isNull()) |
5727 | return QualType(); |
5728 | // Don't drop implicit cast if it's an array decay. |
5729 | if (auto *ICE = dyn_cast<ImplicitCastExpr>(Val: E); |
5730 | !ICE || ICE->getCastKind() != CK_ArrayToPointerDecay) |
5731 | E = E->IgnoreParenImpCasts(); |
5732 | QualType Unresolved = E->getType(); |
5733 | // Resolve DependentNameType |
5734 | if (const auto *DNT = Unresolved->getAs<DependentNameType>()) { |
5735 | if (auto Decls = Resolver.resolveDependentNameType(DNT); |
5736 | Decls.size() == 1) { |
5737 | if (const auto *TD = dyn_cast<TypeDecl>(Val: Decls[0])) |
5738 | return QualType(TD->getTypeForDecl(), 0); |
5739 | } |
5740 | } |
5741 | // We only resolve DependentTy, or undeduced autos (including auto* etc). |
5742 | if (!Unresolved->isSpecificBuiltinType(K: BuiltinType::Dependent)) { |
5743 | AutoType *Auto = Unresolved->getContainedAutoType(); |
5744 | if (!Auto || !Auto->isUndeducedAutoType()) |
5745 | return Unresolved; |
5746 | } |
5747 | // A call: approximate-resolve callee to a function type, get its return type |
5748 | if (const CallExpr *CE = llvm::dyn_cast<CallExpr>(Val: E)) { |
5749 | QualType Callee = getApproximateType(E: CE->getCallee(), Resolver); |
5750 | if (Callee.isNull() || |
5751 | Callee->isSpecificPlaceholderType(K: BuiltinType::BoundMember)) |
5752 | Callee = Expr::findBoundMemberType(expr: CE->getCallee()); |
5753 | if (Callee.isNull()) |
5754 | return Unresolved; |
5755 | |
5756 | if (const auto *FnTypePtr = Callee->getAs<PointerType>()) { |
5757 | Callee = FnTypePtr->getPointeeType(); |
5758 | } else if (const auto *BPT = Callee->getAs<BlockPointerType>()) { |
5759 | Callee = BPT->getPointeeType(); |
5760 | } |
5761 | if (const FunctionType *FnType = Callee->getAs<FunctionType>()) |
5762 | return FnType->getReturnType().getNonReferenceType(); |
5763 | |
5764 | // Unresolved call: try to guess the return type. |
5765 | if (const auto *OE = llvm::dyn_cast<OverloadExpr>(Val: CE->getCallee())) { |
5766 | // If all candidates have the same approximate return type, use it. |
5767 | // Discard references and const to allow more to be "the same". |
5768 | // (In particular, if there's one candidate + ADL, resolve it). |
5769 | const Type *Common = nullptr; |
5770 | for (const auto *D : OE->decls()) { |
5771 | QualType ReturnType; |
5772 | if (const auto *FD = llvm::dyn_cast<FunctionDecl>(Val: D)) |
5773 | ReturnType = FD->getReturnType(); |
5774 | else if (const auto *FTD = llvm::dyn_cast<FunctionTemplateDecl>(Val: D)) |
5775 | ReturnType = FTD->getTemplatedDecl()->getReturnType(); |
5776 | if (ReturnType.isNull()) |
5777 | continue; |
5778 | const Type *Candidate = |
5779 | ReturnType.getNonReferenceType().getCanonicalType().getTypePtr(); |
5780 | if (Common && Common != Candidate) |
5781 | return Unresolved; // Multiple candidates. |
5782 | Common = Candidate; |
5783 | } |
5784 | if (Common != nullptr) |
5785 | return QualType(Common, 0); |
5786 | } |
5787 | } |
5788 | // A dependent member: resolve using HeuristicResolver. |
5789 | if (const auto *CDSME = llvm::dyn_cast<CXXDependentScopeMemberExpr>(Val: E)) { |
5790 | for (const auto *Member : Resolver.resolveMemberExpr(ME: CDSME)) { |
5791 | if (const auto *VD = dyn_cast<ValueDecl>(Val: Member)) { |
5792 | return VD->getType().getNonReferenceType(); |
5793 | } |
5794 | } |
5795 | } |
5796 | // A reference to an `auto` variable: approximate-resolve its initializer. |
5797 | if (const auto *DRE = llvm::dyn_cast<DeclRefExpr>(Val: E)) { |
5798 | if (const auto *VD = llvm::dyn_cast<VarDecl>(Val: DRE->getDecl())) { |
5799 | if (VD->hasInit()) |
5800 | return getApproximateType(E: VD->getInit(), Resolver); |
5801 | } |
5802 | } |
5803 | if (const auto *UO = llvm::dyn_cast<UnaryOperator>(Val: E)) { |
5804 | if (UO->getOpcode() == UnaryOperatorKind::UO_Deref) { |
5805 | // We recurse into the subexpression because it could be of dependent |
5806 | // type. |
5807 | if (auto Pointee = |
5808 | getApproximateType(E: UO->getSubExpr(), Resolver)->getPointeeType(); |
5809 | !Pointee.isNull()) |
5810 | return Pointee; |
5811 | // Our caller expects a non-null result, even though the SubType is |
5812 | // supposed to have a pointee. Fall through to Unresolved anyway. |
5813 | } |
5814 | } |
5815 | return Unresolved; |
5816 | } |
5817 | |
5818 | // If \p Base is ParenListExpr, assume a chain of comma operators and pick the |
5819 | // last expr. We expect other ParenListExprs to be resolved to e.g. constructor |
5820 | // calls before here. (So the ParenListExpr should be nonempty, but check just |
5821 | // in case) |
5822 | Expr *unwrapParenList(Expr *Base) { |
5823 | if (auto *PLE = llvm::dyn_cast_or_null<ParenListExpr>(Val: Base)) { |
5824 | if (PLE->getNumExprs() == 0) |
5825 | return nullptr; |
5826 | Base = PLE->getExpr(Init: PLE->getNumExprs() - 1); |
5827 | } |
5828 | return Base; |
5829 | } |
5830 | |
5831 | } // namespace |
5832 | |
5833 | void SemaCodeCompletion::CodeCompleteMemberReferenceExpr( |
5834 | Scope *S, Expr *Base, Expr *OtherOpBase, SourceLocation OpLoc, bool IsArrow, |
5835 | bool IsBaseExprStatement, QualType PreferredType) { |
5836 | Base = unwrapParenList(Base); |
5837 | OtherOpBase = unwrapParenList(Base: OtherOpBase); |
5838 | if (!Base || !CodeCompleter) |
5839 | return; |
5840 | |
5841 | ExprResult ConvertedBase = |
5842 | SemaRef.PerformMemberExprBaseConversion(Base, IsArrow); |
5843 | if (ConvertedBase.isInvalid()) |
5844 | return; |
5845 | QualType ConvertedBaseType = |
5846 | getApproximateType(E: ConvertedBase.get(), Resolver); |
5847 | |
5848 | enum CodeCompletionContext::Kind contextKind; |
5849 | |
5850 | if (IsArrow) { |
5851 | if (QualType PointeeType = Resolver.getPointeeType(T: ConvertedBaseType); |
5852 | !PointeeType.isNull()) { |
5853 | ConvertedBaseType = PointeeType; |
5854 | } |
5855 | } |
5856 | |
5857 | if (IsArrow) { |
5858 | contextKind = CodeCompletionContext::CCC_ArrowMemberAccess; |
5859 | } else { |
5860 | if (ConvertedBaseType->isObjCObjectPointerType() || |
5861 | ConvertedBaseType->isObjCObjectOrInterfaceType()) { |
5862 | contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess; |
5863 | } else { |
5864 | contextKind = CodeCompletionContext::CCC_DotMemberAccess; |
5865 | } |
5866 | } |
5867 | |
5868 | CodeCompletionContext CCContext(contextKind, ConvertedBaseType); |
5869 | CCContext.setPreferredType(PreferredType); |
5870 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
5871 | CodeCompleter->getCodeCompletionTUInfo(), CCContext, |
5872 | &ResultBuilder::IsMember); |
5873 | |
5874 | auto DoCompletion = [&](Expr *Base, bool IsArrow, |
5875 | std::optional<FixItHint> AccessOpFixIt) -> bool { |
5876 | if (!Base) |
5877 | return false; |
5878 | |
5879 | ExprResult ConvertedBase = |
5880 | SemaRef.PerformMemberExprBaseConversion(Base, IsArrow); |
5881 | if (ConvertedBase.isInvalid()) |
5882 | return false; |
5883 | Base = ConvertedBase.get(); |
5884 | |
5885 | QualType BaseType = getApproximateType(E: Base, Resolver); |
5886 | if (BaseType.isNull()) |
5887 | return false; |
5888 | ExprValueKind BaseKind = Base->getValueKind(); |
5889 | |
5890 | if (IsArrow) { |
5891 | if (QualType PointeeType = Resolver.getPointeeType(T: BaseType); |
5892 | !PointeeType.isNull()) { |
5893 | BaseType = PointeeType; |
5894 | BaseKind = VK_LValue; |
5895 | } else if (BaseType->isObjCObjectPointerType() || |
5896 | BaseType->isTemplateTypeParmType()) { |
5897 | // Both cases (dot/arrow) handled below. |
5898 | } else { |
5899 | return false; |
5900 | } |
5901 | } |
5902 | |
5903 | if (RecordDecl *RD = getAsRecordDecl(BaseType, Resolver)) { |
5904 | AddRecordMembersCompletionResults(SemaRef, Results, S, BaseType, BaseKind, |
5905 | RD, AccessOpFixIt: std::move(AccessOpFixIt)); |
5906 | } else if (const auto *TTPT = |
5907 | dyn_cast<TemplateTypeParmType>(Val: BaseType.getTypePtr())) { |
5908 | auto Operator = |
5909 | IsArrow ? ConceptInfo::Member::Arrow : ConceptInfo::Member::Dot; |
5910 | for (const auto &R : ConceptInfo(*TTPT, S).members()) { |
5911 | if (R.Operator != Operator) |
5912 | continue; |
5913 | CodeCompletionResult Result( |
5914 | R.render(S&: SemaRef, Alloc&: CodeCompleter->getAllocator(), |
5915 | Info&: CodeCompleter->getCodeCompletionTUInfo())); |
5916 | if (AccessOpFixIt) |
5917 | Result.FixIts.push_back(x: *AccessOpFixIt); |
5918 | Results.AddResult(R: std::move(Result)); |
5919 | } |
5920 | } else if (!IsArrow && BaseType->isObjCObjectPointerType()) { |
5921 | // Objective-C property reference. Bail if we're performing fix-it code |
5922 | // completion since Objective-C properties are normally backed by ivars, |
5923 | // most Objective-C fix-its here would have little value. |
5924 | if (AccessOpFixIt) { |
5925 | return false; |
5926 | } |
5927 | AddedPropertiesSet AddedProperties; |
5928 | |
5929 | if (const ObjCObjectPointerType *ObjCPtr = |
5930 | BaseType->getAsObjCInterfacePointerType()) { |
5931 | // Add property results based on our interface. |
5932 | assert(ObjCPtr && "Non-NULL pointer guaranteed above!"); |
5933 | AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true, |
5934 | /*AllowNullaryMethods=*/true, SemaRef.CurContext, |
5935 | AddedProperties, Results, IsBaseExprStatement); |
5936 | } |
5937 | |
5938 | // Add properties from the protocols in a qualified interface. |
5939 | for (auto *I : BaseType->castAs<ObjCObjectPointerType>()->quals()) |
5940 | AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true, |
5941 | SemaRef.CurContext, AddedProperties, Results, |
5942 | IsBaseExprStatement, /*IsClassProperty*/ false, |
5943 | /*InOriginalClass*/ false); |
5944 | } else if ((IsArrow && BaseType->isObjCObjectPointerType()) || |
5945 | (!IsArrow && BaseType->isObjCObjectType())) { |
5946 | // Objective-C instance variable access. Bail if we're performing fix-it |
5947 | // code completion since Objective-C properties are normally backed by |
5948 | // ivars, most Objective-C fix-its here would have little value. |
5949 | if (AccessOpFixIt) { |
5950 | return false; |
5951 | } |
5952 | ObjCInterfaceDecl *Class = nullptr; |
5953 | if (const ObjCObjectPointerType *ObjCPtr = |
5954 | BaseType->getAs<ObjCObjectPointerType>()) |
5955 | Class = ObjCPtr->getInterfaceDecl(); |
5956 | else |
5957 | Class = BaseType->castAs<ObjCObjectType>()->getInterface(); |
5958 | |
5959 | // Add all ivars from this class and its superclasses. |
5960 | if (Class) { |
5961 | CodeCompletionDeclConsumer Consumer(Results, Class, BaseType); |
5962 | Results.setFilter(&ResultBuilder::IsObjCIvar); |
5963 | SemaRef.LookupVisibleDecls(Class, Sema::LookupMemberName, Consumer, |
5964 | CodeCompleter->includeGlobals(), |
5965 | /*IncludeDependentBases=*/false, |
5966 | CodeCompleter->loadExternal()); |
5967 | } |
5968 | } |
5969 | |
5970 | // FIXME: How do we cope with isa? |
5971 | return true; |
5972 | }; |
5973 | |
5974 | Results.EnterNewScope(); |
5975 | |
5976 | bool CompletionSucceded = DoCompletion(Base, IsArrow, std::nullopt); |
5977 | if (CodeCompleter->includeFixIts()) { |
5978 | const CharSourceRange OpRange = |
5979 | CharSourceRange::getTokenRange(B: OpLoc, E: OpLoc); |
5980 | CompletionSucceded |= DoCompletion( |
5981 | OtherOpBase, !IsArrow, |
5982 | FixItHint::CreateReplacement(RemoveRange: OpRange, Code: IsArrow ? ".": "->")); |
5983 | } |
5984 | |
5985 | Results.ExitScope(); |
5986 | |
5987 | if (!CompletionSucceded) |
5988 | return; |
5989 | |
5990 | // Hand off the results found for code completion. |
5991 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
5992 | Context: Results.getCompletionContext(), Results: Results.data(), |
5993 | NumResults: Results.size()); |
5994 | } |
5995 | |
5996 | void SemaCodeCompletion::CodeCompleteObjCClassPropertyRefExpr( |
5997 | Scope *S, const IdentifierInfo &ClassName, SourceLocation ClassNameLoc, |
5998 | bool IsBaseExprStatement) { |
5999 | const IdentifierInfo *ClassNamePtr = &ClassName; |
6000 | ObjCInterfaceDecl *IFace = |
6001 | SemaRef.ObjC().getObjCInterfaceDecl(Id&: ClassNamePtr, IdLoc: ClassNameLoc); |
6002 | if (!IFace) |
6003 | return; |
6004 | CodeCompletionContext CCContext( |
6005 | CodeCompletionContext::CCC_ObjCPropertyAccess); |
6006 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
6007 | CodeCompleter->getCodeCompletionTUInfo(), CCContext, |
6008 | &ResultBuilder::IsMember); |
6009 | Results.EnterNewScope(); |
6010 | AddedPropertiesSet AddedProperties; |
6011 | AddObjCProperties(CCContext, IFace, true, |
6012 | /*AllowNullaryMethods=*/true, SemaRef.CurContext, |
6013 | AddedProperties, Results, IsBaseExprStatement, |
6014 | /*IsClassProperty=*/true); |
6015 | Results.ExitScope(); |
6016 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
6017 | Context: Results.getCompletionContext(), Results: Results.data(), |
6018 | NumResults: Results.size()); |
6019 | } |
6020 | |
6021 | void SemaCodeCompletion::CodeCompleteTag(Scope *S, unsigned TagSpec) { |
6022 | if (!CodeCompleter) |
6023 | return; |
6024 | |
6025 | ResultBuilder::LookupFilter Filter = nullptr; |
6026 | enum CodeCompletionContext::Kind ContextKind = |
6027 | CodeCompletionContext::CCC_Other; |
6028 | switch ((DeclSpec::TST)TagSpec) { |
6029 | case DeclSpec::TST_enum: |
6030 | Filter = &ResultBuilder::IsEnum; |
6031 | ContextKind = CodeCompletionContext::CCC_EnumTag; |
6032 | break; |
6033 | |
6034 | case DeclSpec::TST_union: |
6035 | Filter = &ResultBuilder::IsUnion; |
6036 | ContextKind = CodeCompletionContext::CCC_UnionTag; |
6037 | break; |
6038 | |
6039 | case DeclSpec::TST_struct: |
6040 | case DeclSpec::TST_class: |
6041 | case DeclSpec::TST_interface: |
6042 | Filter = &ResultBuilder::IsClassOrStruct; |
6043 | ContextKind = CodeCompletionContext::CCC_ClassOrStructTag; |
6044 | break; |
6045 | |
6046 | default: |
6047 | llvm_unreachable("Unknown type specifier kind in CodeCompleteTag"); |
6048 | } |
6049 | |
6050 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
6051 | CodeCompleter->getCodeCompletionTUInfo(), ContextKind); |
6052 | CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext); |
6053 | |
6054 | // First pass: look for tags. |
6055 | Results.setFilter(Filter); |
6056 | SemaRef.LookupVisibleDecls(S, Sema::LookupTagName, Consumer, |
6057 | CodeCompleter->includeGlobals(), |
6058 | CodeCompleter->loadExternal()); |
6059 | |
6060 | if (CodeCompleter->includeGlobals()) { |
6061 | // Second pass: look for nested name specifiers. |
6062 | Results.setFilter(&ResultBuilder::IsNestedNameSpecifier); |
6063 | SemaRef.LookupVisibleDecls(S, Sema::LookupNestedNameSpecifierName, Consumer, |
6064 | CodeCompleter->includeGlobals(), |
6065 | CodeCompleter->loadExternal()); |
6066 | } |
6067 | |
6068 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
6069 | Context: Results.getCompletionContext(), Results: Results.data(), |
6070 | NumResults: Results.size()); |
6071 | } |
6072 | |
6073 | static void AddTypeQualifierResults(DeclSpec &DS, ResultBuilder &Results, |
6074 | const LangOptions &LangOpts) { |
6075 | if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const)) |
6076 | Results.AddResult(R: "const"); |
6077 | if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile)) |
6078 | Results.AddResult(R: "volatile"); |
6079 | if (LangOpts.C99 && !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict)) |
6080 | Results.AddResult(R: "restrict"); |
6081 | if (LangOpts.C11 && !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic)) |
6082 | Results.AddResult(R: "_Atomic"); |
6083 | if (LangOpts.MSVCCompat && !(DS.getTypeQualifiers() & DeclSpec::TQ_unaligned)) |
6084 | Results.AddResult(R: "__unaligned"); |
6085 | } |
6086 | |
6087 | void SemaCodeCompletion::CodeCompleteTypeQualifiers(DeclSpec &DS) { |
6088 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
6089 | CodeCompleter->getCodeCompletionTUInfo(), |
6090 | CodeCompletionContext::CCC_TypeQualifiers); |
6091 | Results.EnterNewScope(); |
6092 | AddTypeQualifierResults(DS, Results, LangOpts: getLangOpts()); |
6093 | Results.ExitScope(); |
6094 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
6095 | Context: Results.getCompletionContext(), Results: Results.data(), |
6096 | NumResults: Results.size()); |
6097 | } |
6098 | |
6099 | void SemaCodeCompletion::CodeCompleteFunctionQualifiers( |
6100 | DeclSpec &DS, Declarator &D, const VirtSpecifiers *VS) { |
6101 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
6102 | CodeCompleter->getCodeCompletionTUInfo(), |
6103 | CodeCompletionContext::CCC_TypeQualifiers); |
6104 | Results.EnterNewScope(); |
6105 | AddTypeQualifierResults(DS, Results, LangOpts: getLangOpts()); |
6106 | if (getLangOpts().CPlusPlus11) { |
6107 | Results.AddResult(R: "noexcept"); |
6108 | if (D.getContext() == DeclaratorContext::Member && !D.isCtorOrDtor() && |
6109 | !D.isStaticMember()) { |
6110 | if (!VS || !VS->isFinalSpecified()) |
6111 | Results.AddResult(R: "final"); |
6112 | if (!VS || !VS->isOverrideSpecified()) |
6113 | Results.AddResult(R: "override"); |
6114 | } |
6115 | } |
6116 | Results.ExitScope(); |
6117 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
6118 | Context: Results.getCompletionContext(), Results: Results.data(), |
6119 | NumResults: Results.size()); |
6120 | } |
6121 | |
6122 | void SemaCodeCompletion::CodeCompleteBracketDeclarator(Scope *S) { |
6123 | CodeCompleteExpression(S, PreferredType: QualType(getASTContext().getSizeType())); |
6124 | } |
6125 | |
6126 | void SemaCodeCompletion::CodeCompleteCase(Scope *S) { |
6127 | if (SemaRef.getCurFunction()->SwitchStack.empty() || !CodeCompleter) |
6128 | return; |
6129 | |
6130 | SwitchStmt *Switch = |
6131 | SemaRef.getCurFunction()->SwitchStack.back().getPointer(); |
6132 | // Condition expression might be invalid, do not continue in this case. |
6133 | if (!Switch->getCond()) |
6134 | return; |
6135 | QualType type = Switch->getCond()->IgnoreImplicit()->getType(); |
6136 | if (!type->isEnumeralType()) { |
6137 | CodeCompleteExpressionData Data(type); |
6138 | Data.IntegralConstantExpression = true; |
6139 | CodeCompleteExpression(S, Data); |
6140 | return; |
6141 | } |
6142 | |
6143 | // Code-complete the cases of a switch statement over an enumeration type |
6144 | // by providing the list of |
6145 | EnumDecl *Enum = type->castAs<EnumType>()->getDecl(); |
6146 | if (EnumDecl *Def = Enum->getDefinition()) |
6147 | Enum = Def; |
6148 | |
6149 | // Determine which enumerators we have already seen in the switch statement. |
6150 | // FIXME: Ideally, we would also be able to look *past* the code-completion |
6151 | // token, in case we are code-completing in the middle of the switch and not |
6152 | // at the end. However, we aren't able to do so at the moment. |
6153 | CoveredEnumerators Enumerators; |
6154 | for (SwitchCase *SC = Switch->getSwitchCaseList(); SC; |
6155 | SC = SC->getNextSwitchCase()) { |
6156 | CaseStmt *Case = dyn_cast<CaseStmt>(Val: SC); |
6157 | if (!Case) |
6158 | continue; |
6159 | |
6160 | Expr *CaseVal = Case->getLHS()->IgnoreParenCasts(); |
6161 | if (auto *DRE = dyn_cast<DeclRefExpr>(Val: CaseVal)) |
6162 | if (auto *Enumerator = |
6163 | dyn_cast<EnumConstantDecl>(Val: DRE->getDecl())) { |
6164 | // We look into the AST of the case statement to determine which |
6165 | // enumerator was named. Alternatively, we could compute the value of |
6166 | // the integral constant expression, then compare it against the |
6167 | // values of each enumerator. However, value-based approach would not |
6168 | // work as well with C++ templates where enumerators declared within a |
6169 | // template are type- and value-dependent. |
6170 | Enumerators.Seen.insert(Ptr: Enumerator); |
6171 | |
6172 | // If this is a qualified-id, keep track of the nested-name-specifier |
6173 | // so that we can reproduce it as part of code completion, e.g., |
6174 | // |
6175 | // switch (TagD.getKind()) { |
6176 | // case TagDecl::TK_enum: |
6177 | // break; |
6178 | // case XXX |
6179 | // |
6180 | // At the XXX, our completions are TagDecl::TK_union, |
6181 | // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union, |
6182 | // TK_struct, and TK_class. |
6183 | Enumerators.SuggestedQualifier = DRE->getQualifier(); |
6184 | } |
6185 | } |
6186 | |
6187 | // Add any enumerators that have not yet been mentioned. |
6188 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
6189 | CodeCompleter->getCodeCompletionTUInfo(), |
6190 | CodeCompletionContext::CCC_Expression); |
6191 | AddEnumerators(Results, Context&: getASTContext(), Enum, CurContext: SemaRef.CurContext, |
6192 | Enumerators); |
6193 | |
6194 | if (CodeCompleter->includeMacros()) { |
6195 | AddMacroResults(PP&: SemaRef.PP, Results, LoadExternal: CodeCompleter->loadExternal(), IncludeUndefined: false); |
6196 | } |
6197 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
6198 | Context: Results.getCompletionContext(), Results: Results.data(), |
6199 | NumResults: Results.size()); |
6200 | } |
6201 | |
6202 | static bool anyNullArguments(ArrayRef<Expr *> Args) { |
6203 | if (Args.size() && !Args.data()) |
6204 | return true; |
6205 | |
6206 | for (unsigned I = 0; I != Args.size(); ++I) |
6207 | if (!Args[I]) |
6208 | return true; |
6209 | |
6210 | return false; |
6211 | } |
6212 | |
6213 | typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate; |
6214 | |
6215 | static void mergeCandidatesWithResults( |
6216 | Sema &SemaRef, SmallVectorImpl<ResultCandidate> &Results, |
6217 | OverloadCandidateSet &CandidateSet, SourceLocation Loc, size_t ArgSize) { |
6218 | // Sort the overload candidate set by placing the best overloads first. |
6219 | llvm::stable_sort(Range&: CandidateSet, C: [&](const OverloadCandidate &X, |
6220 | const OverloadCandidate &Y) { |
6221 | return isBetterOverloadCandidate(S&: SemaRef, Cand1: X, Cand2: Y, Loc, Kind: CandidateSet.getKind(), |
6222 | /*PartialOverloading=*/true); |
6223 | }); |
6224 | |
6225 | // Add the remaining viable overload candidates as code-completion results. |
6226 | for (OverloadCandidate &Candidate : CandidateSet) { |
6227 | if (Candidate.Function) { |
6228 | if (Candidate.Function->isDeleted()) |
6229 | continue; |
6230 | if (shouldEnforceArgLimit(/*PartialOverloading=*/true, |
6231 | Function: Candidate.Function) && |
6232 | Candidate.Function->getNumParams() <= ArgSize && |
6233 | // Having zero args is annoying, normally we don't surface a function |
6234 | // with 2 params, if you already have 2 params, because you are |
6235 | // inserting the 3rd now. But with zero, it helps the user to figure |
6236 | // out there are no overloads that take any arguments. Hence we are |
6237 | // keeping the overload. |
6238 | ArgSize > 0) |
6239 | continue; |
6240 | } |
6241 | if (Candidate.Viable) |
6242 | Results.push_back(Elt: ResultCandidate(Candidate.Function)); |
6243 | } |
6244 | } |
6245 | |
6246 | /// Get the type of the Nth parameter from a given set of overload |
6247 | /// candidates. |
6248 | static QualType getParamType(Sema &SemaRef, |
6249 | ArrayRef<ResultCandidate> Candidates, unsigned N) { |
6250 | |
6251 | // Given the overloads 'Candidates' for a function call matching all arguments |
6252 | // up to N, return the type of the Nth parameter if it is the same for all |
6253 | // overload candidates. |
6254 | QualType ParamType; |
6255 | for (auto &Candidate : Candidates) { |
6256 | QualType CandidateParamType = Candidate.getParamType(N); |
6257 | if (CandidateParamType.isNull()) |
6258 | continue; |
6259 | if (ParamType.isNull()) { |
6260 | ParamType = CandidateParamType; |
6261 | continue; |
6262 | } |
6263 | if (!SemaRef.Context.hasSameUnqualifiedType( |
6264 | T1: ParamType.getNonReferenceType(), |
6265 | T2: CandidateParamType.getNonReferenceType())) |
6266 | // Two conflicting types, give up. |
6267 | return QualType(); |
6268 | } |
6269 | |
6270 | return ParamType; |
6271 | } |
6272 | |
6273 | static QualType |
6274 | ProduceSignatureHelp(Sema &SemaRef, MutableArrayRef<ResultCandidate> Candidates, |
6275 | unsigned CurrentArg, SourceLocation OpenParLoc, |
6276 | bool Braced) { |
6277 | if (Candidates.empty()) |
6278 | return QualType(); |
6279 | if (SemaRef.getPreprocessor().isCodeCompletionReached()) |
6280 | SemaRef.CodeCompletion().CodeCompleter->ProcessOverloadCandidates( |
6281 | S&: SemaRef, CurrentArg, Candidates: Candidates.data(), NumCandidates: Candidates.size(), OpenParLoc, |
6282 | Braced); |
6283 | return getParamType(SemaRef, Candidates, N: CurrentArg); |
6284 | } |
6285 | |
6286 | // Given a callee expression `Fn`, if the call is through a function pointer, |
6287 | // try to find the declaration of the corresponding function pointer type, |
6288 | // so that we can recover argument names from it. |
6289 | static FunctionProtoTypeLoc GetPrototypeLoc(Expr *Fn) { |
6290 | TypeLoc Target; |
6291 | |
6292 | if (const auto *T = Fn->getType().getTypePtr()->getAs<TypedefType>()) { |
6293 | Target = T->getDecl()->getTypeSourceInfo()->getTypeLoc(); |
6294 | |
6295 | } else if (const auto *DR = dyn_cast<DeclRefExpr>(Val: Fn)) { |
6296 | const auto *D = DR->getDecl(); |
6297 | if (const auto *const VD = dyn_cast<VarDecl>(Val: D)) { |
6298 | Target = VD->getTypeSourceInfo()->getTypeLoc(); |
6299 | } |
6300 | } else if (const auto *ME = dyn_cast<MemberExpr>(Val: Fn)) { |
6301 | const auto *MD = ME->getMemberDecl(); |
6302 | if (const auto *FD = dyn_cast<FieldDecl>(Val: MD)) { |
6303 | Target = FD->getTypeSourceInfo()->getTypeLoc(); |
6304 | } |
6305 | } |
6306 | |
6307 | if (!Target) |
6308 | return {}; |
6309 | |
6310 | // Unwrap types that may be wrapping the function type |
6311 | while (true) { |
6312 | if (auto P = Target.getAs<PointerTypeLoc>()) { |
6313 | Target = P.getPointeeLoc(); |
6314 | continue; |
6315 | } |
6316 | if (auto A = Target.getAs<AttributedTypeLoc>()) { |
6317 | Target = A.getModifiedLoc(); |
6318 | continue; |
6319 | } |
6320 | if (auto P = Target.getAs<ParenTypeLoc>()) { |
6321 | Target = P.getInnerLoc(); |
6322 | continue; |
6323 | } |
6324 | break; |
6325 | } |
6326 | |
6327 | if (auto F = Target.getAs<FunctionProtoTypeLoc>()) { |
6328 | return F; |
6329 | } |
6330 | |
6331 | return {}; |
6332 | } |
6333 | |
6334 | QualType |
6335 | SemaCodeCompletion::ProduceCallSignatureHelp(Expr *Fn, ArrayRef<Expr *> Args, |
6336 | SourceLocation OpenParLoc) { |
6337 | Fn = unwrapParenList(Base: Fn); |
6338 | if (!CodeCompleter || !Fn) |
6339 | return QualType(); |
6340 | |
6341 | // FIXME: Provide support for variadic template functions. |
6342 | // Ignore type-dependent call expressions entirely. |
6343 | if (Fn->isTypeDependent() || anyNullArguments(Args)) |
6344 | return QualType(); |
6345 | // In presence of dependent args we surface all possible signatures using the |
6346 | // non-dependent args in the prefix. Afterwards we do a post filtering to make |
6347 | // sure provided candidates satisfy parameter count restrictions. |
6348 | auto ArgsWithoutDependentTypes = |
6349 | Args.take_while(Pred: [](Expr *Arg) { return !Arg->isTypeDependent(); }); |
6350 | |
6351 | SmallVector<ResultCandidate, 8> Results; |
6352 | |
6353 | Expr *NakedFn = Fn->IgnoreParenCasts(); |
6354 | // Build an overload candidate set based on the functions we find. |
6355 | SourceLocation Loc = Fn->getExprLoc(); |
6356 | OverloadCandidateSet CandidateSet(Loc, |
6357 | OverloadCandidateSet::CSK_CodeCompletion); |
6358 | |
6359 | if (auto ULE = dyn_cast<UnresolvedLookupExpr>(Val: NakedFn)) { |
6360 | SemaRef.AddOverloadedCallCandidates(ULE, Args: ArgsWithoutDependentTypes, |
6361 | CandidateSet, |
6362 | /*PartialOverloading=*/true); |
6363 | } else if (auto UME = dyn_cast<UnresolvedMemberExpr>(Val: NakedFn)) { |
6364 | TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr; |
6365 | if (UME->hasExplicitTemplateArgs()) { |
6366 | UME->copyTemplateArgumentsInto(TemplateArgsBuffer); |
6367 | TemplateArgs = &TemplateArgsBuffer; |
6368 | } |
6369 | |
6370 | // Add the base as first argument (use a nullptr if the base is implicit). |
6371 | SmallVector<Expr *, 12> ArgExprs( |
6372 | 1, UME->isImplicitAccess() ? nullptr : UME->getBase()); |
6373 | ArgExprs.append(in_start: ArgsWithoutDependentTypes.begin(), |
6374 | in_end: ArgsWithoutDependentTypes.end()); |
6375 | UnresolvedSet<8> Decls; |
6376 | Decls.append(I: UME->decls_begin(), E: UME->decls_end()); |
6377 | const bool FirstArgumentIsBase = !UME->isImplicitAccess() && UME->getBase(); |
6378 | SemaRef.AddFunctionCandidates(Functions: Decls, Args: ArgExprs, CandidateSet, ExplicitTemplateArgs: TemplateArgs, |
6379 | /*SuppressUserConversions=*/false, |
6380 | /*PartialOverloading=*/true, |
6381 | FirstArgumentIsBase); |
6382 | } else { |
6383 | FunctionDecl *FD = nullptr; |
6384 | if (auto *MCE = dyn_cast<MemberExpr>(Val: NakedFn)) |
6385 | FD = dyn_cast<FunctionDecl>(Val: MCE->getMemberDecl()); |
6386 | else if (auto *DRE = dyn_cast<DeclRefExpr>(Val: NakedFn)) |
6387 | FD = dyn_cast<FunctionDecl>(Val: DRE->getDecl()); |
6388 | if (FD) { // We check whether it's a resolved function declaration. |
6389 | if (!getLangOpts().CPlusPlus || |
6390 | !FD->getType()->getAs<FunctionProtoType>()) |
6391 | Results.push_back(Elt: ResultCandidate(FD)); |
6392 | else |
6393 | SemaRef.AddOverloadCandidate(Function: FD, |
6394 | FoundDecl: DeclAccessPair::make(D: FD, AS: FD->getAccess()), |
6395 | Args: ArgsWithoutDependentTypes, CandidateSet, |
6396 | /*SuppressUserConversions=*/false, |
6397 | /*PartialOverloading=*/true); |
6398 | |
6399 | } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) { |
6400 | // If expression's type is CXXRecordDecl, it may overload the function |
6401 | // call operator, so we check if it does and add them as candidates. |
6402 | // A complete type is needed to lookup for member function call operators. |
6403 | if (SemaRef.isCompleteType(Loc, T: NakedFn->getType())) { |
6404 | DeclarationName OpName = |
6405 | getASTContext().DeclarationNames.getCXXOperatorName(Op: OO_Call); |
6406 | LookupResult R(SemaRef, OpName, Loc, Sema::LookupOrdinaryName); |
6407 | SemaRef.LookupQualifiedName(R, DC); |
6408 | R.suppressDiagnostics(); |
6409 | SmallVector<Expr *, 12> ArgExprs(1, NakedFn); |
6410 | ArgExprs.append(in_start: ArgsWithoutDependentTypes.begin(), |
6411 | in_end: ArgsWithoutDependentTypes.end()); |
6412 | SemaRef.AddFunctionCandidates(Functions: R.asUnresolvedSet(), Args: ArgExprs, |
6413 | CandidateSet, |
6414 | /*ExplicitArgs=*/ExplicitTemplateArgs: nullptr, |
6415 | /*SuppressUserConversions=*/false, |
6416 | /*PartialOverloading=*/true); |
6417 | } |
6418 | } else { |
6419 | // Lastly we check whether expression's type is function pointer or |
6420 | // function. |
6421 | |
6422 | FunctionProtoTypeLoc P = GetPrototypeLoc(Fn: NakedFn); |
6423 | QualType T = NakedFn->getType(); |
6424 | if (!T->getPointeeType().isNull()) |
6425 | T = T->getPointeeType(); |
6426 | |
6427 | if (auto FP = T->getAs<FunctionProtoType>()) { |
6428 | if (!SemaRef.TooManyArguments(NumParams: FP->getNumParams(), |
6429 | NumArgs: ArgsWithoutDependentTypes.size(), |
6430 | /*PartialOverloading=*/true) || |
6431 | FP->isVariadic()) { |
6432 | if (P) { |
6433 | Results.push_back(Elt: ResultCandidate(P)); |
6434 | } else { |
6435 | Results.push_back(Elt: ResultCandidate(FP)); |
6436 | } |
6437 | } |
6438 | } else if (auto FT = T->getAs<FunctionType>()) |
6439 | // No prototype and declaration, it may be a K & R style function. |
6440 | Results.push_back(Elt: ResultCandidate(FT)); |
6441 | } |
6442 | } |
6443 | mergeCandidatesWithResults(SemaRef, Results, CandidateSet, Loc, ArgSize: Args.size()); |
6444 | QualType ParamType = ProduceSignatureHelp(SemaRef, Candidates: Results, CurrentArg: Args.size(), |
6445 | OpenParLoc, /*Braced=*/false); |
6446 | return !CandidateSet.empty() ? ParamType : QualType(); |
6447 | } |
6448 | |
6449 | // Determine which param to continue aggregate initialization from after |
6450 | // a designated initializer. |
6451 | // |
6452 | // Given struct S { int a,b,c,d,e; }: |
6453 | // after `S{.b=1,` we want to suggest c to continue |
6454 | // after `S{.b=1, 2,` we continue with d (this is legal C and ext in C++) |
6455 | // after `S{.b=1, .a=2,` we continue with b (this is legal C and ext in C++) |
6456 | // |
6457 | // Possible outcomes: |
6458 | // - we saw a designator for a field, and continue from the returned index. |
6459 | // Only aggregate initialization is allowed. |
6460 | // - we saw a designator, but it was complex or we couldn't find the field. |
6461 | // Only aggregate initialization is possible, but we can't assist with it. |
6462 | // Returns an out-of-range index. |
6463 | // - we saw no designators, just positional arguments. |
6464 | // Returns std::nullopt. |
6465 | static std::optional<unsigned> |
6466 | getNextAggregateIndexAfterDesignatedInit(const ResultCandidate &Aggregate, |
6467 | ArrayRef<Expr *> Args) { |
6468 | static constexpr unsigned Invalid = std::numeric_limits<unsigned>::max(); |
6469 | assert(Aggregate.getKind() == ResultCandidate::CK_Aggregate); |
6470 | |
6471 | // Look for designated initializers. |
6472 | // They're in their syntactic form, not yet resolved to fields. |
6473 | const IdentifierInfo *DesignatedFieldName = nullptr; |
6474 | unsigned ArgsAfterDesignator = 0; |
6475 | for (const Expr *Arg : Args) { |
6476 | if (const auto *DIE = dyn_cast<DesignatedInitExpr>(Val: Arg)) { |
6477 | if (DIE->size() == 1 && DIE->getDesignator(Idx: 0)->isFieldDesignator()) { |
6478 | DesignatedFieldName = DIE->getDesignator(Idx: 0)->getFieldName(); |
6479 | ArgsAfterDesignator = 0; |
6480 | } else { |
6481 | return Invalid; // Complicated designator. |
6482 | } |
6483 | } else if (isa<DesignatedInitUpdateExpr>(Val: Arg)) { |
6484 | return Invalid; // Unsupported. |
6485 | } else { |
6486 | ++ArgsAfterDesignator; |
6487 | } |
6488 | } |
6489 | if (!DesignatedFieldName) |
6490 | return std::nullopt; |
6491 | |
6492 | // Find the index within the class's fields. |
6493 | // (Probing getParamDecl() directly would be quadratic in number of fields). |
6494 | unsigned DesignatedIndex = 0; |
6495 | const FieldDecl *DesignatedField = nullptr; |
6496 | for (const auto *Field : Aggregate.getAggregate()->fields()) { |
6497 | if (Field->getIdentifier() == DesignatedFieldName) { |
6498 | DesignatedField = Field; |
6499 | break; |
6500 | } |
6501 | ++DesignatedIndex; |
6502 | } |
6503 | if (!DesignatedField) |
6504 | return Invalid; // Designator referred to a missing field, give up. |
6505 | |
6506 | // Find the index within the aggregate (which may have leading bases). |
6507 | unsigned AggregateSize = Aggregate.getNumParams(); |
6508 | while (DesignatedIndex < AggregateSize && |
6509 | Aggregate.getParamDecl(N: DesignatedIndex) != DesignatedField) |
6510 | ++DesignatedIndex; |
6511 | |
6512 | // Continue from the index after the last named field. |
6513 | return DesignatedIndex + ArgsAfterDesignator + 1; |
6514 | } |
6515 | |
6516 | QualType SemaCodeCompletion::ProduceConstructorSignatureHelp( |
6517 | QualType Type, SourceLocation Loc, ArrayRef<Expr *> Args, |
6518 | SourceLocation OpenParLoc, bool Braced) { |
6519 | if (!CodeCompleter) |
6520 | return QualType(); |
6521 | SmallVector<ResultCandidate, 8> Results; |
6522 | |
6523 | // A complete type is needed to lookup for constructors. |
6524 | RecordDecl *RD = |
6525 | SemaRef.isCompleteType(Loc, T: Type) ? Type->getAsRecordDecl() : nullptr; |
6526 | if (!RD) |
6527 | return Type; |
6528 | CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(Val: RD); |
6529 | |
6530 | // Consider aggregate initialization. |
6531 | // We don't check that types so far are correct. |
6532 | // We also don't handle C99/C++17 brace-elision, we assume init-list elements |
6533 | // are 1:1 with fields. |
6534 | // FIXME: it would be nice to support "unwrapping" aggregates that contain |
6535 | // a single subaggregate, like std::array<T, N> -> T __elements[N]. |
6536 | if (Braced && !RD->isUnion() && |
6537 | (!getLangOpts().CPlusPlus || (CRD && CRD->isAggregate()))) { |
6538 | ResultCandidate AggregateSig(RD); |
6539 | unsigned AggregateSize = AggregateSig.getNumParams(); |
6540 | |
6541 | if (auto NextIndex = |
6542 | getNextAggregateIndexAfterDesignatedInit(Aggregate: AggregateSig, Args)) { |
6543 | // A designator was used, only aggregate init is possible. |
6544 | if (*NextIndex >= AggregateSize) |
6545 | return Type; |
6546 | Results.push_back(Elt: AggregateSig); |
6547 | return ProduceSignatureHelp(SemaRef, Candidates: Results, CurrentArg: *NextIndex, OpenParLoc, |
6548 | Braced); |
6549 | } |
6550 | |
6551 | // Describe aggregate initialization, but also constructors below. |
6552 | if (Args.size() < AggregateSize) |
6553 | Results.push_back(Elt: AggregateSig); |
6554 | } |
6555 | |
6556 | // FIXME: Provide support for member initializers. |
6557 | // FIXME: Provide support for variadic template constructors. |
6558 | |
6559 | if (CRD) { |
6560 | OverloadCandidateSet CandidateSet(Loc, |
6561 | OverloadCandidateSet::CSK_CodeCompletion); |
6562 | for (NamedDecl *C : SemaRef.LookupConstructors(Class: CRD)) { |
6563 | if (auto *FD = dyn_cast<FunctionDecl>(Val: C)) { |
6564 | // FIXME: we can't yet provide correct signature help for initializer |
6565 | // list constructors, so skip them entirely. |
6566 | if (Braced && getLangOpts().CPlusPlus && |
6567 | SemaRef.isInitListConstructor(Ctor: FD)) |
6568 | continue; |
6569 | SemaRef.AddOverloadCandidate( |
6570 | Function: FD, FoundDecl: DeclAccessPair::make(D: FD, AS: C->getAccess()), Args, CandidateSet, |
6571 | /*SuppressUserConversions=*/false, |
6572 | /*PartialOverloading=*/true, |
6573 | /*AllowExplicit*/ true); |
6574 | } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(Val: C)) { |
6575 | if (Braced && getLangOpts().CPlusPlus && |
6576 | SemaRef.isInitListConstructor(Ctor: FTD->getTemplatedDecl())) |
6577 | continue; |
6578 | |
6579 | SemaRef.AddTemplateOverloadCandidate( |
6580 | FunctionTemplate: FTD, FoundDecl: DeclAccessPair::make(D: FTD, AS: C->getAccess()), |
6581 | /*ExplicitTemplateArgs=*/nullptr, Args, CandidateSet, |
6582 | /*SuppressUserConversions=*/false, |
6583 | /*PartialOverloading=*/true); |
6584 | } |
6585 | } |
6586 | mergeCandidatesWithResults(SemaRef, Results, CandidateSet, Loc, |
6587 | ArgSize: Args.size()); |
6588 | } |
6589 | |
6590 | return ProduceSignatureHelp(SemaRef, Candidates: Results, CurrentArg: Args.size(), OpenParLoc, |
6591 | Braced); |
6592 | } |
6593 | |
6594 | QualType SemaCodeCompletion::ProduceCtorInitMemberSignatureHelp( |
6595 | Decl *ConstructorDecl, CXXScopeSpec SS, ParsedType TemplateTypeTy, |
6596 | ArrayRef<Expr *> ArgExprs, IdentifierInfo *II, SourceLocation OpenParLoc, |
6597 | bool Braced) { |
6598 | if (!CodeCompleter) |
6599 | return QualType(); |
6600 | |
6601 | CXXConstructorDecl *Constructor = |
6602 | dyn_cast<CXXConstructorDecl>(Val: ConstructorDecl); |
6603 | if (!Constructor) |
6604 | return QualType(); |
6605 | // FIXME: Add support for Base class constructors as well. |
6606 | if (ValueDecl *MemberDecl = SemaRef.tryLookupCtorInitMemberDecl( |
6607 | ClassDecl: Constructor->getParent(), SS, TemplateTypeTy, MemberOrBase: II)) |
6608 | return ProduceConstructorSignatureHelp(Type: MemberDecl->getType(), |
6609 | Loc: MemberDecl->getLocation(), Args: ArgExprs, |
6610 | OpenParLoc, Braced); |
6611 | return QualType(); |
6612 | } |
6613 | |
6614 | static bool argMatchesTemplateParams(const ParsedTemplateArgument &Arg, |
6615 | unsigned Index, |
6616 | const TemplateParameterList &Params) { |
6617 | const NamedDecl *Param; |
6618 | if (Index < Params.size()) |
6619 | Param = Params.getParam(Idx: Index); |
6620 | else if (Params.hasParameterPack()) |
6621 | Param = Params.asArray().back(); |
6622 | else |
6623 | return false; // too many args |
6624 | |
6625 | switch (Arg.getKind()) { |
6626 | case ParsedTemplateArgument::Type: |
6627 | return llvm::isa<TemplateTypeParmDecl>(Val: Param); // constraints not checked |
6628 | case ParsedTemplateArgument::NonType: |
6629 | return llvm::isa<NonTypeTemplateParmDecl>(Val: Param); // type not checked |
6630 | case ParsedTemplateArgument::Template: |
6631 | return llvm::isa<TemplateTemplateParmDecl>(Val: Param); // signature not checked |
6632 | } |
6633 | llvm_unreachable("Unhandled switch case"); |
6634 | } |
6635 | |
6636 | QualType SemaCodeCompletion::ProduceTemplateArgumentSignatureHelp( |
6637 | TemplateTy ParsedTemplate, ArrayRef<ParsedTemplateArgument> Args, |
6638 | SourceLocation LAngleLoc) { |
6639 | if (!CodeCompleter || !ParsedTemplate) |
6640 | return QualType(); |
6641 | |
6642 | SmallVector<ResultCandidate, 8> Results; |
6643 | auto Consider = [&](const TemplateDecl *TD) { |
6644 | // Only add if the existing args are compatible with the template. |
6645 | bool Matches = true; |
6646 | for (unsigned I = 0; I < Args.size(); ++I) { |
6647 | if (!argMatchesTemplateParams(Arg: Args[I], Index: I, Params: *TD->getTemplateParameters())) { |
6648 | Matches = false; |
6649 | break; |
6650 | } |
6651 | } |
6652 | if (Matches) |
6653 | Results.emplace_back(Args&: TD); |
6654 | }; |
6655 | |
6656 | TemplateName Template = ParsedTemplate.get(); |
6657 | if (const auto *TD = Template.getAsTemplateDecl()) { |
6658 | Consider(TD); |
6659 | } else if (const auto *OTS = Template.getAsOverloadedTemplate()) { |
6660 | for (const NamedDecl *ND : *OTS) |
6661 | if (const auto *TD = llvm::dyn_cast<TemplateDecl>(Val: ND)) |
6662 | Consider(TD); |
6663 | } |
6664 | return ProduceSignatureHelp(SemaRef, Candidates: Results, CurrentArg: Args.size(), OpenParLoc: LAngleLoc, |
6665 | /*Braced=*/false); |
6666 | } |
6667 | |
6668 | static QualType getDesignatedType(QualType BaseType, const Designation &Desig, |
6669 | HeuristicResolver &Resolver) { |
6670 | for (unsigned I = 0; I < Desig.getNumDesignators(); ++I) { |
6671 | if (BaseType.isNull()) |
6672 | break; |
6673 | QualType NextType; |
6674 | const auto &D = Desig.getDesignator(Idx: I); |
6675 | if (D.isArrayDesignator() || D.isArrayRangeDesignator()) { |
6676 | if (BaseType->isArrayType()) |
6677 | NextType = BaseType->getAsArrayTypeUnsafe()->getElementType(); |
6678 | } else { |
6679 | assert(D.isFieldDesignator()); |
6680 | auto *RD = getAsRecordDecl(BaseType, Resolver); |
6681 | if (RD && RD->isCompleteDefinition()) { |
6682 | for (const auto *Member : RD->lookup(D.getFieldDecl())) |
6683 | if (const FieldDecl *FD = llvm::dyn_cast<FieldDecl>(Member)) { |
6684 | NextType = FD->getType(); |
6685 | break; |
6686 | } |
6687 | } |
6688 | } |
6689 | BaseType = NextType; |
6690 | } |
6691 | return BaseType; |
6692 | } |
6693 | |
6694 | void SemaCodeCompletion::CodeCompleteDesignator( |
6695 | QualType BaseType, llvm::ArrayRef<Expr *> InitExprs, const Designation &D) { |
6696 | BaseType = getDesignatedType(BaseType, Desig: D, Resolver); |
6697 | if (BaseType.isNull()) |
6698 | return; |
6699 | const auto *RD = getAsRecordDecl(BaseType, Resolver); |
6700 | if (!RD || RD->fields().empty()) |
6701 | return; |
6702 | |
6703 | CodeCompletionContext CCC(CodeCompletionContext::CCC_DotMemberAccess, |
6704 | BaseType); |
6705 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
6706 | CodeCompleter->getCodeCompletionTUInfo(), CCC); |
6707 | |
6708 | Results.EnterNewScope(); |
6709 | for (const Decl *D : RD->decls()) { |
6710 | const FieldDecl *FD; |
6711 | if (auto *IFD = dyn_cast<IndirectFieldDecl>(D)) |
6712 | FD = IFD->getAnonField(); |
6713 | else if (auto *DFD = dyn_cast<FieldDecl>(D)) |
6714 | FD = DFD; |
6715 | else |
6716 | continue; |
6717 | |
6718 | // FIXME: Make use of previous designators to mark any fields before those |
6719 | // inaccessible, and also compute the next initializer priority. |
6720 | ResultBuilder::Result Result(FD, Results.getBasePriority(FD)); |
6721 | Results.AddResult(Result, SemaRef.CurContext, /*Hiding=*/nullptr); |
6722 | } |
6723 | Results.ExitScope(); |
6724 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
6725 | Context: Results.getCompletionContext(), Results: Results.data(), |
6726 | NumResults: Results.size()); |
6727 | } |
6728 | |
6729 | void SemaCodeCompletion::CodeCompleteInitializer(Scope *S, Decl *D) { |
6730 | ValueDecl *VD = dyn_cast_or_null<ValueDecl>(Val: D); |
6731 | if (!VD) { |
6732 | CodeCompleteOrdinaryName(S, CompletionContext: PCC_Expression); |
6733 | return; |
6734 | } |
6735 | |
6736 | CodeCompleteExpressionData Data; |
6737 | Data.PreferredType = VD->getType(); |
6738 | // Ignore VD to avoid completing the variable itself, e.g. in 'int foo = ^'. |
6739 | Data.IgnoreDecls.push_back(VD); |
6740 | |
6741 | CodeCompleteExpression(S, Data); |
6742 | } |
6743 | |
6744 | void SemaCodeCompletion::CodeCompleteKeywordAfterIf(bool AfterExclaim) const { |
6745 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
6746 | CodeCompleter->getCodeCompletionTUInfo(), |
6747 | CodeCompletionContext::CCC_Other); |
6748 | CodeCompletionBuilder Builder(Results.getAllocator(), |
6749 | Results.getCodeCompletionTUInfo()); |
6750 | if (getLangOpts().CPlusPlus17) { |
6751 | if (!AfterExclaim) { |
6752 | if (Results.includeCodePatterns()) { |
6753 | Builder.AddTypedTextChunk(Text: "constexpr"); |
6754 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
6755 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
6756 | Builder.AddPlaceholderChunk(Placeholder: "condition"); |
6757 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
6758 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
6759 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
6760 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
6761 | Builder.AddPlaceholderChunk(Placeholder: "statements"); |
6762 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
6763 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
6764 | Results.AddResult(R: {Builder.TakeString()}); |
6765 | } else { |
6766 | Results.AddResult(R: {"constexpr"}); |
6767 | } |
6768 | } |
6769 | } |
6770 | if (getLangOpts().CPlusPlus23) { |
6771 | if (Results.includeCodePatterns()) { |
6772 | Builder.AddTypedTextChunk(Text: "consteval"); |
6773 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
6774 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
6775 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
6776 | Builder.AddPlaceholderChunk(Placeholder: "statements"); |
6777 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
6778 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
6779 | Results.AddResult(R: {Builder.TakeString()}); |
6780 | } else { |
6781 | Results.AddResult(R: {"consteval"}); |
6782 | } |
6783 | } |
6784 | |
6785 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
6786 | Context: Results.getCompletionContext(), Results: Results.data(), |
6787 | NumResults: Results.size()); |
6788 | } |
6789 | |
6790 | void SemaCodeCompletion::CodeCompleteAfterIf(Scope *S, bool IsBracedThen) { |
6791 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
6792 | CodeCompleter->getCodeCompletionTUInfo(), |
6793 | mapCodeCompletionContext(S&: SemaRef, PCC: PCC_Statement)); |
6794 | Results.setFilter(&ResultBuilder::IsOrdinaryName); |
6795 | Results.EnterNewScope(); |
6796 | |
6797 | CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext); |
6798 | SemaRef.LookupVisibleDecls(S, Sema::LookupOrdinaryName, Consumer, |
6799 | CodeCompleter->includeGlobals(), |
6800 | CodeCompleter->loadExternal()); |
6801 | |
6802 | AddOrdinaryNameResults(CCC: PCC_Statement, S, SemaRef, Results); |
6803 | |
6804 | // "else" block |
6805 | CodeCompletionBuilder Builder(Results.getAllocator(), |
6806 | Results.getCodeCompletionTUInfo()); |
6807 | |
6808 | auto AddElseBodyPattern = [&] { |
6809 | if (IsBracedThen) { |
6810 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
6811 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
6812 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
6813 | Builder.AddPlaceholderChunk(Placeholder: "statements"); |
6814 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
6815 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
6816 | } else { |
6817 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
6818 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
6819 | Builder.AddPlaceholderChunk(Placeholder: "statement"); |
6820 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
6821 | } |
6822 | }; |
6823 | Builder.AddTypedTextChunk(Text: "else"); |
6824 | if (Results.includeCodePatterns()) |
6825 | AddElseBodyPattern(); |
6826 | Results.AddResult(R: Builder.TakeString()); |
6827 | |
6828 | // "else if" block |
6829 | Builder.AddTypedTextChunk(Text: "else if"); |
6830 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
6831 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
6832 | if (getLangOpts().CPlusPlus) |
6833 | Builder.AddPlaceholderChunk(Placeholder: "condition"); |
6834 | else |
6835 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
6836 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
6837 | if (Results.includeCodePatterns()) { |
6838 | AddElseBodyPattern(); |
6839 | } |
6840 | Results.AddResult(R: Builder.TakeString()); |
6841 | |
6842 | Results.ExitScope(); |
6843 | |
6844 | if (S->getFnParent()) |
6845 | AddPrettyFunctionResults(LangOpts: getLangOpts(), Results); |
6846 | |
6847 | if (CodeCompleter->includeMacros()) |
6848 | AddMacroResults(PP&: SemaRef.PP, Results, LoadExternal: CodeCompleter->loadExternal(), IncludeUndefined: false); |
6849 | |
6850 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
6851 | Context: Results.getCompletionContext(), Results: Results.data(), |
6852 | NumResults: Results.size()); |
6853 | } |
6854 | |
6855 | void SemaCodeCompletion::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, |
6856 | bool EnteringContext, |
6857 | bool IsUsingDeclaration, |
6858 | QualType BaseType, |
6859 | QualType PreferredType) { |
6860 | if (SS.isEmpty() || !CodeCompleter) |
6861 | return; |
6862 | |
6863 | CodeCompletionContext CC(CodeCompletionContext::CCC_Symbol, PreferredType); |
6864 | CC.setIsUsingDeclaration(IsUsingDeclaration); |
6865 | CC.setCXXScopeSpecifier(SS); |
6866 | |
6867 | // We want to keep the scope specifier even if it's invalid (e.g. the scope |
6868 | // "a::b::" is not corresponding to any context/namespace in the AST), since |
6869 | // it can be useful for global code completion which have information about |
6870 | // contexts/symbols that are not in the AST. |
6871 | if (SS.isInvalid()) { |
6872 | // As SS is invalid, we try to collect accessible contexts from the current |
6873 | // scope with a dummy lookup so that the completion consumer can try to |
6874 | // guess what the specified scope is. |
6875 | ResultBuilder DummyResults(SemaRef, CodeCompleter->getAllocator(), |
6876 | CodeCompleter->getCodeCompletionTUInfo(), CC); |
6877 | if (!PreferredType.isNull()) |
6878 | DummyResults.setPreferredType(PreferredType); |
6879 | if (S->getEntity()) { |
6880 | CodeCompletionDeclConsumer Consumer(DummyResults, S->getEntity(), |
6881 | BaseType); |
6882 | SemaRef.LookupVisibleDecls(S, Sema::LookupOrdinaryName, Consumer, |
6883 | /*IncludeGlobalScope=*/false, |
6884 | /*LoadExternal=*/false); |
6885 | } |
6886 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
6887 | Context: DummyResults.getCompletionContext(), Results: nullptr, NumResults: 0); |
6888 | return; |
6889 | } |
6890 | // Always pretend to enter a context to ensure that a dependent type |
6891 | // resolves to a dependent record. |
6892 | DeclContext *Ctx = SemaRef.computeDeclContext(SS, /*EnteringContext=*/true); |
6893 | |
6894 | // Try to instantiate any non-dependent declaration contexts before |
6895 | // we look in them. Bail out if we fail. |
6896 | NestedNameSpecifier *NNS = SS.getScopeRep(); |
6897 | if (NNS != nullptr && SS.isValid() && !NNS->isDependent()) { |
6898 | if (Ctx == nullptr || SemaRef.RequireCompleteDeclContext(SS, DC: Ctx)) |
6899 | return; |
6900 | } |
6901 | |
6902 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
6903 | CodeCompleter->getCodeCompletionTUInfo(), CC); |
6904 | if (!PreferredType.isNull()) |
6905 | Results.setPreferredType(PreferredType); |
6906 | Results.EnterNewScope(); |
6907 | |
6908 | // The "template" keyword can follow "::" in the grammar, but only |
6909 | // put it into the grammar if the nested-name-specifier is dependent. |
6910 | // FIXME: results is always empty, this appears to be dead. |
6911 | if (!Results.empty() && NNS && NNS->isDependent()) |
6912 | Results.AddResult(R: "template"); |
6913 | |
6914 | // If the scope is a concept-constrained type parameter, infer nested |
6915 | // members based on the constraints. |
6916 | if (NNS) { |
6917 | if (const auto *TTPT = |
6918 | dyn_cast_or_null<TemplateTypeParmType>(Val: NNS->getAsType())) { |
6919 | for (const auto &R : ConceptInfo(*TTPT, S).members()) { |
6920 | if (R.Operator != ConceptInfo::Member::Colons) |
6921 | continue; |
6922 | Results.AddResult(R: CodeCompletionResult( |
6923 | R.render(S&: SemaRef, Alloc&: CodeCompleter->getAllocator(), |
6924 | Info&: CodeCompleter->getCodeCompletionTUInfo()))); |
6925 | } |
6926 | } |
6927 | } |
6928 | |
6929 | // Add calls to overridden virtual functions, if there are any. |
6930 | // |
6931 | // FIXME: This isn't wonderful, because we don't know whether we're actually |
6932 | // in a context that permits expressions. This is a general issue with |
6933 | // qualified-id completions. |
6934 | if (Ctx && !EnteringContext) |
6935 | MaybeAddOverrideCalls(S&: SemaRef, InContext: Ctx, Results); |
6936 | Results.ExitScope(); |
6937 | |
6938 | if (Ctx && |
6939 | (CodeCompleter->includeNamespaceLevelDecls() || !Ctx->isFileContext())) { |
6940 | CodeCompletionDeclConsumer Consumer(Results, Ctx, BaseType); |
6941 | SemaRef.LookupVisibleDecls(Ctx, Sema::LookupOrdinaryName, Consumer, |
6942 | /*IncludeGlobalScope=*/true, |
6943 | /*IncludeDependentBases=*/true, |
6944 | CodeCompleter->loadExternal()); |
6945 | } |
6946 | |
6947 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
6948 | Context: Results.getCompletionContext(), Results: Results.data(), |
6949 | NumResults: Results.size()); |
6950 | } |
6951 | |
6952 | void SemaCodeCompletion::CodeCompleteUsing(Scope *S) { |
6953 | if (!CodeCompleter) |
6954 | return; |
6955 | |
6956 | // This can be both a using alias or using declaration, in the former we |
6957 | // expect a new name and a symbol in the latter case. |
6958 | CodeCompletionContext Context(CodeCompletionContext::CCC_SymbolOrNewName); |
6959 | Context.setIsUsingDeclaration(true); |
6960 | |
6961 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
6962 | CodeCompleter->getCodeCompletionTUInfo(), Context, |
6963 | &ResultBuilder::IsNestedNameSpecifier); |
6964 | Results.EnterNewScope(); |
6965 | |
6966 | // If we aren't in class scope, we could see the "namespace" keyword. |
6967 | if (!S->isClassScope()) |
6968 | Results.AddResult(R: CodeCompletionResult("namespace")); |
6969 | |
6970 | // After "using", we can see anything that would start a |
6971 | // nested-name-specifier. |
6972 | CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext); |
6973 | SemaRef.LookupVisibleDecls(S, Sema::LookupOrdinaryName, Consumer, |
6974 | CodeCompleter->includeGlobals(), |
6975 | CodeCompleter->loadExternal()); |
6976 | Results.ExitScope(); |
6977 | |
6978 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
6979 | Context: Results.getCompletionContext(), Results: Results.data(), |
6980 | NumResults: Results.size()); |
6981 | } |
6982 | |
6983 | void SemaCodeCompletion::CodeCompleteUsingDirective(Scope *S) { |
6984 | if (!CodeCompleter) |
6985 | return; |
6986 | |
6987 | // After "using namespace", we expect to see a namespace name or namespace |
6988 | // alias. |
6989 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
6990 | CodeCompleter->getCodeCompletionTUInfo(), |
6991 | CodeCompletionContext::CCC_Namespace, |
6992 | &ResultBuilder::IsNamespaceOrAlias); |
6993 | Results.EnterNewScope(); |
6994 | CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext); |
6995 | SemaRef.LookupVisibleDecls(S, Sema::LookupOrdinaryName, Consumer, |
6996 | CodeCompleter->includeGlobals(), |
6997 | CodeCompleter->loadExternal()); |
6998 | Results.ExitScope(); |
6999 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
7000 | Context: Results.getCompletionContext(), Results: Results.data(), |
7001 | NumResults: Results.size()); |
7002 | } |
7003 | |
7004 | void SemaCodeCompletion::CodeCompleteNamespaceDecl(Scope *S) { |
7005 | if (!CodeCompleter) |
7006 | return; |
7007 | |
7008 | DeclContext *Ctx = S->getEntity(); |
7009 | if (!S->getParent()) |
7010 | Ctx = getASTContext().getTranslationUnitDecl(); |
7011 | |
7012 | bool SuppressedGlobalResults = |
7013 | Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Val: Ctx); |
7014 | |
7015 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
7016 | CodeCompleter->getCodeCompletionTUInfo(), |
7017 | SuppressedGlobalResults |
7018 | ? CodeCompletionContext::CCC_Namespace |
7019 | : CodeCompletionContext::CCC_Other, |
7020 | &ResultBuilder::IsNamespace); |
7021 | |
7022 | if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) { |
7023 | // We only want to see those namespaces that have already been defined |
7024 | // within this scope, because its likely that the user is creating an |
7025 | // extended namespace declaration. Keep track of the most recent |
7026 | // definition of each namespace. |
7027 | std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest; |
7028 | for (DeclContext::specific_decl_iterator<NamespaceDecl> |
7029 | NS(Ctx->decls_begin()), |
7030 | NSEnd(Ctx->decls_end()); |
7031 | NS != NSEnd; ++NS) |
7032 | OrigToLatest[NS->getFirstDecl()] = *NS; |
7033 | |
7034 | // Add the most recent definition (or extended definition) of each |
7035 | // namespace to the list of results. |
7036 | Results.EnterNewScope(); |
7037 | for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator |
7038 | NS = OrigToLatest.begin(), |
7039 | NSEnd = OrigToLatest.end(); |
7040 | NS != NSEnd; ++NS) |
7041 | Results.AddResult( |
7042 | R: CodeCompletionResult(NS->second, Results.getBasePriority(NS->second), |
7043 | nullptr), |
7044 | CurContext: SemaRef.CurContext, Hiding: nullptr, InBaseClass: false); |
7045 | Results.ExitScope(); |
7046 | } |
7047 | |
7048 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
7049 | Context: Results.getCompletionContext(), Results: Results.data(), |
7050 | NumResults: Results.size()); |
7051 | } |
7052 | |
7053 | void SemaCodeCompletion::CodeCompleteNamespaceAliasDecl(Scope *S) { |
7054 | if (!CodeCompleter) |
7055 | return; |
7056 | |
7057 | // After "namespace", we expect to see a namespace or alias. |
7058 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
7059 | CodeCompleter->getCodeCompletionTUInfo(), |
7060 | CodeCompletionContext::CCC_Namespace, |
7061 | &ResultBuilder::IsNamespaceOrAlias); |
7062 | CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext); |
7063 | SemaRef.LookupVisibleDecls(S, Sema::LookupOrdinaryName, Consumer, |
7064 | CodeCompleter->includeGlobals(), |
7065 | CodeCompleter->loadExternal()); |
7066 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
7067 | Context: Results.getCompletionContext(), Results: Results.data(), |
7068 | NumResults: Results.size()); |
7069 | } |
7070 | |
7071 | void SemaCodeCompletion::CodeCompleteOperatorName(Scope *S) { |
7072 | if (!CodeCompleter) |
7073 | return; |
7074 | |
7075 | typedef CodeCompletionResult Result; |
7076 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
7077 | CodeCompleter->getCodeCompletionTUInfo(), |
7078 | CodeCompletionContext::CCC_Type, |
7079 | &ResultBuilder::IsType); |
7080 | Results.EnterNewScope(); |
7081 | |
7082 | // Add the names of overloadable operators. Note that OO_Conditional is not |
7083 | // actually overloadable. |
7084 | #define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \ |
7085 | if (OO_##Name != OO_Conditional) \ |
7086 | Results.AddResult(Result(Spelling)); |
7087 | #include "clang/Basic/OperatorKinds.def" |
7088 | |
7089 | // Add any type names visible from the current scope |
7090 | Results.allowNestedNameSpecifiers(); |
7091 | CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext); |
7092 | SemaRef.LookupVisibleDecls(S, Sema::LookupOrdinaryName, Consumer, |
7093 | CodeCompleter->includeGlobals(), |
7094 | CodeCompleter->loadExternal()); |
7095 | |
7096 | // Add any type specifiers |
7097 | AddTypeSpecifierResults(LangOpts: getLangOpts(), Results); |
7098 | Results.ExitScope(); |
7099 | |
7100 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
7101 | Context: Results.getCompletionContext(), Results: Results.data(), |
7102 | NumResults: Results.size()); |
7103 | } |
7104 | |
7105 | void SemaCodeCompletion::CodeCompleteConstructorInitializer( |
7106 | Decl *ConstructorD, ArrayRef<CXXCtorInitializer *> Initializers) { |
7107 | if (!ConstructorD) |
7108 | return; |
7109 | |
7110 | SemaRef.AdjustDeclIfTemplate(Decl&: ConstructorD); |
7111 | |
7112 | auto *Constructor = dyn_cast<CXXConstructorDecl>(Val: ConstructorD); |
7113 | if (!Constructor) |
7114 | return; |
7115 | |
7116 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
7117 | CodeCompleter->getCodeCompletionTUInfo(), |
7118 | CodeCompletionContext::CCC_Symbol); |
7119 | Results.EnterNewScope(); |
7120 | |
7121 | // Fill in any already-initialized fields or base classes. |
7122 | llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields; |
7123 | llvm::SmallPtrSet<CanQualType, 4> InitializedBases; |
7124 | for (unsigned I = 0, E = Initializers.size(); I != E; ++I) { |
7125 | if (Initializers[I]->isBaseInitializer()) |
7126 | InitializedBases.insert(Ptr: getASTContext().getCanonicalType( |
7127 | T: QualType(Initializers[I]->getBaseClass(), 0))); |
7128 | else |
7129 | InitializedFields.insert( |
7130 | Ptr: cast<FieldDecl>(Val: Initializers[I]->getAnyMember())); |
7131 | } |
7132 | |
7133 | // Add completions for base classes. |
7134 | PrintingPolicy Policy = getCompletionPrintingPolicy(S&: SemaRef); |
7135 | bool SawLastInitializer = Initializers.empty(); |
7136 | CXXRecordDecl *ClassDecl = Constructor->getParent(); |
7137 | |
7138 | auto GenerateCCS = [&](const NamedDecl *ND, const char *Name) { |
7139 | CodeCompletionBuilder Builder(Results.getAllocator(), |
7140 | Results.getCodeCompletionTUInfo()); |
7141 | Builder.AddTypedTextChunk(Text: Name); |
7142 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
7143 | if (const auto *Function = dyn_cast<FunctionDecl>(Val: ND)) |
7144 | AddFunctionParameterChunks(PP&: SemaRef.PP, Policy, Function, Result&: Builder); |
7145 | else if (const auto *FunTemplDecl = dyn_cast<FunctionTemplateDecl>(Val: ND)) |
7146 | AddFunctionParameterChunks(PP&: SemaRef.PP, Policy, |
7147 | Function: FunTemplDecl->getTemplatedDecl(), Result&: Builder); |
7148 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
7149 | return Builder.TakeString(); |
7150 | }; |
7151 | auto AddDefaultCtorInit = [&](const char *Name, const char *Type, |
7152 | const NamedDecl *ND) { |
7153 | CodeCompletionBuilder Builder(Results.getAllocator(), |
7154 | Results.getCodeCompletionTUInfo()); |
7155 | Builder.AddTypedTextChunk(Text: Name); |
7156 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
7157 | Builder.AddPlaceholderChunk(Placeholder: Type); |
7158 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
7159 | if (ND) { |
7160 | auto CCR = CodeCompletionResult( |
7161 | Builder.TakeString(), ND, |
7162 | SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration); |
7163 | if (isa<FieldDecl>(Val: ND)) |
7164 | CCR.CursorKind = CXCursor_MemberRef; |
7165 | return Results.AddResult(R: CCR); |
7166 | } |
7167 | return Results.AddResult(R: CodeCompletionResult( |
7168 | Builder.TakeString(), |
7169 | SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration)); |
7170 | }; |
7171 | auto AddCtorsWithName = [&](const CXXRecordDecl *RD, unsigned int Priority, |
7172 | const char *Name, const FieldDecl *FD) { |
7173 | if (!RD) |
7174 | return AddDefaultCtorInit(Name, |
7175 | FD ? Results.getAllocator().CopyString( |
7176 | FD->getType().getAsString(Policy)) |
7177 | : Name, |
7178 | FD); |
7179 | auto Ctors = getConstructors(Context&: getASTContext(), Record: RD); |
7180 | if (Ctors.begin() == Ctors.end()) |
7181 | return AddDefaultCtorInit(Name, Name, RD); |
7182 | for (const NamedDecl *Ctor : Ctors) { |
7183 | auto CCR = CodeCompletionResult(GenerateCCS(Ctor, Name), RD, Priority); |
7184 | CCR.CursorKind = getCursorKindForDecl(Ctor); |
7185 | Results.AddResult(CCR); |
7186 | } |
7187 | }; |
7188 | auto AddBase = [&](const CXXBaseSpecifier &Base) { |
7189 | const char *BaseName = |
7190 | Results.getAllocator().CopyString(String: Base.getType().getAsString(Policy)); |
7191 | const auto *RD = Base.getType()->getAsCXXRecordDecl(); |
7192 | AddCtorsWithName( |
7193 | RD, SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration, |
7194 | BaseName, nullptr); |
7195 | }; |
7196 | auto AddField = [&](const FieldDecl *FD) { |
7197 | const char *FieldName = |
7198 | Results.getAllocator().CopyString(String: FD->getIdentifier()->getName()); |
7199 | const CXXRecordDecl *RD = FD->getType()->getAsCXXRecordDecl(); |
7200 | AddCtorsWithName( |
7201 | RD, SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration, |
7202 | FieldName, FD); |
7203 | }; |
7204 | |
7205 | for (const auto &Base : ClassDecl->bases()) { |
7206 | if (!InitializedBases |
7207 | .insert(getASTContext().getCanonicalType(Base.getType())) |
7208 | .second) { |
7209 | SawLastInitializer = |
7210 | !Initializers.empty() && Initializers.back()->isBaseInitializer() && |
7211 | getASTContext().hasSameUnqualifiedType( |
7212 | Base.getType(), QualType(Initializers.back()->getBaseClass(), 0)); |
7213 | continue; |
7214 | } |
7215 | |
7216 | AddBase(Base); |
7217 | SawLastInitializer = false; |
7218 | } |
7219 | |
7220 | // Add completions for virtual base classes. |
7221 | for (const auto &Base : ClassDecl->vbases()) { |
7222 | if (!InitializedBases |
7223 | .insert(getASTContext().getCanonicalType(Base.getType())) |
7224 | .second) { |
7225 | SawLastInitializer = |
7226 | !Initializers.empty() && Initializers.back()->isBaseInitializer() && |
7227 | getASTContext().hasSameUnqualifiedType( |
7228 | Base.getType(), QualType(Initializers.back()->getBaseClass(), 0)); |
7229 | continue; |
7230 | } |
7231 | |
7232 | AddBase(Base); |
7233 | SawLastInitializer = false; |
7234 | } |
7235 | |
7236 | // Add completions for members. |
7237 | for (auto *Field : ClassDecl->fields()) { |
7238 | if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl())) |
7239 | .second) { |
7240 | SawLastInitializer = !Initializers.empty() && |
7241 | Initializers.back()->isAnyMemberInitializer() && |
7242 | Initializers.back()->getAnyMember() == Field; |
7243 | continue; |
7244 | } |
7245 | |
7246 | if (!Field->getDeclName()) |
7247 | continue; |
7248 | |
7249 | AddField(Field); |
7250 | SawLastInitializer = false; |
7251 | } |
7252 | Results.ExitScope(); |
7253 | |
7254 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
7255 | Context: Results.getCompletionContext(), Results: Results.data(), |
7256 | NumResults: Results.size()); |
7257 | } |
7258 | |
7259 | /// Determine whether this scope denotes a namespace. |
7260 | static bool isNamespaceScope(Scope *S) { |
7261 | DeclContext *DC = S->getEntity(); |
7262 | if (!DC) |
7263 | return false; |
7264 | |
7265 | return DC->isFileContext(); |
7266 | } |
7267 | |
7268 | void SemaCodeCompletion::CodeCompleteLambdaIntroducer(Scope *S, |
7269 | LambdaIntroducer &Intro, |
7270 | bool AfterAmpersand) { |
7271 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
7272 | CodeCompleter->getCodeCompletionTUInfo(), |
7273 | CodeCompletionContext::CCC_Other); |
7274 | Results.EnterNewScope(); |
7275 | |
7276 | // Note what has already been captured. |
7277 | llvm::SmallPtrSet<IdentifierInfo *, 4> Known; |
7278 | bool IncludedThis = false; |
7279 | for (const auto &C : Intro.Captures) { |
7280 | if (C.Kind == LCK_This) { |
7281 | IncludedThis = true; |
7282 | continue; |
7283 | } |
7284 | |
7285 | Known.insert(Ptr: C.Id); |
7286 | } |
7287 | |
7288 | // Look for other capturable variables. |
7289 | for (; S && !isNamespaceScope(S); S = S->getParent()) { |
7290 | for (const auto *D : S->decls()) { |
7291 | const auto *Var = dyn_cast<VarDecl>(Val: D); |
7292 | if (!Var || !Var->hasLocalStorage() || Var->hasAttr<BlocksAttr>()) |
7293 | continue; |
7294 | |
7295 | if (Known.insert(Var->getIdentifier()).second) |
7296 | Results.AddResult(R: CodeCompletionResult(Var, CCP_LocalDeclaration), |
7297 | CurContext: SemaRef.CurContext, Hiding: nullptr, InBaseClass: false); |
7298 | } |
7299 | } |
7300 | |
7301 | // Add 'this', if it would be valid. |
7302 | if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy) |
7303 | addThisCompletion(S&: SemaRef, Results); |
7304 | |
7305 | Results.ExitScope(); |
7306 | |
7307 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
7308 | Context: Results.getCompletionContext(), Results: Results.data(), |
7309 | NumResults: Results.size()); |
7310 | } |
7311 | |
7312 | void SemaCodeCompletion::CodeCompleteAfterFunctionEquals(Declarator &D) { |
7313 | if (!getLangOpts().CPlusPlus11) |
7314 | return; |
7315 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
7316 | CodeCompleter->getCodeCompletionTUInfo(), |
7317 | CodeCompletionContext::CCC_Other); |
7318 | auto ShouldAddDefault = [&D, this]() { |
7319 | if (!D.isFunctionDeclarator()) |
7320 | return false; |
7321 | auto &Id = D.getName(); |
7322 | if (Id.getKind() == UnqualifiedIdKind::IK_DestructorName) |
7323 | return true; |
7324 | // FIXME(liuhui): Ideally, we should check the constructor parameter list to |
7325 | // verify that it is the default, copy or move constructor? |
7326 | if (Id.getKind() == UnqualifiedIdKind::IK_ConstructorName && |
7327 | D.getFunctionTypeInfo().NumParams <= 1) |
7328 | return true; |
7329 | if (Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId) { |
7330 | auto Op = Id.OperatorFunctionId.Operator; |
7331 | // FIXME(liuhui): Ideally, we should check the function parameter list to |
7332 | // verify that it is the copy or move assignment? |
7333 | if (Op == OverloadedOperatorKind::OO_Equal) |
7334 | return true; |
7335 | if (getLangOpts().CPlusPlus20 && |
7336 | (Op == OverloadedOperatorKind::OO_EqualEqual || |
7337 | Op == OverloadedOperatorKind::OO_ExclaimEqual || |
7338 | Op == OverloadedOperatorKind::OO_Less || |
7339 | Op == OverloadedOperatorKind::OO_LessEqual || |
7340 | Op == OverloadedOperatorKind::OO_Greater || |
7341 | Op == OverloadedOperatorKind::OO_GreaterEqual || |
7342 | Op == OverloadedOperatorKind::OO_Spaceship)) |
7343 | return true; |
7344 | } |
7345 | return false; |
7346 | }; |
7347 | |
7348 | Results.EnterNewScope(); |
7349 | if (ShouldAddDefault()) |
7350 | Results.AddResult(R: "default"); |
7351 | // FIXME(liuhui): Ideally, we should only provide `delete` completion for the |
7352 | // first function declaration. |
7353 | Results.AddResult(R: "delete"); |
7354 | Results.ExitScope(); |
7355 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
7356 | Context: Results.getCompletionContext(), Results: Results.data(), |
7357 | NumResults: Results.size()); |
7358 | } |
7359 | |
7360 | /// Macro that optionally prepends an "@" to the string literal passed in via |
7361 | /// Keyword, depending on whether NeedAt is true or false. |
7362 | #define OBJC_AT_KEYWORD_NAME(NeedAt, Keyword) ((NeedAt) ? "@" Keyword : Keyword) |
7363 | |
7364 | static void AddObjCImplementationResults(const LangOptions &LangOpts, |
7365 | ResultBuilder &Results, bool NeedAt) { |
7366 | typedef CodeCompletionResult Result; |
7367 | // Since we have an implementation, we can end it. |
7368 | Results.AddResult(R: Result(OBJC_AT_KEYWORD_NAME(NeedAt, "end"))); |
7369 | |
7370 | CodeCompletionBuilder Builder(Results.getAllocator(), |
7371 | Results.getCodeCompletionTUInfo()); |
7372 | if (LangOpts.ObjC) { |
7373 | // @dynamic |
7374 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "dynamic")); |
7375 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
7376 | Builder.AddPlaceholderChunk(Placeholder: "property"); |
7377 | Results.AddResult(R: Result(Builder.TakeString())); |
7378 | |
7379 | // @synthesize |
7380 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "synthesize")); |
7381 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
7382 | Builder.AddPlaceholderChunk(Placeholder: "property"); |
7383 | Results.AddResult(R: Result(Builder.TakeString())); |
7384 | } |
7385 | } |
7386 | |
7387 | static void AddObjCInterfaceResults(const LangOptions &LangOpts, |
7388 | ResultBuilder &Results, bool NeedAt) { |
7389 | typedef CodeCompletionResult Result; |
7390 | |
7391 | // Since we have an interface or protocol, we can end it. |
7392 | Results.AddResult(R: Result(OBJC_AT_KEYWORD_NAME(NeedAt, "end"))); |
7393 | |
7394 | if (LangOpts.ObjC) { |
7395 | // @property |
7396 | Results.AddResult(R: Result(OBJC_AT_KEYWORD_NAME(NeedAt, "property"))); |
7397 | |
7398 | // @required |
7399 | Results.AddResult(R: Result(OBJC_AT_KEYWORD_NAME(NeedAt, "required"))); |
7400 | |
7401 | // @optional |
7402 | Results.AddResult(R: Result(OBJC_AT_KEYWORD_NAME(NeedAt, "optional"))); |
7403 | } |
7404 | } |
7405 | |
7406 | static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) { |
7407 | typedef CodeCompletionResult Result; |
7408 | CodeCompletionBuilder Builder(Results.getAllocator(), |
7409 | Results.getCodeCompletionTUInfo()); |
7410 | |
7411 | // @class name ; |
7412 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "class")); |
7413 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
7414 | Builder.AddPlaceholderChunk(Placeholder: "name"); |
7415 | Results.AddResult(R: Result(Builder.TakeString())); |
7416 | |
7417 | if (Results.includeCodePatterns()) { |
7418 | // @interface name |
7419 | // FIXME: Could introduce the whole pattern, including superclasses and |
7420 | // such. |
7421 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "interface")); |
7422 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
7423 | Builder.AddPlaceholderChunk(Placeholder: "class"); |
7424 | Results.AddResult(R: Result(Builder.TakeString())); |
7425 | |
7426 | // @protocol name |
7427 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "protocol")); |
7428 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
7429 | Builder.AddPlaceholderChunk(Placeholder: "protocol"); |
7430 | Results.AddResult(R: Result(Builder.TakeString())); |
7431 | |
7432 | // @implementation name |
7433 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "implementation")); |
7434 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
7435 | Builder.AddPlaceholderChunk(Placeholder: "class"); |
7436 | Results.AddResult(R: Result(Builder.TakeString())); |
7437 | } |
7438 | |
7439 | // @compatibility_alias name |
7440 | Builder.AddTypedTextChunk( |
7441 | OBJC_AT_KEYWORD_NAME(NeedAt, "compatibility_alias")); |
7442 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
7443 | Builder.AddPlaceholderChunk(Placeholder: "alias"); |
7444 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
7445 | Builder.AddPlaceholderChunk(Placeholder: "class"); |
7446 | Results.AddResult(R: Result(Builder.TakeString())); |
7447 | |
7448 | if (Results.getSema().getLangOpts().Modules) { |
7449 | // @import name |
7450 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import")); |
7451 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
7452 | Builder.AddPlaceholderChunk(Placeholder: "module"); |
7453 | Results.AddResult(R: Result(Builder.TakeString())); |
7454 | } |
7455 | } |
7456 | |
7457 | void SemaCodeCompletion::CodeCompleteObjCAtDirective(Scope *S) { |
7458 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
7459 | CodeCompleter->getCodeCompletionTUInfo(), |
7460 | CodeCompletionContext::CCC_Other); |
7461 | Results.EnterNewScope(); |
7462 | if (isa<ObjCImplDecl>(Val: SemaRef.CurContext)) |
7463 | AddObjCImplementationResults(LangOpts: getLangOpts(), Results, NeedAt: false); |
7464 | else if (SemaRef.CurContext->isObjCContainer()) |
7465 | AddObjCInterfaceResults(LangOpts: getLangOpts(), Results, NeedAt: false); |
7466 | else |
7467 | AddObjCTopLevelResults(Results, NeedAt: false); |
7468 | Results.ExitScope(); |
7469 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
7470 | Context: Results.getCompletionContext(), Results: Results.data(), |
7471 | NumResults: Results.size()); |
7472 | } |
7473 | |
7474 | static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) { |
7475 | typedef CodeCompletionResult Result; |
7476 | CodeCompletionBuilder Builder(Results.getAllocator(), |
7477 | Results.getCodeCompletionTUInfo()); |
7478 | |
7479 | // @encode ( type-name ) |
7480 | const char *EncodeType = "char[]"; |
7481 | if (Results.getSema().getLangOpts().CPlusPlus || |
7482 | Results.getSema().getLangOpts().ConstStrings) |
7483 | EncodeType = "const char[]"; |
7484 | Builder.AddResultTypeChunk(ResultType: EncodeType); |
7485 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "encode")); |
7486 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
7487 | Builder.AddPlaceholderChunk(Placeholder: "type-name"); |
7488 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
7489 | Results.AddResult(R: Result(Builder.TakeString())); |
7490 | |
7491 | // @protocol ( protocol-name ) |
7492 | Builder.AddResultTypeChunk(ResultType: "Protocol *"); |
7493 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "protocol")); |
7494 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
7495 | Builder.AddPlaceholderChunk(Placeholder: "protocol-name"); |
7496 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
7497 | Results.AddResult(R: Result(Builder.TakeString())); |
7498 | |
7499 | // @selector ( selector ) |
7500 | Builder.AddResultTypeChunk(ResultType: "SEL"); |
7501 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "selector")); |
7502 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
7503 | Builder.AddPlaceholderChunk(Placeholder: "selector"); |
7504 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
7505 | Results.AddResult(R: Result(Builder.TakeString())); |
7506 | |
7507 | // @"string" |
7508 | Builder.AddResultTypeChunk(ResultType: "NSString *"); |
7509 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "\"")); |
7510 | Builder.AddPlaceholderChunk(Placeholder: "string"); |
7511 | Builder.AddTextChunk(Text: "\""); |
7512 | Results.AddResult(R: Result(Builder.TakeString())); |
7513 | |
7514 | // @[objects, ...] |
7515 | Builder.AddResultTypeChunk(ResultType: "NSArray *"); |
7516 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "[")); |
7517 | Builder.AddPlaceholderChunk(Placeholder: "objects, ..."); |
7518 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBracket); |
7519 | Results.AddResult(R: Result(Builder.TakeString())); |
7520 | |
7521 | // @{key : object, ...} |
7522 | Builder.AddResultTypeChunk(ResultType: "NSDictionary *"); |
7523 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "{")); |
7524 | Builder.AddPlaceholderChunk(Placeholder: "key"); |
7525 | Builder.AddChunk(CK: CodeCompletionString::CK_Colon); |
7526 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
7527 | Builder.AddPlaceholderChunk(Placeholder: "object, ..."); |
7528 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
7529 | Results.AddResult(R: Result(Builder.TakeString())); |
7530 | |
7531 | // @(expression) |
7532 | Builder.AddResultTypeChunk(ResultType: "id"); |
7533 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "(")); |
7534 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
7535 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
7536 | Results.AddResult(R: Result(Builder.TakeString())); |
7537 | } |
7538 | |
7539 | static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) { |
7540 | typedef CodeCompletionResult Result; |
7541 | CodeCompletionBuilder Builder(Results.getAllocator(), |
7542 | Results.getCodeCompletionTUInfo()); |
7543 | |
7544 | if (Results.includeCodePatterns()) { |
7545 | // @try { statements } @catch ( declaration ) { statements } @finally |
7546 | // { statements } |
7547 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "try")); |
7548 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
7549 | Builder.AddPlaceholderChunk(Placeholder: "statements"); |
7550 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
7551 | Builder.AddTextChunk(Text: "@catch"); |
7552 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
7553 | Builder.AddPlaceholderChunk(Placeholder: "parameter"); |
7554 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
7555 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
7556 | Builder.AddPlaceholderChunk(Placeholder: "statements"); |
7557 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
7558 | Builder.AddTextChunk(Text: "@finally"); |
7559 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
7560 | Builder.AddPlaceholderChunk(Placeholder: "statements"); |
7561 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
7562 | Results.AddResult(R: Result(Builder.TakeString())); |
7563 | } |
7564 | |
7565 | // @throw |
7566 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "throw")); |
7567 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
7568 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
7569 | Results.AddResult(R: Result(Builder.TakeString())); |
7570 | |
7571 | if (Results.includeCodePatterns()) { |
7572 | // @synchronized ( expression ) { statements } |
7573 | Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "synchronized")); |
7574 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
7575 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
7576 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
7577 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
7578 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
7579 | Builder.AddPlaceholderChunk(Placeholder: "statements"); |
7580 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
7581 | Results.AddResult(R: Result(Builder.TakeString())); |
7582 | } |
7583 | } |
7584 | |
7585 | static void AddObjCVisibilityResults(const LangOptions &LangOpts, |
7586 | ResultBuilder &Results, bool NeedAt) { |
7587 | typedef CodeCompletionResult Result; |
7588 | Results.AddResult(R: Result(OBJC_AT_KEYWORD_NAME(NeedAt, "private"))); |
7589 | Results.AddResult(R: Result(OBJC_AT_KEYWORD_NAME(NeedAt, "protected"))); |
7590 | Results.AddResult(R: Result(OBJC_AT_KEYWORD_NAME(NeedAt, "public"))); |
7591 | if (LangOpts.ObjC) |
7592 | Results.AddResult(R: Result(OBJC_AT_KEYWORD_NAME(NeedAt, "package"))); |
7593 | } |
7594 | |
7595 | void SemaCodeCompletion::CodeCompleteObjCAtVisibility(Scope *S) { |
7596 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
7597 | CodeCompleter->getCodeCompletionTUInfo(), |
7598 | CodeCompletionContext::CCC_Other); |
7599 | Results.EnterNewScope(); |
7600 | AddObjCVisibilityResults(LangOpts: getLangOpts(), Results, NeedAt: false); |
7601 | Results.ExitScope(); |
7602 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
7603 | Context: Results.getCompletionContext(), Results: Results.data(), |
7604 | NumResults: Results.size()); |
7605 | } |
7606 | |
7607 | void SemaCodeCompletion::CodeCompleteObjCAtStatement(Scope *S) { |
7608 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
7609 | CodeCompleter->getCodeCompletionTUInfo(), |
7610 | CodeCompletionContext::CCC_Other); |
7611 | Results.EnterNewScope(); |
7612 | AddObjCStatementResults(Results, NeedAt: false); |
7613 | AddObjCExpressionResults(Results, NeedAt: false); |
7614 | Results.ExitScope(); |
7615 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
7616 | Context: Results.getCompletionContext(), Results: Results.data(), |
7617 | NumResults: Results.size()); |
7618 | } |
7619 | |
7620 | void SemaCodeCompletion::CodeCompleteObjCAtExpression(Scope *S) { |
7621 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
7622 | CodeCompleter->getCodeCompletionTUInfo(), |
7623 | CodeCompletionContext::CCC_Other); |
7624 | Results.EnterNewScope(); |
7625 | AddObjCExpressionResults(Results, NeedAt: false); |
7626 | Results.ExitScope(); |
7627 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
7628 | Context: Results.getCompletionContext(), Results: Results.data(), |
7629 | NumResults: Results.size()); |
7630 | } |
7631 | |
7632 | /// Determine whether the addition of the given flag to an Objective-C |
7633 | /// property's attributes will cause a conflict. |
7634 | static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) { |
7635 | // Check if we've already added this flag. |
7636 | if (Attributes & NewFlag) |
7637 | return true; |
7638 | |
7639 | Attributes |= NewFlag; |
7640 | |
7641 | // Check for collisions with "readonly". |
7642 | if ((Attributes & ObjCPropertyAttribute::kind_readonly) && |
7643 | (Attributes & ObjCPropertyAttribute::kind_readwrite)) |
7644 | return true; |
7645 | |
7646 | // Check for more than one of { assign, copy, retain, strong, weak }. |
7647 | unsigned AssignCopyRetMask = |
7648 | Attributes & |
7649 | (ObjCPropertyAttribute::kind_assign | |
7650 | ObjCPropertyAttribute::kind_unsafe_unretained | |
7651 | ObjCPropertyAttribute::kind_copy | ObjCPropertyAttribute::kind_retain | |
7652 | ObjCPropertyAttribute::kind_strong | ObjCPropertyAttribute::kind_weak); |
7653 | if (AssignCopyRetMask && |
7654 | AssignCopyRetMask != ObjCPropertyAttribute::kind_assign && |
7655 | AssignCopyRetMask != ObjCPropertyAttribute::kind_unsafe_unretained && |
7656 | AssignCopyRetMask != ObjCPropertyAttribute::kind_copy && |
7657 | AssignCopyRetMask != ObjCPropertyAttribute::kind_retain && |
7658 | AssignCopyRetMask != ObjCPropertyAttribute::kind_strong && |
7659 | AssignCopyRetMask != ObjCPropertyAttribute::kind_weak) |
7660 | return true; |
7661 | |
7662 | return false; |
7663 | } |
7664 | |
7665 | void SemaCodeCompletion::CodeCompleteObjCPropertyFlags(Scope *S, |
7666 | ObjCDeclSpec &ODS) { |
7667 | if (!CodeCompleter) |
7668 | return; |
7669 | |
7670 | unsigned Attributes = ODS.getPropertyAttributes(); |
7671 | |
7672 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
7673 | CodeCompleter->getCodeCompletionTUInfo(), |
7674 | CodeCompletionContext::CCC_Other); |
7675 | Results.EnterNewScope(); |
7676 | if (!ObjCPropertyFlagConflicts(Attributes, |
7677 | NewFlag: ObjCPropertyAttribute::kind_readonly)) |
7678 | Results.AddResult(R: CodeCompletionResult("readonly")); |
7679 | if (!ObjCPropertyFlagConflicts(Attributes, |
7680 | NewFlag: ObjCPropertyAttribute::kind_assign)) |
7681 | Results.AddResult(R: CodeCompletionResult("assign")); |
7682 | if (!ObjCPropertyFlagConflicts(Attributes, |
7683 | NewFlag: ObjCPropertyAttribute::kind_unsafe_unretained)) |
7684 | Results.AddResult(R: CodeCompletionResult("unsafe_unretained")); |
7685 | if (!ObjCPropertyFlagConflicts(Attributes, |
7686 | NewFlag: ObjCPropertyAttribute::kind_readwrite)) |
7687 | Results.AddResult(R: CodeCompletionResult("readwrite")); |
7688 | if (!ObjCPropertyFlagConflicts(Attributes, |
7689 | NewFlag: ObjCPropertyAttribute::kind_retain)) |
7690 | Results.AddResult(R: CodeCompletionResult("retain")); |
7691 | if (!ObjCPropertyFlagConflicts(Attributes, |
7692 | NewFlag: ObjCPropertyAttribute::kind_strong)) |
7693 | Results.AddResult(R: CodeCompletionResult("strong")); |
7694 | if (!ObjCPropertyFlagConflicts(Attributes, NewFlag: ObjCPropertyAttribute::kind_copy)) |
7695 | Results.AddResult(R: CodeCompletionResult("copy")); |
7696 | if (!ObjCPropertyFlagConflicts(Attributes, |
7697 | NewFlag: ObjCPropertyAttribute::kind_nonatomic)) |
7698 | Results.AddResult(R: CodeCompletionResult("nonatomic")); |
7699 | if (!ObjCPropertyFlagConflicts(Attributes, |
7700 | NewFlag: ObjCPropertyAttribute::kind_atomic)) |
7701 | Results.AddResult(R: CodeCompletionResult("atomic")); |
7702 | |
7703 | // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC. |
7704 | if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC) |
7705 | if (!ObjCPropertyFlagConflicts(Attributes, |
7706 | NewFlag: ObjCPropertyAttribute::kind_weak)) |
7707 | Results.AddResult(R: CodeCompletionResult("weak")); |
7708 | |
7709 | if (!ObjCPropertyFlagConflicts(Attributes, |
7710 | NewFlag: ObjCPropertyAttribute::kind_setter)) { |
7711 | CodeCompletionBuilder Setter(Results.getAllocator(), |
7712 | Results.getCodeCompletionTUInfo()); |
7713 | Setter.AddTypedTextChunk(Text: "setter"); |
7714 | Setter.AddTextChunk(Text: "="); |
7715 | Setter.AddPlaceholderChunk(Placeholder: "method"); |
7716 | Results.AddResult(R: CodeCompletionResult(Setter.TakeString())); |
7717 | } |
7718 | if (!ObjCPropertyFlagConflicts(Attributes, |
7719 | NewFlag: ObjCPropertyAttribute::kind_getter)) { |
7720 | CodeCompletionBuilder Getter(Results.getAllocator(), |
7721 | Results.getCodeCompletionTUInfo()); |
7722 | Getter.AddTypedTextChunk(Text: "getter"); |
7723 | Getter.AddTextChunk(Text: "="); |
7724 | Getter.AddPlaceholderChunk(Placeholder: "method"); |
7725 | Results.AddResult(R: CodeCompletionResult(Getter.TakeString())); |
7726 | } |
7727 | if (!ObjCPropertyFlagConflicts(Attributes, |
7728 | NewFlag: ObjCPropertyAttribute::kind_nullability)) { |
7729 | Results.AddResult(R: CodeCompletionResult("nonnull")); |
7730 | Results.AddResult(R: CodeCompletionResult("nullable")); |
7731 | Results.AddResult(R: CodeCompletionResult("null_unspecified")); |
7732 | Results.AddResult(R: CodeCompletionResult("null_resettable")); |
7733 | } |
7734 | Results.ExitScope(); |
7735 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
7736 | Context: Results.getCompletionContext(), Results: Results.data(), |
7737 | NumResults: Results.size()); |
7738 | } |
7739 | |
7740 | /// Describes the kind of Objective-C method that we want to find |
7741 | /// via code completion. |
7742 | enum ObjCMethodKind { |
7743 | MK_Any, ///< Any kind of method, provided it means other specified criteria. |
7744 | MK_ZeroArgSelector, ///< Zero-argument (unary) selector. |
7745 | MK_OneArgSelector ///< One-argument selector. |
7746 | }; |
7747 | |
7748 | static bool isAcceptableObjCSelector(Selector Sel, ObjCMethodKind WantKind, |
7749 | ArrayRef<const IdentifierInfo *> SelIdents, |
7750 | bool AllowSameLength = true) { |
7751 | unsigned NumSelIdents = SelIdents.size(); |
7752 | if (NumSelIdents > Sel.getNumArgs()) |
7753 | return false; |
7754 | |
7755 | switch (WantKind) { |
7756 | case MK_Any: |
7757 | break; |
7758 | case MK_ZeroArgSelector: |
7759 | return Sel.isUnarySelector(); |
7760 | case MK_OneArgSelector: |
7761 | return Sel.getNumArgs() == 1; |
7762 | } |
7763 | |
7764 | if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs()) |
7765 | return false; |
7766 | |
7767 | for (unsigned I = 0; I != NumSelIdents; ++I) |
7768 | if (SelIdents[I] != Sel.getIdentifierInfoForSlot(argIndex: I)) |
7769 | return false; |
7770 | |
7771 | return true; |
7772 | } |
7773 | |
7774 | static bool isAcceptableObjCMethod(ObjCMethodDecl *Method, |
7775 | ObjCMethodKind WantKind, |
7776 | ArrayRef<const IdentifierInfo *> SelIdents, |
7777 | bool AllowSameLength = true) { |
7778 | return isAcceptableObjCSelector(Sel: Method->getSelector(), WantKind, SelIdents, |
7779 | AllowSameLength); |
7780 | } |
7781 | |
7782 | /// A set of selectors, which is used to avoid introducing multiple |
7783 | /// completions with the same selector into the result set. |
7784 | typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet; |
7785 | |
7786 | /// Add all of the Objective-C methods in the given Objective-C |
7787 | /// container to the set of results. |
7788 | /// |
7789 | /// The container will be a class, protocol, category, or implementation of |
7790 | /// any of the above. This mether will recurse to include methods from |
7791 | /// the superclasses of classes along with their categories, protocols, and |
7792 | /// implementations. |
7793 | /// |
7794 | /// \param Container the container in which we'll look to find methods. |
7795 | /// |
7796 | /// \param WantInstanceMethods Whether to add instance methods (only); if |
7797 | /// false, this routine will add factory methods (only). |
7798 | /// |
7799 | /// \param CurContext the context in which we're performing the lookup that |
7800 | /// finds methods. |
7801 | /// |
7802 | /// \param AllowSameLength Whether we allow a method to be added to the list |
7803 | /// when it has the same number of parameters as we have selector identifiers. |
7804 | /// |
7805 | /// \param Results the structure into which we'll add results. |
7806 | static void AddObjCMethods(ObjCContainerDecl *Container, |
7807 | bool WantInstanceMethods, ObjCMethodKind WantKind, |
7808 | ArrayRef<const IdentifierInfo *> SelIdents, |
7809 | DeclContext *CurContext, |
7810 | VisitedSelectorSet &Selectors, bool AllowSameLength, |
7811 | ResultBuilder &Results, bool InOriginalClass = true, |
7812 | bool IsRootClass = false) { |
7813 | typedef CodeCompletionResult Result; |
7814 | Container = getContainerDef(Container); |
7815 | ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Val: Container); |
7816 | IsRootClass = IsRootClass || (IFace && !IFace->getSuperClass()); |
7817 | for (ObjCMethodDecl *M : Container->methods()) { |
7818 | // The instance methods on the root class can be messaged via the |
7819 | // metaclass. |
7820 | if (M->isInstanceMethod() == WantInstanceMethods || |
7821 | (IsRootClass && !WantInstanceMethods)) { |
7822 | // Check whether the selector identifiers we've been given are a |
7823 | // subset of the identifiers for this particular method. |
7824 | if (!isAcceptableObjCMethod(Method: M, WantKind, SelIdents, AllowSameLength)) |
7825 | continue; |
7826 | |
7827 | if (!Selectors.insert(Ptr: M->getSelector()).second) |
7828 | continue; |
7829 | |
7830 | Result R = Result(M, Results.getBasePriority(M), nullptr); |
7831 | R.StartParameter = SelIdents.size(); |
7832 | R.AllParametersAreInformative = (WantKind != MK_Any); |
7833 | if (!InOriginalClass) |
7834 | setInBaseClass(R); |
7835 | Results.MaybeAddResult(R, CurContext); |
7836 | } |
7837 | } |
7838 | |
7839 | // Visit the protocols of protocols. |
7840 | if (const auto *Protocol = dyn_cast<ObjCProtocolDecl>(Val: Container)) { |
7841 | if (Protocol->hasDefinition()) { |
7842 | const ObjCList<ObjCProtocolDecl> &Protocols = |
7843 | Protocol->getReferencedProtocols(); |
7844 | for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), |
7845 | E = Protocols.end(); |
7846 | I != E; ++I) |
7847 | AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext, |
7848 | Selectors, AllowSameLength, Results, false, IsRootClass); |
7849 | } |
7850 | } |
7851 | |
7852 | if (!IFace || !IFace->hasDefinition()) |
7853 | return; |
7854 | |
7855 | // Add methods in protocols. |
7856 | for (ObjCProtocolDecl *I : IFace->protocols()) |
7857 | AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents, CurContext, |
7858 | Selectors, AllowSameLength, Results, false, IsRootClass); |
7859 | |
7860 | // Add methods in categories. |
7861 | for (ObjCCategoryDecl *CatDecl : IFace->known_categories()) { |
7862 | AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents, |
7863 | CurContext, Selectors, AllowSameLength, Results, |
7864 | InOriginalClass, IsRootClass); |
7865 | |
7866 | // Add a categories protocol methods. |
7867 | const ObjCList<ObjCProtocolDecl> &Protocols = |
7868 | CatDecl->getReferencedProtocols(); |
7869 | for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), |
7870 | E = Protocols.end(); |
7871 | I != E; ++I) |
7872 | AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext, |
7873 | Selectors, AllowSameLength, Results, false, IsRootClass); |
7874 | |
7875 | // Add methods in category implementations. |
7876 | if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation()) |
7877 | AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext, |
7878 | Selectors, AllowSameLength, Results, InOriginalClass, |
7879 | IsRootClass); |
7880 | } |
7881 | |
7882 | // Add methods in superclass. |
7883 | // Avoid passing in IsRootClass since root classes won't have super classes. |
7884 | if (IFace->getSuperClass()) |
7885 | AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind, |
7886 | SelIdents, CurContext, Selectors, AllowSameLength, Results, |
7887 | /*IsRootClass=*/false); |
7888 | |
7889 | // Add methods in our implementation, if any. |
7890 | if (ObjCImplementationDecl *Impl = IFace->getImplementation()) |
7891 | AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext, |
7892 | Selectors, AllowSameLength, Results, InOriginalClass, |
7893 | IsRootClass); |
7894 | } |
7895 | |
7896 | void SemaCodeCompletion::CodeCompleteObjCPropertyGetter(Scope *S) { |
7897 | // Try to find the interface where getters might live. |
7898 | ObjCInterfaceDecl *Class = |
7899 | dyn_cast_or_null<ObjCInterfaceDecl>(Val: SemaRef.CurContext); |
7900 | if (!Class) { |
7901 | if (ObjCCategoryDecl *Category = |
7902 | dyn_cast_or_null<ObjCCategoryDecl>(Val: SemaRef.CurContext)) |
7903 | Class = Category->getClassInterface(); |
7904 | |
7905 | if (!Class) |
7906 | return; |
7907 | } |
7908 | |
7909 | // Find all of the potential getters. |
7910 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
7911 | CodeCompleter->getCodeCompletionTUInfo(), |
7912 | CodeCompletionContext::CCC_Other); |
7913 | Results.EnterNewScope(); |
7914 | |
7915 | VisitedSelectorSet Selectors; |
7916 | AddObjCMethods(Class, true, MK_ZeroArgSelector, {}, SemaRef.CurContext, |
7917 | Selectors, |
7918 | /*AllowSameLength=*/true, Results); |
7919 | Results.ExitScope(); |
7920 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
7921 | Context: Results.getCompletionContext(), Results: Results.data(), |
7922 | NumResults: Results.size()); |
7923 | } |
7924 | |
7925 | void SemaCodeCompletion::CodeCompleteObjCPropertySetter(Scope *S) { |
7926 | // Try to find the interface where setters might live. |
7927 | ObjCInterfaceDecl *Class = |
7928 | dyn_cast_or_null<ObjCInterfaceDecl>(Val: SemaRef.CurContext); |
7929 | if (!Class) { |
7930 | if (ObjCCategoryDecl *Category = |
7931 | dyn_cast_or_null<ObjCCategoryDecl>(Val: SemaRef.CurContext)) |
7932 | Class = Category->getClassInterface(); |
7933 | |
7934 | if (!Class) |
7935 | return; |
7936 | } |
7937 | |
7938 | // Find all of the potential getters. |
7939 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
7940 | CodeCompleter->getCodeCompletionTUInfo(), |
7941 | CodeCompletionContext::CCC_Other); |
7942 | Results.EnterNewScope(); |
7943 | |
7944 | VisitedSelectorSet Selectors; |
7945 | AddObjCMethods(Class, true, MK_OneArgSelector, {}, SemaRef.CurContext, |
7946 | Selectors, |
7947 | /*AllowSameLength=*/true, Results); |
7948 | |
7949 | Results.ExitScope(); |
7950 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
7951 | Context: Results.getCompletionContext(), Results: Results.data(), |
7952 | NumResults: Results.size()); |
7953 | } |
7954 | |
7955 | void SemaCodeCompletion::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS, |
7956 | bool IsParameter) { |
7957 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
7958 | CodeCompleter->getCodeCompletionTUInfo(), |
7959 | CodeCompletionContext::CCC_Type); |
7960 | Results.EnterNewScope(); |
7961 | |
7962 | // Add context-sensitive, Objective-C parameter-passing keywords. |
7963 | bool AddedInOut = false; |
7964 | if ((DS.getObjCDeclQualifier() & |
7965 | (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) { |
7966 | Results.AddResult(R: "in"); |
7967 | Results.AddResult(R: "inout"); |
7968 | AddedInOut = true; |
7969 | } |
7970 | if ((DS.getObjCDeclQualifier() & |
7971 | (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) { |
7972 | Results.AddResult(R: "out"); |
7973 | if (!AddedInOut) |
7974 | Results.AddResult(R: "inout"); |
7975 | } |
7976 | if ((DS.getObjCDeclQualifier() & |
7977 | (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref | |
7978 | ObjCDeclSpec::DQ_Oneway)) == 0) { |
7979 | Results.AddResult(R: "bycopy"); |
7980 | Results.AddResult(R: "byref"); |
7981 | Results.AddResult(R: "oneway"); |
7982 | } |
7983 | if ((DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) == 0) { |
7984 | Results.AddResult(R: "nonnull"); |
7985 | Results.AddResult(R: "nullable"); |
7986 | Results.AddResult(R: "null_unspecified"); |
7987 | } |
7988 | |
7989 | // If we're completing the return type of an Objective-C method and the |
7990 | // identifier IBAction refers to a macro, provide a completion item for |
7991 | // an action, e.g., |
7992 | // IBAction)<#selector#>:(id)sender |
7993 | if (DS.getObjCDeclQualifier() == 0 && !IsParameter && |
7994 | SemaRef.PP.isMacroDefined(Id: "IBAction")) { |
7995 | CodeCompletionBuilder Builder(Results.getAllocator(), |
7996 | Results.getCodeCompletionTUInfo(), |
7997 | CCP_CodePattern, CXAvailability_Available); |
7998 | Builder.AddTypedTextChunk(Text: "IBAction"); |
7999 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
8000 | Builder.AddPlaceholderChunk(Placeholder: "selector"); |
8001 | Builder.AddChunk(CK: CodeCompletionString::CK_Colon); |
8002 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
8003 | Builder.AddTextChunk(Text: "id"); |
8004 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
8005 | Builder.AddTextChunk(Text: "sender"); |
8006 | Results.AddResult(R: CodeCompletionResult(Builder.TakeString())); |
8007 | } |
8008 | |
8009 | // If we're completing the return type, provide 'instancetype'. |
8010 | if (!IsParameter) { |
8011 | Results.AddResult(R: CodeCompletionResult("instancetype")); |
8012 | } |
8013 | |
8014 | // Add various builtin type names and specifiers. |
8015 | AddOrdinaryNameResults(CCC: PCC_Type, S, SemaRef, Results); |
8016 | Results.ExitScope(); |
8017 | |
8018 | // Add the various type names |
8019 | Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName); |
8020 | CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext); |
8021 | SemaRef.LookupVisibleDecls(S, Sema::LookupOrdinaryName, Consumer, |
8022 | CodeCompleter->includeGlobals(), |
8023 | CodeCompleter->loadExternal()); |
8024 | |
8025 | if (CodeCompleter->includeMacros()) |
8026 | AddMacroResults(PP&: SemaRef.PP, Results, LoadExternal: CodeCompleter->loadExternal(), IncludeUndefined: false); |
8027 | |
8028 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
8029 | Context: Results.getCompletionContext(), Results: Results.data(), |
8030 | NumResults: Results.size()); |
8031 | } |
8032 | |
8033 | /// When we have an expression with type "id", we may assume |
8034 | /// that it has some more-specific class type based on knowledge of |
8035 | /// common uses of Objective-C. This routine returns that class type, |
8036 | /// or NULL if no better result could be determined. |
8037 | static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) { |
8038 | auto *Msg = dyn_cast_or_null<ObjCMessageExpr>(Val: E); |
8039 | if (!Msg) |
8040 | return nullptr; |
8041 | |
8042 | Selector Sel = Msg->getSelector(); |
8043 | if (Sel.isNull()) |
8044 | return nullptr; |
8045 | |
8046 | const IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(argIndex: 0); |
8047 | if (!Id) |
8048 | return nullptr; |
8049 | |
8050 | ObjCMethodDecl *Method = Msg->getMethodDecl(); |
8051 | if (!Method) |
8052 | return nullptr; |
8053 | |
8054 | // Determine the class that we're sending the message to. |
8055 | ObjCInterfaceDecl *IFace = nullptr; |
8056 | switch (Msg->getReceiverKind()) { |
8057 | case ObjCMessageExpr::Class: |
8058 | if (const ObjCObjectType *ObjType = |
8059 | Msg->getClassReceiver()->getAs<ObjCObjectType>()) |
8060 | IFace = ObjType->getInterface(); |
8061 | break; |
8062 | |
8063 | case ObjCMessageExpr::Instance: { |
8064 | QualType T = Msg->getInstanceReceiver()->getType(); |
8065 | if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>()) |
8066 | IFace = Ptr->getInterfaceDecl(); |
8067 | break; |
8068 | } |
8069 | |
8070 | case ObjCMessageExpr::SuperInstance: |
8071 | case ObjCMessageExpr::SuperClass: |
8072 | break; |
8073 | } |
8074 | |
8075 | if (!IFace) |
8076 | return nullptr; |
8077 | |
8078 | ObjCInterfaceDecl *Super = IFace->getSuperClass(); |
8079 | if (Method->isInstanceMethod()) |
8080 | return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName()) |
8081 | .Case(S: "retain", Value: IFace) |
8082 | .Case(S: "strong", Value: IFace) |
8083 | .Case(S: "autorelease", Value: IFace) |
8084 | .Case(S: "copy", Value: IFace) |
8085 | .Case(S: "copyWithZone", Value: IFace) |
8086 | .Case(S: "mutableCopy", Value: IFace) |
8087 | .Case(S: "mutableCopyWithZone", Value: IFace) |
8088 | .Case(S: "awakeFromCoder", Value: IFace) |
8089 | .Case(S: "replacementObjectFromCoder", Value: IFace) |
8090 | .Case(S: "class", Value: IFace) |
8091 | .Case(S: "classForCoder", Value: IFace) |
8092 | .Case(S: "superclass", Value: Super) |
8093 | .Default(Value: nullptr); |
8094 | |
8095 | return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName()) |
8096 | .Case(S: "new", Value: IFace) |
8097 | .Case(S: "alloc", Value: IFace) |
8098 | .Case(S: "allocWithZone", Value: IFace) |
8099 | .Case(S: "class", Value: IFace) |
8100 | .Case(S: "superclass", Value: Super) |
8101 | .Default(Value: nullptr); |
8102 | } |
8103 | |
8104 | // Add a special completion for a message send to "super", which fills in the |
8105 | // most likely case of forwarding all of our arguments to the superclass |
8106 | // function. |
8107 | /// |
8108 | /// \param S The semantic analysis object. |
8109 | /// |
8110 | /// \param NeedSuperKeyword Whether we need to prefix this completion with |
8111 | /// the "super" keyword. Otherwise, we just need to provide the arguments. |
8112 | /// |
8113 | /// \param SelIdents The identifiers in the selector that have already been |
8114 | /// provided as arguments for a send to "super". |
8115 | /// |
8116 | /// \param Results The set of results to augment. |
8117 | /// |
8118 | /// \returns the Objective-C method declaration that would be invoked by |
8119 | /// this "super" completion. If NULL, no completion was added. |
8120 | static ObjCMethodDecl * |
8121 | AddSuperSendCompletion(Sema &S, bool NeedSuperKeyword, |
8122 | ArrayRef<const IdentifierInfo *> SelIdents, |
8123 | ResultBuilder &Results) { |
8124 | ObjCMethodDecl *CurMethod = S.getCurMethodDecl(); |
8125 | if (!CurMethod) |
8126 | return nullptr; |
8127 | |
8128 | ObjCInterfaceDecl *Class = CurMethod->getClassInterface(); |
8129 | if (!Class) |
8130 | return nullptr; |
8131 | |
8132 | // Try to find a superclass method with the same selector. |
8133 | ObjCMethodDecl *SuperMethod = nullptr; |
8134 | while ((Class = Class->getSuperClass()) && !SuperMethod) { |
8135 | // Check in the class |
8136 | SuperMethod = Class->getMethod(CurMethod->getSelector(), |
8137 | CurMethod->isInstanceMethod()); |
8138 | |
8139 | // Check in categories or class extensions. |
8140 | if (!SuperMethod) { |
8141 | for (const auto *Cat : Class->known_categories()) { |
8142 | if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(), |
8143 | CurMethod->isInstanceMethod()))) |
8144 | break; |
8145 | } |
8146 | } |
8147 | } |
8148 | |
8149 | if (!SuperMethod) |
8150 | return nullptr; |
8151 | |
8152 | // Check whether the superclass method has the same signature. |
8153 | if (CurMethod->param_size() != SuperMethod->param_size() || |
8154 | CurMethod->isVariadic() != SuperMethod->isVariadic()) |
8155 | return nullptr; |
8156 | |
8157 | for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(), |
8158 | CurPEnd = CurMethod->param_end(), |
8159 | SuperP = SuperMethod->param_begin(); |
8160 | CurP != CurPEnd; ++CurP, ++SuperP) { |
8161 | // Make sure the parameter types are compatible. |
8162 | if (!S.Context.hasSameUnqualifiedType(T1: (*CurP)->getType(), |
8163 | T2: (*SuperP)->getType())) |
8164 | return nullptr; |
8165 | |
8166 | // Make sure we have a parameter name to forward! |
8167 | if (!(*CurP)->getIdentifier()) |
8168 | return nullptr; |
8169 | } |
8170 | |
8171 | // We have a superclass method. Now, form the send-to-super completion. |
8172 | CodeCompletionBuilder Builder(Results.getAllocator(), |
8173 | Results.getCodeCompletionTUInfo()); |
8174 | |
8175 | // Give this completion a return type. |
8176 | AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod, |
8177 | Results.getCompletionContext().getBaseType(), Builder); |
8178 | |
8179 | // If we need the "super" keyword, add it (plus some spacing). |
8180 | if (NeedSuperKeyword) { |
8181 | Builder.AddTypedTextChunk(Text: "super"); |
8182 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
8183 | } |
8184 | |
8185 | Selector Sel = CurMethod->getSelector(); |
8186 | if (Sel.isUnarySelector()) { |
8187 | if (NeedSuperKeyword) |
8188 | Builder.AddTextChunk( |
8189 | Text: Builder.getAllocator().CopyString(String: Sel.getNameForSlot(argIndex: 0))); |
8190 | else |
8191 | Builder.AddTypedTextChunk( |
8192 | Text: Builder.getAllocator().CopyString(String: Sel.getNameForSlot(argIndex: 0))); |
8193 | } else { |
8194 | ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(); |
8195 | for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) { |
8196 | if (I > SelIdents.size()) |
8197 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
8198 | |
8199 | if (I < SelIdents.size()) |
8200 | Builder.AddInformativeChunk( |
8201 | Text: Builder.getAllocator().CopyString(String: Sel.getNameForSlot(argIndex: I) + ":")); |
8202 | else if (NeedSuperKeyword || I > SelIdents.size()) { |
8203 | Builder.AddTextChunk( |
8204 | Text: Builder.getAllocator().CopyString(String: Sel.getNameForSlot(argIndex: I) + ":")); |
8205 | Builder.AddPlaceholderChunk(Placeholder: Builder.getAllocator().CopyString( |
8206 | String: (*CurP)->getIdentifier()->getName())); |
8207 | } else { |
8208 | Builder.AddTypedTextChunk( |
8209 | Text: Builder.getAllocator().CopyString(String: Sel.getNameForSlot(argIndex: I) + ":")); |
8210 | Builder.AddPlaceholderChunk(Placeholder: Builder.getAllocator().CopyString( |
8211 | String: (*CurP)->getIdentifier()->getName())); |
8212 | } |
8213 | } |
8214 | } |
8215 | |
8216 | Results.AddResult(R: CodeCompletionResult(Builder.TakeString(), SuperMethod, |
8217 | CCP_SuperCompletion)); |
8218 | return SuperMethod; |
8219 | } |
8220 | |
8221 | void SemaCodeCompletion::CodeCompleteObjCMessageReceiver(Scope *S) { |
8222 | typedef CodeCompletionResult Result; |
8223 | ResultBuilder Results( |
8224 | SemaRef, CodeCompleter->getAllocator(), |
8225 | CodeCompleter->getCodeCompletionTUInfo(), |
8226 | CodeCompletionContext::CCC_ObjCMessageReceiver, |
8227 | getLangOpts().CPlusPlus11 |
8228 | ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture |
8229 | : &ResultBuilder::IsObjCMessageReceiver); |
8230 | |
8231 | CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext); |
8232 | Results.EnterNewScope(); |
8233 | SemaRef.LookupVisibleDecls(S, Sema::LookupOrdinaryName, Consumer, |
8234 | CodeCompleter->includeGlobals(), |
8235 | CodeCompleter->loadExternal()); |
8236 | |
8237 | // If we are in an Objective-C method inside a class that has a superclass, |
8238 | // add "super" as an option. |
8239 | if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) |
8240 | if (ObjCInterfaceDecl *Iface = Method->getClassInterface()) |
8241 | if (Iface->getSuperClass()) { |
8242 | Results.AddResult(R: Result("super")); |
8243 | |
8244 | AddSuperSendCompletion(S&: SemaRef, /*NeedSuperKeyword=*/true, SelIdents: {}, Results); |
8245 | } |
8246 | |
8247 | if (getLangOpts().CPlusPlus11) |
8248 | addThisCompletion(S&: SemaRef, Results); |
8249 | |
8250 | Results.ExitScope(); |
8251 | |
8252 | if (CodeCompleter->includeMacros()) |
8253 | AddMacroResults(PP&: SemaRef.PP, Results, LoadExternal: CodeCompleter->loadExternal(), IncludeUndefined: false); |
8254 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
8255 | Context: Results.getCompletionContext(), Results: Results.data(), |
8256 | NumResults: Results.size()); |
8257 | } |
8258 | |
8259 | void SemaCodeCompletion::CodeCompleteObjCSuperMessage( |
8260 | Scope *S, SourceLocation SuperLoc, |
8261 | ArrayRef<const IdentifierInfo *> SelIdents, bool AtArgumentExpression) { |
8262 | ObjCInterfaceDecl *CDecl = nullptr; |
8263 | if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl()) { |
8264 | // Figure out which interface we're in. |
8265 | CDecl = CurMethod->getClassInterface(); |
8266 | if (!CDecl) |
8267 | return; |
8268 | |
8269 | // Find the superclass of this class. |
8270 | CDecl = CDecl->getSuperClass(); |
8271 | if (!CDecl) |
8272 | return; |
8273 | |
8274 | if (CurMethod->isInstanceMethod()) { |
8275 | // We are inside an instance method, which means that the message |
8276 | // send [super ...] is actually calling an instance method on the |
8277 | // current object. |
8278 | return CodeCompleteObjCInstanceMessage(S, Receiver: nullptr, SelIdents, |
8279 | AtArgumentExpression, Super: CDecl); |
8280 | } |
8281 | |
8282 | // Fall through to send to the superclass in CDecl. |
8283 | } else { |
8284 | // "super" may be the name of a type or variable. Figure out which |
8285 | // it is. |
8286 | const IdentifierInfo *Super = SemaRef.getSuperIdentifier(); |
8287 | NamedDecl *ND = |
8288 | SemaRef.LookupSingleName(S, Name: Super, Loc: SuperLoc, NameKind: Sema::LookupOrdinaryName); |
8289 | if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(Val: ND))) { |
8290 | // "super" names an interface. Use it. |
8291 | } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(Val: ND)) { |
8292 | if (const ObjCObjectType *Iface = |
8293 | getASTContext().getTypeDeclType(Decl: TD)->getAs<ObjCObjectType>()) |
8294 | CDecl = Iface->getInterface(); |
8295 | } else if (ND && isa<UnresolvedUsingTypenameDecl>(Val: ND)) { |
8296 | // "super" names an unresolved type; we can't be more specific. |
8297 | } else { |
8298 | // Assume that "super" names some kind of value and parse that way. |
8299 | CXXScopeSpec SS; |
8300 | SourceLocation TemplateKWLoc; |
8301 | UnqualifiedId id; |
8302 | id.setIdentifier(Id: Super, IdLoc: SuperLoc); |
8303 | ExprResult SuperExpr = |
8304 | SemaRef.ActOnIdExpression(S, SS, TemplateKWLoc, Id&: id, |
8305 | /*HasTrailingLParen=*/false, |
8306 | /*IsAddressOfOperand=*/false); |
8307 | return CodeCompleteObjCInstanceMessage(S, Receiver: (Expr *)SuperExpr.get(), |
8308 | SelIdents, AtArgumentExpression); |
8309 | } |
8310 | |
8311 | // Fall through |
8312 | } |
8313 | |
8314 | ParsedType Receiver; |
8315 | if (CDecl) |
8316 | Receiver = ParsedType::make(P: getASTContext().getObjCInterfaceType(Decl: CDecl)); |
8317 | return CodeCompleteObjCClassMessage(S, Receiver, SelIdents, |
8318 | AtArgumentExpression, |
8319 | /*IsSuper=*/true); |
8320 | } |
8321 | |
8322 | /// Given a set of code-completion results for the argument of a message |
8323 | /// send, determine the preferred type (if any) for that argument expression. |
8324 | static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results, |
8325 | unsigned NumSelIdents) { |
8326 | typedef CodeCompletionResult Result; |
8327 | ASTContext &Context = Results.getSema().Context; |
8328 | |
8329 | QualType PreferredType; |
8330 | unsigned BestPriority = CCP_Unlikely * 2; |
8331 | Result *ResultsData = Results.data(); |
8332 | for (unsigned I = 0, N = Results.size(); I != N; ++I) { |
8333 | Result &R = ResultsData[I]; |
8334 | if (R.Kind == Result::RK_Declaration && |
8335 | isa<ObjCMethodDecl>(Val: R.Declaration)) { |
8336 | if (R.Priority <= BestPriority) { |
8337 | const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(Val: R.Declaration); |
8338 | if (NumSelIdents <= Method->param_size()) { |
8339 | QualType MyPreferredType = |
8340 | Method->parameters()[NumSelIdents - 1]->getType(); |
8341 | if (R.Priority < BestPriority || PreferredType.isNull()) { |
8342 | BestPriority = R.Priority; |
8343 | PreferredType = MyPreferredType; |
8344 | } else if (!Context.hasSameUnqualifiedType(T1: PreferredType, |
8345 | T2: MyPreferredType)) { |
8346 | PreferredType = QualType(); |
8347 | } |
8348 | } |
8349 | } |
8350 | } |
8351 | } |
8352 | |
8353 | return PreferredType; |
8354 | } |
8355 | |
8356 | static void |
8357 | AddClassMessageCompletions(Sema &SemaRef, Scope *S, ParsedType Receiver, |
8358 | ArrayRef<const IdentifierInfo *> SelIdents, |
8359 | bool AtArgumentExpression, bool IsSuper, |
8360 | ResultBuilder &Results) { |
8361 | typedef CodeCompletionResult Result; |
8362 | ObjCInterfaceDecl *CDecl = nullptr; |
8363 | |
8364 | // If the given name refers to an interface type, retrieve the |
8365 | // corresponding declaration. |
8366 | if (Receiver) { |
8367 | QualType T = SemaRef.GetTypeFromParser(Ty: Receiver, TInfo: nullptr); |
8368 | if (!T.isNull()) |
8369 | if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>()) |
8370 | CDecl = Interface->getInterface(); |
8371 | } |
8372 | |
8373 | // Add all of the factory methods in this Objective-C class, its protocols, |
8374 | // superclasses, categories, implementation, etc. |
8375 | Results.EnterNewScope(); |
8376 | |
8377 | // If this is a send-to-super, try to add the special "super" send |
8378 | // completion. |
8379 | if (IsSuper) { |
8380 | if (ObjCMethodDecl *SuperMethod = |
8381 | AddSuperSendCompletion(S&: SemaRef, NeedSuperKeyword: false, SelIdents, Results)) |
8382 | Results.Ignore(SuperMethod); |
8383 | } |
8384 | |
8385 | // If we're inside an Objective-C method definition, prefer its selector to |
8386 | // others. |
8387 | if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl()) |
8388 | Results.setPreferredSelector(CurMethod->getSelector()); |
8389 | |
8390 | VisitedSelectorSet Selectors; |
8391 | if (CDecl) |
8392 | AddObjCMethods(CDecl, false, MK_Any, SelIdents, SemaRef.CurContext, |
8393 | Selectors, AtArgumentExpression, Results); |
8394 | else { |
8395 | // We're messaging "id" as a type; provide all class/factory methods. |
8396 | |
8397 | // If we have an external source, load the entire class method |
8398 | // pool from the AST file. |
8399 | if (SemaRef.getExternalSource()) { |
8400 | for (uint32_t I = 0, |
8401 | N = SemaRef.getExternalSource()->GetNumExternalSelectors(); |
8402 | I != N; ++I) { |
8403 | Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(ID: I); |
8404 | if (Sel.isNull() || SemaRef.ObjC().MethodPool.count(Val: Sel)) |
8405 | continue; |
8406 | |
8407 | SemaRef.ObjC().ReadMethodPool(Sel); |
8408 | } |
8409 | } |
8410 | |
8411 | for (SemaObjC::GlobalMethodPool::iterator |
8412 | M = SemaRef.ObjC().MethodPool.begin(), |
8413 | MEnd = SemaRef.ObjC().MethodPool.end(); |
8414 | M != MEnd; ++M) { |
8415 | for (ObjCMethodList *MethList = &M->second.second; |
8416 | MethList && MethList->getMethod(); MethList = MethList->getNext()) { |
8417 | if (!isAcceptableObjCMethod(Method: MethList->getMethod(), WantKind: MK_Any, SelIdents)) |
8418 | continue; |
8419 | |
8420 | Result R(MethList->getMethod(), |
8421 | Results.getBasePriority(MethList->getMethod()), nullptr); |
8422 | R.StartParameter = SelIdents.size(); |
8423 | R.AllParametersAreInformative = false; |
8424 | Results.MaybeAddResult(R, CurContext: SemaRef.CurContext); |
8425 | } |
8426 | } |
8427 | } |
8428 | |
8429 | Results.ExitScope(); |
8430 | } |
8431 | |
8432 | void SemaCodeCompletion::CodeCompleteObjCClassMessage( |
8433 | Scope *S, ParsedType Receiver, ArrayRef<const IdentifierInfo *> SelIdents, |
8434 | bool AtArgumentExpression, bool IsSuper) { |
8435 | |
8436 | QualType T = SemaRef.GetTypeFromParser(Ty: Receiver); |
8437 | |
8438 | ResultBuilder Results( |
8439 | SemaRef, CodeCompleter->getAllocator(), |
8440 | CodeCompleter->getCodeCompletionTUInfo(), |
8441 | CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage, T, |
8442 | SelIdents)); |
8443 | |
8444 | AddClassMessageCompletions(SemaRef, S, Receiver, SelIdents, |
8445 | AtArgumentExpression, IsSuper, Results); |
8446 | |
8447 | // If we're actually at the argument expression (rather than prior to the |
8448 | // selector), we're actually performing code completion for an expression. |
8449 | // Determine whether we have a single, best method. If so, we can |
8450 | // code-complete the expression using the corresponding parameter type as |
8451 | // our preferred type, improving completion results. |
8452 | if (AtArgumentExpression) { |
8453 | QualType PreferredType = |
8454 | getPreferredArgumentTypeForMessageSend(Results, NumSelIdents: SelIdents.size()); |
8455 | if (PreferredType.isNull()) |
8456 | CodeCompleteOrdinaryName(S, CompletionContext: PCC_Expression); |
8457 | else |
8458 | CodeCompleteExpression(S, PreferredType); |
8459 | return; |
8460 | } |
8461 | |
8462 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
8463 | Context: Results.getCompletionContext(), Results: Results.data(), |
8464 | NumResults: Results.size()); |
8465 | } |
8466 | |
8467 | void SemaCodeCompletion::CodeCompleteObjCInstanceMessage( |
8468 | Scope *S, Expr *Receiver, ArrayRef<const IdentifierInfo *> SelIdents, |
8469 | bool AtArgumentExpression, ObjCInterfaceDecl *Super) { |
8470 | typedef CodeCompletionResult Result; |
8471 | ASTContext &Context = getASTContext(); |
8472 | |
8473 | Expr *RecExpr = static_cast<Expr *>(Receiver); |
8474 | |
8475 | // If necessary, apply function/array conversion to the receiver. |
8476 | // C99 6.7.5.3p[7,8]. |
8477 | if (RecExpr) { |
8478 | ExprResult Conv = SemaRef.DefaultFunctionArrayLvalueConversion(E: RecExpr); |
8479 | if (Conv.isInvalid()) // conversion failed. bail. |
8480 | return; |
8481 | RecExpr = Conv.get(); |
8482 | } |
8483 | QualType ReceiverType = RecExpr |
8484 | ? RecExpr->getType() |
8485 | : Super ? Context.getObjCObjectPointerType( |
8486 | OIT: Context.getObjCInterfaceType(Decl: Super)) |
8487 | : Context.getObjCIdType(); |
8488 | |
8489 | // If we're messaging an expression with type "id" or "Class", check |
8490 | // whether we know something special about the receiver that allows |
8491 | // us to assume a more-specific receiver type. |
8492 | if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) { |
8493 | if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(E: RecExpr)) { |
8494 | if (ReceiverType->isObjCClassType()) |
8495 | return CodeCompleteObjCClassMessage( |
8496 | S, Receiver: ParsedType::make(P: Context.getObjCInterfaceType(Decl: IFace)), SelIdents, |
8497 | AtArgumentExpression, IsSuper: Super); |
8498 | |
8499 | ReceiverType = |
8500 | Context.getObjCObjectPointerType(OIT: Context.getObjCInterfaceType(Decl: IFace)); |
8501 | } |
8502 | } else if (RecExpr && getLangOpts().CPlusPlus) { |
8503 | ExprResult Conv = SemaRef.PerformContextuallyConvertToObjCPointer(From: RecExpr); |
8504 | if (Conv.isUsable()) { |
8505 | RecExpr = Conv.get(); |
8506 | ReceiverType = RecExpr->getType(); |
8507 | } |
8508 | } |
8509 | |
8510 | // Build the set of methods we can see. |
8511 | ResultBuilder Results( |
8512 | SemaRef, CodeCompleter->getAllocator(), |
8513 | CodeCompleter->getCodeCompletionTUInfo(), |
8514 | CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage, |
8515 | ReceiverType, SelIdents)); |
8516 | |
8517 | Results.EnterNewScope(); |
8518 | |
8519 | // If this is a send-to-super, try to add the special "super" send |
8520 | // completion. |
8521 | if (Super) { |
8522 | if (ObjCMethodDecl *SuperMethod = |
8523 | AddSuperSendCompletion(S&: SemaRef, NeedSuperKeyword: false, SelIdents, Results)) |
8524 | Results.Ignore(SuperMethod); |
8525 | } |
8526 | |
8527 | // If we're inside an Objective-C method definition, prefer its selector to |
8528 | // others. |
8529 | if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl()) |
8530 | Results.setPreferredSelector(CurMethod->getSelector()); |
8531 | |
8532 | // Keep track of the selectors we've already added. |
8533 | VisitedSelectorSet Selectors; |
8534 | |
8535 | // Handle messages to Class. This really isn't a message to an instance |
8536 | // method, so we treat it the same way we would treat a message send to a |
8537 | // class method. |
8538 | if (ReceiverType->isObjCClassType() || |
8539 | ReceiverType->isObjCQualifiedClassType()) { |
8540 | if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl()) { |
8541 | if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface()) |
8542 | AddObjCMethods(ClassDecl, false, MK_Any, SelIdents, SemaRef.CurContext, |
8543 | Selectors, AtArgumentExpression, Results); |
8544 | } |
8545 | } |
8546 | // Handle messages to a qualified ID ("id<foo>"). |
8547 | else if (const ObjCObjectPointerType *QualID = |
8548 | ReceiverType->getAsObjCQualifiedIdType()) { |
8549 | // Search protocols for instance methods. |
8550 | for (auto *I : QualID->quals()) |
8551 | AddObjCMethods(I, true, MK_Any, SelIdents, SemaRef.CurContext, Selectors, |
8552 | AtArgumentExpression, Results); |
8553 | } |
8554 | // Handle messages to a pointer to interface type. |
8555 | else if (const ObjCObjectPointerType *IFacePtr = |
8556 | ReceiverType->getAsObjCInterfacePointerType()) { |
8557 | // Search the class, its superclasses, etc., for instance methods. |
8558 | AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents, |
8559 | SemaRef.CurContext, Selectors, AtArgumentExpression, |
8560 | Results); |
8561 | |
8562 | // Search protocols for instance methods. |
8563 | for (auto *I : IFacePtr->quals()) |
8564 | AddObjCMethods(I, true, MK_Any, SelIdents, SemaRef.CurContext, Selectors, |
8565 | AtArgumentExpression, Results); |
8566 | } |
8567 | // Handle messages to "id". |
8568 | else if (ReceiverType->isObjCIdType()) { |
8569 | // We're messaging "id", so provide all instance methods we know |
8570 | // about as code-completion results. |
8571 | |
8572 | // If we have an external source, load the entire class method |
8573 | // pool from the AST file. |
8574 | if (SemaRef.ExternalSource) { |
8575 | for (uint32_t I = 0, |
8576 | N = SemaRef.ExternalSource->GetNumExternalSelectors(); |
8577 | I != N; ++I) { |
8578 | Selector Sel = SemaRef.ExternalSource->GetExternalSelector(ID: I); |
8579 | if (Sel.isNull() || SemaRef.ObjC().MethodPool.count(Val: Sel)) |
8580 | continue; |
8581 | |
8582 | SemaRef.ObjC().ReadMethodPool(Sel); |
8583 | } |
8584 | } |
8585 | |
8586 | for (SemaObjC::GlobalMethodPool::iterator |
8587 | M = SemaRef.ObjC().MethodPool.begin(), |
8588 | MEnd = SemaRef.ObjC().MethodPool.end(); |
8589 | M != MEnd; ++M) { |
8590 | for (ObjCMethodList *MethList = &M->second.first; |
8591 | MethList && MethList->getMethod(); MethList = MethList->getNext()) { |
8592 | if (!isAcceptableObjCMethod(Method: MethList->getMethod(), WantKind: MK_Any, SelIdents)) |
8593 | continue; |
8594 | |
8595 | if (!Selectors.insert(Ptr: MethList->getMethod()->getSelector()).second) |
8596 | continue; |
8597 | |
8598 | Result R(MethList->getMethod(), |
8599 | Results.getBasePriority(MethList->getMethod()), nullptr); |
8600 | R.StartParameter = SelIdents.size(); |
8601 | R.AllParametersAreInformative = false; |
8602 | Results.MaybeAddResult(R, CurContext: SemaRef.CurContext); |
8603 | } |
8604 | } |
8605 | } |
8606 | Results.ExitScope(); |
8607 | |
8608 | // If we're actually at the argument expression (rather than prior to the |
8609 | // selector), we're actually performing code completion for an expression. |
8610 | // Determine whether we have a single, best method. If so, we can |
8611 | // code-complete the expression using the corresponding parameter type as |
8612 | // our preferred type, improving completion results. |
8613 | if (AtArgumentExpression) { |
8614 | QualType PreferredType = |
8615 | getPreferredArgumentTypeForMessageSend(Results, NumSelIdents: SelIdents.size()); |
8616 | if (PreferredType.isNull()) |
8617 | CodeCompleteOrdinaryName(S, CompletionContext: PCC_Expression); |
8618 | else |
8619 | CodeCompleteExpression(S, PreferredType); |
8620 | return; |
8621 | } |
8622 | |
8623 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
8624 | Context: Results.getCompletionContext(), Results: Results.data(), |
8625 | NumResults: Results.size()); |
8626 | } |
8627 | |
8628 | void SemaCodeCompletion::CodeCompleteObjCForCollection( |
8629 | Scope *S, DeclGroupPtrTy IterationVar) { |
8630 | CodeCompleteExpressionData Data; |
8631 | Data.ObjCCollection = true; |
8632 | |
8633 | if (IterationVar.getAsOpaquePtr()) { |
8634 | DeclGroupRef DG = IterationVar.get(); |
8635 | for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) { |
8636 | if (*I) |
8637 | Data.IgnoreDecls.push_back(Elt: *I); |
8638 | } |
8639 | } |
8640 | |
8641 | CodeCompleteExpression(S, Data); |
8642 | } |
8643 | |
8644 | void SemaCodeCompletion::CodeCompleteObjCSelector( |
8645 | Scope *S, ArrayRef<const IdentifierInfo *> SelIdents) { |
8646 | // If we have an external source, load the entire class method |
8647 | // pool from the AST file. |
8648 | if (SemaRef.ExternalSource) { |
8649 | for (uint32_t I = 0, N = SemaRef.ExternalSource->GetNumExternalSelectors(); |
8650 | I != N; ++I) { |
8651 | Selector Sel = SemaRef.ExternalSource->GetExternalSelector(ID: I); |
8652 | if (Sel.isNull() || SemaRef.ObjC().MethodPool.count(Val: Sel)) |
8653 | continue; |
8654 | |
8655 | SemaRef.ObjC().ReadMethodPool(Sel); |
8656 | } |
8657 | } |
8658 | |
8659 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
8660 | CodeCompleter->getCodeCompletionTUInfo(), |
8661 | CodeCompletionContext::CCC_SelectorName); |
8662 | Results.EnterNewScope(); |
8663 | for (SemaObjC::GlobalMethodPool::iterator |
8664 | M = SemaRef.ObjC().MethodPool.begin(), |
8665 | MEnd = SemaRef.ObjC().MethodPool.end(); |
8666 | M != MEnd; ++M) { |
8667 | |
8668 | Selector Sel = M->first; |
8669 | if (!isAcceptableObjCSelector(Sel, WantKind: MK_Any, SelIdents)) |
8670 | continue; |
8671 | |
8672 | CodeCompletionBuilder Builder(Results.getAllocator(), |
8673 | Results.getCodeCompletionTUInfo()); |
8674 | if (Sel.isUnarySelector()) { |
8675 | Builder.AddTypedTextChunk( |
8676 | Text: Builder.getAllocator().CopyString(String: Sel.getNameForSlot(argIndex: 0))); |
8677 | Results.AddResult(R: Builder.TakeString()); |
8678 | continue; |
8679 | } |
8680 | |
8681 | std::string Accumulator; |
8682 | for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) { |
8683 | if (I == SelIdents.size()) { |
8684 | if (!Accumulator.empty()) { |
8685 | Builder.AddInformativeChunk( |
8686 | Text: Builder.getAllocator().CopyString(String: Accumulator)); |
8687 | Accumulator.clear(); |
8688 | } |
8689 | } |
8690 | |
8691 | Accumulator += Sel.getNameForSlot(argIndex: I); |
8692 | Accumulator += ':'; |
8693 | } |
8694 | Builder.AddTypedTextChunk(Text: Builder.getAllocator().CopyString(String: Accumulator)); |
8695 | Results.AddResult(R: Builder.TakeString()); |
8696 | } |
8697 | Results.ExitScope(); |
8698 | |
8699 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
8700 | Context: Results.getCompletionContext(), Results: Results.data(), |
8701 | NumResults: Results.size()); |
8702 | } |
8703 | |
8704 | /// Add all of the protocol declarations that we find in the given |
8705 | /// (translation unit) context. |
8706 | static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext, |
8707 | bool OnlyForwardDeclarations, |
8708 | ResultBuilder &Results) { |
8709 | typedef CodeCompletionResult Result; |
8710 | |
8711 | for (const auto *D : Ctx->decls()) { |
8712 | // Record any protocols we find. |
8713 | if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(Val: D)) |
8714 | if (!OnlyForwardDeclarations || !Proto->hasDefinition()) |
8715 | Results.AddResult( |
8716 | R: Result(Proto, Results.getBasePriority(Proto), nullptr), CurContext, |
8717 | Hiding: nullptr, InBaseClass: false); |
8718 | } |
8719 | } |
8720 | |
8721 | void SemaCodeCompletion::CodeCompleteObjCProtocolReferences( |
8722 | ArrayRef<IdentifierLoc> Protocols) { |
8723 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
8724 | CodeCompleter->getCodeCompletionTUInfo(), |
8725 | CodeCompletionContext::CCC_ObjCProtocolName); |
8726 | |
8727 | if (CodeCompleter->includeGlobals()) { |
8728 | Results.EnterNewScope(); |
8729 | |
8730 | // Tell the result set to ignore all of the protocols we have |
8731 | // already seen. |
8732 | // FIXME: This doesn't work when caching code-completion results. |
8733 | for (const IdentifierLoc &Pair : Protocols) |
8734 | if (ObjCProtocolDecl *Protocol = SemaRef.ObjC().LookupProtocol( |
8735 | II: Pair.getIdentifierInfo(), IdLoc: Pair.getLoc())) |
8736 | Results.Ignore(Protocol); |
8737 | |
8738 | // Add all protocols. |
8739 | AddProtocolResults(getASTContext().getTranslationUnitDecl(), |
8740 | SemaRef.CurContext, false, Results); |
8741 | |
8742 | Results.ExitScope(); |
8743 | } |
8744 | |
8745 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
8746 | Context: Results.getCompletionContext(), Results: Results.data(), |
8747 | NumResults: Results.size()); |
8748 | } |
8749 | |
8750 | void SemaCodeCompletion::CodeCompleteObjCProtocolDecl(Scope *) { |
8751 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
8752 | CodeCompleter->getCodeCompletionTUInfo(), |
8753 | CodeCompletionContext::CCC_ObjCProtocolName); |
8754 | |
8755 | if (CodeCompleter->includeGlobals()) { |
8756 | Results.EnterNewScope(); |
8757 | |
8758 | // Add all protocols. |
8759 | AddProtocolResults(getASTContext().getTranslationUnitDecl(), |
8760 | SemaRef.CurContext, true, Results); |
8761 | |
8762 | Results.ExitScope(); |
8763 | } |
8764 | |
8765 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
8766 | Context: Results.getCompletionContext(), Results: Results.data(), |
8767 | NumResults: Results.size()); |
8768 | } |
8769 | |
8770 | /// Add all of the Objective-C interface declarations that we find in |
8771 | /// the given (translation unit) context. |
8772 | static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext, |
8773 | bool OnlyForwardDeclarations, |
8774 | bool OnlyUnimplemented, |
8775 | ResultBuilder &Results) { |
8776 | typedef CodeCompletionResult Result; |
8777 | |
8778 | for (const auto *D : Ctx->decls()) { |
8779 | // Record any interfaces we find. |
8780 | if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(Val: D)) |
8781 | if ((!OnlyForwardDeclarations || !Class->hasDefinition()) && |
8782 | (!OnlyUnimplemented || !Class->getImplementation())) |
8783 | Results.AddResult( |
8784 | R: Result(Class, Results.getBasePriority(Class), nullptr), CurContext, |
8785 | Hiding: nullptr, InBaseClass: false); |
8786 | } |
8787 | } |
8788 | |
8789 | void SemaCodeCompletion::CodeCompleteObjCInterfaceDecl(Scope *S) { |
8790 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
8791 | CodeCompleter->getCodeCompletionTUInfo(), |
8792 | CodeCompletionContext::CCC_ObjCInterfaceName); |
8793 | Results.EnterNewScope(); |
8794 | |
8795 | if (CodeCompleter->includeGlobals()) { |
8796 | // Add all classes. |
8797 | AddInterfaceResults(getASTContext().getTranslationUnitDecl(), |
8798 | SemaRef.CurContext, false, false, Results); |
8799 | } |
8800 | |
8801 | Results.ExitScope(); |
8802 | |
8803 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
8804 | Context: Results.getCompletionContext(), Results: Results.data(), |
8805 | NumResults: Results.size()); |
8806 | } |
8807 | |
8808 | void SemaCodeCompletion::CodeCompleteObjCClassForwardDecl(Scope *S) { |
8809 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
8810 | CodeCompleter->getCodeCompletionTUInfo(), |
8811 | CodeCompletionContext::CCC_ObjCClassForwardDecl); |
8812 | Results.EnterNewScope(); |
8813 | |
8814 | if (CodeCompleter->includeGlobals()) { |
8815 | // Add all classes. |
8816 | AddInterfaceResults(getASTContext().getTranslationUnitDecl(), |
8817 | SemaRef.CurContext, false, false, Results); |
8818 | } |
8819 | |
8820 | Results.ExitScope(); |
8821 | |
8822 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
8823 | Context: Results.getCompletionContext(), Results: Results.data(), |
8824 | NumResults: Results.size()); |
8825 | } |
8826 | |
8827 | void SemaCodeCompletion::CodeCompleteObjCSuperclass( |
8828 | Scope *S, IdentifierInfo *ClassName, SourceLocation ClassNameLoc) { |
8829 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
8830 | CodeCompleter->getCodeCompletionTUInfo(), |
8831 | CodeCompletionContext::CCC_ObjCInterfaceName); |
8832 | Results.EnterNewScope(); |
8833 | |
8834 | // Make sure that we ignore the class we're currently defining. |
8835 | NamedDecl *CurClass = SemaRef.LookupSingleName( |
8836 | S: SemaRef.TUScope, Name: ClassName, Loc: ClassNameLoc, NameKind: Sema::LookupOrdinaryName); |
8837 | if (CurClass && isa<ObjCInterfaceDecl>(Val: CurClass)) |
8838 | Results.Ignore(CurClass); |
8839 | |
8840 | if (CodeCompleter->includeGlobals()) { |
8841 | // Add all classes. |
8842 | AddInterfaceResults(getASTContext().getTranslationUnitDecl(), |
8843 | SemaRef.CurContext, false, false, Results); |
8844 | } |
8845 | |
8846 | Results.ExitScope(); |
8847 | |
8848 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
8849 | Context: Results.getCompletionContext(), Results: Results.data(), |
8850 | NumResults: Results.size()); |
8851 | } |
8852 | |
8853 | void SemaCodeCompletion::CodeCompleteObjCImplementationDecl(Scope *S) { |
8854 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
8855 | CodeCompleter->getCodeCompletionTUInfo(), |
8856 | CodeCompletionContext::CCC_ObjCImplementation); |
8857 | Results.EnterNewScope(); |
8858 | |
8859 | if (CodeCompleter->includeGlobals()) { |
8860 | // Add all unimplemented classes. |
8861 | AddInterfaceResults(getASTContext().getTranslationUnitDecl(), |
8862 | SemaRef.CurContext, false, true, Results); |
8863 | } |
8864 | |
8865 | Results.ExitScope(); |
8866 | |
8867 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
8868 | Context: Results.getCompletionContext(), Results: Results.data(), |
8869 | NumResults: Results.size()); |
8870 | } |
8871 | |
8872 | void SemaCodeCompletion::CodeCompleteObjCInterfaceCategory( |
8873 | Scope *S, IdentifierInfo *ClassName, SourceLocation ClassNameLoc) { |
8874 | typedef CodeCompletionResult Result; |
8875 | |
8876 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
8877 | CodeCompleter->getCodeCompletionTUInfo(), |
8878 | CodeCompletionContext::CCC_ObjCCategoryName); |
8879 | |
8880 | // Ignore any categories we find that have already been implemented by this |
8881 | // interface. |
8882 | llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames; |
8883 | NamedDecl *CurClass = SemaRef.LookupSingleName( |
8884 | S: SemaRef.TUScope, Name: ClassName, Loc: ClassNameLoc, NameKind: Sema::LookupOrdinaryName); |
8885 | if (ObjCInterfaceDecl *Class = |
8886 | dyn_cast_or_null<ObjCInterfaceDecl>(Val: CurClass)) { |
8887 | for (const auto *Cat : Class->visible_categories()) |
8888 | CategoryNames.insert(Cat->getIdentifier()); |
8889 | } |
8890 | |
8891 | // Add all of the categories we know about. |
8892 | Results.EnterNewScope(); |
8893 | TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl(); |
8894 | for (const auto *D : TU->decls()) |
8895 | if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D)) |
8896 | if (CategoryNames.insert(Category->getIdentifier()).second) |
8897 | Results.AddResult( |
8898 | Result(Category, Results.getBasePriority(Category), nullptr), |
8899 | SemaRef.CurContext, nullptr, false); |
8900 | Results.ExitScope(); |
8901 | |
8902 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
8903 | Context: Results.getCompletionContext(), Results: Results.data(), |
8904 | NumResults: Results.size()); |
8905 | } |
8906 | |
8907 | void SemaCodeCompletion::CodeCompleteObjCImplementationCategory( |
8908 | Scope *S, IdentifierInfo *ClassName, SourceLocation ClassNameLoc) { |
8909 | typedef CodeCompletionResult Result; |
8910 | |
8911 | // Find the corresponding interface. If we couldn't find the interface, the |
8912 | // program itself is ill-formed. However, we'll try to be helpful still by |
8913 | // providing the list of all of the categories we know about. |
8914 | NamedDecl *CurClass = SemaRef.LookupSingleName( |
8915 | S: SemaRef.TUScope, Name: ClassName, Loc: ClassNameLoc, NameKind: Sema::LookupOrdinaryName); |
8916 | ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(Val: CurClass); |
8917 | if (!Class) |
8918 | return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc); |
8919 | |
8920 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
8921 | CodeCompleter->getCodeCompletionTUInfo(), |
8922 | CodeCompletionContext::CCC_ObjCCategoryName); |
8923 | |
8924 | // Add all of the categories that have corresponding interface |
8925 | // declarations in this class and any of its superclasses, except for |
8926 | // already-implemented categories in the class itself. |
8927 | llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames; |
8928 | Results.EnterNewScope(); |
8929 | bool IgnoreImplemented = true; |
8930 | while (Class) { |
8931 | for (const auto *Cat : Class->visible_categories()) { |
8932 | if ((!IgnoreImplemented || !Cat->getImplementation()) && |
8933 | CategoryNames.insert(Cat->getIdentifier()).second) |
8934 | Results.AddResult(R: Result(Cat, Results.getBasePriority(Cat), nullptr), |
8935 | CurContext: SemaRef.CurContext, Hiding: nullptr, InBaseClass: false); |
8936 | } |
8937 | |
8938 | Class = Class->getSuperClass(); |
8939 | IgnoreImplemented = false; |
8940 | } |
8941 | Results.ExitScope(); |
8942 | |
8943 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
8944 | Context: Results.getCompletionContext(), Results: Results.data(), |
8945 | NumResults: Results.size()); |
8946 | } |
8947 | |
8948 | void SemaCodeCompletion::CodeCompleteObjCPropertyDefinition(Scope *S) { |
8949 | CodeCompletionContext CCContext(CodeCompletionContext::CCC_Other); |
8950 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
8951 | CodeCompleter->getCodeCompletionTUInfo(), CCContext); |
8952 | |
8953 | // Figure out where this @synthesize lives. |
8954 | ObjCContainerDecl *Container = |
8955 | dyn_cast_or_null<ObjCContainerDecl>(Val: SemaRef.CurContext); |
8956 | if (!Container || (!isa<ObjCImplementationDecl>(Val: Container) && |
8957 | !isa<ObjCCategoryImplDecl>(Val: Container))) |
8958 | return; |
8959 | |
8960 | // Ignore any properties that have already been implemented. |
8961 | Container = getContainerDef(Container); |
8962 | for (const auto *D : Container->decls()) |
8963 | if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D)) |
8964 | Results.Ignore(PropertyImpl->getPropertyDecl()); |
8965 | |
8966 | // Add any properties that we find. |
8967 | AddedPropertiesSet AddedProperties; |
8968 | Results.EnterNewScope(); |
8969 | if (ObjCImplementationDecl *ClassImpl = |
8970 | dyn_cast<ObjCImplementationDecl>(Val: Container)) |
8971 | AddObjCProperties(CCContext, ClassImpl->getClassInterface(), false, |
8972 | /*AllowNullaryMethods=*/false, SemaRef.CurContext, |
8973 | AddedProperties, Results); |
8974 | else |
8975 | AddObjCProperties(CCContext, |
8976 | cast<ObjCCategoryImplDecl>(Val: Container)->getCategoryDecl(), |
8977 | false, /*AllowNullaryMethods=*/false, SemaRef.CurContext, |
8978 | AddedProperties, Results); |
8979 | Results.ExitScope(); |
8980 | |
8981 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
8982 | Context: Results.getCompletionContext(), Results: Results.data(), |
8983 | NumResults: Results.size()); |
8984 | } |
8985 | |
8986 | void SemaCodeCompletion::CodeCompleteObjCPropertySynthesizeIvar( |
8987 | Scope *S, IdentifierInfo *PropertyName) { |
8988 | typedef CodeCompletionResult Result; |
8989 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
8990 | CodeCompleter->getCodeCompletionTUInfo(), |
8991 | CodeCompletionContext::CCC_Other); |
8992 | |
8993 | // Figure out where this @synthesize lives. |
8994 | ObjCContainerDecl *Container = |
8995 | dyn_cast_or_null<ObjCContainerDecl>(Val: SemaRef.CurContext); |
8996 | if (!Container || (!isa<ObjCImplementationDecl>(Val: Container) && |
8997 | !isa<ObjCCategoryImplDecl>(Val: Container))) |
8998 | return; |
8999 | |
9000 | // Figure out which interface we're looking into. |
9001 | ObjCInterfaceDecl *Class = nullptr; |
9002 | if (ObjCImplementationDecl *ClassImpl = |
9003 | dyn_cast<ObjCImplementationDecl>(Val: Container)) |
9004 | Class = ClassImpl->getClassInterface(); |
9005 | else |
9006 | Class = cast<ObjCCategoryImplDecl>(Val: Container) |
9007 | ->getCategoryDecl() |
9008 | ->getClassInterface(); |
9009 | |
9010 | // Determine the type of the property we're synthesizing. |
9011 | QualType PropertyType = getASTContext().getObjCIdType(); |
9012 | if (Class) { |
9013 | if (ObjCPropertyDecl *Property = Class->FindPropertyDeclaration( |
9014 | PropertyName, ObjCPropertyQueryKind::OBJC_PR_query_instance)) { |
9015 | PropertyType = |
9016 | Property->getType().getNonReferenceType().getUnqualifiedType(); |
9017 | |
9018 | // Give preference to ivars |
9019 | Results.setPreferredType(PropertyType); |
9020 | } |
9021 | } |
9022 | |
9023 | // Add all of the instance variables in this class and its superclasses. |
9024 | Results.EnterNewScope(); |
9025 | bool SawSimilarlyNamedIvar = false; |
9026 | std::string NameWithPrefix; |
9027 | NameWithPrefix += '_'; |
9028 | NameWithPrefix += PropertyName->getName(); |
9029 | std::string NameWithSuffix = PropertyName->getName().str(); |
9030 | NameWithSuffix += '_'; |
9031 | for (; Class; Class = Class->getSuperClass()) { |
9032 | for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar; |
9033 | Ivar = Ivar->getNextIvar()) { |
9034 | Results.AddResult(R: Result(Ivar, Results.getBasePriority(Ivar), nullptr), |
9035 | CurContext: SemaRef.CurContext, Hiding: nullptr, InBaseClass: false); |
9036 | |
9037 | // Determine whether we've seen an ivar with a name similar to the |
9038 | // property. |
9039 | if ((PropertyName == Ivar->getIdentifier() || |
9040 | NameWithPrefix == Ivar->getName() || |
9041 | NameWithSuffix == Ivar->getName())) { |
9042 | SawSimilarlyNamedIvar = true; |
9043 | |
9044 | // Reduce the priority of this result by one, to give it a slight |
9045 | // advantage over other results whose names don't match so closely. |
9046 | if (Results.size() && |
9047 | Results.data()[Results.size() - 1].Kind == |
9048 | CodeCompletionResult::RK_Declaration && |
9049 | Results.data()[Results.size() - 1].Declaration == Ivar) |
9050 | Results.data()[Results.size() - 1].Priority--; |
9051 | } |
9052 | } |
9053 | } |
9054 | |
9055 | if (!SawSimilarlyNamedIvar) { |
9056 | // Create ivar result _propName, that the user can use to synthesize |
9057 | // an ivar of the appropriate type. |
9058 | unsigned Priority = CCP_MemberDeclaration + 1; |
9059 | typedef CodeCompletionResult Result; |
9060 | CodeCompletionAllocator &Allocator = Results.getAllocator(); |
9061 | CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(), |
9062 | Priority, CXAvailability_Available); |
9063 | |
9064 | PrintingPolicy Policy = getCompletionPrintingPolicy(S&: SemaRef); |
9065 | Builder.AddResultTypeChunk(ResultType: GetCompletionTypeString( |
9066 | T: PropertyType, Context&: getASTContext(), Policy, Allocator)); |
9067 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: NameWithPrefix)); |
9068 | Results.AddResult( |
9069 | R: Result(Builder.TakeString(), Priority, CXCursor_ObjCIvarDecl)); |
9070 | } |
9071 | |
9072 | Results.ExitScope(); |
9073 | |
9074 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
9075 | Context: Results.getCompletionContext(), Results: Results.data(), |
9076 | NumResults: Results.size()); |
9077 | } |
9078 | |
9079 | // Mapping from selectors to the methods that implement that selector, along |
9080 | // with the "in original class" flag. |
9081 | typedef llvm::DenseMap<Selector, |
9082 | llvm::PointerIntPair<ObjCMethodDecl *, 1, bool>> |
9083 | KnownMethodsMap; |
9084 | |
9085 | /// Find all of the methods that reside in the given container |
9086 | /// (and its superclasses, protocols, etc.) that meet the given |
9087 | /// criteria. Insert those methods into the map of known methods, |
9088 | /// indexed by selector so they can be easily found. |
9089 | static void FindImplementableMethods(ASTContext &Context, |
9090 | ObjCContainerDecl *Container, |
9091 | std::optional<bool> WantInstanceMethods, |
9092 | QualType ReturnType, |
9093 | KnownMethodsMap &KnownMethods, |
9094 | bool InOriginalClass = true) { |
9095 | if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Val: Container)) { |
9096 | // Make sure we have a definition; that's what we'll walk. |
9097 | if (!IFace->hasDefinition()) |
9098 | return; |
9099 | |
9100 | IFace = IFace->getDefinition(); |
9101 | Container = IFace; |
9102 | |
9103 | const ObjCList<ObjCProtocolDecl> &Protocols = |
9104 | IFace->getReferencedProtocols(); |
9105 | for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), |
9106 | E = Protocols.end(); |
9107 | I != E; ++I) |
9108 | FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType, |
9109 | KnownMethods, InOriginalClass); |
9110 | |
9111 | // Add methods from any class extensions and categories. |
9112 | for (auto *Cat : IFace->visible_categories()) { |
9113 | FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType, |
9114 | KnownMethods, false); |
9115 | } |
9116 | |
9117 | // Visit the superclass. |
9118 | if (IFace->getSuperClass()) |
9119 | FindImplementableMethods(Context, IFace->getSuperClass(), |
9120 | WantInstanceMethods, ReturnType, KnownMethods, |
9121 | false); |
9122 | } |
9123 | |
9124 | if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Val: Container)) { |
9125 | // Recurse into protocols. |
9126 | const ObjCList<ObjCProtocolDecl> &Protocols = |
9127 | Category->getReferencedProtocols(); |
9128 | for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), |
9129 | E = Protocols.end(); |
9130 | I != E; ++I) |
9131 | FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType, |
9132 | KnownMethods, InOriginalClass); |
9133 | |
9134 | // If this category is the original class, jump to the interface. |
9135 | if (InOriginalClass && Category->getClassInterface()) |
9136 | FindImplementableMethods(Context, Category->getClassInterface(), |
9137 | WantInstanceMethods, ReturnType, KnownMethods, |
9138 | false); |
9139 | } |
9140 | |
9141 | if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Val: Container)) { |
9142 | // Make sure we have a definition; that's what we'll walk. |
9143 | if (!Protocol->hasDefinition()) |
9144 | return; |
9145 | Protocol = Protocol->getDefinition(); |
9146 | Container = Protocol; |
9147 | |
9148 | // Recurse into protocols. |
9149 | const ObjCList<ObjCProtocolDecl> &Protocols = |
9150 | Protocol->getReferencedProtocols(); |
9151 | for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), |
9152 | E = Protocols.end(); |
9153 | I != E; ++I) |
9154 | FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType, |
9155 | KnownMethods, false); |
9156 | } |
9157 | |
9158 | // Add methods in this container. This operation occurs last because |
9159 | // we want the methods from this container to override any methods |
9160 | // we've previously seen with the same selector. |
9161 | for (auto *M : Container->methods()) { |
9162 | if (!WantInstanceMethods || M->isInstanceMethod() == *WantInstanceMethods) { |
9163 | if (!ReturnType.isNull() && |
9164 | !Context.hasSameUnqualifiedType(T1: ReturnType, T2: M->getReturnType())) |
9165 | continue; |
9166 | |
9167 | KnownMethods[M->getSelector()] = |
9168 | KnownMethodsMap::mapped_type(M, InOriginalClass); |
9169 | } |
9170 | } |
9171 | } |
9172 | |
9173 | /// Add the parenthesized return or parameter type chunk to a code |
9174 | /// completion string. |
9175 | static void AddObjCPassingTypeChunk(QualType Type, unsigned ObjCDeclQuals, |
9176 | ASTContext &Context, |
9177 | const PrintingPolicy &Policy, |
9178 | CodeCompletionBuilder &Builder) { |
9179 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9180 | std::string Quals = formatObjCParamQualifiers(ObjCQuals: ObjCDeclQuals, Type); |
9181 | if (!Quals.empty()) |
9182 | Builder.AddTextChunk(Text: Builder.getAllocator().CopyString(String: Quals)); |
9183 | Builder.AddTextChunk( |
9184 | Text: GetCompletionTypeString(T: Type, Context, Policy, Allocator&: Builder.getAllocator())); |
9185 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9186 | } |
9187 | |
9188 | /// Determine whether the given class is or inherits from a class by |
9189 | /// the given name. |
9190 | static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class, StringRef Name) { |
9191 | if (!Class) |
9192 | return false; |
9193 | |
9194 | if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name) |
9195 | return true; |
9196 | |
9197 | return InheritsFromClassNamed(Class: Class->getSuperClass(), Name); |
9198 | } |
9199 | |
9200 | /// Add code completions for Objective-C Key-Value Coding (KVC) and |
9201 | /// Key-Value Observing (KVO). |
9202 | static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property, |
9203 | bool IsInstanceMethod, |
9204 | QualType ReturnType, ASTContext &Context, |
9205 | VisitedSelectorSet &KnownSelectors, |
9206 | ResultBuilder &Results) { |
9207 | IdentifierInfo *PropName = Property->getIdentifier(); |
9208 | if (!PropName || PropName->getLength() == 0) |
9209 | return; |
9210 | |
9211 | PrintingPolicy Policy = getCompletionPrintingPolicy(S&: Results.getSema()); |
9212 | |
9213 | // Builder that will create each code completion. |
9214 | typedef CodeCompletionResult Result; |
9215 | CodeCompletionAllocator &Allocator = Results.getAllocator(); |
9216 | CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo()); |
9217 | |
9218 | // The selector table. |
9219 | SelectorTable &Selectors = Context.Selectors; |
9220 | |
9221 | // The property name, copied into the code completion allocation region |
9222 | // on demand. |
9223 | struct KeyHolder { |
9224 | CodeCompletionAllocator &Allocator; |
9225 | StringRef Key; |
9226 | const char *CopiedKey; |
9227 | |
9228 | KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key) |
9229 | : Allocator(Allocator), Key(Key), CopiedKey(nullptr) {} |
9230 | |
9231 | operator const char *() { |
9232 | if (CopiedKey) |
9233 | return CopiedKey; |
9234 | |
9235 | return CopiedKey = Allocator.CopyString(String: Key); |
9236 | } |
9237 | } Key(Allocator, PropName->getName()); |
9238 | |
9239 | // The uppercased name of the property name. |
9240 | std::string UpperKey = std::string(PropName->getName()); |
9241 | if (!UpperKey.empty()) |
9242 | UpperKey[0] = toUppercase(c: UpperKey[0]); |
9243 | |
9244 | bool ReturnTypeMatchesProperty = |
9245 | ReturnType.isNull() || |
9246 | Context.hasSameUnqualifiedType(T1: ReturnType.getNonReferenceType(), |
9247 | T2: Property->getType()); |
9248 | bool ReturnTypeMatchesVoid = ReturnType.isNull() || ReturnType->isVoidType(); |
9249 | |
9250 | // Add the normal accessor -(type)key. |
9251 | if (IsInstanceMethod && |
9252 | KnownSelectors.insert(Ptr: Selectors.getNullarySelector(ID: PropName)).second && |
9253 | ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) { |
9254 | if (ReturnType.isNull()) |
9255 | AddObjCPassingTypeChunk(Type: Property->getType(), /*Quals=*/ObjCDeclQuals: 0, Context, Policy, |
9256 | Builder); |
9257 | |
9258 | Builder.AddTypedTextChunk(Text: Key); |
9259 | Results.AddResult(R: Result(Builder.TakeString(), CCP_CodePattern, |
9260 | CXCursor_ObjCInstanceMethodDecl)); |
9261 | } |
9262 | |
9263 | // If we have an integral or boolean property (or the user has provided |
9264 | // an integral or boolean return type), add the accessor -(type)isKey. |
9265 | if (IsInstanceMethod && |
9266 | ((!ReturnType.isNull() && |
9267 | (ReturnType->isIntegerType() || ReturnType->isBooleanType())) || |
9268 | (ReturnType.isNull() && (Property->getType()->isIntegerType() || |
9269 | Property->getType()->isBooleanType())))) { |
9270 | std::string SelectorName = (Twine("is") + UpperKey).str(); |
9271 | IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9272 | if (KnownSelectors.insert(Ptr: Selectors.getNullarySelector(ID: SelectorId)) |
9273 | .second) { |
9274 | if (ReturnType.isNull()) { |
9275 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9276 | Builder.AddTextChunk(Text: "BOOL"); |
9277 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9278 | } |
9279 | |
9280 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorId->getName())); |
9281 | Results.AddResult(R: Result(Builder.TakeString(), CCP_CodePattern, |
9282 | CXCursor_ObjCInstanceMethodDecl)); |
9283 | } |
9284 | } |
9285 | |
9286 | // Add the normal mutator. |
9287 | if (IsInstanceMethod && ReturnTypeMatchesVoid && |
9288 | !Property->getSetterMethodDecl()) { |
9289 | std::string SelectorName = (Twine("set") + UpperKey).str(); |
9290 | IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9291 | if (KnownSelectors.insert(Ptr: Selectors.getUnarySelector(ID: SelectorId)).second) { |
9292 | if (ReturnType.isNull()) { |
9293 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9294 | Builder.AddTextChunk(Text: "void"); |
9295 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9296 | } |
9297 | |
9298 | Builder.AddTypedTextChunk( |
9299 | Text: Allocator.CopyString(String: SelectorId->getName() + ":")); |
9300 | AddObjCPassingTypeChunk(Type: Property->getType(), /*Quals=*/ObjCDeclQuals: 0, Context, Policy, |
9301 | Builder); |
9302 | Builder.AddTextChunk(Text: Key); |
9303 | Results.AddResult(R: Result(Builder.TakeString(), CCP_CodePattern, |
9304 | CXCursor_ObjCInstanceMethodDecl)); |
9305 | } |
9306 | } |
9307 | |
9308 | // Indexed and unordered accessors |
9309 | unsigned IndexedGetterPriority = CCP_CodePattern; |
9310 | unsigned IndexedSetterPriority = CCP_CodePattern; |
9311 | unsigned UnorderedGetterPriority = CCP_CodePattern; |
9312 | unsigned UnorderedSetterPriority = CCP_CodePattern; |
9313 | if (const auto *ObjCPointer = |
9314 | Property->getType()->getAs<ObjCObjectPointerType>()) { |
9315 | if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) { |
9316 | // If this interface type is not provably derived from a known |
9317 | // collection, penalize the corresponding completions. |
9318 | if (!InheritsFromClassNamed(Class: IFace, Name: "NSMutableArray")) { |
9319 | IndexedSetterPriority += CCD_ProbablyNotObjCCollection; |
9320 | if (!InheritsFromClassNamed(Class: IFace, Name: "NSArray")) |
9321 | IndexedGetterPriority += CCD_ProbablyNotObjCCollection; |
9322 | } |
9323 | |
9324 | if (!InheritsFromClassNamed(Class: IFace, Name: "NSMutableSet")) { |
9325 | UnorderedSetterPriority += CCD_ProbablyNotObjCCollection; |
9326 | if (!InheritsFromClassNamed(Class: IFace, Name: "NSSet")) |
9327 | UnorderedGetterPriority += CCD_ProbablyNotObjCCollection; |
9328 | } |
9329 | } |
9330 | } else { |
9331 | IndexedGetterPriority += CCD_ProbablyNotObjCCollection; |
9332 | IndexedSetterPriority += CCD_ProbablyNotObjCCollection; |
9333 | UnorderedGetterPriority += CCD_ProbablyNotObjCCollection; |
9334 | UnorderedSetterPriority += CCD_ProbablyNotObjCCollection; |
9335 | } |
9336 | |
9337 | // Add -(NSUInteger)countOf<key> |
9338 | if (IsInstanceMethod && |
9339 | (ReturnType.isNull() || ReturnType->isIntegerType())) { |
9340 | std::string SelectorName = (Twine("countOf") + UpperKey).str(); |
9341 | IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9342 | if (KnownSelectors.insert(Ptr: Selectors.getNullarySelector(ID: SelectorId)) |
9343 | .second) { |
9344 | if (ReturnType.isNull()) { |
9345 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9346 | Builder.AddTextChunk(Text: "NSUInteger"); |
9347 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9348 | } |
9349 | |
9350 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorId->getName())); |
9351 | Results.AddResult( |
9352 | R: Result(Builder.TakeString(), |
9353 | std::min(a: IndexedGetterPriority, b: UnorderedGetterPriority), |
9354 | CXCursor_ObjCInstanceMethodDecl)); |
9355 | } |
9356 | } |
9357 | |
9358 | // Indexed getters |
9359 | // Add -(id)objectInKeyAtIndex:(NSUInteger)index |
9360 | if (IsInstanceMethod && |
9361 | (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) { |
9362 | std::string SelectorName = (Twine("objectIn") + UpperKey + "AtIndex").str(); |
9363 | IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9364 | if (KnownSelectors.insert(Ptr: Selectors.getUnarySelector(ID: SelectorId)).second) { |
9365 | if (ReturnType.isNull()) { |
9366 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9367 | Builder.AddTextChunk(Text: "id"); |
9368 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9369 | } |
9370 | |
9371 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName + ":")); |
9372 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9373 | Builder.AddTextChunk(Text: "NSUInteger"); |
9374 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9375 | Builder.AddTextChunk(Text: "index"); |
9376 | Results.AddResult(R: Result(Builder.TakeString(), IndexedGetterPriority, |
9377 | CXCursor_ObjCInstanceMethodDecl)); |
9378 | } |
9379 | } |
9380 | |
9381 | // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes |
9382 | if (IsInstanceMethod && |
9383 | (ReturnType.isNull() || |
9384 | (ReturnType->isObjCObjectPointerType() && |
9385 | ReturnType->castAs<ObjCObjectPointerType>()->getInterfaceDecl() && |
9386 | ReturnType->castAs<ObjCObjectPointerType>() |
9387 | ->getInterfaceDecl() |
9388 | ->getName() == "NSArray"))) { |
9389 | std::string SelectorName = (Twine(Property->getName()) + "AtIndexes").str(); |
9390 | IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9391 | if (KnownSelectors.insert(Ptr: Selectors.getUnarySelector(ID: SelectorId)).second) { |
9392 | if (ReturnType.isNull()) { |
9393 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9394 | Builder.AddTextChunk(Text: "NSArray *"); |
9395 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9396 | } |
9397 | |
9398 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName + ":")); |
9399 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9400 | Builder.AddTextChunk(Text: "NSIndexSet *"); |
9401 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9402 | Builder.AddTextChunk(Text: "indexes"); |
9403 | Results.AddResult(R: Result(Builder.TakeString(), IndexedGetterPriority, |
9404 | CXCursor_ObjCInstanceMethodDecl)); |
9405 | } |
9406 | } |
9407 | |
9408 | // Add -(void)getKey:(type **)buffer range:(NSRange)inRange |
9409 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { |
9410 | std::string SelectorName = (Twine("get") + UpperKey).str(); |
9411 | const IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(Name: SelectorName), |
9412 | &Context.Idents.get(Name: "range")}; |
9413 | |
9414 | if (KnownSelectors.insert(Ptr: Selectors.getSelector(NumArgs: 2, IIV: SelectorIds)).second) { |
9415 | if (ReturnType.isNull()) { |
9416 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9417 | Builder.AddTextChunk(Text: "void"); |
9418 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9419 | } |
9420 | |
9421 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName + ":")); |
9422 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9423 | Builder.AddPlaceholderChunk(Placeholder: "object-type"); |
9424 | Builder.AddTextChunk(Text: " **"); |
9425 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9426 | Builder.AddTextChunk(Text: "buffer"); |
9427 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
9428 | Builder.AddTypedTextChunk(Text: "range:"); |
9429 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9430 | Builder.AddTextChunk(Text: "NSRange"); |
9431 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9432 | Builder.AddTextChunk(Text: "inRange"); |
9433 | Results.AddResult(R: Result(Builder.TakeString(), IndexedGetterPriority, |
9434 | CXCursor_ObjCInstanceMethodDecl)); |
9435 | } |
9436 | } |
9437 | |
9438 | // Mutable indexed accessors |
9439 | |
9440 | // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index |
9441 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { |
9442 | std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str(); |
9443 | const IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(Name: "insertObject"), |
9444 | &Context.Idents.get(Name: SelectorName)}; |
9445 | |
9446 | if (KnownSelectors.insert(Ptr: Selectors.getSelector(NumArgs: 2, IIV: SelectorIds)).second) { |
9447 | if (ReturnType.isNull()) { |
9448 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9449 | Builder.AddTextChunk(Text: "void"); |
9450 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9451 | } |
9452 | |
9453 | Builder.AddTypedTextChunk(Text: "insertObject:"); |
9454 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9455 | Builder.AddPlaceholderChunk(Placeholder: "object-type"); |
9456 | Builder.AddTextChunk(Text: " *"); |
9457 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9458 | Builder.AddTextChunk(Text: "object"); |
9459 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
9460 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName + ":")); |
9461 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9462 | Builder.AddPlaceholderChunk(Placeholder: "NSUInteger"); |
9463 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9464 | Builder.AddTextChunk(Text: "index"); |
9465 | Results.AddResult(R: Result(Builder.TakeString(), IndexedSetterPriority, |
9466 | CXCursor_ObjCInstanceMethodDecl)); |
9467 | } |
9468 | } |
9469 | |
9470 | // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes |
9471 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { |
9472 | std::string SelectorName = (Twine("insert") + UpperKey).str(); |
9473 | const IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(Name: SelectorName), |
9474 | &Context.Idents.get(Name: "atIndexes")}; |
9475 | |
9476 | if (KnownSelectors.insert(Ptr: Selectors.getSelector(NumArgs: 2, IIV: SelectorIds)).second) { |
9477 | if (ReturnType.isNull()) { |
9478 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9479 | Builder.AddTextChunk(Text: "void"); |
9480 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9481 | } |
9482 | |
9483 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName + ":")); |
9484 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9485 | Builder.AddTextChunk(Text: "NSArray *"); |
9486 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9487 | Builder.AddTextChunk(Text: "array"); |
9488 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
9489 | Builder.AddTypedTextChunk(Text: "atIndexes:"); |
9490 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9491 | Builder.AddPlaceholderChunk(Placeholder: "NSIndexSet *"); |
9492 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9493 | Builder.AddTextChunk(Text: "indexes"); |
9494 | Results.AddResult(R: Result(Builder.TakeString(), IndexedSetterPriority, |
9495 | CXCursor_ObjCInstanceMethodDecl)); |
9496 | } |
9497 | } |
9498 | |
9499 | // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index |
9500 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { |
9501 | std::string SelectorName = |
9502 | (Twine("removeObjectFrom") + UpperKey + "AtIndex").str(); |
9503 | const IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9504 | if (KnownSelectors.insert(Ptr: Selectors.getUnarySelector(ID: SelectorId)).second) { |
9505 | if (ReturnType.isNull()) { |
9506 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9507 | Builder.AddTextChunk(Text: "void"); |
9508 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9509 | } |
9510 | |
9511 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName + ":")); |
9512 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9513 | Builder.AddTextChunk(Text: "NSUInteger"); |
9514 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9515 | Builder.AddTextChunk(Text: "index"); |
9516 | Results.AddResult(R: Result(Builder.TakeString(), IndexedSetterPriority, |
9517 | CXCursor_ObjCInstanceMethodDecl)); |
9518 | } |
9519 | } |
9520 | |
9521 | // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes |
9522 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { |
9523 | std::string SelectorName = (Twine("remove") + UpperKey + "AtIndexes").str(); |
9524 | const IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9525 | if (KnownSelectors.insert(Ptr: Selectors.getUnarySelector(ID: SelectorId)).second) { |
9526 | if (ReturnType.isNull()) { |
9527 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9528 | Builder.AddTextChunk(Text: "void"); |
9529 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9530 | } |
9531 | |
9532 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName + ":")); |
9533 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9534 | Builder.AddTextChunk(Text: "NSIndexSet *"); |
9535 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9536 | Builder.AddTextChunk(Text: "indexes"); |
9537 | Results.AddResult(R: Result(Builder.TakeString(), IndexedSetterPriority, |
9538 | CXCursor_ObjCInstanceMethodDecl)); |
9539 | } |
9540 | } |
9541 | |
9542 | // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object |
9543 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { |
9544 | std::string SelectorName = |
9545 | (Twine("replaceObjectIn") + UpperKey + "AtIndex").str(); |
9546 | const IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(Name: SelectorName), |
9547 | &Context.Idents.get(Name: "withObject")}; |
9548 | |
9549 | if (KnownSelectors.insert(Ptr: Selectors.getSelector(NumArgs: 2, IIV: SelectorIds)).second) { |
9550 | if (ReturnType.isNull()) { |
9551 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9552 | Builder.AddTextChunk(Text: "void"); |
9553 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9554 | } |
9555 | |
9556 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName + ":")); |
9557 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9558 | Builder.AddPlaceholderChunk(Placeholder: "NSUInteger"); |
9559 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9560 | Builder.AddTextChunk(Text: "index"); |
9561 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
9562 | Builder.AddTypedTextChunk(Text: "withObject:"); |
9563 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9564 | Builder.AddTextChunk(Text: "id"); |
9565 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9566 | Builder.AddTextChunk(Text: "object"); |
9567 | Results.AddResult(R: Result(Builder.TakeString(), IndexedSetterPriority, |
9568 | CXCursor_ObjCInstanceMethodDecl)); |
9569 | } |
9570 | } |
9571 | |
9572 | // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array |
9573 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { |
9574 | std::string SelectorName1 = |
9575 | (Twine("replace") + UpperKey + "AtIndexes").str(); |
9576 | std::string SelectorName2 = (Twine("with") + UpperKey).str(); |
9577 | const IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(Name: SelectorName1), |
9578 | &Context.Idents.get(Name: SelectorName2)}; |
9579 | |
9580 | if (KnownSelectors.insert(Ptr: Selectors.getSelector(NumArgs: 2, IIV: SelectorIds)).second) { |
9581 | if (ReturnType.isNull()) { |
9582 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9583 | Builder.AddTextChunk(Text: "void"); |
9584 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9585 | } |
9586 | |
9587 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName1 + ":")); |
9588 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9589 | Builder.AddPlaceholderChunk(Placeholder: "NSIndexSet *"); |
9590 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9591 | Builder.AddTextChunk(Text: "indexes"); |
9592 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
9593 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName2 + ":")); |
9594 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9595 | Builder.AddTextChunk(Text: "NSArray *"); |
9596 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9597 | Builder.AddTextChunk(Text: "array"); |
9598 | Results.AddResult(R: Result(Builder.TakeString(), IndexedSetterPriority, |
9599 | CXCursor_ObjCInstanceMethodDecl)); |
9600 | } |
9601 | } |
9602 | |
9603 | // Unordered getters |
9604 | // - (NSEnumerator *)enumeratorOfKey |
9605 | if (IsInstanceMethod && |
9606 | (ReturnType.isNull() || |
9607 | (ReturnType->isObjCObjectPointerType() && |
9608 | ReturnType->castAs<ObjCObjectPointerType>()->getInterfaceDecl() && |
9609 | ReturnType->castAs<ObjCObjectPointerType>() |
9610 | ->getInterfaceDecl() |
9611 | ->getName() == "NSEnumerator"))) { |
9612 | std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str(); |
9613 | const IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9614 | if (KnownSelectors.insert(Ptr: Selectors.getNullarySelector(ID: SelectorId)) |
9615 | .second) { |
9616 | if (ReturnType.isNull()) { |
9617 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9618 | Builder.AddTextChunk(Text: "NSEnumerator *"); |
9619 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9620 | } |
9621 | |
9622 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName)); |
9623 | Results.AddResult(R: Result(Builder.TakeString(), UnorderedGetterPriority, |
9624 | CXCursor_ObjCInstanceMethodDecl)); |
9625 | } |
9626 | } |
9627 | |
9628 | // - (type *)memberOfKey:(type *)object |
9629 | if (IsInstanceMethod && |
9630 | (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) { |
9631 | std::string SelectorName = (Twine("memberOf") + UpperKey).str(); |
9632 | const IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9633 | if (KnownSelectors.insert(Ptr: Selectors.getUnarySelector(ID: SelectorId)).second) { |
9634 | if (ReturnType.isNull()) { |
9635 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9636 | Builder.AddPlaceholderChunk(Placeholder: "object-type"); |
9637 | Builder.AddTextChunk(Text: " *"); |
9638 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9639 | } |
9640 | |
9641 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName + ":")); |
9642 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9643 | if (ReturnType.isNull()) { |
9644 | Builder.AddPlaceholderChunk(Placeholder: "object-type"); |
9645 | Builder.AddTextChunk(Text: " *"); |
9646 | } else { |
9647 | Builder.AddTextChunk(Text: GetCompletionTypeString( |
9648 | T: ReturnType, Context, Policy, Allocator&: Builder.getAllocator())); |
9649 | } |
9650 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9651 | Builder.AddTextChunk(Text: "object"); |
9652 | Results.AddResult(R: Result(Builder.TakeString(), UnorderedGetterPriority, |
9653 | CXCursor_ObjCInstanceMethodDecl)); |
9654 | } |
9655 | } |
9656 | |
9657 | // Mutable unordered accessors |
9658 | // - (void)addKeyObject:(type *)object |
9659 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { |
9660 | std::string SelectorName = |
9661 | (Twine("add") + UpperKey + Twine( "Object")).str(); |
9662 | const IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9663 | if (KnownSelectors.insert(Ptr: Selectors.getUnarySelector(ID: SelectorId)).second) { |
9664 | if (ReturnType.isNull()) { |
9665 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9666 | Builder.AddTextChunk(Text: "void"); |
9667 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9668 | } |
9669 | |
9670 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName + ":")); |
9671 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9672 | Builder.AddPlaceholderChunk(Placeholder: "object-type"); |
9673 | Builder.AddTextChunk(Text: " *"); |
9674 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9675 | Builder.AddTextChunk(Text: "object"); |
9676 | Results.AddResult(R: Result(Builder.TakeString(), UnorderedSetterPriority, |
9677 | CXCursor_ObjCInstanceMethodDecl)); |
9678 | } |
9679 | } |
9680 | |
9681 | // - (void)addKey:(NSSet *)objects |
9682 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { |
9683 | std::string SelectorName = (Twine("add") + UpperKey).str(); |
9684 | const IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9685 | if (KnownSelectors.insert(Ptr: Selectors.getUnarySelector(ID: SelectorId)).second) { |
9686 | if (ReturnType.isNull()) { |
9687 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9688 | Builder.AddTextChunk(Text: "void"); |
9689 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9690 | } |
9691 | |
9692 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName + ":")); |
9693 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9694 | Builder.AddTextChunk(Text: "NSSet *"); |
9695 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9696 | Builder.AddTextChunk(Text: "objects"); |
9697 | Results.AddResult(R: Result(Builder.TakeString(), UnorderedSetterPriority, |
9698 | CXCursor_ObjCInstanceMethodDecl)); |
9699 | } |
9700 | } |
9701 | |
9702 | // - (void)removeKeyObject:(type *)object |
9703 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { |
9704 | std::string SelectorName = |
9705 | (Twine("remove") + UpperKey + Twine( "Object")).str(); |
9706 | const IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9707 | if (KnownSelectors.insert(Ptr: Selectors.getUnarySelector(ID: SelectorId)).second) { |
9708 | if (ReturnType.isNull()) { |
9709 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9710 | Builder.AddTextChunk(Text: "void"); |
9711 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9712 | } |
9713 | |
9714 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName + ":")); |
9715 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9716 | Builder.AddPlaceholderChunk(Placeholder: "object-type"); |
9717 | Builder.AddTextChunk(Text: " *"); |
9718 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9719 | Builder.AddTextChunk(Text: "object"); |
9720 | Results.AddResult(R: Result(Builder.TakeString(), UnorderedSetterPriority, |
9721 | CXCursor_ObjCInstanceMethodDecl)); |
9722 | } |
9723 | } |
9724 | |
9725 | // - (void)removeKey:(NSSet *)objects |
9726 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { |
9727 | std::string SelectorName = (Twine("remove") + UpperKey).str(); |
9728 | const IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9729 | if (KnownSelectors.insert(Ptr: Selectors.getUnarySelector(ID: SelectorId)).second) { |
9730 | if (ReturnType.isNull()) { |
9731 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9732 | Builder.AddTextChunk(Text: "void"); |
9733 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9734 | } |
9735 | |
9736 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName + ":")); |
9737 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9738 | Builder.AddTextChunk(Text: "NSSet *"); |
9739 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9740 | Builder.AddTextChunk(Text: "objects"); |
9741 | Results.AddResult(R: Result(Builder.TakeString(), UnorderedSetterPriority, |
9742 | CXCursor_ObjCInstanceMethodDecl)); |
9743 | } |
9744 | } |
9745 | |
9746 | // - (void)intersectKey:(NSSet *)objects |
9747 | if (IsInstanceMethod && ReturnTypeMatchesVoid) { |
9748 | std::string SelectorName = (Twine("intersect") + UpperKey).str(); |
9749 | const IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9750 | if (KnownSelectors.insert(Ptr: Selectors.getUnarySelector(ID: SelectorId)).second) { |
9751 | if (ReturnType.isNull()) { |
9752 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9753 | Builder.AddTextChunk(Text: "void"); |
9754 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9755 | } |
9756 | |
9757 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName + ":")); |
9758 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9759 | Builder.AddTextChunk(Text: "NSSet *"); |
9760 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9761 | Builder.AddTextChunk(Text: "objects"); |
9762 | Results.AddResult(R: Result(Builder.TakeString(), UnorderedSetterPriority, |
9763 | CXCursor_ObjCInstanceMethodDecl)); |
9764 | } |
9765 | } |
9766 | |
9767 | // Key-Value Observing |
9768 | // + (NSSet *)keyPathsForValuesAffectingKey |
9769 | if (!IsInstanceMethod && |
9770 | (ReturnType.isNull() || |
9771 | (ReturnType->isObjCObjectPointerType() && |
9772 | ReturnType->castAs<ObjCObjectPointerType>()->getInterfaceDecl() && |
9773 | ReturnType->castAs<ObjCObjectPointerType>() |
9774 | ->getInterfaceDecl() |
9775 | ->getName() == "NSSet"))) { |
9776 | std::string SelectorName = |
9777 | (Twine("keyPathsForValuesAffecting") + UpperKey).str(); |
9778 | const IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9779 | if (KnownSelectors.insert(Ptr: Selectors.getNullarySelector(ID: SelectorId)) |
9780 | .second) { |
9781 | if (ReturnType.isNull()) { |
9782 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9783 | Builder.AddTextChunk(Text: "NSSet<NSString *> *"); |
9784 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9785 | } |
9786 | |
9787 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName)); |
9788 | Results.AddResult(R: Result(Builder.TakeString(), CCP_CodePattern, |
9789 | CXCursor_ObjCClassMethodDecl)); |
9790 | } |
9791 | } |
9792 | |
9793 | // + (BOOL)automaticallyNotifiesObserversForKey |
9794 | if (!IsInstanceMethod && |
9795 | (ReturnType.isNull() || ReturnType->isIntegerType() || |
9796 | ReturnType->isBooleanType())) { |
9797 | std::string SelectorName = |
9798 | (Twine("automaticallyNotifiesObserversOf") + UpperKey).str(); |
9799 | const IdentifierInfo *SelectorId = &Context.Idents.get(Name: SelectorName); |
9800 | if (KnownSelectors.insert(Ptr: Selectors.getNullarySelector(ID: SelectorId)) |
9801 | .second) { |
9802 | if (ReturnType.isNull()) { |
9803 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
9804 | Builder.AddTextChunk(Text: "BOOL"); |
9805 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
9806 | } |
9807 | |
9808 | Builder.AddTypedTextChunk(Text: Allocator.CopyString(String: SelectorName)); |
9809 | Results.AddResult(R: Result(Builder.TakeString(), CCP_CodePattern, |
9810 | CXCursor_ObjCClassMethodDecl)); |
9811 | } |
9812 | } |
9813 | } |
9814 | |
9815 | void SemaCodeCompletion::CodeCompleteObjCMethodDecl( |
9816 | Scope *S, std::optional<bool> IsInstanceMethod, ParsedType ReturnTy) { |
9817 | ASTContext &Context = getASTContext(); |
9818 | // Determine the return type of the method we're declaring, if |
9819 | // provided. |
9820 | QualType ReturnType = SemaRef.GetTypeFromParser(Ty: ReturnTy); |
9821 | Decl *IDecl = nullptr; |
9822 | if (SemaRef.CurContext->isObjCContainer()) { |
9823 | ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(Val: SemaRef.CurContext); |
9824 | IDecl = OCD; |
9825 | } |
9826 | // Determine where we should start searching for methods. |
9827 | ObjCContainerDecl *SearchDecl = nullptr; |
9828 | bool IsInImplementation = false; |
9829 | if (Decl *D = IDecl) { |
9830 | if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(Val: D)) { |
9831 | SearchDecl = Impl->getClassInterface(); |
9832 | IsInImplementation = true; |
9833 | } else if (ObjCCategoryImplDecl *CatImpl = |
9834 | dyn_cast<ObjCCategoryImplDecl>(Val: D)) { |
9835 | SearchDecl = CatImpl->getCategoryDecl(); |
9836 | IsInImplementation = true; |
9837 | } else |
9838 | SearchDecl = dyn_cast<ObjCContainerDecl>(Val: D); |
9839 | } |
9840 | |
9841 | if (!SearchDecl && S) { |
9842 | if (DeclContext *DC = S->getEntity()) |
9843 | SearchDecl = dyn_cast<ObjCContainerDecl>(Val: DC); |
9844 | } |
9845 | |
9846 | if (!SearchDecl) { |
9847 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
9848 | Context: CodeCompletionContext::CCC_Other, Results: nullptr, NumResults: 0); |
9849 | return; |
9850 | } |
9851 | |
9852 | // Find all of the methods that we could declare/implement here. |
9853 | KnownMethodsMap KnownMethods; |
9854 | FindImplementableMethods(Context, Container: SearchDecl, WantInstanceMethods: IsInstanceMethod, ReturnType, |
9855 | KnownMethods); |
9856 | |
9857 | // Add declarations or definitions for each of the known methods. |
9858 | typedef CodeCompletionResult Result; |
9859 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
9860 | CodeCompleter->getCodeCompletionTUInfo(), |
9861 | CodeCompletionContext::CCC_Other); |
9862 | Results.EnterNewScope(); |
9863 | PrintingPolicy Policy = getCompletionPrintingPolicy(S&: SemaRef); |
9864 | for (KnownMethodsMap::iterator M = KnownMethods.begin(), |
9865 | MEnd = KnownMethods.end(); |
9866 | M != MEnd; ++M) { |
9867 | ObjCMethodDecl *Method = M->second.getPointer(); |
9868 | CodeCompletionBuilder Builder(Results.getAllocator(), |
9869 | Results.getCodeCompletionTUInfo()); |
9870 | |
9871 | // Add the '-'/'+' prefix if it wasn't provided yet. |
9872 | if (!IsInstanceMethod) { |
9873 | Builder.AddTextChunk(Text: Method->isInstanceMethod() ? "-": "+"); |
9874 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
9875 | } |
9876 | |
9877 | // If the result type was not already provided, add it to the |
9878 | // pattern as (type). |
9879 | if (ReturnType.isNull()) { |
9880 | QualType ResTy = Method->getSendResultType().stripObjCKindOfType(ctx: Context); |
9881 | AttributedType::stripOuterNullability(T&: ResTy); |
9882 | AddObjCPassingTypeChunk(Type: ResTy, ObjCDeclQuals: Method->getObjCDeclQualifier(), Context, |
9883 | Policy, Builder); |
9884 | } |
9885 | |
9886 | Selector Sel = Method->getSelector(); |
9887 | |
9888 | if (Sel.isUnarySelector()) { |
9889 | // Unary selectors have no arguments. |
9890 | Builder.AddTypedTextChunk( |
9891 | Text: Builder.getAllocator().CopyString(String: Sel.getNameForSlot(argIndex: 0))); |
9892 | } else { |
9893 | // Add all parameters to the pattern. |
9894 | unsigned I = 0; |
9895 | for (ObjCMethodDecl::param_iterator P = Method->param_begin(), |
9896 | PEnd = Method->param_end(); |
9897 | P != PEnd; (void)++P, ++I) { |
9898 | // Add the part of the selector name. |
9899 | if (I == 0) |
9900 | Builder.AddTypedTextChunk( |
9901 | Text: Builder.getAllocator().CopyString(String: Sel.getNameForSlot(argIndex: I) + ":")); |
9902 | else if (I < Sel.getNumArgs()) { |
9903 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
9904 | Builder.AddTypedTextChunk( |
9905 | Text: Builder.getAllocator().CopyString(String: Sel.getNameForSlot(argIndex: I) + ":")); |
9906 | } else |
9907 | break; |
9908 | |
9909 | // Add the parameter type. |
9910 | QualType ParamType; |
9911 | if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) |
9912 | ParamType = (*P)->getType(); |
9913 | else |
9914 | ParamType = (*P)->getOriginalType(); |
9915 | ParamType = ParamType.substObjCTypeArgs( |
9916 | ctx&: Context, typeArgs: {}, context: ObjCSubstitutionContext::Parameter); |
9917 | AttributedType::stripOuterNullability(T&: ParamType); |
9918 | AddObjCPassingTypeChunk(Type: ParamType, ObjCDeclQuals: (*P)->getObjCDeclQualifier(), |
9919 | Context, Policy, Builder); |
9920 | |
9921 | if (IdentifierInfo *Id = (*P)->getIdentifier()) |
9922 | Builder.AddTextChunk( |
9923 | Text: Builder.getAllocator().CopyString(String: Id->getName())); |
9924 | } |
9925 | } |
9926 | |
9927 | if (Method->isVariadic()) { |
9928 | if (Method->param_size() > 0) |
9929 | Builder.AddChunk(CK: CodeCompletionString::CK_Comma); |
9930 | Builder.AddTextChunk(Text: "..."); |
9931 | } |
9932 | |
9933 | if (IsInImplementation && Results.includeCodePatterns()) { |
9934 | // We will be defining the method here, so add a compound statement. |
9935 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
9936 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftBrace); |
9937 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
9938 | if (!Method->getReturnType()->isVoidType()) { |
9939 | // If the result type is not void, add a return clause. |
9940 | Builder.AddTextChunk(Text: "return"); |
9941 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
9942 | Builder.AddPlaceholderChunk(Placeholder: "expression"); |
9943 | Builder.AddChunk(CK: CodeCompletionString::CK_SemiColon); |
9944 | } else |
9945 | Builder.AddPlaceholderChunk(Placeholder: "statements"); |
9946 | |
9947 | Builder.AddChunk(CK: CodeCompletionString::CK_VerticalSpace); |
9948 | Builder.AddChunk(CK: CodeCompletionString::CK_RightBrace); |
9949 | } |
9950 | |
9951 | unsigned Priority = CCP_CodePattern; |
9952 | auto R = Result(Builder.TakeString(), Method, Priority); |
9953 | if (!M->second.getInt()) |
9954 | setInBaseClass(R); |
9955 | Results.AddResult(std::move(R)); |
9956 | } |
9957 | |
9958 | // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of |
9959 | // the properties in this class and its categories. |
9960 | if (Context.getLangOpts().ObjC) { |
9961 | SmallVector<ObjCContainerDecl *, 4> Containers; |
9962 | Containers.push_back(Elt: SearchDecl); |
9963 | |
9964 | VisitedSelectorSet KnownSelectors; |
9965 | for (KnownMethodsMap::iterator M = KnownMethods.begin(), |
9966 | MEnd = KnownMethods.end(); |
9967 | M != MEnd; ++M) |
9968 | KnownSelectors.insert(M->first); |
9969 | |
9970 | ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Val: SearchDecl); |
9971 | if (!IFace) |
9972 | if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Val: SearchDecl)) |
9973 | IFace = Category->getClassInterface(); |
9974 | |
9975 | if (IFace) |
9976 | llvm::append_range(C&: Containers, R: IFace->visible_categories()); |
9977 | |
9978 | if (IsInstanceMethod) { |
9979 | for (unsigned I = 0, N = Containers.size(); I != N; ++I) |
9980 | for (auto *P : Containers[I]->instance_properties()) |
9981 | AddObjCKeyValueCompletions(Property: P, IsInstanceMethod: *IsInstanceMethod, ReturnType, Context, |
9982 | KnownSelectors, Results); |
9983 | } |
9984 | } |
9985 | |
9986 | Results.ExitScope(); |
9987 | |
9988 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
9989 | Context: Results.getCompletionContext(), Results: Results.data(), |
9990 | NumResults: Results.size()); |
9991 | } |
9992 | |
9993 | void SemaCodeCompletion::CodeCompleteObjCMethodDeclSelector( |
9994 | Scope *S, bool IsInstanceMethod, bool AtParameterName, ParsedType ReturnTy, |
9995 | ArrayRef<const IdentifierInfo *> SelIdents) { |
9996 | // If we have an external source, load the entire class method |
9997 | // pool from the AST file. |
9998 | if (SemaRef.ExternalSource) { |
9999 | for (uint32_t I = 0, N = SemaRef.ExternalSource->GetNumExternalSelectors(); |
10000 | I != N; ++I) { |
10001 | Selector Sel = SemaRef.ExternalSource->GetExternalSelector(ID: I); |
10002 | if (Sel.isNull() || SemaRef.ObjC().MethodPool.count(Val: Sel)) |
10003 | continue; |
10004 | |
10005 | SemaRef.ObjC().ReadMethodPool(Sel); |
10006 | } |
10007 | } |
10008 | |
10009 | // Build the set of methods we can see. |
10010 | typedef CodeCompletionResult Result; |
10011 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
10012 | CodeCompleter->getCodeCompletionTUInfo(), |
10013 | CodeCompletionContext::CCC_Other); |
10014 | |
10015 | if (ReturnTy) |
10016 | Results.setPreferredType( |
10017 | SemaRef.GetTypeFromParser(Ty: ReturnTy).getNonReferenceType()); |
10018 | |
10019 | Results.EnterNewScope(); |
10020 | for (SemaObjC::GlobalMethodPool::iterator |
10021 | M = SemaRef.ObjC().MethodPool.begin(), |
10022 | MEnd = SemaRef.ObjC().MethodPool.end(); |
10023 | M != MEnd; ++M) { |
10024 | for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first |
10025 | : &M->second.second; |
10026 | MethList && MethList->getMethod(); MethList = MethList->getNext()) { |
10027 | if (!isAcceptableObjCMethod(Method: MethList->getMethod(), WantKind: MK_Any, SelIdents)) |
10028 | continue; |
10029 | |
10030 | if (AtParameterName) { |
10031 | // Suggest parameter names we've seen before. |
10032 | unsigned NumSelIdents = SelIdents.size(); |
10033 | if (NumSelIdents && |
10034 | NumSelIdents <= MethList->getMethod()->param_size()) { |
10035 | ParmVarDecl *Param = |
10036 | MethList->getMethod()->parameters()[NumSelIdents - 1]; |
10037 | if (Param->getIdentifier()) { |
10038 | CodeCompletionBuilder Builder(Results.getAllocator(), |
10039 | Results.getCodeCompletionTUInfo()); |
10040 | Builder.AddTypedTextChunk(Text: Builder.getAllocator().CopyString( |
10041 | String: Param->getIdentifier()->getName())); |
10042 | Results.AddResult(R: Builder.TakeString()); |
10043 | } |
10044 | } |
10045 | |
10046 | continue; |
10047 | } |
10048 | |
10049 | Result R(MethList->getMethod(), |
10050 | Results.getBasePriority(MethList->getMethod()), nullptr); |
10051 | R.StartParameter = SelIdents.size(); |
10052 | R.AllParametersAreInformative = false; |
10053 | R.DeclaringEntity = true; |
10054 | Results.MaybeAddResult(R, CurContext: SemaRef.CurContext); |
10055 | } |
10056 | } |
10057 | |
10058 | Results.ExitScope(); |
10059 | |
10060 | if (!AtParameterName && !SelIdents.empty() && |
10061 | SelIdents.front()->getName().starts_with(Prefix: "init")) { |
10062 | for (const auto &M : SemaRef.PP.macros()) { |
10063 | if (M.first->getName() != "NS_DESIGNATED_INITIALIZER") |
10064 | continue; |
10065 | Results.EnterNewScope(); |
10066 | CodeCompletionBuilder Builder(Results.getAllocator(), |
10067 | Results.getCodeCompletionTUInfo()); |
10068 | Builder.AddTypedTextChunk( |
10069 | Text: Builder.getAllocator().CopyString(String: M.first->getName())); |
10070 | Results.AddResult(R: CodeCompletionResult(Builder.TakeString(), CCP_Macro, |
10071 | CXCursor_MacroDefinition)); |
10072 | Results.ExitScope(); |
10073 | } |
10074 | } |
10075 | |
10076 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
10077 | Context: Results.getCompletionContext(), Results: Results.data(), |
10078 | NumResults: Results.size()); |
10079 | } |
10080 | |
10081 | void SemaCodeCompletion::CodeCompletePreprocessorDirective(bool InConditional) { |
10082 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
10083 | CodeCompleter->getCodeCompletionTUInfo(), |
10084 | CodeCompletionContext::CCC_PreprocessorDirective); |
10085 | Results.EnterNewScope(); |
10086 | |
10087 | // #if <condition> |
10088 | CodeCompletionBuilder Builder(Results.getAllocator(), |
10089 | Results.getCodeCompletionTUInfo()); |
10090 | Builder.AddTypedTextChunk(Text: "if"); |
10091 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10092 | Builder.AddPlaceholderChunk(Placeholder: "condition"); |
10093 | Results.AddResult(R: Builder.TakeString()); |
10094 | |
10095 | // #ifdef <macro> |
10096 | Builder.AddTypedTextChunk(Text: "ifdef"); |
10097 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10098 | Builder.AddPlaceholderChunk(Placeholder: "macro"); |
10099 | Results.AddResult(R: Builder.TakeString()); |
10100 | |
10101 | // #ifndef <macro> |
10102 | Builder.AddTypedTextChunk(Text: "ifndef"); |
10103 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10104 | Builder.AddPlaceholderChunk(Placeholder: "macro"); |
10105 | Results.AddResult(R: Builder.TakeString()); |
10106 | |
10107 | if (InConditional) { |
10108 | // #elif <condition> |
10109 | Builder.AddTypedTextChunk(Text: "elif"); |
10110 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10111 | Builder.AddPlaceholderChunk(Placeholder: "condition"); |
10112 | Results.AddResult(R: Builder.TakeString()); |
10113 | |
10114 | // #elifdef <macro> |
10115 | Builder.AddTypedTextChunk(Text: "elifdef"); |
10116 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10117 | Builder.AddPlaceholderChunk(Placeholder: "macro"); |
10118 | Results.AddResult(R: Builder.TakeString()); |
10119 | |
10120 | // #elifndef <macro> |
10121 | Builder.AddTypedTextChunk(Text: "elifndef"); |
10122 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10123 | Builder.AddPlaceholderChunk(Placeholder: "macro"); |
10124 | Results.AddResult(R: Builder.TakeString()); |
10125 | |
10126 | // #else |
10127 | Builder.AddTypedTextChunk(Text: "else"); |
10128 | Results.AddResult(R: Builder.TakeString()); |
10129 | |
10130 | // #endif |
10131 | Builder.AddTypedTextChunk(Text: "endif"); |
10132 | Results.AddResult(R: Builder.TakeString()); |
10133 | } |
10134 | |
10135 | // #include "header" |
10136 | Builder.AddTypedTextChunk(Text: "include"); |
10137 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10138 | Builder.AddTextChunk(Text: "\""); |
10139 | Builder.AddPlaceholderChunk(Placeholder: "header"); |
10140 | Builder.AddTextChunk(Text: "\""); |
10141 | Results.AddResult(R: Builder.TakeString()); |
10142 | |
10143 | // #include <header> |
10144 | Builder.AddTypedTextChunk(Text: "include"); |
10145 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10146 | Builder.AddTextChunk(Text: "<"); |
10147 | Builder.AddPlaceholderChunk(Placeholder: "header"); |
10148 | Builder.AddTextChunk(Text: ">"); |
10149 | Results.AddResult(R: Builder.TakeString()); |
10150 | |
10151 | // #define <macro> |
10152 | Builder.AddTypedTextChunk(Text: "define"); |
10153 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10154 | Builder.AddPlaceholderChunk(Placeholder: "macro"); |
10155 | Results.AddResult(R: Builder.TakeString()); |
10156 | |
10157 | // #define <macro>(<args>) |
10158 | Builder.AddTypedTextChunk(Text: "define"); |
10159 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10160 | Builder.AddPlaceholderChunk(Placeholder: "macro"); |
10161 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
10162 | Builder.AddPlaceholderChunk(Placeholder: "args"); |
10163 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
10164 | Results.AddResult(R: Builder.TakeString()); |
10165 | |
10166 | // #undef <macro> |
10167 | Builder.AddTypedTextChunk(Text: "undef"); |
10168 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10169 | Builder.AddPlaceholderChunk(Placeholder: "macro"); |
10170 | Results.AddResult(R: Builder.TakeString()); |
10171 | |
10172 | // #line <number> |
10173 | Builder.AddTypedTextChunk(Text: "line"); |
10174 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10175 | Builder.AddPlaceholderChunk(Placeholder: "number"); |
10176 | Results.AddResult(R: Builder.TakeString()); |
10177 | |
10178 | // #line <number> "filename" |
10179 | Builder.AddTypedTextChunk(Text: "line"); |
10180 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10181 | Builder.AddPlaceholderChunk(Placeholder: "number"); |
10182 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10183 | Builder.AddTextChunk(Text: "\""); |
10184 | Builder.AddPlaceholderChunk(Placeholder: "filename"); |
10185 | Builder.AddTextChunk(Text: "\""); |
10186 | Results.AddResult(R: Builder.TakeString()); |
10187 | |
10188 | // #error <message> |
10189 | Builder.AddTypedTextChunk(Text: "error"); |
10190 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10191 | Builder.AddPlaceholderChunk(Placeholder: "message"); |
10192 | Results.AddResult(R: Builder.TakeString()); |
10193 | |
10194 | // #pragma <arguments> |
10195 | Builder.AddTypedTextChunk(Text: "pragma"); |
10196 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10197 | Builder.AddPlaceholderChunk(Placeholder: "arguments"); |
10198 | Results.AddResult(R: Builder.TakeString()); |
10199 | |
10200 | if (getLangOpts().ObjC) { |
10201 | // #import "header" |
10202 | Builder.AddTypedTextChunk(Text: "import"); |
10203 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10204 | Builder.AddTextChunk(Text: "\""); |
10205 | Builder.AddPlaceholderChunk(Placeholder: "header"); |
10206 | Builder.AddTextChunk(Text: "\""); |
10207 | Results.AddResult(R: Builder.TakeString()); |
10208 | |
10209 | // #import <header> |
10210 | Builder.AddTypedTextChunk(Text: "import"); |
10211 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10212 | Builder.AddTextChunk(Text: "<"); |
10213 | Builder.AddPlaceholderChunk(Placeholder: "header"); |
10214 | Builder.AddTextChunk(Text: ">"); |
10215 | Results.AddResult(R: Builder.TakeString()); |
10216 | } |
10217 | |
10218 | // #include_next "header" |
10219 | Builder.AddTypedTextChunk(Text: "include_next"); |
10220 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10221 | Builder.AddTextChunk(Text: "\""); |
10222 | Builder.AddPlaceholderChunk(Placeholder: "header"); |
10223 | Builder.AddTextChunk(Text: "\""); |
10224 | Results.AddResult(R: Builder.TakeString()); |
10225 | |
10226 | // #include_next <header> |
10227 | Builder.AddTypedTextChunk(Text: "include_next"); |
10228 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10229 | Builder.AddTextChunk(Text: "<"); |
10230 | Builder.AddPlaceholderChunk(Placeholder: "header"); |
10231 | Builder.AddTextChunk(Text: ">"); |
10232 | Results.AddResult(R: Builder.TakeString()); |
10233 | |
10234 | // #warning <message> |
10235 | Builder.AddTypedTextChunk(Text: "warning"); |
10236 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10237 | Builder.AddPlaceholderChunk(Placeholder: "message"); |
10238 | Results.AddResult(R: Builder.TakeString()); |
10239 | |
10240 | // Note: #ident and #sccs are such crazy anachronisms that we don't provide |
10241 | // completions for them. And __include_macros is a Clang-internal extension |
10242 | // that we don't want to encourage anyone to use. |
10243 | |
10244 | // FIXME: we don't support #assert or #unassert, so don't suggest them. |
10245 | Results.ExitScope(); |
10246 | |
10247 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
10248 | Context: Results.getCompletionContext(), Results: Results.data(), |
10249 | NumResults: Results.size()); |
10250 | } |
10251 | |
10252 | void SemaCodeCompletion::CodeCompleteInPreprocessorConditionalExclusion( |
10253 | Scope *S) { |
10254 | CodeCompleteOrdinaryName(S, CompletionContext: S->getFnParent() |
10255 | ? SemaCodeCompletion::PCC_RecoveryInFunction |
10256 | : SemaCodeCompletion::PCC_Namespace); |
10257 | } |
10258 | |
10259 | void SemaCodeCompletion::CodeCompletePreprocessorMacroName(bool IsDefinition) { |
10260 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
10261 | CodeCompleter->getCodeCompletionTUInfo(), |
10262 | IsDefinition ? CodeCompletionContext::CCC_MacroName |
10263 | : CodeCompletionContext::CCC_MacroNameUse); |
10264 | if (!IsDefinition && CodeCompleter->includeMacros()) { |
10265 | // Add just the names of macros, not their arguments. |
10266 | CodeCompletionBuilder Builder(Results.getAllocator(), |
10267 | Results.getCodeCompletionTUInfo()); |
10268 | Results.EnterNewScope(); |
10269 | for (Preprocessor::macro_iterator M = SemaRef.PP.macro_begin(), |
10270 | MEnd = SemaRef.PP.macro_end(); |
10271 | M != MEnd; ++M) { |
10272 | Builder.AddTypedTextChunk( |
10273 | Text: Builder.getAllocator().CopyString(String: M->first->getName())); |
10274 | Results.AddResult(R: CodeCompletionResult( |
10275 | Builder.TakeString(), CCP_CodePattern, CXCursor_MacroDefinition)); |
10276 | } |
10277 | Results.ExitScope(); |
10278 | } else if (IsDefinition) { |
10279 | // FIXME: Can we detect when the user just wrote an include guard above? |
10280 | } |
10281 | |
10282 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
10283 | Context: Results.getCompletionContext(), Results: Results.data(), |
10284 | NumResults: Results.size()); |
10285 | } |
10286 | |
10287 | void SemaCodeCompletion::CodeCompletePreprocessorExpression() { |
10288 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
10289 | CodeCompleter->getCodeCompletionTUInfo(), |
10290 | CodeCompletionContext::CCC_PreprocessorExpression); |
10291 | |
10292 | if (CodeCompleter->includeMacros()) |
10293 | AddMacroResults(PP&: SemaRef.PP, Results, LoadExternal: CodeCompleter->loadExternal(), IncludeUndefined: true); |
10294 | |
10295 | // defined (<macro>) |
10296 | Results.EnterNewScope(); |
10297 | CodeCompletionBuilder Builder(Results.getAllocator(), |
10298 | Results.getCodeCompletionTUInfo()); |
10299 | Builder.AddTypedTextChunk(Text: "defined"); |
10300 | Builder.AddChunk(CK: CodeCompletionString::CK_HorizontalSpace); |
10301 | Builder.AddChunk(CK: CodeCompletionString::CK_LeftParen); |
10302 | Builder.AddPlaceholderChunk(Placeholder: "macro"); |
10303 | Builder.AddChunk(CK: CodeCompletionString::CK_RightParen); |
10304 | Results.AddResult(R: Builder.TakeString()); |
10305 | Results.ExitScope(); |
10306 | |
10307 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
10308 | Context: Results.getCompletionContext(), Results: Results.data(), |
10309 | NumResults: Results.size()); |
10310 | } |
10311 | |
10312 | void SemaCodeCompletion::CodeCompletePreprocessorMacroArgument( |
10313 | Scope *S, IdentifierInfo *Macro, MacroInfo *MacroInfo, unsigned Argument) { |
10314 | // FIXME: In the future, we could provide "overload" results, much like we |
10315 | // do for function calls. |
10316 | |
10317 | // Now just ignore this. There will be another code-completion callback |
10318 | // for the expanded tokens. |
10319 | } |
10320 | |
10321 | // This handles completion inside an #include filename, e.g. #include <foo/ba |
10322 | // We look for the directory "foo" under each directory on the include path, |
10323 | // list its files, and reassemble the appropriate #include. |
10324 | void SemaCodeCompletion::CodeCompleteIncludedFile(llvm::StringRef Dir, |
10325 | bool Angled) { |
10326 | // RelDir should use /, but unescaped \ is possible on windows! |
10327 | // Our completions will normalize to / for simplicity, this case is rare. |
10328 | std::string RelDir = llvm::sys::path::convert_to_slash(path: Dir); |
10329 | // We need the native slashes for the actual file system interactions. |
10330 | SmallString<128> NativeRelDir = StringRef(RelDir); |
10331 | llvm::sys::path::native(path&: NativeRelDir); |
10332 | llvm::vfs::FileSystem &FS = |
10333 | SemaRef.getSourceManager().getFileManager().getVirtualFileSystem(); |
10334 | |
10335 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
10336 | CodeCompleter->getCodeCompletionTUInfo(), |
10337 | CodeCompletionContext::CCC_IncludedFile); |
10338 | llvm::DenseSet<StringRef> SeenResults; // To deduplicate results. |
10339 | |
10340 | // Helper: adds one file or directory completion result. |
10341 | auto AddCompletion = [&](StringRef Filename, bool IsDirectory) { |
10342 | SmallString<64> TypedChunk = Filename; |
10343 | // Directory completion is up to the slash, e.g. <sys/ |
10344 | TypedChunk.push_back(Elt: IsDirectory ? '/' : Angled ? '>' : '"'); |
10345 | auto R = SeenResults.insert(V: TypedChunk); |
10346 | if (R.second) { // New completion |
10347 | const char *InternedTyped = Results.getAllocator().CopyString(String: TypedChunk); |
10348 | *R.first = InternedTyped; // Avoid dangling StringRef. |
10349 | CodeCompletionBuilder Builder(CodeCompleter->getAllocator(), |
10350 | CodeCompleter->getCodeCompletionTUInfo()); |
10351 | Builder.AddTypedTextChunk(Text: InternedTyped); |
10352 | // The result is a "Pattern", which is pretty opaque. |
10353 | // We may want to include the real filename to allow smart ranking. |
10354 | Results.AddResult(R: CodeCompletionResult(Builder.TakeString())); |
10355 | } |
10356 | }; |
10357 | |
10358 | // Helper: scans IncludeDir for nice files, and adds results for each. |
10359 | auto AddFilesFromIncludeDir = [&](StringRef IncludeDir, |
10360 | bool IsSystem, |
10361 | DirectoryLookup::LookupType_t LookupType) { |
10362 | llvm::SmallString<128> Dir = IncludeDir; |
10363 | if (!NativeRelDir.empty()) { |
10364 | if (LookupType == DirectoryLookup::LT_Framework) { |
10365 | // For a framework dir, #include <Foo/Bar/> actually maps to |
10366 | // a path of Foo.framework/Headers/Bar/. |
10367 | auto Begin = llvm::sys::path::begin(path: NativeRelDir); |
10368 | auto End = llvm::sys::path::end(path: NativeRelDir); |
10369 | |
10370 | llvm::sys::path::append(path&: Dir, a: *Begin + ".framework", b: "Headers"); |
10371 | llvm::sys::path::append(path&: Dir, begin: ++Begin, end: End); |
10372 | } else { |
10373 | llvm::sys::path::append(path&: Dir, a: NativeRelDir); |
10374 | } |
10375 | } |
10376 | |
10377 | const StringRef &Dirname = llvm::sys::path::filename(path: Dir); |
10378 | const bool isQt = Dirname.starts_with(Prefix: "Qt") || Dirname == "ActiveQt"; |
10379 | const bool ExtensionlessHeaders = |
10380 | IsSystem || isQt || Dir.ends_with(Suffix: ".framework/Headers"); |
10381 | std::error_code EC; |
10382 | unsigned Count = 0; |
10383 | for (auto It = FS.dir_begin(Dir, EC); |
10384 | !EC && It != llvm::vfs::directory_iterator(); It.increment(EC)) { |
10385 | if (++Count == 2500) // If we happen to hit a huge directory, |
10386 | break; // bail out early so we're not too slow. |
10387 | StringRef Filename = llvm::sys::path::filename(path: It->path()); |
10388 | |
10389 | // To know whether a symlink should be treated as file or a directory, we |
10390 | // have to stat it. This should be cheap enough as there shouldn't be many |
10391 | // symlinks. |
10392 | llvm::sys::fs::file_type Type = It->type(); |
10393 | if (Type == llvm::sys::fs::file_type::symlink_file) { |
10394 | if (auto FileStatus = FS.status(Path: It->path())) |
10395 | Type = FileStatus->getType(); |
10396 | } |
10397 | switch (Type) { |
10398 | case llvm::sys::fs::file_type::directory_file: |
10399 | // All entries in a framework directory must have a ".framework" suffix, |
10400 | // but the suffix does not appear in the source code's include/import. |
10401 | if (LookupType == DirectoryLookup::LT_Framework && |
10402 | NativeRelDir.empty() && !Filename.consume_back(Suffix: ".framework")) |
10403 | break; |
10404 | |
10405 | AddCompletion(Filename, /*IsDirectory=*/true); |
10406 | break; |
10407 | case llvm::sys::fs::file_type::regular_file: { |
10408 | // Only files that really look like headers. (Except in special dirs). |
10409 | const bool IsHeader = Filename.ends_with_insensitive(Suffix: ".h") || |
10410 | Filename.ends_with_insensitive(Suffix: ".hh") || |
10411 | Filename.ends_with_insensitive(Suffix: ".hpp") || |
10412 | Filename.ends_with_insensitive(Suffix: ".hxx") || |
10413 | Filename.ends_with_insensitive(Suffix: ".inc") || |
10414 | (ExtensionlessHeaders && !Filename.contains(C: '.')); |
10415 | if (!IsHeader) |
10416 | break; |
10417 | AddCompletion(Filename, /*IsDirectory=*/false); |
10418 | break; |
10419 | } |
10420 | default: |
10421 | break; |
10422 | } |
10423 | } |
10424 | }; |
10425 | |
10426 | // Helper: adds results relative to IncludeDir, if possible. |
10427 | auto AddFilesFromDirLookup = [&](const DirectoryLookup &IncludeDir, |
10428 | bool IsSystem) { |
10429 | switch (IncludeDir.getLookupType()) { |
10430 | case DirectoryLookup::LT_HeaderMap: |
10431 | // header maps are not (currently) enumerable. |
10432 | break; |
10433 | case DirectoryLookup::LT_NormalDir: |
10434 | AddFilesFromIncludeDir(IncludeDir.getDirRef()->getName(), IsSystem, |
10435 | DirectoryLookup::LT_NormalDir); |
10436 | break; |
10437 | case DirectoryLookup::LT_Framework: |
10438 | AddFilesFromIncludeDir(IncludeDir.getFrameworkDirRef()->getName(), |
10439 | IsSystem, DirectoryLookup::LT_Framework); |
10440 | break; |
10441 | } |
10442 | }; |
10443 | |
10444 | // Finally with all our helpers, we can scan the include path. |
10445 | // Do this in standard order so deduplication keeps the right file. |
10446 | // (In case we decide to add more details to the results later). |
10447 | const auto &S = SemaRef.PP.getHeaderSearchInfo(); |
10448 | using llvm::make_range; |
10449 | if (!Angled) { |
10450 | // The current directory is on the include path for "quoted" includes. |
10451 | if (auto CurFile = SemaRef.PP.getCurrentFileLexer()->getFileEntry()) |
10452 | AddFilesFromIncludeDir(CurFile->getDir().getName(), false, |
10453 | DirectoryLookup::LT_NormalDir); |
10454 | for (const auto &D : make_range(x: S.quoted_dir_begin(), y: S.quoted_dir_end())) |
10455 | AddFilesFromDirLookup(D, false); |
10456 | } |
10457 | for (const auto &D : make_range(x: S.angled_dir_begin(), y: S.angled_dir_end())) |
10458 | AddFilesFromDirLookup(D, false); |
10459 | for (const auto &D : make_range(x: S.system_dir_begin(), y: S.system_dir_end())) |
10460 | AddFilesFromDirLookup(D, true); |
10461 | |
10462 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
10463 | Context: Results.getCompletionContext(), Results: Results.data(), |
10464 | NumResults: Results.size()); |
10465 | } |
10466 | |
10467 | void SemaCodeCompletion::CodeCompleteNaturalLanguage() { |
10468 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
10469 | Context: CodeCompletionContext::CCC_NaturalLanguage, Results: nullptr, |
10470 | NumResults: 0); |
10471 | } |
10472 | |
10473 | void SemaCodeCompletion::CodeCompleteAvailabilityPlatformName() { |
10474 | ResultBuilder Results(SemaRef, CodeCompleter->getAllocator(), |
10475 | CodeCompleter->getCodeCompletionTUInfo(), |
10476 | CodeCompletionContext::CCC_Other); |
10477 | Results.EnterNewScope(); |
10478 | static const char *Platforms[] = {"macOS", "iOS", "watchOS", "tvOS"}; |
10479 | for (const char *Platform : llvm::ArrayRef(Platforms)) { |
10480 | Results.AddResult(R: CodeCompletionResult(Platform)); |
10481 | Results.AddResult(R: CodeCompletionResult(Results.getAllocator().CopyString( |
10482 | String: Twine(Platform) + "ApplicationExtension"))); |
10483 | } |
10484 | Results.ExitScope(); |
10485 | HandleCodeCompleteResults(S: &SemaRef, CodeCompleter, |
10486 | Context: Results.getCompletionContext(), Results: Results.data(), |
10487 | NumResults: Results.size()); |
10488 | } |
10489 | |
10490 | void SemaCodeCompletion::GatherGlobalCodeCompletions( |
10491 | CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo, |
10492 | SmallVectorImpl<CodeCompletionResult> &Results) { |
10493 | ResultBuilder Builder(SemaRef, Allocator, CCTUInfo, |
10494 | CodeCompletionContext::CCC_Recovery); |
10495 | if (!CodeCompleter || CodeCompleter->includeGlobals()) { |
10496 | CodeCompletionDeclConsumer Consumer( |
10497 | Builder, getASTContext().getTranslationUnitDecl()); |
10498 | SemaRef.LookupVisibleDecls(getASTContext().getTranslationUnitDecl(), |
10499 | Sema::LookupAnyName, Consumer, |
10500 | !CodeCompleter || CodeCompleter->loadExternal()); |
10501 | } |
10502 | |
10503 | if (!CodeCompleter || CodeCompleter->includeMacros()) |
10504 | AddMacroResults(PP&: SemaRef.PP, Results&: Builder, |
10505 | LoadExternal: !CodeCompleter || CodeCompleter->loadExternal(), IncludeUndefined: true); |
10506 | |
10507 | Results.clear(); |
10508 | Results.insert(I: Results.end(), From: Builder.data(), |
10509 | To: Builder.data() + Builder.size()); |
10510 | } |
10511 | |
10512 | SemaCodeCompletion::SemaCodeCompletion(Sema &S, |
10513 | CodeCompleteConsumer *CompletionConsumer) |
10514 | : SemaBase(S), CodeCompleter(CompletionConsumer), |
10515 | Resolver(S.getASTContext()) {} |
10516 |
Definitions
- ResultBuilder
- ShadowMapEntry
- ShadowMapEntry
- ShadowMapEntry
- ShadowMapEntry
- operator=
- operator=
- Add
- ~ShadowMapEntry
- ResultBuilder
- includeCodePatterns
- setFilter
- data
- size
- empty
- setPreferredType
- setObjectTypeQualifiers
- setPreferredSelector
- getCompletionContext
- allowNestedNameSpecifiers
- getSema
- getAllocator
- getCodeCompletionTUInfo
- Ignore
- addVisitedContext
- enterReturn
- enterVariableInit
- enterDesignatedInitializer
- enterFunctionArgument
- enterParenExpr
- getPreferredTypeOfBinaryRHS
- getPreferredTypeOfUnaryArg
- enterBinary
- enterMemAccess
- enterUnary
- enterSubscript
- enterTypeCast
- enterCondition
- iterator
- pointer
- pointer
- operator->
- iterator
- iterator
- iterator
- operator++
- operator*
- operator->
- operator==
- operator!=
- begin
- end
- getRequiredQualification
- shouldIgnoreDueToReservedName
- isInterestingDecl
- CheckHiddenResult
- getSimplifiedTypeClass
- getDeclUsageType
- getBasePriority
- AdjustResultPriorityForDecl
- getConstructors
- MaybeAddConstructorResults
- isConstructor
- MaybeAddResult
- setInBaseClass
- OverloadCompare
- compareOverloads
- canCxxMethodBeCalled
- canFunctionBeCalled
- AddResult
- AddResult
- EnterNewScope
- ExitScope
- IsOrdinaryName
- IsOrdinaryNonTypeName
- IsIntegralConstantValue
- IsOrdinaryNonValueName
- IsNestedNameSpecifier
- IsEnum
- IsClassOrStruct
- IsUnion
- IsNamespace
- IsNamespaceOrAlias
- IsType
- IsMember
- isObjCReceiverType
- IsObjCMessageReceiver
- IsObjCMessageReceiverOrLambdaCapture
- IsObjCCollection
- IsImpossibleToSatisfy
- IsObjCIvar
- CodeCompletionDeclConsumer
- CodeCompletionDeclConsumer
- FoundDecl
- EnteredContext
- IsAccessible
- AddTypeSpecifierResults
- AddStorageSpecifiers
- AddFunctionSpecifiers
- AddTypedefResult
- AddUsingAliasResult
- WantTypesInContext
- getCompletionPrintingPolicy
- getCompletionPrintingPolicy
- GetCompletionTypeString
- addThisCompletion
- AddStaticAssertResult
- AddOverrideResults
- AddOrdinaryNameResults
- AddResultTypeChunk
- MaybeAddSentinel
- formatObjCParamQualifiers
- findTypeLocationForBlockDecl
- FormatFunctionParameter
- formatBlockPlaceholder
- GetDefaultValueString
- AddFunctionParameterChunks
- AddTemplateParameterChunks
- AddQualifierToCompletionString
- AddFunctionTypeQualsToCompletionString
- AddTypedNameChunk
- CreateCodeCompletionString
- CreateCodeCompletionStringForMacro
- CreateCodeCompletionString
- printOverrideString
- createCodeCompletionStringForOverride
- extractFunctorCallOperator
- createCodeCompletionStringForDecl
- getCompletionComment
- getPatternCompletionComment
- getParameterComment
- AddOverloadAggregateChunks
- AddOverloadParameterChunks
- formatTemplateParameterPlaceholder
- templateResultType
- createTemplateSignatureString
- CreateSignatureString
- getMacroUsagePriority
- getCursorKindForDecl
- AddMacroResults
- AddPrettyFunctionResults
- HandleCodeCompleteResults
- mapCodeCompletionContext
- MaybeAddOverrideCalls
- CodeCompleteModuleImport
- CodeCompleteOrdinaryName
- CodeCompleteDeclSpec
- underscoreAttrScope
- noUnderscoreAttrScope
- CodeCompleteAttribute
- CodeCompleteExpressionData
- CodeCompleteExpressionData
- CoveredEnumerators
- AddEnumerators
- TryDeconstructFunctionLike
- AddLambdaCompletion
- CodeCompleteExpression
- CodeCompleteExpression
- CodeCompletePostfixExpression
- getContainerDef
- AddObjCBlockCall
- AddObjCProperties
- AddRecordMembersCompletionResults
- getAsRecordDecl
- ConceptInfo
- Member
- AccessOperator
- render
- ConceptInfo
- members
- believe
- ValidVisitor
- ValidVisitor
- VisitCXXDependentScopeMemberExpr
- VisitDependentScopeDeclRefExpr
- VisitDependentNameType
- TraverseNestedNameSpecifierLoc
- VisitCallExpr
- addResult
- addType
- addValue
- isApprox
- isApprox
- getTemplatedEntity
- constraintsForTemplatedEntity
- deduceType
- getApproximateType
- unwrapParenList
- CodeCompleteMemberReferenceExpr
- CodeCompleteObjCClassPropertyRefExpr
- CodeCompleteTag
- AddTypeQualifierResults
- CodeCompleteTypeQualifiers
- CodeCompleteFunctionQualifiers
- CodeCompleteBracketDeclarator
- CodeCompleteCase
- anyNullArguments
- mergeCandidatesWithResults
- getParamType
- ProduceSignatureHelp
- GetPrototypeLoc
- ProduceCallSignatureHelp
- getNextAggregateIndexAfterDesignatedInit
- ProduceConstructorSignatureHelp
- ProduceCtorInitMemberSignatureHelp
- argMatchesTemplateParams
- ProduceTemplateArgumentSignatureHelp
- getDesignatedType
- CodeCompleteDesignator
- CodeCompleteInitializer
- CodeCompleteKeywordAfterIf
- CodeCompleteAfterIf
- CodeCompleteQualifiedId
- CodeCompleteUsing
- CodeCompleteUsingDirective
- CodeCompleteNamespaceDecl
- CodeCompleteNamespaceAliasDecl
- CodeCompleteOperatorName
- CodeCompleteConstructorInitializer
- isNamespaceScope
- CodeCompleteLambdaIntroducer
- CodeCompleteAfterFunctionEquals
- AddObjCImplementationResults
- AddObjCInterfaceResults
- AddObjCTopLevelResults
- CodeCompleteObjCAtDirective
- AddObjCExpressionResults
- AddObjCStatementResults
- AddObjCVisibilityResults
- CodeCompleteObjCAtVisibility
- CodeCompleteObjCAtStatement
- CodeCompleteObjCAtExpression
- ObjCPropertyFlagConflicts
- CodeCompleteObjCPropertyFlags
- ObjCMethodKind
- isAcceptableObjCSelector
- isAcceptableObjCMethod
- AddObjCMethods
- CodeCompleteObjCPropertyGetter
- CodeCompleteObjCPropertySetter
- CodeCompleteObjCPassingType
- GetAssumedMessageSendExprType
- AddSuperSendCompletion
- CodeCompleteObjCMessageReceiver
- CodeCompleteObjCSuperMessage
- getPreferredArgumentTypeForMessageSend
- AddClassMessageCompletions
- CodeCompleteObjCClassMessage
- CodeCompleteObjCInstanceMessage
- CodeCompleteObjCForCollection
- CodeCompleteObjCSelector
- AddProtocolResults
- CodeCompleteObjCProtocolReferences
- CodeCompleteObjCProtocolDecl
- AddInterfaceResults
- CodeCompleteObjCInterfaceDecl
- CodeCompleteObjCClassForwardDecl
- CodeCompleteObjCSuperclass
- CodeCompleteObjCImplementationDecl
- CodeCompleteObjCInterfaceCategory
- CodeCompleteObjCImplementationCategory
- CodeCompleteObjCPropertyDefinition
- CodeCompleteObjCPropertySynthesizeIvar
- FindImplementableMethods
- AddObjCPassingTypeChunk
- InheritsFromClassNamed
- AddObjCKeyValueCompletions
- CodeCompleteObjCMethodDecl
- CodeCompleteObjCMethodDeclSelector
- CodeCompletePreprocessorDirective
- CodeCompleteInPreprocessorConditionalExclusion
- CodeCompletePreprocessorMacroName
- CodeCompletePreprocessorExpression
- CodeCompletePreprocessorMacroArgument
- CodeCompleteIncludedFile
- CodeCompleteNaturalLanguage
- CodeCompleteAvailabilityPlatformName
- GatherGlobalCodeCompletions
Improve your Profiling and Debugging skills
Find out more