Bug Summary

File:clang/lib/Sema/SemaCodeComplete.cpp
Warning:line 4802, column 22
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaCodeComplete.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/include -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/tools/clang/lib/Sema -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2020-01-11-115256-23437-1 -x c++ /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp

/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp

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/Decl.h"
13#include "clang/AST/DeclBase.h"
14#include "clang/AST/DeclCXX.h"
15#include "clang/AST/DeclObjC.h"
16#include "clang/AST/ExprCXX.h"
17#include "clang/AST/ExprObjC.h"
18#include "clang/AST/QualTypeNames.h"
19#include "clang/AST/Type.h"
20#include "clang/Basic/CharInfo.h"
21#include "clang/Basic/Specifiers.h"
22#include "clang/Lex/HeaderSearch.h"
23#include "clang/Lex/MacroInfo.h"
24#include "clang/Lex/Preprocessor.h"
25#include "clang/Sema/CodeCompleteConsumer.h"
26#include "clang/Sema/Lookup.h"
27#include "clang/Sema/Overload.h"
28#include "clang/Sema/Scope.h"
29#include "clang/Sema/ScopeInfo.h"
30#include "clang/Sema/SemaInternal.h"
31#include "llvm/ADT/DenseSet.h"
32#include "llvm/ADT/SmallBitVector.h"
33#include "llvm/ADT/SmallPtrSet.h"
34#include "llvm/ADT/SmallString.h"
35#include "llvm/ADT/StringExtras.h"
36#include "llvm/ADT/StringSwitch.h"
37#include "llvm/ADT/Twine.h"
38#include "llvm/ADT/iterator_range.h"
39#include "llvm/Support/Path.h"
40#include <list>
41#include <map>
42#include <string>
43#include <vector>
44
45using namespace clang;
46using namespace sema;
47
48namespace {
49/// A container of code-completion results.
50class ResultBuilder {
51public:
52 /// The type of a name-lookup filter, which can be provided to the
53 /// name-lookup routines to specify which declarations should be included in
54 /// the result set (when it returns true) and which declarations should be
55 /// filtered out (returns false).
56 typedef bool (ResultBuilder::*LookupFilter)(const NamedDecl *) const;
57
58 typedef CodeCompletionResult Result;
59
60private:
61 /// The actual results we have found.
62 std::vector<Result> Results;
63
64 /// A record of all of the declarations we have found and placed
65 /// into the result set, used to ensure that no declaration ever gets into
66 /// the result set twice.
67 llvm::SmallPtrSet<const Decl *, 16> AllDeclsFound;
68
69 typedef std::pair<const NamedDecl *, unsigned> DeclIndexPair;
70
71 /// An entry in the shadow map, which is optimized to store
72 /// a single (declaration, index) mapping (the common case) but
73 /// can also store a list of (declaration, index) mappings.
74 class ShadowMapEntry {
75 typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector;
76
77 /// Contains either the solitary NamedDecl * or a vector
78 /// of (declaration, index) pairs.
79 llvm::PointerUnion<const NamedDecl *, DeclIndexPairVector *> DeclOrVector;
80
81 /// When the entry contains a single declaration, this is
82 /// the index associated with that entry.
83 unsigned SingleDeclIndex;
84
85 public:
86 ShadowMapEntry() : DeclOrVector(), SingleDeclIndex(0) {}
87 ShadowMapEntry(const ShadowMapEntry &) = delete;
88 ShadowMapEntry(ShadowMapEntry &&Move) { *this = std::move(Move); }
89 ShadowMapEntry &operator=(const ShadowMapEntry &) = delete;
90 ShadowMapEntry &operator=(ShadowMapEntry &&Move) {
91 SingleDeclIndex = Move.SingleDeclIndex;
92 DeclOrVector = Move.DeclOrVector;
93 Move.DeclOrVector = nullptr;
94 return *this;
95 }
96
97 void Add(const NamedDecl *ND, unsigned Index) {
98 if (DeclOrVector.isNull()) {
99 // 0 - > 1 elements: just set the single element information.
100 DeclOrVector = ND;
101 SingleDeclIndex = Index;
102 return;
103 }
104
105 if (const NamedDecl *PrevND =
106 DeclOrVector.dyn_cast<const NamedDecl *>()) {
107 // 1 -> 2 elements: create the vector of results and push in the
108 // existing declaration.
109 DeclIndexPairVector *Vec = new DeclIndexPairVector;
110 Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex));
111 DeclOrVector = Vec;
112 }
113
114 // Add the new element to the end of the vector.
115 DeclOrVector.get<DeclIndexPairVector *>()->push_back(
116 DeclIndexPair(ND, Index));
117 }
118
119 ~ShadowMapEntry() {
120 if (DeclIndexPairVector *Vec =
121 DeclOrVector.dyn_cast<DeclIndexPairVector *>()) {
122 delete Vec;
123 DeclOrVector = ((NamedDecl *)nullptr);
124 }
125 }
126
127 // Iteration.
128 class iterator;
129 iterator begin() const;
130 iterator end() const;
131 };
132
133 /// A mapping from declaration names to the declarations that have
134 /// this name within a particular scope and their index within the list of
135 /// results.
136 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
137
138 /// The semantic analysis object for which results are being
139 /// produced.
140 Sema &SemaRef;
141
142 /// The allocator used to allocate new code-completion strings.
143 CodeCompletionAllocator &Allocator;
144
145 CodeCompletionTUInfo &CCTUInfo;
146
147 /// If non-NULL, a filter function used to remove any code-completion
148 /// results that are not desirable.
149 LookupFilter Filter;
150
151 /// Whether we should allow declarations as
152 /// nested-name-specifiers that would otherwise be filtered out.
153 bool AllowNestedNameSpecifiers;
154
155 /// If set, the type that we would prefer our resulting value
156 /// declarations to have.
157 ///
158 /// Closely matching the preferred type gives a boost to a result's
159 /// priority.
160 CanQualType PreferredType;
161
162 /// A list of shadow maps, which is used to model name hiding at
163 /// different levels of, e.g., the inheritance hierarchy.
164 std::list<ShadowMap> ShadowMaps;
165
166 /// Overloaded C++ member functions found by SemaLookup.
167 /// Used to determine when one overload is dominated by another.
168 llvm::DenseMap<std::pair<DeclContext *, /*Name*/uintptr_t>, ShadowMapEntry>
169 OverloadMap;
170
171 /// If we're potentially referring to a C++ member function, the set
172 /// of qualifiers applied to the object type.
173 Qualifiers ObjectTypeQualifiers;
174 /// The kind of the object expression, for rvalue/lvalue overloads.
175 ExprValueKind ObjectKind;
176
177 /// Whether the \p ObjectTypeQualifiers field is active.
178 bool HasObjectTypeQualifiers;
179
180 /// The selector that we prefer.
181 Selector PreferredSelector;
182
183 /// The completion context in which we are gathering results.
184 CodeCompletionContext CompletionContext;
185
186 /// If we are in an instance method definition, the \@implementation
187 /// object.
188 ObjCImplementationDecl *ObjCImplementation;
189
190 void AdjustResultPriorityForDecl(Result &R);
191
192 void MaybeAddConstructorResults(Result R);
193
194public:
195 explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator,
196 CodeCompletionTUInfo &CCTUInfo,
197 const CodeCompletionContext &CompletionContext,
198 LookupFilter Filter = nullptr)
199 : SemaRef(SemaRef), Allocator(Allocator), CCTUInfo(CCTUInfo),
200 Filter(Filter), AllowNestedNameSpecifiers(false),
201 HasObjectTypeQualifiers(false), CompletionContext(CompletionContext),
202 ObjCImplementation(nullptr) {
203 // If this is an Objective-C instance method definition, dig out the
204 // corresponding implementation.
205 switch (CompletionContext.getKind()) {
206 case CodeCompletionContext::CCC_Expression:
207 case CodeCompletionContext::CCC_ObjCMessageReceiver:
208 case CodeCompletionContext::CCC_ParenthesizedExpression:
209 case CodeCompletionContext::CCC_Statement:
210 case CodeCompletionContext::CCC_Recovery:
211 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl())
212 if (Method->isInstanceMethod())
213 if (ObjCInterfaceDecl *Interface = Method->getClassInterface())
214 ObjCImplementation = Interface->getImplementation();
215 break;
216
217 default:
218 break;
219 }
220 }
221
222 /// Determine the priority for a reference to the given declaration.
223 unsigned getBasePriority(const NamedDecl *D);
224
225 /// Whether we should include code patterns in the completion
226 /// results.
227 bool includeCodePatterns() const {
228 return SemaRef.CodeCompleter &&
229 SemaRef.CodeCompleter->includeCodePatterns();
230 }
231
232 /// Set the filter used for code-completion results.
233 void setFilter(LookupFilter Filter) { this->Filter = Filter; }
234
235 Result *data() { return Results.empty() ? nullptr : &Results.front(); }
236 unsigned size() const { return Results.size(); }
237 bool empty() const { return Results.empty(); }
238
239 /// Specify the preferred type.
240 void setPreferredType(QualType T) {
241 PreferredType = SemaRef.Context.getCanonicalType(T);
242 }
243
244 /// Set the cv-qualifiers on the object type, for us in filtering
245 /// calls to member functions.
246 ///
247 /// When there are qualifiers in this set, they will be used to filter
248 /// out member functions that aren't available (because there will be a
249 /// cv-qualifier mismatch) or prefer functions with an exact qualifier
250 /// match.
251 void setObjectTypeQualifiers(Qualifiers Quals, ExprValueKind Kind) {
252 ObjectTypeQualifiers = Quals;
253 ObjectKind = Kind;
254 HasObjectTypeQualifiers = true;
255 }
256
257 /// Set the preferred selector.
258 ///
259 /// When an Objective-C method declaration result is added, and that
260 /// method's selector matches this preferred selector, we give that method
261 /// a slight priority boost.
262 void setPreferredSelector(Selector Sel) { PreferredSelector = Sel; }
263
264 /// Retrieve the code-completion context for which results are
265 /// being collected.
266 const CodeCompletionContext &getCompletionContext() const {
267 return CompletionContext;
268 }
269
270 /// Specify whether nested-name-specifiers are allowed.
271 void allowNestedNameSpecifiers(bool Allow = true) {
272 AllowNestedNameSpecifiers = Allow;
273 }
274
275 /// Return the semantic analysis object for which we are collecting
276 /// code completion results.
277 Sema &getSema() const { return SemaRef; }
278
279 /// Retrieve the allocator used to allocate code completion strings.
280 CodeCompletionAllocator &getAllocator() const { return Allocator; }
281
282 CodeCompletionTUInfo &getCodeCompletionTUInfo() const { return CCTUInfo; }
283
284 /// Determine whether the given declaration is at all interesting
285 /// as a code-completion result.
286 ///
287 /// \param ND the declaration that we are inspecting.
288 ///
289 /// \param AsNestedNameSpecifier will be set true if this declaration is
290 /// only interesting when it is a nested-name-specifier.
291 bool isInterestingDecl(const NamedDecl *ND,
292 bool &AsNestedNameSpecifier) const;
293
294 /// Check whether the result is hidden by the Hiding declaration.
295 ///
296 /// \returns true if the result is hidden and cannot be found, false if
297 /// the hidden result could still be found. When false, \p R may be
298 /// modified to describe how the result can be found (e.g., via extra
299 /// qualification).
300 bool CheckHiddenResult(Result &R, DeclContext *CurContext,
301 const NamedDecl *Hiding);
302
303 /// Add a new result to this result set (if it isn't already in one
304 /// of the shadow maps), or replace an existing result (for, e.g., a
305 /// redeclaration).
306 ///
307 /// \param R the result to add (if it is unique).
308 ///
309 /// \param CurContext the context in which this result will be named.
310 void MaybeAddResult(Result R, DeclContext *CurContext = nullptr);
311
312 /// Add a new result to this result set, where we already know
313 /// the hiding declaration (if any).
314 ///
315 /// \param R the result to add (if it is unique).
316 ///
317 /// \param CurContext the context in which this result will be named.
318 ///
319 /// \param Hiding the declaration that hides the result.
320 ///
321 /// \param InBaseClass whether the result was found in a base
322 /// class of the searched context.
323 void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding,
324 bool InBaseClass);
325
326 /// Add a new non-declaration result to this result set.
327 void AddResult(Result R);
328
329 /// Enter into a new scope.
330 void EnterNewScope();
331
332 /// Exit from the current scope.
333 void ExitScope();
334
335 /// Ignore this declaration, if it is seen again.
336 void Ignore(const Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); }
337
338 /// Add a visited context.
339 void addVisitedContext(DeclContext *Ctx) {
340 CompletionContext.addVisitedContext(Ctx);
341 }
342
343 /// \name Name lookup predicates
344 ///
345 /// These predicates can be passed to the name lookup functions to filter the
346 /// results of name lookup. All of the predicates have the same type, so that
347 ///
348 //@{
349 bool IsOrdinaryName(const NamedDecl *ND) const;
350 bool IsOrdinaryNonTypeName(const NamedDecl *ND) const;
351 bool IsIntegralConstantValue(const NamedDecl *ND) const;
352 bool IsOrdinaryNonValueName(const NamedDecl *ND) const;
353 bool IsNestedNameSpecifier(const NamedDecl *ND) const;
354 bool IsEnum(const NamedDecl *ND) const;
355 bool IsClassOrStruct(const NamedDecl *ND) const;
356 bool IsUnion(const NamedDecl *ND) const;
357 bool IsNamespace(const NamedDecl *ND) const;
358 bool IsNamespaceOrAlias(const NamedDecl *ND) const;
359 bool IsType(const NamedDecl *ND) const;
360 bool IsMember(const NamedDecl *ND) const;
361 bool IsObjCIvar(const NamedDecl *ND) const;
362 bool IsObjCMessageReceiver(const NamedDecl *ND) const;
363 bool IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const;
364 bool IsObjCCollection(const NamedDecl *ND) const;
365 bool IsImpossibleToSatisfy(const NamedDecl *ND) const;
366 //@}
367};
368} // namespace
369
370void PreferredTypeBuilder::enterReturn(Sema &S, SourceLocation Tok) {
371 if (isa<BlockDecl>(S.CurContext)) {
372 if (sema::BlockScopeInfo *BSI = S.getCurBlock()) {
373 ComputeType = nullptr;
374 Type = BSI->ReturnType;
375 ExpectedLoc = Tok;
376 }
377 } else if (const auto *Function = dyn_cast<FunctionDecl>(S.CurContext)) {
378 ComputeType = nullptr;
379 Type = Function->getReturnType();
380 ExpectedLoc = Tok;
381 } else if (const auto *Method = dyn_cast<ObjCMethodDecl>(S.CurContext)) {
382 ComputeType = nullptr;
383 Type = Method->getReturnType();
384 ExpectedLoc = Tok;
385 }
386}
387
388void PreferredTypeBuilder::enterVariableInit(SourceLocation Tok, Decl *D) {
389 auto *VD = llvm::dyn_cast_or_null<ValueDecl>(D);
390 ComputeType = nullptr;
391 Type = VD ? VD->getType() : QualType();
392 ExpectedLoc = Tok;
393}
394
395void PreferredTypeBuilder::enterFunctionArgument(
396 SourceLocation Tok, llvm::function_ref<QualType()> ComputeType) {
397 this->ComputeType = ComputeType;
398 Type = QualType();
399 ExpectedLoc = Tok;
400}
401
402void PreferredTypeBuilder::enterParenExpr(SourceLocation Tok,
403 SourceLocation LParLoc) {
404 // expected type for parenthesized expression does not change.
405 if (ExpectedLoc == LParLoc)
406 ExpectedLoc = Tok;
407}
408
409static QualType getPreferredTypeOfBinaryRHS(Sema &S, Expr *LHS,
410 tok::TokenKind Op) {
411 if (!LHS)
412 return QualType();
413
414 QualType LHSType = LHS->getType();
415 if (LHSType->isPointerType()) {
416 if (Op == tok::plus || Op == tok::plusequal || Op == tok::minusequal)
417 return S.getASTContext().getPointerDiffType();
418 // Pointer difference is more common than subtracting an int from a pointer.
419 if (Op == tok::minus)
420 return LHSType;
421 }
422
423 switch (Op) {
424 // No way to infer the type of RHS from LHS.
425 case tok::comma:
426 return QualType();
427 // Prefer the type of the left operand for all of these.
428 // Arithmetic operations.
429 case tok::plus:
430 case tok::plusequal:
431 case tok::minus:
432 case tok::minusequal:
433 case tok::percent:
434 case tok::percentequal:
435 case tok::slash:
436 case tok::slashequal:
437 case tok::star:
438 case tok::starequal:
439 // Assignment.
440 case tok::equal:
441 // Comparison operators.
442 case tok::equalequal:
443 case tok::exclaimequal:
444 case tok::less:
445 case tok::lessequal:
446 case tok::greater:
447 case tok::greaterequal:
448 case tok::spaceship:
449 return LHS->getType();
450 // Binary shifts are often overloaded, so don't try to guess those.
451 case tok::greatergreater:
452 case tok::greatergreaterequal:
453 case tok::lessless:
454 case tok::lesslessequal:
455 if (LHSType->isIntegralOrEnumerationType())
456 return S.getASTContext().IntTy;
457 return QualType();
458 // Logical operators, assume we want bool.
459 case tok::ampamp:
460 case tok::pipepipe:
461 case tok::caretcaret:
462 return S.getASTContext().BoolTy;
463 // Operators often used for bit manipulation are typically used with the type
464 // of the left argument.
465 case tok::pipe:
466 case tok::pipeequal:
467 case tok::caret:
468 case tok::caretequal:
469 case tok::amp:
470 case tok::ampequal:
471 if (LHSType->isIntegralOrEnumerationType())
472 return LHSType;
473 return QualType();
474 // RHS should be a pointer to a member of the 'LHS' type, but we can't give
475 // any particular type here.
476 case tok::periodstar:
477 case tok::arrowstar:
478 return QualType();
479 default:
480 // FIXME(ibiryukov): handle the missing op, re-add the assertion.
481 // assert(false && "unhandled binary op");
482 return QualType();
483 }
484}
485
486/// Get preferred type for an argument of an unary expression. \p ContextType is
487/// preferred type of the whole unary expression.
488static QualType getPreferredTypeOfUnaryArg(Sema &S, QualType ContextType,
489 tok::TokenKind Op) {
490 switch (Op) {
491 case tok::exclaim:
492 return S.getASTContext().BoolTy;
493 case tok::amp:
494 if (!ContextType.isNull() && ContextType->isPointerType())
495 return ContextType->getPointeeType();
496 return QualType();
497 case tok::star:
498 if (ContextType.isNull())
499 return QualType();
500 return S.getASTContext().getPointerType(ContextType.getNonReferenceType());
501 case tok::plus:
502 case tok::minus:
503 case tok::tilde:
504 case tok::minusminus:
505 case tok::plusplus:
506 if (ContextType.isNull())
507 return S.getASTContext().IntTy;
508 // leave as is, these operators typically return the same type.
509 return ContextType;
510 case tok::kw___real:
511 case tok::kw___imag:
512 return QualType();
513 default:
514 assert(false && "unhandled unary op")((false && "unhandled unary op") ? static_cast<void
> (0) : __assert_fail ("false && \"unhandled unary op\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 514, __PRETTY_FUNCTION__))
;
515 return QualType();
516 }
517}
518
519void PreferredTypeBuilder::enterBinary(Sema &S, SourceLocation Tok, Expr *LHS,
520 tok::TokenKind Op) {
521 ComputeType = nullptr;
522 Type = getPreferredTypeOfBinaryRHS(S, LHS, Op);
523 ExpectedLoc = Tok;
524}
525
526void PreferredTypeBuilder::enterMemAccess(Sema &S, SourceLocation Tok,
527 Expr *Base) {
528 if (!Base)
529 return;
530 // Do we have expected type for Base?
531 if (ExpectedLoc != Base->getBeginLoc())
532 return;
533 // Keep the expected type, only update the location.
534 ExpectedLoc = Tok;
535 return;
536}
537
538void PreferredTypeBuilder::enterUnary(Sema &S, SourceLocation Tok,
539 tok::TokenKind OpKind,
540 SourceLocation OpLoc) {
541 ComputeType = nullptr;
542 Type = getPreferredTypeOfUnaryArg(S, this->get(OpLoc), OpKind);
543 ExpectedLoc = Tok;
544}
545
546void PreferredTypeBuilder::enterSubscript(Sema &S, SourceLocation Tok,
547 Expr *LHS) {
548 ComputeType = nullptr;
549 Type = S.getASTContext().IntTy;
550 ExpectedLoc = Tok;
551}
552
553void PreferredTypeBuilder::enterTypeCast(SourceLocation Tok,
554 QualType CastType) {
555 ComputeType = nullptr;
556 Type = !CastType.isNull() ? CastType.getCanonicalType() : QualType();
557 ExpectedLoc = Tok;
558}
559
560void PreferredTypeBuilder::enterCondition(Sema &S, SourceLocation Tok) {
561 ComputeType = nullptr;
562 Type = S.getASTContext().BoolTy;
563 ExpectedLoc = Tok;
564}
565
566class ResultBuilder::ShadowMapEntry::iterator {
567 llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator;
568 unsigned SingleDeclIndex;
569
570public:
571 typedef DeclIndexPair value_type;
572 typedef value_type reference;
573 typedef std::ptrdiff_t difference_type;
574 typedef std::input_iterator_tag iterator_category;
575
576 class pointer {
577 DeclIndexPair Value;
578
579 public:
580 pointer(const DeclIndexPair &Value) : Value(Value) {}
581
582 const DeclIndexPair *operator->() const { return &Value; }
583 };
584
585 iterator() : DeclOrIterator((NamedDecl *)nullptr), SingleDeclIndex(0) {}
586
587 iterator(const NamedDecl *SingleDecl, unsigned Index)
588 : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) {}
589
590 iterator(const DeclIndexPair *Iterator)
591 : DeclOrIterator(Iterator), SingleDeclIndex(0) {}
592
593 iterator &operator++() {
594 if (DeclOrIterator.is<const NamedDecl *>()) {
595 DeclOrIterator = (NamedDecl *)nullptr;
596 SingleDeclIndex = 0;
597 return *this;
598 }
599
600 const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair *>();
601 ++I;
602 DeclOrIterator = I;
603 return *this;
604 }
605
606 /*iterator operator++(int) {
607 iterator tmp(*this);
608 ++(*this);
609 return tmp;
610 }*/
611
612 reference operator*() const {
613 if (const NamedDecl *ND = DeclOrIterator.dyn_cast<const NamedDecl *>())
614 return reference(ND, SingleDeclIndex);
615
616 return *DeclOrIterator.get<const DeclIndexPair *>();
617 }
618
619 pointer operator->() const { return pointer(**this); }
620
621 friend bool operator==(const iterator &X, const iterator &Y) {
622 return X.DeclOrIterator.getOpaqueValue() ==
623 Y.DeclOrIterator.getOpaqueValue() &&
624 X.SingleDeclIndex == Y.SingleDeclIndex;
625 }
626
627 friend bool operator!=(const iterator &X, const iterator &Y) {
628 return !(X == Y);
629 }
630};
631
632ResultBuilder::ShadowMapEntry::iterator
633ResultBuilder::ShadowMapEntry::begin() const {
634 if (DeclOrVector.isNull())
635 return iterator();
636
637 if (const NamedDecl *ND = DeclOrVector.dyn_cast<const NamedDecl *>())
638 return iterator(ND, SingleDeclIndex);
639
640 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin());
641}
642
643ResultBuilder::ShadowMapEntry::iterator
644ResultBuilder::ShadowMapEntry::end() const {
645 if (DeclOrVector.is<const NamedDecl *>() || DeclOrVector.isNull())
646 return iterator();
647
648 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end());
649}
650
651/// Compute the qualification required to get from the current context
652/// (\p CurContext) to the target context (\p TargetContext).
653///
654/// \param Context the AST context in which the qualification will be used.
655///
656/// \param CurContext the context where an entity is being named, which is
657/// typically based on the current scope.
658///
659/// \param TargetContext the context in which the named entity actually
660/// resides.
661///
662/// \returns a nested name specifier that refers into the target context, or
663/// NULL if no qualification is needed.
664static NestedNameSpecifier *
665getRequiredQualification(ASTContext &Context, const DeclContext *CurContext,
666 const DeclContext *TargetContext) {
667 SmallVector<const DeclContext *, 4> TargetParents;
668
669 for (const DeclContext *CommonAncestor = TargetContext;
670 CommonAncestor && !CommonAncestor->Encloses(CurContext);
671 CommonAncestor = CommonAncestor->getLookupParent()) {
672 if (CommonAncestor->isTransparentContext() ||
673 CommonAncestor->isFunctionOrMethod())
674 continue;
675
676 TargetParents.push_back(CommonAncestor);
677 }
678
679 NestedNameSpecifier *Result = nullptr;
680 while (!TargetParents.empty()) {
681 const DeclContext *Parent = TargetParents.pop_back_val();
682
683 if (const auto *Namespace = dyn_cast<NamespaceDecl>(Parent)) {
684 if (!Namespace->getIdentifier())
685 continue;
686
687 Result = NestedNameSpecifier::Create(Context, Result, Namespace);
688 } else if (const auto *TD = dyn_cast<TagDecl>(Parent))
689 Result = NestedNameSpecifier::Create(
690 Context, Result, false, Context.getTypeDeclType(TD).getTypePtr());
691 }
692 return Result;
693}
694
695// Some declarations have reserved names that we don't want to ever show.
696// Filter out names reserved for the implementation if they come from a
697// system header.
698static bool shouldIgnoreDueToReservedName(const NamedDecl *ND, Sema &SemaRef) {
699 const IdentifierInfo *Id = ND->getIdentifier();
700 if (!Id)
701 return false;
702
703 // Ignore reserved names for compiler provided decls.
704 if (Id->isReservedName() && ND->getLocation().isInvalid())
705 return true;
706
707 // For system headers ignore only double-underscore names.
708 // This allows for system headers providing private symbols with a single
709 // underscore.
710 if (Id->isReservedName(/*doubleUnderscoreOnly=*/true) &&
711 SemaRef.SourceMgr.isInSystemHeader(
712 SemaRef.SourceMgr.getSpellingLoc(ND->getLocation())))
713 return true;
714
715 return false;
716}
717
718bool ResultBuilder::isInterestingDecl(const NamedDecl *ND,
719 bool &AsNestedNameSpecifier) const {
720 AsNestedNameSpecifier = false;
721
722 auto *Named = ND;
723 ND = ND->getUnderlyingDecl();
724
725 // Skip unnamed entities.
726 if (!ND->getDeclName())
727 return false;
728
729 // Friend declarations and declarations introduced due to friends are never
730 // added as results.
731 if (ND->getFriendObjectKind() == Decl::FOK_Undeclared)
732 return false;
733
734 // Class template (partial) specializations are never added as results.
735 if (isa<ClassTemplateSpecializationDecl>(ND) ||
736 isa<ClassTemplatePartialSpecializationDecl>(ND))
737 return false;
738
739 // Using declarations themselves are never added as results.
740 if (isa<UsingDecl>(ND))
741 return false;
742
743 if (shouldIgnoreDueToReservedName(ND, SemaRef))
744 return false;
745
746 if (Filter == &ResultBuilder::IsNestedNameSpecifier ||
747 (isa<NamespaceDecl>(ND) && Filter != &ResultBuilder::IsNamespace &&
748 Filter != &ResultBuilder::IsNamespaceOrAlias && Filter != nullptr))
749 AsNestedNameSpecifier = true;
750
751 // Filter out any unwanted results.
752 if (Filter && !(this->*Filter)(Named)) {
753 // Check whether it is interesting as a nested-name-specifier.
754 if (AllowNestedNameSpecifiers && SemaRef.getLangOpts().CPlusPlus &&
755 IsNestedNameSpecifier(ND) &&
756 (Filter != &ResultBuilder::IsMember ||
757 (isa<CXXRecordDecl>(ND) &&
758 cast<CXXRecordDecl>(ND)->isInjectedClassName()))) {
759 AsNestedNameSpecifier = true;
760 return true;
761 }
762
763 return false;
764 }
765 // ... then it must be interesting!
766 return true;
767}
768
769bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext,
770 const NamedDecl *Hiding) {
771 // In C, there is no way to refer to a hidden name.
772 // FIXME: This isn't true; we can find a tag name hidden by an ordinary
773 // name if we introduce the tag type.
774 if (!SemaRef.getLangOpts().CPlusPlus)
775 return true;
776
777 const DeclContext *HiddenCtx =
778 R.Declaration->getDeclContext()->getRedeclContext();
779
780 // There is no way to qualify a name declared in a function or method.
781 if (HiddenCtx->isFunctionOrMethod())
782 return true;
783
784 if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext())
785 return true;
786
787 // We can refer to the result with the appropriate qualification. Do it.
788 R.Hidden = true;
789 R.QualifierIsInformative = false;
790
791 if (!R.Qualifier)
792 R.Qualifier = getRequiredQualification(SemaRef.Context, CurContext,
793 R.Declaration->getDeclContext());
794 return false;
795}
796
797/// A simplified classification of types used to determine whether two
798/// types are "similar enough" when adjusting priorities.
799SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) {
800 switch (T->getTypeClass()) {
801 case Type::Builtin:
802 switch (cast<BuiltinType>(T)->getKind()) {
803 case BuiltinType::Void:
804 return STC_Void;
805
806 case BuiltinType::NullPtr:
807 return STC_Pointer;
808
809 case BuiltinType::Overload:
810 case BuiltinType::Dependent:
811 return STC_Other;
812
813 case BuiltinType::ObjCId:
814 case BuiltinType::ObjCClass:
815 case BuiltinType::ObjCSel:
816 return STC_ObjectiveC;
817
818 default:
819 return STC_Arithmetic;
820 }
821
822 case Type::Complex:
823 return STC_Arithmetic;
824
825 case Type::Pointer:
826 return STC_Pointer;
827
828 case Type::BlockPointer:
829 return STC_Block;
830
831 case Type::LValueReference:
832 case Type::RValueReference:
833 return getSimplifiedTypeClass(T->getAs<ReferenceType>()->getPointeeType());
834
835 case Type::ConstantArray:
836 case Type::IncompleteArray:
837 case Type::VariableArray:
838 case Type::DependentSizedArray:
839 return STC_Array;
840
841 case Type::DependentSizedExtVector:
842 case Type::Vector:
843 case Type::ExtVector:
844 return STC_Arithmetic;
845
846 case Type::FunctionProto:
847 case Type::FunctionNoProto:
848 return STC_Function;
849
850 case Type::Record:
851 return STC_Record;
852
853 case Type::Enum:
854 return STC_Arithmetic;
855
856 case Type::ObjCObject:
857 case Type::ObjCInterface:
858 case Type::ObjCObjectPointer:
859 return STC_ObjectiveC;
860
861 default:
862 return STC_Other;
863 }
864}
865
866/// Get the type that a given expression will have if this declaration
867/// is used as an expression in its "typical" code-completion form.
868QualType clang::getDeclUsageType(ASTContext &C, const NamedDecl *ND) {
869 ND = ND->getUnderlyingDecl();
870
871 if (const auto *Type = dyn_cast<TypeDecl>(ND))
872 return C.getTypeDeclType(Type);
873 if (const auto *Iface = dyn_cast<ObjCInterfaceDecl>(ND))
874 return C.getObjCInterfaceType(Iface);
875
876 QualType T;
877 if (const FunctionDecl *Function = ND->getAsFunction())
878 T = Function->getCallResultType();
879 else if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND))
880 T = Method->getSendResultType();
881 else if (const auto *Enumerator = dyn_cast<EnumConstantDecl>(ND))
882 T = C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext()));
883 else if (const auto *Property = dyn_cast<ObjCPropertyDecl>(ND))
884 T = Property->getType();
885 else if (const auto *Value = dyn_cast<ValueDecl>(ND))
886 T = Value->getType();
887
888 if (T.isNull())
889 return QualType();
890
891 // Dig through references, function pointers, and block pointers to
892 // get down to the likely type of an expression when the entity is
893 // used.
894 do {
895 if (const auto *Ref = T->getAs<ReferenceType>()) {
896 T = Ref->getPointeeType();
897 continue;
898 }
899
900 if (const auto *Pointer = T->getAs<PointerType>()) {
901 if (Pointer->getPointeeType()->isFunctionType()) {
902 T = Pointer->getPointeeType();
903 continue;
904 }
905
906 break;
907 }
908
909 if (const auto *Block = T->getAs<BlockPointerType>()) {
910 T = Block->getPointeeType();
911 continue;
912 }
913
914 if (const auto *Function = T->getAs<FunctionType>()) {
915 T = Function->getReturnType();
916 continue;
917 }
918
919 break;
920 } while (true);
921
922 return T;
923}
924
925unsigned ResultBuilder::getBasePriority(const NamedDecl *ND) {
926 if (!ND)
927 return CCP_Unlikely;
928
929 // Context-based decisions.
930 const DeclContext *LexicalDC = ND->getLexicalDeclContext();
931 if (LexicalDC->isFunctionOrMethod()) {
932 // _cmd is relatively rare
933 if (const auto *ImplicitParam = dyn_cast<ImplicitParamDecl>(ND))
934 if (ImplicitParam->getIdentifier() &&
935 ImplicitParam->getIdentifier()->isStr("_cmd"))
936 return CCP_ObjC_cmd;
937
938 return CCP_LocalDeclaration;
939 }
940
941 const DeclContext *DC = ND->getDeclContext()->getRedeclContext();
942 if (DC->isRecord() || isa<ObjCContainerDecl>(DC)) {
943 // Explicit destructor calls are very rare.
944 if (isa<CXXDestructorDecl>(ND))
945 return CCP_Unlikely;
946 // Explicit operator and conversion function calls are also very rare.
947 auto DeclNameKind = ND->getDeclName().getNameKind();
948 if (DeclNameKind == DeclarationName::CXXOperatorName ||
949 DeclNameKind == DeclarationName::CXXLiteralOperatorName ||
950 DeclNameKind == DeclarationName::CXXConversionFunctionName)
951 return CCP_Unlikely;
952 return CCP_MemberDeclaration;
953 }
954
955 // Content-based decisions.
956 if (isa<EnumConstantDecl>(ND))
957 return CCP_Constant;
958
959 // Use CCP_Type for type declarations unless we're in a statement, Objective-C
960 // message receiver, or parenthesized expression context. There, it's as
961 // likely that the user will want to write a type as other declarations.
962 if ((isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) &&
963 !(CompletionContext.getKind() == CodeCompletionContext::CCC_Statement ||
964 CompletionContext.getKind() ==
965 CodeCompletionContext::CCC_ObjCMessageReceiver ||
966 CompletionContext.getKind() ==
967 CodeCompletionContext::CCC_ParenthesizedExpression))
968 return CCP_Type;
969
970 return CCP_Declaration;
971}
972
973void ResultBuilder::AdjustResultPriorityForDecl(Result &R) {
974 // If this is an Objective-C method declaration whose selector matches our
975 // preferred selector, give it a priority boost.
976 if (!PreferredSelector.isNull())
977 if (const auto *Method = dyn_cast<ObjCMethodDecl>(R.Declaration))
978 if (PreferredSelector == Method->getSelector())
979 R.Priority += CCD_SelectorMatch;
980
981 // If we have a preferred type, adjust the priority for results with exactly-
982 // matching or nearly-matching types.
983 if (!PreferredType.isNull()) {
984 QualType T = getDeclUsageType(SemaRef.Context, R.Declaration);
985 if (!T.isNull()) {
986 CanQualType TC = SemaRef.Context.getCanonicalType(T);
987 // Check for exactly-matching types (modulo qualifiers).
988 if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC))
989 R.Priority /= CCF_ExactTypeMatch;
990 // Check for nearly-matching types, based on classification of each.
991 else if ((getSimplifiedTypeClass(PreferredType) ==
992 getSimplifiedTypeClass(TC)) &&
993 !(PreferredType->isEnumeralType() && TC->isEnumeralType()))
994 R.Priority /= CCF_SimilarTypeMatch;
995 }
996 }
997}
998
999static DeclContext::lookup_result getConstructors(ASTContext &Context,
1000 const CXXRecordDecl *Record) {
1001 QualType RecordTy = Context.getTypeDeclType(Record);
1002 DeclarationName ConstructorName =
1003 Context.DeclarationNames.getCXXConstructorName(
1004 Context.getCanonicalType(RecordTy));
1005 return Record->lookup(ConstructorName);
1006}
1007
1008void ResultBuilder::MaybeAddConstructorResults(Result R) {
1009 if (!SemaRef.getLangOpts().CPlusPlus || !R.Declaration ||
1010 !CompletionContext.wantConstructorResults())
1011 return;
1012
1013 const NamedDecl *D = R.Declaration;
1014 const CXXRecordDecl *Record = nullptr;
1015 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D))
1016 Record = ClassTemplate->getTemplatedDecl();
1017 else if ((Record = dyn_cast<CXXRecordDecl>(D))) {
1018 // Skip specializations and partial specializations.
1019 if (isa<ClassTemplateSpecializationDecl>(Record))
1020 return;
1021 } else {
1022 // There are no constructors here.
1023 return;
1024 }
1025
1026 Record = Record->getDefinition();
1027 if (!Record)
1028 return;
1029
1030 for (NamedDecl *Ctor : getConstructors(SemaRef.Context, Record)) {
1031 R.Declaration = Ctor;
1032 R.CursorKind = getCursorKindForDecl(R.Declaration);
1033 Results.push_back(R);
1034 }
1035}
1036
1037static bool isConstructor(const Decl *ND) {
1038 if (const auto *Tmpl = dyn_cast<FunctionTemplateDecl>(ND))
1039 ND = Tmpl->getTemplatedDecl();
1040 return isa<CXXConstructorDecl>(ND);
1041}
1042
1043void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) {
1044 assert(!ShadowMaps.empty() && "Must enter into a results scope")((!ShadowMaps.empty() && "Must enter into a results scope"
) ? static_cast<void> (0) : __assert_fail ("!ShadowMaps.empty() && \"Must enter into a results scope\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 1044, __PRETTY_FUNCTION__))
;
1045
1046 if (R.Kind != Result::RK_Declaration) {
1047 // For non-declaration results, just add the result.
1048 Results.push_back(R);
1049 return;
1050 }
1051
1052 // Look through using declarations.
1053 if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
1054 CodeCompletionResult Result(Using->getTargetDecl(),
1055 getBasePriority(Using->getTargetDecl()),
1056 R.Qualifier);
1057 Result.ShadowDecl = Using;
1058 MaybeAddResult(Result, CurContext);
1059 return;
1060 }
1061
1062 const Decl *CanonDecl = R.Declaration->getCanonicalDecl();
1063 unsigned IDNS = CanonDecl->getIdentifierNamespace();
1064
1065 bool AsNestedNameSpecifier = false;
1066 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
1067 return;
1068
1069 // C++ constructors are never found by name lookup.
1070 if (isConstructor(R.Declaration))
1071 return;
1072
1073 ShadowMap &SMap = ShadowMaps.back();
1074 ShadowMapEntry::iterator I, IEnd;
1075 ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName());
1076 if (NamePos != SMap.end()) {
1077 I = NamePos->second.begin();
1078 IEnd = NamePos->second.end();
1079 }
1080
1081 for (; I != IEnd; ++I) {
1082 const NamedDecl *ND = I->first;
1083 unsigned Index = I->second;
1084 if (ND->getCanonicalDecl() == CanonDecl) {
1085 // This is a redeclaration. Always pick the newer declaration.
1086 Results[Index].Declaration = R.Declaration;
1087
1088 // We're done.
1089 return;
1090 }
1091 }
1092
1093 // This is a new declaration in this scope. However, check whether this
1094 // declaration name is hidden by a similarly-named declaration in an outer
1095 // scope.
1096 std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end();
1097 --SMEnd;
1098 for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) {
1099 ShadowMapEntry::iterator I, IEnd;
1100 ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName());
1101 if (NamePos != SM->end()) {
1102 I = NamePos->second.begin();
1103 IEnd = NamePos->second.end();
1104 }
1105 for (; I != IEnd; ++I) {
1106 // A tag declaration does not hide a non-tag declaration.
1107 if (I->first->hasTagIdentifierNamespace() &&
1108 (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary |
1109 Decl::IDNS_LocalExtern | Decl::IDNS_ObjCProtocol)))
1110 continue;
1111
1112 // Protocols are in distinct namespaces from everything else.
1113 if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol) ||
1114 (IDNS & Decl::IDNS_ObjCProtocol)) &&
1115 I->first->getIdentifierNamespace() != IDNS)
1116 continue;
1117
1118 // The newly-added result is hidden by an entry in the shadow map.
1119 if (CheckHiddenResult(R, CurContext, I->first))
1120 return;
1121
1122 break;
1123 }
1124 }
1125
1126 // Make sure that any given declaration only shows up in the result set once.
1127 if (!AllDeclsFound.insert(CanonDecl).second)
1128 return;
1129
1130 // If the filter is for nested-name-specifiers, then this result starts a
1131 // nested-name-specifier.
1132 if (AsNestedNameSpecifier) {
1133 R.StartsNestedNameSpecifier = true;
1134 R.Priority = CCP_NestedNameSpecifier;
1135 } else
1136 AdjustResultPriorityForDecl(R);
1137
1138 // If this result is supposed to have an informative qualifier, add one.
1139 if (R.QualifierIsInformative && !R.Qualifier &&
1140 !R.StartsNestedNameSpecifier) {
1141 const DeclContext *Ctx = R.Declaration->getDeclContext();
1142 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
1143 R.Qualifier =
1144 NestedNameSpecifier::Create(SemaRef.Context, nullptr, Namespace);
1145 else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
1146 R.Qualifier = NestedNameSpecifier::Create(
1147 SemaRef.Context, nullptr, false,
1148 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
1149 else
1150 R.QualifierIsInformative = false;
1151 }
1152
1153 // Insert this result into the set of results and into the current shadow
1154 // map.
1155 SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
1156 Results.push_back(R);
1157
1158 if (!AsNestedNameSpecifier)
1159 MaybeAddConstructorResults(R);
1160}
1161
1162static void setInBaseClass(ResultBuilder::Result &R) {
1163 R.Priority += CCD_InBaseClass;
1164 R.InBaseClass = true;
1165}
1166
1167enum class OverloadCompare { BothViable, Dominates, Dominated };
1168// Will Candidate ever be called on the object, when overloaded with Incumbent?
1169// Returns Dominates if Candidate is always called, Dominated if Incumbent is
1170// always called, BothViable if either may be called dependending on arguments.
1171// Precondition: must actually be overloads!
1172static OverloadCompare compareOverloads(const CXXMethodDecl &Candidate,
1173 const CXXMethodDecl &Incumbent,
1174 const Qualifiers &ObjectQuals,
1175 ExprValueKind ObjectKind) {
1176 // Base/derived shadowing is handled elsewhere.
1177 if (Candidate.getDeclContext() != Incumbent.getDeclContext())
1178 return OverloadCompare::BothViable;
1179 if (Candidate.isVariadic() != Incumbent.isVariadic() ||
1180 Candidate.getNumParams() != Incumbent.getNumParams() ||
1181 Candidate.getMinRequiredArguments() !=
1182 Incumbent.getMinRequiredArguments())
1183 return OverloadCompare::BothViable;
1184 for (unsigned I = 0, E = Candidate.getNumParams(); I != E; ++I)
1185 if (Candidate.parameters()[I]->getType().getCanonicalType() !=
1186 Incumbent.parameters()[I]->getType().getCanonicalType())
1187 return OverloadCompare::BothViable;
1188 if (!llvm::empty(Candidate.specific_attrs<EnableIfAttr>()) ||
1189 !llvm::empty(Incumbent.specific_attrs<EnableIfAttr>()))
1190 return OverloadCompare::BothViable;
1191 // At this point, we know calls can't pick one or the other based on
1192 // arguments, so one of the two must win. (Or both fail, handled elsewhere).
1193 RefQualifierKind CandidateRef = Candidate.getRefQualifier();
1194 RefQualifierKind IncumbentRef = Incumbent.getRefQualifier();
1195 if (CandidateRef != IncumbentRef) {
1196 // If the object kind is LValue/RValue, there's one acceptable ref-qualifier
1197 // and it can't be mixed with ref-unqualified overloads (in valid code).
1198
1199 // For xvalue objects, we prefer the rvalue overload even if we have to
1200 // add qualifiers (which is rare, because const&& is rare).
1201 if (ObjectKind == clang::VK_XValue)
1202 return CandidateRef == RQ_RValue ? OverloadCompare::Dominates
1203 : OverloadCompare::Dominated;
1204 }
1205 // Now the ref qualifiers are the same (or we're in some invalid state).
1206 // So make some decision based on the qualifiers.
1207 Qualifiers CandidateQual = Candidate.getMethodQualifiers();
1208 Qualifiers IncumbentQual = Incumbent.getMethodQualifiers();
1209 bool CandidateSuperset = CandidateQual.compatiblyIncludes(IncumbentQual);
1210 bool IncumbentSuperset = IncumbentQual.compatiblyIncludes(CandidateQual);
1211 if (CandidateSuperset == IncumbentSuperset)
1212 return OverloadCompare::BothViable;
1213 return IncumbentSuperset ? OverloadCompare::Dominates
1214 : OverloadCompare::Dominated;
1215}
1216
1217void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
1218 NamedDecl *Hiding, bool InBaseClass = false) {
1219 if (R.Kind != Result::RK_Declaration) {
1220 // For non-declaration results, just add the result.
1221 Results.push_back(R);
1222 return;
1223 }
1224
1225 // Look through using declarations.
1226 if (const auto *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
1227 CodeCompletionResult Result(Using->getTargetDecl(),
1228 getBasePriority(Using->getTargetDecl()),
1229 R.Qualifier);
1230 Result.ShadowDecl = Using;
1231 AddResult(Result, CurContext, Hiding);
1232 return;
1233 }
1234
1235 bool AsNestedNameSpecifier = false;
1236 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
1237 return;
1238
1239 // C++ constructors are never found by name lookup.
1240 if (isConstructor(R.Declaration))
1241 return;
1242
1243 if (Hiding && CheckHiddenResult(R, CurContext, Hiding))
1244 return;
1245
1246 // Make sure that any given declaration only shows up in the result set once.
1247 if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()).second)
1248 return;
1249
1250 // If the filter is for nested-name-specifiers, then this result starts a
1251 // nested-name-specifier.
1252 if (AsNestedNameSpecifier) {
1253 R.StartsNestedNameSpecifier = true;
1254 R.Priority = CCP_NestedNameSpecifier;
1255 } else if (Filter == &ResultBuilder::IsMember && !R.Qualifier &&
1256 InBaseClass &&
1257 isa<CXXRecordDecl>(
1258 R.Declaration->getDeclContext()->getRedeclContext()))
1259 R.QualifierIsInformative = true;
1260
1261 // If this result is supposed to have an informative qualifier, add one.
1262 if (R.QualifierIsInformative && !R.Qualifier &&
1263 !R.StartsNestedNameSpecifier) {
1264 const DeclContext *Ctx = R.Declaration->getDeclContext();
1265 if (const auto *Namespace = dyn_cast<NamespaceDecl>(Ctx))
1266 R.Qualifier =
1267 NestedNameSpecifier::Create(SemaRef.Context, nullptr, Namespace);
1268 else if (const auto *Tag = dyn_cast<TagDecl>(Ctx))
1269 R.Qualifier = NestedNameSpecifier::Create(
1270 SemaRef.Context, nullptr, false,
1271 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
1272 else
1273 R.QualifierIsInformative = false;
1274 }
1275
1276 // Adjust the priority if this result comes from a base class.
1277 if (InBaseClass)
1278 setInBaseClass(R);
1279
1280 AdjustResultPriorityForDecl(R);
1281
1282 if (HasObjectTypeQualifiers)
1283 if (const auto *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
1284 if (Method->isInstance()) {
1285 Qualifiers MethodQuals = Method->getMethodQualifiers();
1286 if (ObjectTypeQualifiers == MethodQuals)
1287 R.Priority += CCD_ObjectQualifierMatch;
1288 else if (ObjectTypeQualifiers - MethodQuals) {
1289 // The method cannot be invoked, because doing so would drop
1290 // qualifiers.
1291 return;
1292 }
1293 // Detect cases where a ref-qualified method cannot be invoked.
1294 switch (Method->getRefQualifier()) {
1295 case RQ_LValue:
1296 if (ObjectKind != VK_LValue && !MethodQuals.hasConst())
1297 return;
1298 break;
1299 case RQ_RValue:
1300 if (ObjectKind == VK_LValue)
1301 return;
1302 break;
1303 case RQ_None:
1304 break;
1305 }
1306
1307 /// Check whether this dominates another overloaded method, which should
1308 /// be suppressed (or vice versa).
1309 /// Motivating case is const_iterator begin() const vs iterator begin().
1310 auto &OverloadSet = OverloadMap[std::make_pair(
1311 CurContext, Method->getDeclName().getAsOpaqueInteger())];
1312 for (const DeclIndexPair Entry : OverloadSet) {
1313 Result &Incumbent = Results[Entry.second];
1314 switch (compareOverloads(*Method,
1315 *cast<CXXMethodDecl>(Incumbent.Declaration),
1316 ObjectTypeQualifiers, ObjectKind)) {
1317 case OverloadCompare::Dominates:
1318 // Replace the dominated overload with this one.
1319 // FIXME: if the overload dominates multiple incumbents then we
1320 // should remove all. But two overloads is by far the common case.
1321 Incumbent = std::move(R);
1322 return;
1323 case OverloadCompare::Dominated:
1324 // This overload can't be called, drop it.
1325 return;
1326 case OverloadCompare::BothViable:
1327 break;
1328 }
1329 }
1330 OverloadSet.Add(Method, Results.size());
1331 }
1332
1333 // Insert this result into the set of results.
1334 Results.push_back(R);
1335
1336 if (!AsNestedNameSpecifier)
1337 MaybeAddConstructorResults(R);
1338}
1339
1340void ResultBuilder::AddResult(Result R) {
1341 assert(R.Kind != Result::RK_Declaration &&((R.Kind != Result::RK_Declaration && "Declaration results need more context"
) ? static_cast<void> (0) : __assert_fail ("R.Kind != Result::RK_Declaration && \"Declaration results need more context\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 1342, __PRETTY_FUNCTION__))
1342 "Declaration results need more context")((R.Kind != Result::RK_Declaration && "Declaration results need more context"
) ? static_cast<void> (0) : __assert_fail ("R.Kind != Result::RK_Declaration && \"Declaration results need more context\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 1342, __PRETTY_FUNCTION__))
;
1343 Results.push_back(R);
1344}
1345
1346/// Enter into a new scope.
1347void ResultBuilder::EnterNewScope() { ShadowMaps.emplace_back(); }
1348
1349/// Exit from the current scope.
1350void ResultBuilder::ExitScope() {
1351 ShadowMaps.pop_back();
1352}
1353
1354/// Determines whether this given declaration will be found by
1355/// ordinary name lookup.
1356bool ResultBuilder::IsOrdinaryName(const NamedDecl *ND) const {
1357 ND = ND->getUnderlyingDecl();
1358
1359 // If name lookup finds a local extern declaration, then we are in a
1360 // context where it behaves like an ordinary name.
1361 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1362 if (SemaRef.getLangOpts().CPlusPlus)
1363 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
1364 else if (SemaRef.getLangOpts().ObjC) {
1365 if (isa<ObjCIvarDecl>(ND))
1366 return true;
1367 }
1368
1369 return ND->getIdentifierNamespace() & IDNS;
1370}
1371
1372/// Determines whether this given declaration will be found by
1373/// ordinary name lookup but is not a type name.
1374bool ResultBuilder::IsOrdinaryNonTypeName(const NamedDecl *ND) const {
1375 ND = ND->getUnderlyingDecl();
1376 if (isa<TypeDecl>(ND))
1377 return false;
1378 // Objective-C interfaces names are not filtered by this method because they
1379 // can be used in a class property expression. We can still filter out
1380 // @class declarations though.
1381 if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND)) {
1382 if (!ID->getDefinition())
1383 return false;
1384 }
1385
1386 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1387 if (SemaRef.getLangOpts().CPlusPlus)
1388 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
1389 else if (SemaRef.getLangOpts().ObjC) {
1390 if (isa<ObjCIvarDecl>(ND))
1391 return true;
1392 }
1393
1394 return ND->getIdentifierNamespace() & IDNS;
1395}
1396
1397bool ResultBuilder::IsIntegralConstantValue(const NamedDecl *ND) const {
1398 if (!IsOrdinaryNonTypeName(ND))
1399 return 0;
1400
1401 if (const auto *VD = dyn_cast<ValueDecl>(ND->getUnderlyingDecl()))
1402 if (VD->getType()->isIntegralOrEnumerationType())
1403 return true;
1404
1405 return false;
1406}
1407
1408/// Determines whether this given declaration will be found by
1409/// ordinary name lookup.
1410bool ResultBuilder::IsOrdinaryNonValueName(const NamedDecl *ND) const {
1411 ND = ND->getUnderlyingDecl();
1412
1413 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1414 if (SemaRef.getLangOpts().CPlusPlus)
1415 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace;
1416
1417 return (ND->getIdentifierNamespace() & IDNS) && !isa<ValueDecl>(ND) &&
1418 !isa<FunctionTemplateDecl>(ND) && !isa<ObjCPropertyDecl>(ND);
1419}
1420
1421/// Determines whether the given declaration is suitable as the
1422/// start of a C++ nested-name-specifier, e.g., a class or namespace.
1423bool ResultBuilder::IsNestedNameSpecifier(const NamedDecl *ND) const {
1424 // Allow us to find class templates, too.
1425 if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1426 ND = ClassTemplate->getTemplatedDecl();
1427
1428 return SemaRef.isAcceptableNestedNameSpecifier(ND);
1429}
1430
1431/// Determines whether the given declaration is an enumeration.
1432bool ResultBuilder::IsEnum(const NamedDecl *ND) const {
1433 return isa<EnumDecl>(ND);
1434}
1435
1436/// Determines whether the given declaration is a class or struct.
1437bool ResultBuilder::IsClassOrStruct(const NamedDecl *ND) const {
1438 // Allow us to find class templates, too.
1439 if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1440 ND = ClassTemplate->getTemplatedDecl();
1441
1442 // For purposes of this check, interfaces match too.
1443 if (const auto *RD = dyn_cast<RecordDecl>(ND))
1444 return RD->getTagKind() == TTK_Class || RD->getTagKind() == TTK_Struct ||
1445 RD->getTagKind() == TTK_Interface;
1446
1447 return false;
1448}
1449
1450/// Determines whether the given declaration is a union.
1451bool ResultBuilder::IsUnion(const NamedDecl *ND) const {
1452 // Allow us to find class templates, too.
1453 if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1454 ND = ClassTemplate->getTemplatedDecl();
1455
1456 if (const auto *RD = dyn_cast<RecordDecl>(ND))
1457 return RD->getTagKind() == TTK_Union;
1458
1459 return false;
1460}
1461
1462/// Determines whether the given declaration is a namespace.
1463bool ResultBuilder::IsNamespace(const NamedDecl *ND) const {
1464 return isa<NamespaceDecl>(ND);
1465}
1466
1467/// Determines whether the given declaration is a namespace or
1468/// namespace alias.
1469bool ResultBuilder::IsNamespaceOrAlias(const NamedDecl *ND) const {
1470 return isa<NamespaceDecl>(ND->getUnderlyingDecl());
1471}
1472
1473/// Determines whether the given declaration is a type.
1474bool ResultBuilder::IsType(const NamedDecl *ND) const {
1475 ND = ND->getUnderlyingDecl();
1476 return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
1477}
1478
1479/// Determines which members of a class should be visible via
1480/// "." or "->". Only value declarations, nested name specifiers, and
1481/// using declarations thereof should show up.
1482bool ResultBuilder::IsMember(const NamedDecl *ND) const {
1483 ND = ND->getUnderlyingDecl();
1484 return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||
1485 isa<ObjCPropertyDecl>(ND);
1486}
1487
1488static bool isObjCReceiverType(ASTContext &C, QualType T) {
1489 T = C.getCanonicalType(T);
1490 switch (T->getTypeClass()) {
1491 case Type::ObjCObject:
1492 case Type::ObjCInterface:
1493 case Type::ObjCObjectPointer:
1494 return true;
1495
1496 case Type::Builtin:
1497 switch (cast<BuiltinType>(T)->getKind()) {
1498 case BuiltinType::ObjCId:
1499 case BuiltinType::ObjCClass:
1500 case BuiltinType::ObjCSel:
1501 return true;
1502
1503 default:
1504 break;
1505 }
1506 return false;
1507
1508 default:
1509 break;
1510 }
1511
1512 if (!C.getLangOpts().CPlusPlus)
1513 return false;
1514
1515 // FIXME: We could perform more analysis here to determine whether a
1516 // particular class type has any conversions to Objective-C types. For now,
1517 // just accept all class types.
1518 return T->isDependentType() || T->isRecordType();
1519}
1520
1521bool ResultBuilder::IsObjCMessageReceiver(const NamedDecl *ND) const {
1522 QualType T = getDeclUsageType(SemaRef.Context, ND);
1523 if (T.isNull())
1524 return false;
1525
1526 T = SemaRef.Context.getBaseElementType(T);
1527 return isObjCReceiverType(SemaRef.Context, T);
1528}
1529
1530bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture(
1531 const NamedDecl *ND) const {
1532 if (IsObjCMessageReceiver(ND))
1533 return true;
1534
1535 const auto *Var = dyn_cast<VarDecl>(ND);
1536 if (!Var)
1537 return false;
1538
1539 return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>();
1540}
1541
1542bool ResultBuilder::IsObjCCollection(const NamedDecl *ND) const {
1543 if ((SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) ||
1544 (!SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND)))
1545 return false;
1546
1547 QualType T = getDeclUsageType(SemaRef.Context, ND);
1548 if (T.isNull())
1549 return false;
1550
1551 T = SemaRef.Context.getBaseElementType(T);
1552 return T->isObjCObjectType() || T->isObjCObjectPointerType() ||
1553 T->isObjCIdType() ||
1554 (SemaRef.getLangOpts().CPlusPlus && T->isRecordType());
1555}
1556
1557bool ResultBuilder::IsImpossibleToSatisfy(const NamedDecl *ND) const {
1558 return false;
1559}
1560
1561/// Determines whether the given declaration is an Objective-C
1562/// instance variable.
1563bool ResultBuilder::IsObjCIvar(const NamedDecl *ND) const {
1564 return isa<ObjCIvarDecl>(ND);
1565}
1566
1567namespace {
1568
1569/// Visible declaration consumer that adds a code-completion result
1570/// for each visible declaration.
1571class CodeCompletionDeclConsumer : public VisibleDeclConsumer {
1572 ResultBuilder &Results;
1573 DeclContext *InitialLookupCtx;
1574 // NamingClass and BaseType are used for access-checking. See
1575 // Sema::IsSimplyAccessible for details.
1576 CXXRecordDecl *NamingClass;
1577 QualType BaseType;
1578 std::vector<FixItHint> FixIts;
1579
1580public:
1581 CodeCompletionDeclConsumer(
1582 ResultBuilder &Results, DeclContext *InitialLookupCtx,
1583 QualType BaseType = QualType(),
1584 std::vector<FixItHint> FixIts = std::vector<FixItHint>())
1585 : Results(Results), InitialLookupCtx(InitialLookupCtx),
1586 FixIts(std::move(FixIts)) {
1587 NamingClass = llvm::dyn_cast<CXXRecordDecl>(InitialLookupCtx);
1588 // If BaseType was not provided explicitly, emulate implicit 'this->'.
1589 if (BaseType.isNull()) {
1590 auto ThisType = Results.getSema().getCurrentThisType();
1591 if (!ThisType.isNull()) {
1592 assert(ThisType->isPointerType())((ThisType->isPointerType()) ? static_cast<void> (0)
: __assert_fail ("ThisType->isPointerType()", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 1592, __PRETTY_FUNCTION__))
;
1593 BaseType = ThisType->getPointeeType();
1594 if (!NamingClass)
1595 NamingClass = BaseType->getAsCXXRecordDecl();
1596 }
1597 }
1598 this->BaseType = BaseType;
1599 }
1600
1601 void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
1602 bool InBaseClass) override {
1603 ResultBuilder::Result Result(ND, Results.getBasePriority(ND), nullptr,
1604 false, IsAccessible(ND, Ctx), FixIts);
1605 Results.AddResult(Result, InitialLookupCtx, Hiding, InBaseClass);
1606 }
1607
1608 void EnteredContext(DeclContext *Ctx) override {
1609 Results.addVisitedContext(Ctx);
1610 }
1611
1612private:
1613 bool IsAccessible(NamedDecl *ND, DeclContext *Ctx) {
1614 // Naming class to use for access check. In most cases it was provided
1615 // explicitly (e.g. member access (lhs.foo) or qualified lookup (X::)),
1616 // for unqualified lookup we fallback to the \p Ctx in which we found the
1617 // member.
1618 auto *NamingClass = this->NamingClass;
1619 QualType BaseType = this->BaseType;
1620 if (auto *Cls = llvm::dyn_cast_or_null<CXXRecordDecl>(Ctx)) {
1621 if (!NamingClass)
1622 NamingClass = Cls;
1623 // When we emulate implicit 'this->' in an unqualified lookup, we might
1624 // end up with an invalid naming class. In that case, we avoid emulating
1625 // 'this->' qualifier to satisfy preconditions of the access checking.
1626 if (NamingClass->getCanonicalDecl() != Cls->getCanonicalDecl() &&
1627 !NamingClass->isDerivedFrom(Cls)) {
1628 NamingClass = Cls;
1629 BaseType = QualType();
1630 }
1631 } else {
1632 // The decl was found outside the C++ class, so only ObjC access checks
1633 // apply. Those do not rely on NamingClass and BaseType, so we clear them
1634 // out.
1635 NamingClass = nullptr;
1636 BaseType = QualType();
1637 }
1638 return Results.getSema().IsSimplyAccessible(ND, NamingClass, BaseType);
1639 }
1640};
1641} // namespace
1642
1643/// Add type specifiers for the current language as keyword results.
1644static void AddTypeSpecifierResults(const LangOptions &LangOpts,
1645 ResultBuilder &Results) {
1646 typedef CodeCompletionResult Result;
1647 Results.AddResult(Result("short", CCP_Type));
1648 Results.AddResult(Result("long", CCP_Type));
1649 Results.AddResult(Result("signed", CCP_Type));
1650 Results.AddResult(Result("unsigned", CCP_Type));
1651 Results.AddResult(Result("void", CCP_Type));
1652 Results.AddResult(Result("char", CCP_Type));
1653 Results.AddResult(Result("int", CCP_Type));
1654 Results.AddResult(Result("float", CCP_Type));
1655 Results.AddResult(Result("double", CCP_Type));
1656 Results.AddResult(Result("enum", CCP_Type));
1657 Results.AddResult(Result("struct", CCP_Type));
1658 Results.AddResult(Result("union", CCP_Type));
1659 Results.AddResult(Result("const", CCP_Type));
1660 Results.AddResult(Result("volatile", CCP_Type));
1661
1662 if (LangOpts.C99) {
1663 // C99-specific
1664 Results.AddResult(Result("_Complex", CCP_Type));
1665 Results.AddResult(Result("_Imaginary", CCP_Type));
1666 Results.AddResult(Result("_Bool", CCP_Type));
1667 Results.AddResult(Result("restrict", CCP_Type));
1668 }
1669
1670 CodeCompletionBuilder Builder(Results.getAllocator(),
1671 Results.getCodeCompletionTUInfo());
1672 if (LangOpts.CPlusPlus) {
1673 // C++-specific
1674 Results.AddResult(
1675 Result("bool", CCP_Type + (LangOpts.ObjC ? CCD_bool_in_ObjC : 0)));
1676 Results.AddResult(Result("class", CCP_Type));
1677 Results.AddResult(Result("wchar_t", CCP_Type));
1678
1679 // typename qualified-id
1680 Builder.AddTypedTextChunk("typename");
1681 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1682 Builder.AddPlaceholderChunk("qualifier");
1683 Builder.AddTextChunk("::");
1684 Builder.AddPlaceholderChunk("name");
1685 Results.AddResult(Result(Builder.TakeString()));
1686
1687 if (LangOpts.CPlusPlus11) {
1688 Results.AddResult(Result("auto", CCP_Type));
1689 Results.AddResult(Result("char16_t", CCP_Type));
1690 Results.AddResult(Result("char32_t", CCP_Type));
1691
1692 Builder.AddTypedTextChunk("decltype");
1693 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1694 Builder.AddPlaceholderChunk("expression");
1695 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1696 Results.AddResult(Result(Builder.TakeString()));
1697 }
1698 } else
1699 Results.AddResult(Result("__auto_type", CCP_Type));
1700
1701 // GNU keywords
1702 if (LangOpts.GNUKeywords) {
1703 // FIXME: Enable when we actually support decimal floating point.
1704 // Results.AddResult(Result("_Decimal32"));
1705 // Results.AddResult(Result("_Decimal64"));
1706 // Results.AddResult(Result("_Decimal128"));
1707
1708 Builder.AddTypedTextChunk("typeof");
1709 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1710 Builder.AddPlaceholderChunk("expression");
1711 Results.AddResult(Result(Builder.TakeString()));
1712
1713 Builder.AddTypedTextChunk("typeof");
1714 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1715 Builder.AddPlaceholderChunk("type");
1716 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1717 Results.AddResult(Result(Builder.TakeString()));
1718 }
1719
1720 // Nullability
1721 Results.AddResult(Result("_Nonnull", CCP_Type));
1722 Results.AddResult(Result("_Null_unspecified", CCP_Type));
1723 Results.AddResult(Result("_Nullable", CCP_Type));
1724}
1725
1726static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC,
1727 const LangOptions &LangOpts,
1728 ResultBuilder &Results) {
1729 typedef CodeCompletionResult Result;
1730 // Note: we don't suggest either "auto" or "register", because both
1731 // are pointless as storage specifiers. Elsewhere, we suggest "auto"
1732 // in C++0x as a type specifier.
1733 Results.AddResult(Result("extern"));
1734 Results.AddResult(Result("static"));
1735
1736 if (LangOpts.CPlusPlus11) {
1737 CodeCompletionAllocator &Allocator = Results.getAllocator();
1738 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1739
1740 // alignas
1741 Builder.AddTypedTextChunk("alignas");
1742 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1743 Builder.AddPlaceholderChunk("expression");
1744 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1745 Results.AddResult(Result(Builder.TakeString()));
1746
1747 Results.AddResult(Result("constexpr"));
1748 Results.AddResult(Result("thread_local"));
1749 }
1750}
1751
1752static void AddFunctionSpecifiers(Sema::ParserCompletionContext CCC,
1753 const LangOptions &LangOpts,
1754 ResultBuilder &Results) {
1755 typedef CodeCompletionResult Result;
1756 switch (CCC) {
1757 case Sema::PCC_Class:
1758 case Sema::PCC_MemberTemplate:
1759 if (LangOpts.CPlusPlus) {
1760 Results.AddResult(Result("explicit"));
1761 Results.AddResult(Result("friend"));
1762 Results.AddResult(Result("mutable"));
1763 Results.AddResult(Result("virtual"));
1764 }
1765 LLVM_FALLTHROUGH[[gnu::fallthrough]];
1766
1767 case Sema::PCC_ObjCInterface:
1768 case Sema::PCC_ObjCImplementation:
1769 case Sema::PCC_Namespace:
1770 case Sema::PCC_Template:
1771 if (LangOpts.CPlusPlus || LangOpts.C99)
1772 Results.AddResult(Result("inline"));
1773 break;
1774
1775 case Sema::PCC_ObjCInstanceVariableList:
1776 case Sema::PCC_Expression:
1777 case Sema::PCC_Statement:
1778 case Sema::PCC_ForInit:
1779 case Sema::PCC_Condition:
1780 case Sema::PCC_RecoveryInFunction:
1781 case Sema::PCC_Type:
1782 case Sema::PCC_ParenthesizedExpression:
1783 case Sema::PCC_LocalDeclarationSpecifiers:
1784 break;
1785 }
1786}
1787
1788static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt);
1789static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt);
1790static void AddObjCVisibilityResults(const LangOptions &LangOpts,
1791 ResultBuilder &Results, bool NeedAt);
1792static void AddObjCImplementationResults(const LangOptions &LangOpts,
1793 ResultBuilder &Results, bool NeedAt);
1794static void AddObjCInterfaceResults(const LangOptions &LangOpts,
1795 ResultBuilder &Results, bool NeedAt);
1796static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt);
1797
1798static void AddTypedefResult(ResultBuilder &Results) {
1799 CodeCompletionBuilder Builder(Results.getAllocator(),
1800 Results.getCodeCompletionTUInfo());
1801 Builder.AddTypedTextChunk("typedef");
1802 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1803 Builder.AddPlaceholderChunk("type");
1804 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1805 Builder.AddPlaceholderChunk("name");
1806 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1807 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1808}
1809
1810static bool WantTypesInContext(Sema::ParserCompletionContext CCC,
1811 const LangOptions &LangOpts) {
1812 switch (CCC) {
1813 case Sema::PCC_Namespace:
1814 case Sema::PCC_Class:
1815 case Sema::PCC_ObjCInstanceVariableList:
1816 case Sema::PCC_Template:
1817 case Sema::PCC_MemberTemplate:
1818 case Sema::PCC_Statement:
1819 case Sema::PCC_RecoveryInFunction:
1820 case Sema::PCC_Type:
1821 case Sema::PCC_ParenthesizedExpression:
1822 case Sema::PCC_LocalDeclarationSpecifiers:
1823 return true;
1824
1825 case Sema::PCC_Expression:
1826 case Sema::PCC_Condition:
1827 return LangOpts.CPlusPlus;
1828
1829 case Sema::PCC_ObjCInterface:
1830 case Sema::PCC_ObjCImplementation:
1831 return false;
1832
1833 case Sema::PCC_ForInit:
1834 return LangOpts.CPlusPlus || LangOpts.ObjC || LangOpts.C99;
1835 }
1836
1837 llvm_unreachable("Invalid ParserCompletionContext!")::llvm::llvm_unreachable_internal("Invalid ParserCompletionContext!"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 1837)
;
1838}
1839
1840static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context,
1841 const Preprocessor &PP) {
1842 PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
1843 Policy.AnonymousTagLocations = false;
1844 Policy.SuppressStrongLifetime = true;
1845 Policy.SuppressUnwrittenScope = true;
1846 Policy.SuppressScope = true;
1847 return Policy;
1848}
1849
1850/// Retrieve a printing policy suitable for code completion.
1851static PrintingPolicy getCompletionPrintingPolicy(Sema &S) {
1852 return getCompletionPrintingPolicy(S.Context, S.PP);
1853}
1854
1855/// Retrieve the string representation of the given type as a string
1856/// that has the appropriate lifetime for code completion.
1857///
1858/// This routine provides a fast path where we provide constant strings for
1859/// common type names.
1860static const char *GetCompletionTypeString(QualType T, ASTContext &Context,
1861 const PrintingPolicy &Policy,
1862 CodeCompletionAllocator &Allocator) {
1863 if (!T.getLocalQualifiers()) {
1864 // Built-in type names are constant strings.
1865 if (const BuiltinType *BT = dyn_cast<BuiltinType>(T))
1866 return BT->getNameAsCString(Policy);
1867
1868 // Anonymous tag types are constant strings.
1869 if (const TagType *TagT = dyn_cast<TagType>(T))
1870 if (TagDecl *Tag = TagT->getDecl())
1871 if (!Tag->hasNameForLinkage()) {
1872 switch (Tag->getTagKind()) {
1873 case TTK_Struct:
1874 return "struct <anonymous>";
1875 case TTK_Interface:
1876 return "__interface <anonymous>";
1877 case TTK_Class:
1878 return "class <anonymous>";
1879 case TTK_Union:
1880 return "union <anonymous>";
1881 case TTK_Enum:
1882 return "enum <anonymous>";
1883 }
1884 }
1885 }
1886
1887 // Slow path: format the type as a string.
1888 std::string Result;
1889 T.getAsStringInternal(Result, Policy);
1890 return Allocator.CopyString(Result);
1891}
1892
1893/// Add a completion for "this", if we're in a member function.
1894static void addThisCompletion(Sema &S, ResultBuilder &Results) {
1895 QualType ThisTy = S.getCurrentThisType();
1896 if (ThisTy.isNull())
1897 return;
1898
1899 CodeCompletionAllocator &Allocator = Results.getAllocator();
1900 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1901 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
1902 Builder.AddResultTypeChunk(
1903 GetCompletionTypeString(ThisTy, S.Context, Policy, Allocator));
1904 Builder.AddTypedTextChunk("this");
1905 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1906}
1907
1908static void AddStaticAssertResult(CodeCompletionBuilder &Builder,
1909 ResultBuilder &Results,
1910 const LangOptions &LangOpts) {
1911 if (!LangOpts.CPlusPlus11)
1912 return;
1913
1914 Builder.AddTypedTextChunk("static_assert");
1915 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1916 Builder.AddPlaceholderChunk("expression");
1917 Builder.AddChunk(CodeCompletionString::CK_Comma);
1918 Builder.AddPlaceholderChunk("message");
1919 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1920 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1921 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1922}
1923
1924static void AddOverrideResults(ResultBuilder &Results,
1925 const CodeCompletionContext &CCContext,
1926 CodeCompletionBuilder &Builder) {
1927 Sema &S = Results.getSema();
1928 const auto *CR = llvm::dyn_cast<CXXRecordDecl>(S.CurContext);
1929 // If not inside a class/struct/union return empty.
1930 if (!CR)
1931 return;
1932 // First store overrides within current class.
1933 // These are stored by name to make querying fast in the later step.
1934 llvm::StringMap<std::vector<FunctionDecl *>> Overrides;
1935 for (auto *Method : CR->methods()) {
1936 if (!Method->isVirtual() || !Method->getIdentifier())
1937 continue;
1938 Overrides[Method->getName()].push_back(Method);
1939 }
1940
1941 for (const auto &Base : CR->bases()) {
1942 const auto *BR = Base.getType().getTypePtr()->getAsCXXRecordDecl();
1943 if (!BR)
1944 continue;
1945 for (auto *Method : BR->methods()) {
1946 if (!Method->isVirtual() || !Method->getIdentifier())
1947 continue;
1948 const auto it = Overrides.find(Method->getName());
1949 bool IsOverriden = false;
1950 if (it != Overrides.end()) {
1951 for (auto *MD : it->second) {
1952 // If the method in current body is not an overload of this virtual
1953 // function, then it overrides this one.
1954 if (!S.IsOverload(MD, Method, false)) {
1955 IsOverriden = true;
1956 break;
1957 }
1958 }
1959 }
1960 if (!IsOverriden) {
1961 // Generates a new CodeCompletionResult by taking this function and
1962 // converting it into an override declaration with only one chunk in the
1963 // final CodeCompletionString as a TypedTextChunk.
1964 std::string OverrideSignature;
1965 llvm::raw_string_ostream OS(OverrideSignature);
1966 CodeCompletionResult CCR(Method, 0);
1967 PrintingPolicy Policy =
1968 getCompletionPrintingPolicy(S.getASTContext(), S.getPreprocessor());
1969 auto *CCS = CCR.createCodeCompletionStringForOverride(
1970 S.getPreprocessor(), S.getASTContext(), Builder,
1971 /*IncludeBriefComments=*/false, CCContext, Policy);
1972 Results.AddResult(CodeCompletionResult(CCS, Method, CCP_CodePattern));
1973 }
1974 }
1975 }
1976}
1977
1978/// Add language constructs that show up for "ordinary" names.
1979static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC, Scope *S,
1980 Sema &SemaRef, ResultBuilder &Results) {
1981 CodeCompletionAllocator &Allocator = Results.getAllocator();
1982 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1983
1984 typedef CodeCompletionResult Result;
1985 switch (CCC) {
1986 case Sema::PCC_Namespace:
1987 if (SemaRef.getLangOpts().CPlusPlus) {
1988 if (Results.includeCodePatterns()) {
1989 // namespace <identifier> { declarations }
1990 Builder.AddTypedTextChunk("namespace");
1991 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1992 Builder.AddPlaceholderChunk("identifier");
1993 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1994 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1995 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1996 Builder.AddPlaceholderChunk("declarations");
1997 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1998 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1999 Results.AddResult(Result(Builder.TakeString()));
2000 }
2001
2002 // namespace identifier = identifier ;
2003 Builder.AddTypedTextChunk("namespace");
2004 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2005 Builder.AddPlaceholderChunk("name");
2006 Builder.AddChunk(CodeCompletionString::CK_Equal);
2007 Builder.AddPlaceholderChunk("namespace");
2008 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2009 Results.AddResult(Result(Builder.TakeString()));
2010
2011 // Using directives
2012 Builder.AddTypedTextChunk("using namespace");
2013 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2014 Builder.AddPlaceholderChunk("identifier");
2015 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2016 Results.AddResult(Result(Builder.TakeString()));
2017
2018 // asm(string-literal)
2019 Builder.AddTypedTextChunk("asm");
2020 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2021 Builder.AddPlaceholderChunk("string-literal");
2022 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2023 Results.AddResult(Result(Builder.TakeString()));
2024
2025 if (Results.includeCodePatterns()) {
2026 // Explicit template instantiation
2027 Builder.AddTypedTextChunk("template");
2028 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2029 Builder.AddPlaceholderChunk("declaration");
2030 Results.AddResult(Result(Builder.TakeString()));
2031 } else {
2032 Results.AddResult(Result("template", CodeCompletionResult::RK_Keyword));
2033 }
2034 }
2035
2036 if (SemaRef.getLangOpts().ObjC)
2037 AddObjCTopLevelResults(Results, true);
2038
2039 AddTypedefResult(Results);
2040 LLVM_FALLTHROUGH[[gnu::fallthrough]];
2041
2042 case Sema::PCC_Class:
2043 if (SemaRef.getLangOpts().CPlusPlus) {
2044 // Using declaration
2045 Builder.AddTypedTextChunk("using");
2046 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2047 Builder.AddPlaceholderChunk("qualifier");
2048 Builder.AddTextChunk("::");
2049 Builder.AddPlaceholderChunk("name");
2050 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2051 Results.AddResult(Result(Builder.TakeString()));
2052
2053 // using typename qualifier::name (only in a dependent context)
2054 if (SemaRef.CurContext->isDependentContext()) {
2055 Builder.AddTypedTextChunk("using typename");
2056 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2057 Builder.AddPlaceholderChunk("qualifier");
2058 Builder.AddTextChunk("::");
2059 Builder.AddPlaceholderChunk("name");
2060 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2061 Results.AddResult(Result(Builder.TakeString()));
2062 }
2063
2064 AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts());
2065
2066 if (CCC == Sema::PCC_Class) {
2067 AddTypedefResult(Results);
2068
2069 bool IsNotInheritanceScope =
2070 !(S->getFlags() & Scope::ClassInheritanceScope);
2071 // public:
2072 Builder.AddTypedTextChunk("public");
2073 if (IsNotInheritanceScope && Results.includeCodePatterns())
2074 Builder.AddChunk(CodeCompletionString::CK_Colon);
2075 Results.AddResult(Result(Builder.TakeString()));
2076
2077 // protected:
2078 Builder.AddTypedTextChunk("protected");
2079 if (IsNotInheritanceScope && Results.includeCodePatterns())
2080 Builder.AddChunk(CodeCompletionString::CK_Colon);
2081 Results.AddResult(Result(Builder.TakeString()));
2082
2083 // private:
2084 Builder.AddTypedTextChunk("private");
2085 if (IsNotInheritanceScope && Results.includeCodePatterns())
2086 Builder.AddChunk(CodeCompletionString::CK_Colon);
2087 Results.AddResult(Result(Builder.TakeString()));
2088
2089 // FIXME: This adds override results only if we are at the first word of
2090 // the declaration/definition. Also call this from other sides to have
2091 // more use-cases.
2092 AddOverrideResults(Results, CodeCompletionContext::CCC_ClassStructUnion,
2093 Builder);
2094 }
2095 }
2096 LLVM_FALLTHROUGH[[gnu::fallthrough]];
2097
2098 case Sema::PCC_Template:
2099 case Sema::PCC_MemberTemplate:
2100 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
2101 // template < parameters >
2102 Builder.AddTypedTextChunk("template");
2103 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
2104 Builder.AddPlaceholderChunk("parameters");
2105 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
2106 Results.AddResult(Result(Builder.TakeString()));
2107 } else {
2108 Results.AddResult(Result("template", CodeCompletionResult::RK_Keyword));
2109 }
2110
2111 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2112 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2113 break;
2114
2115 case Sema::PCC_ObjCInterface:
2116 AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true);
2117 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2118 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2119 break;
2120
2121 case Sema::PCC_ObjCImplementation:
2122 AddObjCImplementationResults(SemaRef.getLangOpts(), Results, true);
2123 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2124 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2125 break;
2126
2127 case Sema::PCC_ObjCInstanceVariableList:
2128 AddObjCVisibilityResults(SemaRef.getLangOpts(), Results, true);
2129 break;
2130
2131 case Sema::PCC_RecoveryInFunction:
2132 case Sema::PCC_Statement: {
2133 AddTypedefResult(Results);
2134
2135 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() &&
2136 SemaRef.getLangOpts().CXXExceptions) {
2137 Builder.AddTypedTextChunk("try");
2138 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2139 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2140 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2141 Builder.AddPlaceholderChunk("statements");
2142 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2143 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2144 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2145 Builder.AddTextChunk("catch");
2146 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2147 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2148 Builder.AddPlaceholderChunk("declaration");
2149 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2150 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2151 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2152 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2153 Builder.AddPlaceholderChunk("statements");
2154 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2155 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2156 Results.AddResult(Result(Builder.TakeString()));
2157 }
2158 if (SemaRef.getLangOpts().ObjC)
2159 AddObjCStatementResults(Results, true);
2160
2161 if (Results.includeCodePatterns()) {
2162 // if (condition) { statements }
2163 Builder.AddTypedTextChunk("if");
2164 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2165 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2166 if (SemaRef.getLangOpts().CPlusPlus)
2167 Builder.AddPlaceholderChunk("condition");
2168 else
2169 Builder.AddPlaceholderChunk("expression");
2170 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2171 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2172 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2173 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2174 Builder.AddPlaceholderChunk("statements");
2175 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2176 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2177 Results.AddResult(Result(Builder.TakeString()));
2178
2179 // switch (condition) { }
2180 Builder.AddTypedTextChunk("switch");
2181 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2182 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2183 if (SemaRef.getLangOpts().CPlusPlus)
2184 Builder.AddPlaceholderChunk("condition");
2185 else
2186 Builder.AddPlaceholderChunk("expression");
2187 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2188 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2189 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2190 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2191 Builder.AddPlaceholderChunk("cases");
2192 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2193 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2194 Results.AddResult(Result(Builder.TakeString()));
2195 }
2196
2197 // Switch-specific statements.
2198 if (SemaRef.getCurFunction() &&
2199 !SemaRef.getCurFunction()->SwitchStack.empty()) {
2200 // case expression:
2201 Builder.AddTypedTextChunk("case");
2202 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2203 Builder.AddPlaceholderChunk("expression");
2204 Builder.AddChunk(CodeCompletionString::CK_Colon);
2205 Results.AddResult(Result(Builder.TakeString()));
2206
2207 // default:
2208 Builder.AddTypedTextChunk("default");
2209 Builder.AddChunk(CodeCompletionString::CK_Colon);
2210 Results.AddResult(Result(Builder.TakeString()));
2211 }
2212
2213 if (Results.includeCodePatterns()) {
2214 /// while (condition) { statements }
2215 Builder.AddTypedTextChunk("while");
2216 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2217 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2218 if (SemaRef.getLangOpts().CPlusPlus)
2219 Builder.AddPlaceholderChunk("condition");
2220 else
2221 Builder.AddPlaceholderChunk("expression");
2222 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2223 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2224 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2225 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2226 Builder.AddPlaceholderChunk("statements");
2227 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2228 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2229 Results.AddResult(Result(Builder.TakeString()));
2230
2231 // do { statements } while ( expression );
2232 Builder.AddTypedTextChunk("do");
2233 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2234 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2235 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2236 Builder.AddPlaceholderChunk("statements");
2237 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2238 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2239 Builder.AddTextChunk("while");
2240 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2241 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2242 Builder.AddPlaceholderChunk("expression");
2243 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2244 Results.AddResult(Result(Builder.TakeString()));
2245
2246 // for ( for-init-statement ; condition ; expression ) { statements }
2247 Builder.AddTypedTextChunk("for");
2248 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2249 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2250 if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99)
2251 Builder.AddPlaceholderChunk("init-statement");
2252 else
2253 Builder.AddPlaceholderChunk("init-expression");
2254 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2255 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2256 Builder.AddPlaceholderChunk("condition");
2257 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2258 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2259 Builder.AddPlaceholderChunk("inc-expression");
2260 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2261 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2262 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2263 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2264 Builder.AddPlaceholderChunk("statements");
2265 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2266 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2267 Results.AddResult(Result(Builder.TakeString()));
2268 }
2269
2270 if (S->getContinueParent()) {
2271 // continue ;
2272 Builder.AddTypedTextChunk("continue");
2273 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2274 Results.AddResult(Result(Builder.TakeString()));
2275 }
2276
2277 if (S->getBreakParent()) {
2278 // break ;
2279 Builder.AddTypedTextChunk("break");
2280 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2281 Results.AddResult(Result(Builder.TakeString()));
2282 }
2283
2284 // "return expression ;" or "return ;", depending on the return type.
2285 QualType ReturnType;
2286 if (const auto *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext))
2287 ReturnType = Function->getReturnType();
2288 else if (const auto *Method = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext))
2289 ReturnType = Method->getReturnType();
2290 else if (SemaRef.getCurBlock() &&
2291 !SemaRef.getCurBlock()->ReturnType.isNull())
2292 ReturnType = SemaRef.getCurBlock()->ReturnType;;
2293 if (ReturnType.isNull() || ReturnType->isVoidType()) {
2294 Builder.AddTypedTextChunk("return");
2295 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2296 Results.AddResult(Result(Builder.TakeString()));
2297 } else {
2298 assert(!ReturnType.isNull())((!ReturnType.isNull()) ? static_cast<void> (0) : __assert_fail
("!ReturnType.isNull()", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 2298, __PRETTY_FUNCTION__))
;
2299 // "return expression ;"
2300 Builder.AddTypedTextChunk("return");
2301 Builder.AddChunk(clang::CodeCompletionString::CK_HorizontalSpace);
2302 Builder.AddPlaceholderChunk("expression");
2303 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2304 Results.AddResult(Result(Builder.TakeString()));
2305 // When boolean, also add 'return true;' and 'return false;'.
2306 if (ReturnType->isBooleanType()) {
2307 Builder.AddTypedTextChunk("return true");
2308 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2309 Results.AddResult(Result(Builder.TakeString()));
2310
2311 Builder.AddTypedTextChunk("return false");
2312 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2313 Results.AddResult(Result(Builder.TakeString()));
2314 }
2315 }
2316
2317 // goto identifier ;
2318 Builder.AddTypedTextChunk("goto");
2319 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2320 Builder.AddPlaceholderChunk("label");
2321 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2322 Results.AddResult(Result(Builder.TakeString()));
2323
2324 // Using directives
2325 Builder.AddTypedTextChunk("using namespace");
2326 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2327 Builder.AddPlaceholderChunk("identifier");
2328 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2329 Results.AddResult(Result(Builder.TakeString()));
2330
2331 AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts());
2332 }
2333 LLVM_FALLTHROUGH[[gnu::fallthrough]];
2334
2335 // Fall through (for statement expressions).
2336 case Sema::PCC_ForInit:
2337 case Sema::PCC_Condition:
2338 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2339 // Fall through: conditions and statements can have expressions.
2340 LLVM_FALLTHROUGH[[gnu::fallthrough]];
2341
2342 case Sema::PCC_ParenthesizedExpression:
2343 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
2344 CCC == Sema::PCC_ParenthesizedExpression) {
2345 // (__bridge <type>)<expression>
2346 Builder.AddTypedTextChunk("__bridge");
2347 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2348 Builder.AddPlaceholderChunk("type");
2349 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2350 Builder.AddPlaceholderChunk("expression");
2351 Results.AddResult(Result(Builder.TakeString()));
2352
2353 // (__bridge_transfer <Objective-C type>)<expression>
2354 Builder.AddTypedTextChunk("__bridge_transfer");
2355 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2356 Builder.AddPlaceholderChunk("Objective-C type");
2357 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2358 Builder.AddPlaceholderChunk("expression");
2359 Results.AddResult(Result(Builder.TakeString()));
2360
2361 // (__bridge_retained <CF type>)<expression>
2362 Builder.AddTypedTextChunk("__bridge_retained");
2363 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2364 Builder.AddPlaceholderChunk("CF type");
2365 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2366 Builder.AddPlaceholderChunk("expression");
2367 Results.AddResult(Result(Builder.TakeString()));
2368 }
2369 // Fall through
2370 LLVM_FALLTHROUGH[[gnu::fallthrough]];
2371
2372 case Sema::PCC_Expression: {
2373 if (SemaRef.getLangOpts().CPlusPlus) {
2374 // 'this', if we're in a non-static member function.
2375 addThisCompletion(SemaRef, Results);
2376
2377 // true
2378 Builder.AddResultTypeChunk("bool");
2379 Builder.AddTypedTextChunk("true");
2380 Results.AddResult(Result(Builder.TakeString()));
2381
2382 // false
2383 Builder.AddResultTypeChunk("bool");
2384 Builder.AddTypedTextChunk("false");
2385 Results.AddResult(Result(Builder.TakeString()));
2386
2387 if (SemaRef.getLangOpts().RTTI) {
2388 // dynamic_cast < type-id > ( expression )
2389 Builder.AddTypedTextChunk("dynamic_cast");
2390 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
2391 Builder.AddPlaceholderChunk("type");
2392 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
2393 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2394 Builder.AddPlaceholderChunk("expression");
2395 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2396 Results.AddResult(Result(Builder.TakeString()));
2397 }
2398
2399 // static_cast < type-id > ( expression )
2400 Builder.AddTypedTextChunk("static_cast");
2401 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
2402 Builder.AddPlaceholderChunk("type");
2403 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
2404 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2405 Builder.AddPlaceholderChunk("expression");
2406 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2407 Results.AddResult(Result(Builder.TakeString()));
2408
2409 // reinterpret_cast < type-id > ( expression )
2410 Builder.AddTypedTextChunk("reinterpret_cast");
2411 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
2412 Builder.AddPlaceholderChunk("type");
2413 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
2414 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2415 Builder.AddPlaceholderChunk("expression");
2416 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2417 Results.AddResult(Result(Builder.TakeString()));
2418
2419 // const_cast < type-id > ( expression )
2420 Builder.AddTypedTextChunk("const_cast");
2421 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
2422 Builder.AddPlaceholderChunk("type");
2423 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
2424 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2425 Builder.AddPlaceholderChunk("expression");
2426 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2427 Results.AddResult(Result(Builder.TakeString()));
2428
2429 if (SemaRef.getLangOpts().RTTI) {
2430 // typeid ( expression-or-type )
2431 Builder.AddResultTypeChunk("std::type_info");
2432 Builder.AddTypedTextChunk("typeid");
2433 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2434 Builder.AddPlaceholderChunk("expression-or-type");
2435 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2436 Results.AddResult(Result(Builder.TakeString()));
2437 }
2438
2439 // new T ( ... )
2440 Builder.AddTypedTextChunk("new");
2441 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2442 Builder.AddPlaceholderChunk("type");
2443 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2444 Builder.AddPlaceholderChunk("expressions");
2445 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2446 Results.AddResult(Result(Builder.TakeString()));
2447
2448 // new T [ ] ( ... )
2449 Builder.AddTypedTextChunk("new");
2450 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2451 Builder.AddPlaceholderChunk("type");
2452 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
2453 Builder.AddPlaceholderChunk("size");
2454 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
2455 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2456 Builder.AddPlaceholderChunk("expressions");
2457 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2458 Results.AddResult(Result(Builder.TakeString()));
2459
2460 // delete expression
2461 Builder.AddResultTypeChunk("void");
2462 Builder.AddTypedTextChunk("delete");
2463 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2464 Builder.AddPlaceholderChunk("expression");
2465 Results.AddResult(Result(Builder.TakeString()));
2466
2467 // delete [] expression
2468 Builder.AddResultTypeChunk("void");
2469 Builder.AddTypedTextChunk("delete");
2470 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2471 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
2472 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
2473 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2474 Builder.AddPlaceholderChunk("expression");
2475 Results.AddResult(Result(Builder.TakeString()));
2476
2477 if (SemaRef.getLangOpts().CXXExceptions) {
2478 // throw expression
2479 Builder.AddResultTypeChunk("void");
2480 Builder.AddTypedTextChunk("throw");
2481 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2482 Builder.AddPlaceholderChunk("expression");
2483 Results.AddResult(Result(Builder.TakeString()));
2484 }
2485
2486 // FIXME: Rethrow?
2487
2488 if (SemaRef.getLangOpts().CPlusPlus11) {
2489 // nullptr
2490 Builder.AddResultTypeChunk("std::nullptr_t");
2491 Builder.AddTypedTextChunk("nullptr");
2492 Results.AddResult(Result(Builder.TakeString()));
2493
2494 // alignof
2495 Builder.AddResultTypeChunk("size_t");
2496 Builder.AddTypedTextChunk("alignof");
2497 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2498 Builder.AddPlaceholderChunk("type");
2499 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2500 Results.AddResult(Result(Builder.TakeString()));
2501
2502 // noexcept
2503 Builder.AddResultTypeChunk("bool");
2504 Builder.AddTypedTextChunk("noexcept");
2505 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2506 Builder.AddPlaceholderChunk("expression");
2507 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2508 Results.AddResult(Result(Builder.TakeString()));
2509
2510 // sizeof... expression
2511 Builder.AddResultTypeChunk("size_t");
2512 Builder.AddTypedTextChunk("sizeof...");
2513 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2514 Builder.AddPlaceholderChunk("parameter-pack");
2515 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2516 Results.AddResult(Result(Builder.TakeString()));
2517 }
2518 }
2519
2520 if (SemaRef.getLangOpts().ObjC) {
2521 // Add "super", if we're in an Objective-C class with a superclass.
2522 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
2523 // The interface can be NULL.
2524 if (ObjCInterfaceDecl *ID = Method->getClassInterface())
2525 if (ID->getSuperClass()) {
2526 std::string SuperType;
2527 SuperType = ID->getSuperClass()->getNameAsString();
2528 if (Method->isInstanceMethod())
2529 SuperType += " *";
2530
2531 Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
2532 Builder.AddTypedTextChunk("super");
2533 Results.AddResult(Result(Builder.TakeString()));
2534 }
2535 }
2536
2537 AddObjCExpressionResults(Results, true);
2538 }
2539
2540 if (SemaRef.getLangOpts().C11) {
2541 // _Alignof
2542 Builder.AddResultTypeChunk("size_t");
2543 if (SemaRef.PP.isMacroDefined("alignof"))
2544 Builder.AddTypedTextChunk("alignof");
2545 else
2546 Builder.AddTypedTextChunk("_Alignof");
2547 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2548 Builder.AddPlaceholderChunk("type");
2549 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2550 Results.AddResult(Result(Builder.TakeString()));
2551 }
2552
2553 // sizeof expression
2554 Builder.AddResultTypeChunk("size_t");
2555 Builder.AddTypedTextChunk("sizeof");
2556 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2557 Builder.AddPlaceholderChunk("expression-or-type");
2558 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2559 Results.AddResult(Result(Builder.TakeString()));
2560 break;
2561 }
2562
2563 case Sema::PCC_Type:
2564 case Sema::PCC_LocalDeclarationSpecifiers:
2565 break;
2566 }
2567
2568 if (WantTypesInContext(CCC, SemaRef.getLangOpts()))
2569 AddTypeSpecifierResults(SemaRef.getLangOpts(), Results);
2570
2571 if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type)
2572 Results.AddResult(Result("operator"));
2573}
2574
2575/// If the given declaration has an associated type, add it as a result
2576/// type chunk.
2577static void AddResultTypeChunk(ASTContext &Context,
2578 const PrintingPolicy &Policy,
2579 const NamedDecl *ND, QualType BaseType,
2580 CodeCompletionBuilder &Result) {
2581 if (!ND)
2582 return;
2583
2584 // Skip constructors and conversion functions, which have their return types
2585 // built into their names.
2586 if (isConstructor(ND) || isa<CXXConversionDecl>(ND))
2587 return;
2588
2589 // Determine the type of the declaration (if it has a type).
2590 QualType T;
2591 if (const FunctionDecl *Function = ND->getAsFunction())
2592 T = Function->getReturnType();
2593 else if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2594 if (!BaseType.isNull())
2595 T = Method->getSendResultType(BaseType);
2596 else
2597 T = Method->getReturnType();
2598 } else if (const auto *Enumerator = dyn_cast<EnumConstantDecl>(ND)) {
2599 T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2600 T = clang::TypeName::getFullyQualifiedType(T, Context);
2601 } else if (isa<UnresolvedUsingValueDecl>(ND)) {
2602 /* Do nothing: ignore unresolved using declarations*/
2603 } else if (const auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
2604 if (!BaseType.isNull())
2605 T = Ivar->getUsageType(BaseType);
2606 else
2607 T = Ivar->getType();
2608 } else if (const auto *Value = dyn_cast<ValueDecl>(ND)) {
2609 T = Value->getType();
2610 } else if (const auto *Property = dyn_cast<ObjCPropertyDecl>(ND)) {
2611 if (!BaseType.isNull())
2612 T = Property->getUsageType(BaseType);
2613 else
2614 T = Property->getType();
2615 }
2616
2617 if (T.isNull() || Context.hasSameType(T, Context.DependentTy))
2618 return;
2619
2620 Result.AddResultTypeChunk(
2621 GetCompletionTypeString(T, Context, Policy, Result.getAllocator()));
2622}
2623
2624static void MaybeAddSentinel(Preprocessor &PP,
2625 const NamedDecl *FunctionOrMethod,
2626 CodeCompletionBuilder &Result) {
2627 if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>())
2628 if (Sentinel->getSentinel() == 0) {
2629 if (PP.getLangOpts().ObjC && PP.isMacroDefined("nil"))
2630 Result.AddTextChunk(", nil");
2631 else if (PP.isMacroDefined("NULL"))
2632 Result.AddTextChunk(", NULL");
2633 else
2634 Result.AddTextChunk(", (void*)0");
2635 }
2636}
2637
2638static std::string formatObjCParamQualifiers(unsigned ObjCQuals,
2639 QualType &Type) {
2640 std::string Result;
2641 if (ObjCQuals & Decl::OBJC_TQ_In)
2642 Result += "in ";
2643 else if (ObjCQuals & Decl::OBJC_TQ_Inout)
2644 Result += "inout ";
2645 else if (ObjCQuals & Decl::OBJC_TQ_Out)
2646 Result += "out ";
2647 if (ObjCQuals & Decl::OBJC_TQ_Bycopy)
2648 Result += "bycopy ";
2649 else if (ObjCQuals & Decl::OBJC_TQ_Byref)
2650 Result += "byref ";
2651 if (ObjCQuals & Decl::OBJC_TQ_Oneway)
2652 Result += "oneway ";
2653 if (ObjCQuals & Decl::OBJC_TQ_CSNullability) {
2654 if (auto nullability = AttributedType::stripOuterNullability(Type)) {
2655 switch (*nullability) {
2656 case NullabilityKind::NonNull:
2657 Result += "nonnull ";
2658 break;
2659
2660 case NullabilityKind::Nullable:
2661 Result += "nullable ";
2662 break;
2663
2664 case NullabilityKind::Unspecified:
2665 Result += "null_unspecified ";
2666 break;
2667 }
2668 }
2669 }
2670 return Result;
2671}
2672
2673/// Tries to find the most appropriate type location for an Objective-C
2674/// block placeholder.
2675///
2676/// This function ignores things like typedefs and qualifiers in order to
2677/// present the most relevant and accurate block placeholders in code completion
2678/// results.
2679static void findTypeLocationForBlockDecl(const TypeSourceInfo *TSInfo,
2680 FunctionTypeLoc &Block,
2681 FunctionProtoTypeLoc &BlockProto,
2682 bool SuppressBlock = false) {
2683 if (!TSInfo)
2684 return;
2685 TypeLoc TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
2686 while (true) {
2687 // Look through typedefs.
2688 if (!SuppressBlock) {
2689 if (TypedefTypeLoc TypedefTL = TL.getAs<TypedefTypeLoc>()) {
2690 if (TypeSourceInfo *InnerTSInfo =
2691 TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) {
2692 TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc();
2693 continue;
2694 }
2695 }
2696
2697 // Look through qualified types
2698 if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) {
2699 TL = QualifiedTL.getUnqualifiedLoc();
2700 continue;
2701 }
2702
2703 if (AttributedTypeLoc AttrTL = TL.getAs<AttributedTypeLoc>()) {
2704 TL = AttrTL.getModifiedLoc();
2705 continue;
2706 }
2707 }
2708
2709 // Try to get the function prototype behind the block pointer type,
2710 // then we're done.
2711 if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) {
2712 TL = BlockPtr.getPointeeLoc().IgnoreParens();
2713 Block = TL.getAs<FunctionTypeLoc>();
2714 BlockProto = TL.getAs<FunctionProtoTypeLoc>();
2715 }
2716 break;
2717 }
2718}
2719
2720static std::string
2721formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
2722 FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2723 bool SuppressBlockName = false,
2724 bool SuppressBlock = false,
2725 Optional<ArrayRef<QualType>> ObjCSubsts = None);
2726
2727static std::string
2728FormatFunctionParameter(const PrintingPolicy &Policy, const ParmVarDecl *Param,
2729 bool SuppressName = false, bool SuppressBlock = false,
2730 Optional<ArrayRef<QualType>> ObjCSubsts = None) {
2731 // Params are unavailable in FunctionTypeLoc if the FunctionType is invalid.
2732 // It would be better to pass in the param Type, which is usually avaliable.
2733 // But this case is rare, so just pretend we fell back to int as elsewhere.
2734 if (!Param)
2735 return "int";
2736 bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
2737 if (Param->getType()->isDependentType() ||
2738 !Param->getType()->isBlockPointerType()) {
2739 // The argument for a dependent or non-block parameter is a placeholder
2740 // containing that parameter's type.
2741 std::string Result;
2742
2743 if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
2744 Result = Param->getIdentifier()->getName();
2745
2746 QualType Type = Param->getType();
2747 if (ObjCSubsts)
2748 Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts,
2749 ObjCSubstitutionContext::Parameter);
2750 if (ObjCMethodParam) {
2751 Result =
2752 "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(), Type);
2753 Result += Type.getAsString(Policy) + ")";
2754 if (Param->getIdentifier() && !SuppressName)
2755 Result += Param->getIdentifier()->getName();
2756 } else {
2757 Type.getAsStringInternal(Result, Policy);
2758 }
2759 return Result;
2760 }
2761
2762 // The argument for a block pointer parameter is a block literal with
2763 // the appropriate type.
2764 FunctionTypeLoc Block;
2765 FunctionProtoTypeLoc BlockProto;
2766 findTypeLocationForBlockDecl(Param->getTypeSourceInfo(), Block, BlockProto,
2767 SuppressBlock);
2768 // Try to retrieve the block type information from the property if this is a
2769 // parameter in a setter.
2770 if (!Block && ObjCMethodParam &&
2771 cast<ObjCMethodDecl>(Param->getDeclContext())->isPropertyAccessor()) {
2772 if (const auto *PD = cast<ObjCMethodDecl>(Param->getDeclContext())
2773 ->findPropertyDecl(/*CheckOverrides=*/false))
2774 findTypeLocationForBlockDecl(PD->getTypeSourceInfo(), Block, BlockProto,
2775 SuppressBlock);
2776 }
2777
2778 if (!Block) {
2779 // We were unable to find a FunctionProtoTypeLoc with parameter names
2780 // for the block; just use the parameter type as a placeholder.
2781 std::string Result;
2782 if (!ObjCMethodParam && Param->getIdentifier())
2783 Result = Param->getIdentifier()->getName();
2784
2785 QualType Type = Param->getType().getUnqualifiedType();
2786
2787 if (ObjCMethodParam) {
2788 Result = Type.getAsString(Policy);
2789 std::string Quals =
2790 formatObjCParamQualifiers(Param->getObjCDeclQualifier(), Type);
2791 if (!Quals.empty())
2792 Result = "(" + Quals + " " + Result + ")";
2793 if (Result.back() != ')')
2794 Result += " ";
2795 if (Param->getIdentifier())
2796 Result += Param->getIdentifier()->getName();
2797 } else {
2798 Type.getAsStringInternal(Result, Policy);
2799 }
2800
2801 return Result;
2802 }
2803
2804 // We have the function prototype behind the block pointer type, as it was
2805 // written in the source.
2806 return formatBlockPlaceholder(Policy, Param, Block, BlockProto,
2807 /*SuppressBlockName=*/false, SuppressBlock,
2808 ObjCSubsts);
2809}
2810
2811/// Returns a placeholder string that corresponds to an Objective-C block
2812/// declaration.
2813///
2814/// \param BlockDecl A declaration with an Objective-C block type.
2815///
2816/// \param Block The most relevant type location for that block type.
2817///
2818/// \param SuppressBlockName Determines whether or not the name of the block
2819/// declaration is included in the resulting string.
2820static std::string
2821formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
2822 FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2823 bool SuppressBlockName, bool SuppressBlock,
2824 Optional<ArrayRef<QualType>> ObjCSubsts) {
2825 std::string Result;
2826 QualType ResultType = Block.getTypePtr()->getReturnType();
2827 if (ObjCSubsts)
2828 ResultType =
2829 ResultType.substObjCTypeArgs(BlockDecl->getASTContext(), *ObjCSubsts,
2830 ObjCSubstitutionContext::Result);
2831 if (!ResultType->isVoidType() || SuppressBlock)
2832 ResultType.getAsStringInternal(Result, Policy);
2833
2834 // Format the parameter list.
2835 std::string Params;
2836 if (!BlockProto || Block.getNumParams() == 0) {
2837 if (BlockProto && BlockProto.getTypePtr()->isVariadic())
2838 Params = "(...)";
2839 else
2840 Params = "(void)";
2841 } else {
2842 Params += "(";
2843 for (unsigned I = 0, N = Block.getNumParams(); I != N; ++I) {
2844 if (I)
2845 Params += ", ";
2846 Params += FormatFunctionParameter(Policy, Block.getParam(I),
2847 /*SuppressName=*/false,
2848 /*SuppressBlock=*/true, ObjCSubsts);
2849
2850 if (I == N - 1 && BlockProto.getTypePtr()->isVariadic())
2851 Params += ", ...";
2852 }
2853 Params += ")";
2854 }
2855
2856 if (SuppressBlock) {
2857 // Format as a parameter.
2858 Result = Result + " (^";
2859 if (!SuppressBlockName && BlockDecl->getIdentifier())
2860 Result += BlockDecl->getIdentifier()->getName();
2861 Result += ")";
2862 Result += Params;
2863 } else {
2864 // Format as a block literal argument.
2865 Result = '^' + Result;
2866 Result += Params;
2867
2868 if (!SuppressBlockName && BlockDecl->getIdentifier())
2869 Result += BlockDecl->getIdentifier()->getName();
2870 }
2871
2872 return Result;
2873}
2874
2875static std::string GetDefaultValueString(const ParmVarDecl *Param,
2876 const SourceManager &SM,
2877 const LangOptions &LangOpts) {
2878 const SourceRange SrcRange = Param->getDefaultArgRange();
2879 CharSourceRange CharSrcRange = CharSourceRange::getTokenRange(SrcRange);
2880 bool Invalid = CharSrcRange.isInvalid();
2881 if (Invalid)
2882 return "";
2883 StringRef srcText =
2884 Lexer::getSourceText(CharSrcRange, SM, LangOpts, &Invalid);
2885 if (Invalid)
2886 return "";
2887
2888 if (srcText.empty() || srcText == "=") {
2889 // Lexer can't determine the value.
2890 // This happens if the code is incorrect (for example class is forward
2891 // declared).
2892 return "";
2893 }
2894 std::string DefValue(srcText.str());
2895 // FIXME: remove this check if the Lexer::getSourceText value is fixed and
2896 // this value always has (or always does not have) '=' in front of it
2897 if (DefValue.at(0) != '=') {
2898 // If we don't have '=' in front of value.
2899 // Lexer returns built-in types values without '=' and user-defined types
2900 // values with it.
2901 return " = " + DefValue;
2902 }
2903 return " " + DefValue;
2904}
2905
2906/// Add function parameter chunks to the given code completion string.
2907static void AddFunctionParameterChunks(Preprocessor &PP,
2908 const PrintingPolicy &Policy,
2909 const FunctionDecl *Function,
2910 CodeCompletionBuilder &Result,
2911 unsigned Start = 0,
2912 bool InOptional = false) {
2913 bool FirstParameter = true;
2914
2915 for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
2916 const ParmVarDecl *Param = Function->getParamDecl(P);
2917
2918 if (Param->hasDefaultArg() && !InOptional) {
2919 // When we see an optional default argument, put that argument and
2920 // the remaining default arguments into a new, optional string.
2921 CodeCompletionBuilder Opt(Result.getAllocator(),
2922 Result.getCodeCompletionTUInfo());
2923 if (!FirstParameter)
2924 Opt.AddChunk(CodeCompletionString::CK_Comma);
2925 AddFunctionParameterChunks(PP, Policy, Function, Opt, P, true);
2926 Result.AddOptionalChunk(Opt.TakeString());
2927 break;
2928 }
2929
2930 if (FirstParameter)
2931 FirstParameter = false;
2932 else
2933 Result.AddChunk(CodeCompletionString::CK_Comma);
2934
2935 InOptional = false;
2936
2937 // Format the placeholder string.
2938 std::string PlaceholderStr = FormatFunctionParameter(Policy, Param);
2939 if (Param->hasDefaultArg())
2940 PlaceholderStr +=
2941 GetDefaultValueString(Param, PP.getSourceManager(), PP.getLangOpts());
2942
2943 if (Function->isVariadic() && P == N - 1)
2944 PlaceholderStr += ", ...";
2945
2946 // Add the placeholder string.
2947 Result.AddPlaceholderChunk(
2948 Result.getAllocator().CopyString(PlaceholderStr));
2949 }
2950
2951 if (const auto *Proto = Function->getType()->getAs<FunctionProtoType>())
2952 if (Proto->isVariadic()) {
2953 if (Proto->getNumParams() == 0)
2954 Result.AddPlaceholderChunk("...");
2955
2956 MaybeAddSentinel(PP, Function, Result);
2957 }
2958}
2959
2960/// Add template parameter chunks to the given code completion string.
2961static void AddTemplateParameterChunks(
2962 ASTContext &Context, const PrintingPolicy &Policy,
2963 const TemplateDecl *Template, CodeCompletionBuilder &Result,
2964 unsigned MaxParameters = 0, unsigned Start = 0, bool InDefaultArg = false) {
2965 bool FirstParameter = true;
2966
2967 // Prefer to take the template parameter names from the first declaration of
2968 // the template.
2969 Template = cast<TemplateDecl>(Template->getCanonicalDecl());
2970
2971 TemplateParameterList *Params = Template->getTemplateParameters();
2972 TemplateParameterList::iterator PEnd = Params->end();
2973 if (MaxParameters)
2974 PEnd = Params->begin() + MaxParameters;
2975 for (TemplateParameterList::iterator P = Params->begin() + Start; P != PEnd;
2976 ++P) {
2977 bool HasDefaultArg = false;
2978 std::string PlaceholderStr;
2979 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
2980 if (TTP->wasDeclaredWithTypename())
2981 PlaceholderStr = "typename";
2982 else
2983 PlaceholderStr = "class";
2984
2985 if (TTP->getIdentifier()) {
2986 PlaceholderStr += ' ';
2987 PlaceholderStr += TTP->getIdentifier()->getName();
2988 }
2989
2990 HasDefaultArg = TTP->hasDefaultArgument();
2991 } else if (NonTypeTemplateParmDecl *NTTP =
2992 dyn_cast<NonTypeTemplateParmDecl>(*P)) {
2993 if (NTTP->getIdentifier())
2994 PlaceholderStr = NTTP->getIdentifier()->getName();
2995 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
2996 HasDefaultArg = NTTP->hasDefaultArgument();
2997 } else {
2998 assert(isa<TemplateTemplateParmDecl>(*P))((isa<TemplateTemplateParmDecl>(*P)) ? static_cast<void
> (0) : __assert_fail ("isa<TemplateTemplateParmDecl>(*P)"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 2998, __PRETTY_FUNCTION__))
;
2999 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
3000
3001 // Since putting the template argument list into the placeholder would
3002 // be very, very long, we just use an abbreviation.
3003 PlaceholderStr = "template<...> class";
3004 if (TTP->getIdentifier()) {
3005 PlaceholderStr += ' ';
3006 PlaceholderStr += TTP->getIdentifier()->getName();
3007 }
3008
3009 HasDefaultArg = TTP->hasDefaultArgument();
3010 }
3011
3012 if (HasDefaultArg && !InDefaultArg) {
3013 // When we see an optional default argument, put that argument and
3014 // the remaining default arguments into a new, optional string.
3015 CodeCompletionBuilder Opt(Result.getAllocator(),
3016 Result.getCodeCompletionTUInfo());
3017 if (!FirstParameter)
3018 Opt.AddChunk(CodeCompletionString::CK_Comma);
3019 AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
3020 P - Params->begin(), true);
3021 Result.AddOptionalChunk(Opt.TakeString());
3022 break;
3023 }
3024
3025 InDefaultArg = false;
3026
3027 if (FirstParameter)
3028 FirstParameter = false;
3029 else
3030 Result.AddChunk(CodeCompletionString::CK_Comma);
3031
3032 // Add the placeholder string.
3033 Result.AddPlaceholderChunk(
3034 Result.getAllocator().CopyString(PlaceholderStr));
3035 }
3036}
3037
3038/// Add a qualifier to the given code-completion string, if the
3039/// provided nested-name-specifier is non-NULL.
3040static void AddQualifierToCompletionString(CodeCompletionBuilder &Result,
3041 NestedNameSpecifier *Qualifier,
3042 bool QualifierIsInformative,
3043 ASTContext &Context,
3044 const PrintingPolicy &Policy) {
3045 if (!Qualifier)
3046 return;
3047
3048 std::string PrintedNNS;
3049 {
3050 llvm::raw_string_ostream OS(PrintedNNS);
3051 Qualifier->print(OS, Policy);
3052 }
3053 if (QualifierIsInformative)
3054 Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
3055 else
3056 Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
3057}
3058
3059static void
3060AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result,
3061 const FunctionDecl *Function) {
3062 const auto *Proto = Function->getType()->getAs<FunctionProtoType>();
3063 if (!Proto || !Proto->getMethodQuals())
3064 return;
3065
3066 // FIXME: Add ref-qualifier!
3067
3068 // Handle single qualifiers without copying
3069 if (Proto->getMethodQuals().hasOnlyConst()) {
3070 Result.AddInformativeChunk(" const");
3071 return;
3072 }
3073
3074 if (Proto->getMethodQuals().hasOnlyVolatile()) {
3075 Result.AddInformativeChunk(" volatile");
3076 return;
3077 }
3078
3079 if (Proto->getMethodQuals().hasOnlyRestrict()) {
3080 Result.AddInformativeChunk(" restrict");
3081 return;
3082 }
3083
3084 // Handle multiple qualifiers.
3085 std::string QualsStr;
3086 if (Proto->isConst())
3087 QualsStr += " const";
3088 if (Proto->isVolatile())
3089 QualsStr += " volatile";
3090 if (Proto->isRestrict())
3091 QualsStr += " restrict";
3092 Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
3093}
3094
3095/// Add the name of the given declaration
3096static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
3097 const NamedDecl *ND,
3098 CodeCompletionBuilder &Result) {
3099 DeclarationName Name = ND->getDeclName();
3100 if (!Name)
3101 return;
3102
3103 switch (Name.getNameKind()) {
3104 case DeclarationName::CXXOperatorName: {
3105 const char *OperatorName = nullptr;
3106 switch (Name.getCXXOverloadedOperator()) {
3107 case OO_None:
3108 case OO_Conditional:
3109 case NUM_OVERLOADED_OPERATORS:
3110 OperatorName = "operator";
3111 break;
3112
3113#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
3114 case OO_##Name: \
3115 OperatorName = "operator" Spelling; \
3116 break;
3117#define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemberOnly)
3118#include "clang/Basic/OperatorKinds.def"
3119
3120 case OO_New:
3121 OperatorName = "operator new";
3122 break;
3123 case OO_Delete:
3124 OperatorName = "operator delete";
3125 break;
3126 case OO_Array_New:
3127 OperatorName = "operator new[]";
3128 break;
3129 case OO_Array_Delete:
3130 OperatorName = "operator delete[]";
3131 break;
3132 case OO_Call:
3133 OperatorName = "operator()";
3134 break;
3135 case OO_Subscript:
3136 OperatorName = "operator[]";
3137 break;
3138 }
3139 Result.AddTypedTextChunk(OperatorName);
3140 break;
3141 }
3142
3143 case DeclarationName::Identifier:
3144 case DeclarationName::CXXConversionFunctionName:
3145 case DeclarationName::CXXDestructorName:
3146 case DeclarationName::CXXLiteralOperatorName:
3147 Result.AddTypedTextChunk(
3148 Result.getAllocator().CopyString(ND->getNameAsString()));
3149 break;
3150
3151 case DeclarationName::CXXDeductionGuideName:
3152 case DeclarationName::CXXUsingDirective:
3153 case DeclarationName::ObjCZeroArgSelector:
3154 case DeclarationName::ObjCOneArgSelector:
3155 case DeclarationName::ObjCMultiArgSelector:
3156 break;
3157
3158 case DeclarationName::CXXConstructorName: {
3159 CXXRecordDecl *Record = nullptr;
3160 QualType Ty = Name.getCXXNameType();
3161 if (const auto *RecordTy = Ty->getAs<RecordType>())
3162 Record = cast<CXXRecordDecl>(RecordTy->getDecl());
3163 else if (const auto *InjectedTy = Ty->getAs<InjectedClassNameType>())
3164 Record = InjectedTy->getDecl();
3165 else {
3166 Result.AddTypedTextChunk(
3167 Result.getAllocator().CopyString(ND->getNameAsString()));
3168 break;
3169 }
3170
3171 Result.AddTypedTextChunk(
3172 Result.getAllocator().CopyString(Record->getNameAsString()));
3173 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
3174 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
3175 AddTemplateParameterChunks(Context, Policy, Template, Result);
3176 Result.AddChunk(CodeCompletionString::CK_RightAngle);
3177 }
3178 break;
3179 }
3180 }
3181}
3182
3183CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(
3184 Sema &S, const CodeCompletionContext &CCContext,
3185 CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo,
3186 bool IncludeBriefComments) {
3187 return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator,
3188 CCTUInfo, IncludeBriefComments);
3189}
3190
3191CodeCompletionString *CodeCompletionResult::CreateCodeCompletionStringForMacro(
3192 Preprocessor &PP, CodeCompletionAllocator &Allocator,
3193 CodeCompletionTUInfo &CCTUInfo) {
3194 assert(Kind == RK_Macro)((Kind == RK_Macro) ? static_cast<void> (0) : __assert_fail
("Kind == RK_Macro", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 3194, __PRETTY_FUNCTION__))
;
3195 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
3196 const MacroInfo *MI = PP.getMacroInfo(Macro);
3197 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Macro->getName()));
3198
3199 if (!MI || !MI->isFunctionLike())
3200 return Result.TakeString();
3201
3202 // Format a function-like macro with placeholders for the arguments.
3203 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3204 MacroInfo::param_iterator A = MI->param_begin(), AEnd = MI->param_end();
3205
3206 // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
3207 if (MI->isC99Varargs()) {
3208 --AEnd;
3209
3210 if (A == AEnd) {
3211 Result.AddPlaceholderChunk("...");
3212 }
3213 }
3214
3215 for (MacroInfo::param_iterator A = MI->param_begin(); A != AEnd; ++A) {
3216 if (A != MI->param_begin())
3217 Result.AddChunk(CodeCompletionString::CK_Comma);
3218
3219 if (MI->isVariadic() && (A + 1) == AEnd) {
3220 SmallString<32> Arg = (*A)->getName();
3221 if (MI->isC99Varargs())
3222 Arg += ", ...";
3223 else
3224 Arg += "...";
3225 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
3226 break;
3227 }
3228
3229 // Non-variadic macros are simple.
3230 Result.AddPlaceholderChunk(
3231 Result.getAllocator().CopyString((*A)->getName()));
3232 }
3233 Result.AddChunk(CodeCompletionString::CK_RightParen);
3234 return Result.TakeString();
3235}
3236
3237/// If possible, create a new code completion string for the given
3238/// result.
3239///
3240/// \returns Either a new, heap-allocated code completion string describing
3241/// how to use this result, or NULL to indicate that the string or name of the
3242/// result is all that is needed.
3243CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(
3244 ASTContext &Ctx, Preprocessor &PP, const CodeCompletionContext &CCContext,
3245 CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo,
3246 bool IncludeBriefComments) {
3247 if (Kind == RK_Macro)
3248 return CreateCodeCompletionStringForMacro(PP, Allocator, CCTUInfo);
3249
3250 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
3251
3252 PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
3253 if (Kind == RK_Pattern) {
3254 Pattern->Priority = Priority;
3255 Pattern->Availability = Availability;
3256
3257 if (Declaration) {
3258 Result.addParentContext(Declaration->getDeclContext());
3259 Pattern->ParentName = Result.getParentName();
3260 if (const RawComment *RC =
3261 getPatternCompletionComment(Ctx, Declaration)) {
3262 Result.addBriefComment(RC->getBriefText(Ctx));
3263 Pattern->BriefComment = Result.getBriefComment();
3264 }
3265 }
3266
3267 return Pattern;
3268 }
3269
3270 if (Kind == RK_Keyword) {
3271 Result.AddTypedTextChunk(Keyword);
3272 return Result.TakeString();
3273 }
3274 assert(Kind == RK_Declaration && "Missed a result kind?")((Kind == RK_Declaration && "Missed a result kind?") ?
static_cast<void> (0) : __assert_fail ("Kind == RK_Declaration && \"Missed a result kind?\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 3274, __PRETTY_FUNCTION__))
;
3275 return createCodeCompletionStringForDecl(
3276 PP, Ctx, Result, IncludeBriefComments, CCContext, Policy);
3277}
3278
3279static void printOverrideString(const CodeCompletionString &CCS,
3280 std::string &BeforeName,
3281 std::string &NameAndSignature) {
3282 bool SeenTypedChunk = false;
3283 for (auto &Chunk : CCS) {
3284 if (Chunk.Kind == CodeCompletionString::CK_Optional) {
3285 assert(SeenTypedChunk && "optional parameter before name")((SeenTypedChunk && "optional parameter before name")
? static_cast<void> (0) : __assert_fail ("SeenTypedChunk && \"optional parameter before name\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 3285, __PRETTY_FUNCTION__))
;
3286 // Note that we put all chunks inside into NameAndSignature.
3287 printOverrideString(*Chunk.Optional, NameAndSignature, NameAndSignature);
3288 continue;
3289 }
3290 SeenTypedChunk |= Chunk.Kind == CodeCompletionString::CK_TypedText;
3291 if (SeenTypedChunk)
3292 NameAndSignature += Chunk.Text;
3293 else
3294 BeforeName += Chunk.Text;
3295 }
3296}
3297
3298CodeCompletionString *
3299CodeCompletionResult::createCodeCompletionStringForOverride(
3300 Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result,
3301 bool IncludeBriefComments, const CodeCompletionContext &CCContext,
3302 PrintingPolicy &Policy) {
3303 auto *CCS = createCodeCompletionStringForDecl(PP, Ctx, Result,
3304 /*IncludeBriefComments=*/false,
3305 CCContext, Policy);
3306 std::string BeforeName;
3307 std::string NameAndSignature;
3308 // For overrides all chunks go into the result, none are informative.
3309 printOverrideString(*CCS, BeforeName, NameAndSignature);
3310 NameAndSignature += " override";
3311
3312 Result.AddTextChunk(Result.getAllocator().CopyString(BeforeName));
3313 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3314 Result.AddTypedTextChunk(Result.getAllocator().CopyString(NameAndSignature));
3315 return Result.TakeString();
3316}
3317
3318// FIXME: Right now this works well with lambdas. Add support for other functor
3319// types like std::function.
3320static const NamedDecl *extractFunctorCallOperator(const NamedDecl *ND) {
3321 const auto *VD = dyn_cast<VarDecl>(ND);
3322 if (!VD)
3323 return nullptr;
3324 const auto *RecordDecl = VD->getType()->getAsCXXRecordDecl();
3325 if (!RecordDecl || !RecordDecl->isLambda())
3326 return nullptr;
3327 return RecordDecl->getLambdaCallOperator();
3328}
3329
3330CodeCompletionString *CodeCompletionResult::createCodeCompletionStringForDecl(
3331 Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result,
3332 bool IncludeBriefComments, const CodeCompletionContext &CCContext,
3333 PrintingPolicy &Policy) {
3334 const NamedDecl *ND = Declaration;
3335 Result.addParentContext(ND->getDeclContext());
3336
3337 if (IncludeBriefComments) {
3338 // Add documentation comment, if it exists.
3339 if (const RawComment *RC = getCompletionComment(Ctx, Declaration)) {
3340 Result.addBriefComment(RC->getBriefText(Ctx));
3341 }
3342 }
3343
3344 if (StartsNestedNameSpecifier) {
3345 Result.AddTypedTextChunk(
3346 Result.getAllocator().CopyString(ND->getNameAsString()));
3347 Result.AddTextChunk("::");
3348 return Result.TakeString();
3349 }
3350
3351 for (const auto *I : ND->specific_attrs<AnnotateAttr>())
3352 Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation()));
3353
3354 auto AddFunctionTypeAndResult = [&](const FunctionDecl *Function) {
3355 AddResultTypeChunk(Ctx, Policy, Function, CCContext.getBaseType(), Result);
3356 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3357 Ctx, Policy);
3358 AddTypedNameChunk(Ctx, Policy, ND, Result);
3359 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3360 AddFunctionParameterChunks(PP, Policy, Function, Result);
3361 Result.AddChunk(CodeCompletionString::CK_RightParen);
3362 AddFunctionTypeQualsToCompletionString(Result, Function);
3363 };
3364
3365 if (const auto *Function = dyn_cast<FunctionDecl>(ND)) {
3366 AddFunctionTypeAndResult(Function);
3367 return Result.TakeString();
3368 }
3369
3370 if (const auto *CallOperator =
3371 dyn_cast_or_null<FunctionDecl>(extractFunctorCallOperator(ND))) {
3372 AddFunctionTypeAndResult(CallOperator);
3373 return Result.TakeString();
3374 }
3375
3376 AddResultTypeChunk(Ctx, Policy, ND, CCContext.getBaseType(), Result);
3377
3378 if (const FunctionTemplateDecl *FunTmpl =
3379 dyn_cast<FunctionTemplateDecl>(ND)) {
3380 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3381 Ctx, Policy);
3382 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
3383 AddTypedNameChunk(Ctx, Policy, Function, Result);
3384
3385 // Figure out which template parameters are deduced (or have default
3386 // arguments).
3387 llvm::SmallBitVector Deduced;
3388 Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
3389 unsigned LastDeducibleArgument;
3390 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
3391 --LastDeducibleArgument) {
3392 if (!Deduced[LastDeducibleArgument - 1]) {
3393 // C++0x: Figure out if the template argument has a default. If so,
3394 // the user doesn't need to type this argument.
3395 // FIXME: We need to abstract template parameters better!
3396 bool HasDefaultArg = false;
3397 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
3398 LastDeducibleArgument - 1);
3399 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
3400 HasDefaultArg = TTP->hasDefaultArgument();
3401 else if (NonTypeTemplateParmDecl *NTTP =
3402 dyn_cast<NonTypeTemplateParmDecl>(Param))
3403 HasDefaultArg = NTTP->hasDefaultArgument();
3404 else {
3405 assert(isa<TemplateTemplateParmDecl>(Param))((isa<TemplateTemplateParmDecl>(Param)) ? static_cast<
void> (0) : __assert_fail ("isa<TemplateTemplateParmDecl>(Param)"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 3405, __PRETTY_FUNCTION__))
;
3406 HasDefaultArg =
3407 cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
3408 }
3409
3410 if (!HasDefaultArg)
3411 break;
3412 }
3413 }
3414
3415 if (LastDeducibleArgument) {
3416 // Some of the function template arguments cannot be deduced from a
3417 // function call, so we introduce an explicit template argument list
3418 // containing all of the arguments up to the first deducible argument.
3419 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
3420 AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
3421 LastDeducibleArgument);
3422 Result.AddChunk(CodeCompletionString::CK_RightAngle);
3423 }
3424
3425 // Add the function parameters
3426 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3427 AddFunctionParameterChunks(PP, Policy, Function, Result);
3428 Result.AddChunk(CodeCompletionString::CK_RightParen);
3429 AddFunctionTypeQualsToCompletionString(Result, Function);
3430 return Result.TakeString();
3431 }
3432
3433 if (const auto *Template = dyn_cast<TemplateDecl>(ND)) {
3434 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3435 Ctx, Policy);
3436 Result.AddTypedTextChunk(
3437 Result.getAllocator().CopyString(Template->getNameAsString()));
3438 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
3439 AddTemplateParameterChunks(Ctx, Policy, Template, Result);
3440 Result.AddChunk(CodeCompletionString::CK_RightAngle);
3441 return Result.TakeString();
3442 }
3443
3444 if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) {
3445 Selector Sel = Method->getSelector();
3446 if (Sel.isUnarySelector()) {
3447 Result.AddTypedTextChunk(
3448 Result.getAllocator().CopyString(Sel.getNameForSlot(0)));
3449 return Result.TakeString();
3450 }
3451
3452 std::string SelName = Sel.getNameForSlot(0).str();
3453 SelName += ':';
3454 if (StartParameter == 0)
3455 Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
3456 else {
3457 Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
3458
3459 // If there is only one parameter, and we're past it, add an empty
3460 // typed-text chunk since there is nothing to type.
3461 if (Method->param_size() == 1)
3462 Result.AddTypedTextChunk("");
3463 }
3464 unsigned Idx = 0;
3465 for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(),
3466 PEnd = Method->param_end();
3467 P != PEnd; (void)++P, ++Idx) {
3468 if (Idx > 0) {
3469 std::string Keyword;
3470 if (Idx > StartParameter)
3471 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3472 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
3473 Keyword += II->getName();
3474 Keyword += ":";
3475 if (Idx < StartParameter || AllParametersAreInformative)
3476 Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
3477 else
3478 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
3479 }
3480
3481 // If we're before the starting parameter, skip the placeholder.
3482 if (Idx < StartParameter)
3483 continue;
3484
3485 std::string Arg;
3486 QualType ParamType = (*P)->getType();
3487 Optional<ArrayRef<QualType>> ObjCSubsts;
3488 if (!CCContext.getBaseType().isNull())
3489 ObjCSubsts = CCContext.getBaseType()->getObjCSubstitutions(Method);
3490
3491 if (ParamType->isBlockPointerType() && !DeclaringEntity)
3492 Arg = FormatFunctionParameter(Policy, *P, true,
3493 /*SuppressBlock=*/false, ObjCSubsts);
3494 else {
3495 if (ObjCSubsts)
3496 ParamType = ParamType.substObjCTypeArgs(
3497 Ctx, *ObjCSubsts, ObjCSubstitutionContext::Parameter);
3498 Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(),
3499 ParamType);
3500 Arg += ParamType.getAsString(Policy) + ")";
3501 if (IdentifierInfo *II = (*P)->getIdentifier())
3502 if (DeclaringEntity || AllParametersAreInformative)
3503 Arg += II->getName();
3504 }
3505
3506 if (Method->isVariadic() && (P + 1) == PEnd)
3507 Arg += ", ...";
3508
3509 if (DeclaringEntity)
3510 Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
3511 else if (AllParametersAreInformative)
3512 Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
3513 else
3514 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
3515 }
3516
3517 if (Method->isVariadic()) {
3518 if (Method->param_size() == 0) {
3519 if (DeclaringEntity)
3520 Result.AddTextChunk(", ...");
3521 else if (AllParametersAreInformative)
3522 Result.AddInformativeChunk(", ...");
3523 else
3524 Result.AddPlaceholderChunk(", ...");
3525 }
3526
3527 MaybeAddSentinel(PP, Method, Result);
3528 }
3529
3530 return Result.TakeString();
3531 }
3532
3533 if (Qualifier)
3534 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3535 Ctx, Policy);
3536
3537 Result.AddTypedTextChunk(
3538 Result.getAllocator().CopyString(ND->getNameAsString()));
3539 return Result.TakeString();
3540}
3541
3542const RawComment *clang::getCompletionComment(const ASTContext &Ctx,
3543 const NamedDecl *ND) {
3544 if (!ND)
3545 return nullptr;
3546 if (auto *RC = Ctx.getRawCommentForAnyRedecl(ND))
3547 return RC;
3548
3549 // Try to find comment from a property for ObjC methods.
3550 const auto *M = dyn_cast<ObjCMethodDecl>(ND);
3551 if (!M)
3552 return nullptr;
3553 const ObjCPropertyDecl *PDecl = M->findPropertyDecl();
3554 if (!PDecl)
3555 return nullptr;
3556
3557 return Ctx.getRawCommentForAnyRedecl(PDecl);
3558}
3559
3560const RawComment *clang::getPatternCompletionComment(const ASTContext &Ctx,
3561 const NamedDecl *ND) {
3562 const auto *M = dyn_cast_or_null<ObjCMethodDecl>(ND);
3563 if (!M || !M->isPropertyAccessor())
3564 return nullptr;
3565
3566 // Provide code completion comment for self.GetterName where
3567 // GetterName is the getter method for a property with name
3568 // different from the property name (declared via a property
3569 // getter attribute.
3570 const ObjCPropertyDecl *PDecl = M->findPropertyDecl();
3571 if (!PDecl)
3572 return nullptr;
3573 if (PDecl->getGetterName() == M->getSelector() &&
3574 PDecl->getIdentifier() != M->getIdentifier()) {
3575 if (auto *RC = Ctx.getRawCommentForAnyRedecl(M))
3576 return RC;
3577 if (auto *RC = Ctx.getRawCommentForAnyRedecl(PDecl))
3578 return RC;
3579 }
3580 return nullptr;
3581}
3582
3583const RawComment *clang::getParameterComment(
3584 const ASTContext &Ctx,
3585 const CodeCompleteConsumer::OverloadCandidate &Result, unsigned ArgIndex) {
3586 auto FDecl = Result.getFunction();
3587 if (!FDecl)
3588 return nullptr;
3589 if (ArgIndex < FDecl->getNumParams())
3590 return Ctx.getRawCommentForAnyRedecl(FDecl->getParamDecl(ArgIndex));
3591 return nullptr;
3592}
3593
3594/// Add function overload parameter chunks to the given code completion
3595/// string.
3596static void AddOverloadParameterChunks(ASTContext &Context,
3597 const PrintingPolicy &Policy,
3598 const FunctionDecl *Function,
3599 const FunctionProtoType *Prototype,
3600 CodeCompletionBuilder &Result,
3601 unsigned CurrentArg, unsigned Start = 0,
3602 bool InOptional = false) {
3603 bool FirstParameter = true;
3604 unsigned NumParams =
3605 Function ? Function->getNumParams() : Prototype->getNumParams();
3606
3607 for (unsigned P = Start; P != NumParams; ++P) {
3608 if (Function && Function->getParamDecl(P)->hasDefaultArg() && !InOptional) {
3609 // When we see an optional default argument, put that argument and
3610 // the remaining default arguments into a new, optional string.
3611 CodeCompletionBuilder Opt(Result.getAllocator(),
3612 Result.getCodeCompletionTUInfo());
3613 if (!FirstParameter)
3614 Opt.AddChunk(CodeCompletionString::CK_Comma);
3615 // Optional sections are nested.
3616 AddOverloadParameterChunks(Context, Policy, Function, Prototype, Opt,
3617 CurrentArg, P, /*InOptional=*/true);
3618 Result.AddOptionalChunk(Opt.TakeString());
3619 return;
3620 }
3621
3622 if (FirstParameter)
3623 FirstParameter = false;
3624 else
3625 Result.AddChunk(CodeCompletionString::CK_Comma);
3626
3627 InOptional = false;
3628
3629 // Format the placeholder string.
3630 std::string Placeholder;
3631 if (Function) {
3632 const ParmVarDecl *Param = Function->getParamDecl(P);
3633 Placeholder = FormatFunctionParameter(Policy, Param);
3634 if (Param->hasDefaultArg())
3635 Placeholder += GetDefaultValueString(Param, Context.getSourceManager(),
3636 Context.getLangOpts());
3637 } else {
3638 Placeholder = Prototype->getParamType(P).getAsString(Policy);
3639 }
3640
3641 if (P == CurrentArg)
3642 Result.AddCurrentParameterChunk(
3643 Result.getAllocator().CopyString(Placeholder));
3644 else
3645 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Placeholder));
3646 }
3647
3648 if (Prototype && Prototype->isVariadic()) {
3649 CodeCompletionBuilder Opt(Result.getAllocator(),
3650 Result.getCodeCompletionTUInfo());
3651 if (!FirstParameter)
3652 Opt.AddChunk(CodeCompletionString::CK_Comma);
3653
3654 if (CurrentArg < NumParams)
3655 Opt.AddPlaceholderChunk("...");
3656 else
3657 Opt.AddCurrentParameterChunk("...");
3658
3659 Result.AddOptionalChunk(Opt.TakeString());
3660 }
3661}
3662
3663CodeCompletionString *
3664CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
3665 unsigned CurrentArg, Sema &S, CodeCompletionAllocator &Allocator,
3666 CodeCompletionTUInfo &CCTUInfo, bool IncludeBriefComments) const {
3667 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3668 // Show signatures of constructors as they are declared:
3669 // vector(int n) rather than vector<string>(int n)
3670 // This is less noisy without being less clear, and avoids tricky cases.
3671 Policy.SuppressTemplateArgsInCXXConstructors = true;
3672
3673 // FIXME: Set priority, availability appropriately.
3674 CodeCompletionBuilder Result(Allocator, CCTUInfo, 1,
3675 CXAvailability_Available);
3676 FunctionDecl *FDecl = getFunction();
3677 const FunctionProtoType *Proto =
3678 dyn_cast<FunctionProtoType>(getFunctionType());
3679 if (!FDecl && !Proto) {
3680 // Function without a prototype. Just give the return type and a
3681 // highlighted ellipsis.
3682 const FunctionType *FT = getFunctionType();
3683 Result.AddResultTypeChunk(Result.getAllocator().CopyString(
3684 FT->getReturnType().getAsString(Policy)));
3685 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3686 Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
3687 Result.AddChunk(CodeCompletionString::CK_RightParen);
3688 return Result.TakeString();
3689 }
3690
3691 if (FDecl) {
3692 if (IncludeBriefComments) {
3693 if (auto RC = getParameterComment(S.getASTContext(), *this, CurrentArg))
3694 Result.addBriefComment(RC->getBriefText(S.getASTContext()));
3695 }
3696 AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result);
3697 Result.AddTextChunk(
3698 Result.getAllocator().CopyString(FDecl->getNameAsString()));
3699 } else {
3700 Result.AddResultTypeChunk(Result.getAllocator().CopyString(
3701 Proto->getReturnType().getAsString(Policy)));
3702 }
3703
3704 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3705 AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
3706 CurrentArg);
3707 Result.AddChunk(CodeCompletionString::CK_RightParen);
3708
3709 return Result.TakeString();
3710}
3711
3712unsigned clang::getMacroUsagePriority(StringRef MacroName,
3713 const LangOptions &LangOpts,
3714 bool PreferredTypeIsPointer) {
3715 unsigned Priority = CCP_Macro;
3716
3717 // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
3718 if (MacroName.equals("nil") || MacroName.equals("NULL") ||
3719 MacroName.equals("Nil")) {
3720 Priority = CCP_Constant;
3721 if (PreferredTypeIsPointer)
3722 Priority = Priority / CCF_SimilarTypeMatch;
3723 }
3724 // Treat "YES", "NO", "true", and "false" as constants.
3725 else if (MacroName.equals("YES") || MacroName.equals("NO") ||
3726 MacroName.equals("true") || MacroName.equals("false"))
3727 Priority = CCP_Constant;
3728 // Treat "bool" as a type.
3729 else if (MacroName.equals("bool"))
3730 Priority = CCP_Type + (LangOpts.ObjC ? CCD_bool_in_ObjC : 0);
3731
3732 return Priority;
3733}
3734
3735CXCursorKind clang::getCursorKindForDecl(const Decl *D) {
3736 if (!D)
3737 return CXCursor_UnexposedDecl;
3738
3739 switch (D->getKind()) {
3740 case Decl::Enum:
3741 return CXCursor_EnumDecl;
3742 case Decl::EnumConstant:
3743 return CXCursor_EnumConstantDecl;
3744 case Decl::Field:
3745 return CXCursor_FieldDecl;
3746 case Decl::Function:
3747 return CXCursor_FunctionDecl;
3748 case Decl::ObjCCategory:
3749 return CXCursor_ObjCCategoryDecl;
3750 case Decl::ObjCCategoryImpl:
3751 return CXCursor_ObjCCategoryImplDecl;
3752 case Decl::ObjCImplementation:
3753 return CXCursor_ObjCImplementationDecl;
3754
3755 case Decl::ObjCInterface:
3756 return CXCursor_ObjCInterfaceDecl;
3757 case Decl::ObjCIvar:
3758 return CXCursor_ObjCIvarDecl;
3759 case Decl::ObjCMethod:
3760 return cast<ObjCMethodDecl>(D)->isInstanceMethod()
3761 ? CXCursor_ObjCInstanceMethodDecl
3762 : CXCursor_ObjCClassMethodDecl;
3763 case Decl::CXXMethod:
3764 return CXCursor_CXXMethod;
3765 case Decl::CXXConstructor:
3766 return CXCursor_Constructor;
3767 case Decl::CXXDestructor:
3768 return CXCursor_Destructor;
3769 case Decl::CXXConversion:
3770 return CXCursor_ConversionFunction;
3771 case Decl::ObjCProperty:
3772 return CXCursor_ObjCPropertyDecl;
3773 case Decl::ObjCProtocol:
3774 return CXCursor_ObjCProtocolDecl;
3775 case Decl::ParmVar:
3776 return CXCursor_ParmDecl;
3777 case Decl::Typedef:
3778 return CXCursor_TypedefDecl;
3779 case Decl::TypeAlias:
3780 return CXCursor_TypeAliasDecl;
3781 case Decl::TypeAliasTemplate:
3782 return CXCursor_TypeAliasTemplateDecl;
3783 case Decl::Var:
3784 return CXCursor_VarDecl;
3785 case Decl::Namespace:
3786 return CXCursor_Namespace;
3787 case Decl::NamespaceAlias:
3788 return CXCursor_NamespaceAlias;
3789 case Decl::TemplateTypeParm:
3790 return CXCursor_TemplateTypeParameter;
3791 case Decl::NonTypeTemplateParm:
3792 return CXCursor_NonTypeTemplateParameter;
3793 case Decl::TemplateTemplateParm:
3794 return CXCursor_TemplateTemplateParameter;
3795 case Decl::FunctionTemplate:
3796 return CXCursor_FunctionTemplate;
3797 case Decl::ClassTemplate:
3798 return CXCursor_ClassTemplate;
3799 case Decl::AccessSpec:
3800 return CXCursor_CXXAccessSpecifier;
3801 case Decl::ClassTemplatePartialSpecialization:
3802 return CXCursor_ClassTemplatePartialSpecialization;
3803 case Decl::UsingDirective:
3804 return CXCursor_UsingDirective;
3805 case Decl::StaticAssert:
3806 return CXCursor_StaticAssert;
3807 case Decl::Friend:
3808 return CXCursor_FriendDecl;
3809 case Decl::TranslationUnit:
3810 return CXCursor_TranslationUnit;
3811
3812 case Decl::Using:
3813 case Decl::UnresolvedUsingValue:
3814 case Decl::UnresolvedUsingTypename:
3815 return CXCursor_UsingDeclaration;
3816
3817 case Decl::ObjCPropertyImpl:
3818 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
3819 case ObjCPropertyImplDecl::Dynamic:
3820 return CXCursor_ObjCDynamicDecl;
3821
3822 case ObjCPropertyImplDecl::Synthesize:
3823 return CXCursor_ObjCSynthesizeDecl;
3824 }
3825 llvm_unreachable("Unexpected Kind!")::llvm::llvm_unreachable_internal("Unexpected Kind!", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 3825)
;
3826
3827 case Decl::Import:
3828 return CXCursor_ModuleImportDecl;
3829
3830 case Decl::ObjCTypeParam:
3831 return CXCursor_TemplateTypeParameter;
3832
3833 default:
3834 if (const auto *TD = dyn_cast<TagDecl>(D)) {
3835 switch (TD->getTagKind()) {
3836 case TTK_Interface: // fall through
3837 case TTK_Struct:
3838 return CXCursor_StructDecl;
3839 case TTK_Class:
3840 return CXCursor_ClassDecl;
3841 case TTK_Union:
3842 return CXCursor_UnionDecl;
3843 case TTK_Enum:
3844 return CXCursor_EnumDecl;
3845 }
3846 }
3847 }
3848
3849 return CXCursor_UnexposedDecl;
3850}
3851
3852static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
3853 bool LoadExternal, bool IncludeUndefined,
3854 bool TargetTypeIsPointer = false) {
3855 typedef CodeCompletionResult Result;
3856
3857 Results.EnterNewScope();
3858
3859 for (Preprocessor::macro_iterator M = PP.macro_begin(LoadExternal),
3860 MEnd = PP.macro_end(LoadExternal);
3861 M != MEnd; ++M) {
3862 auto MD = PP.getMacroDefinition(M->first);
3863 if (IncludeUndefined || MD) {
3864 MacroInfo *MI = MD.getMacroInfo();
3865 if (MI && MI->isUsedForHeaderGuard())
3866 continue;
3867
3868 Results.AddResult(
3869 Result(M->first, MI,
3870 getMacroUsagePriority(M->first->getName(), PP.getLangOpts(),
3871 TargetTypeIsPointer)));
3872 }
3873 }
3874
3875 Results.ExitScope();
3876}
3877
3878static void AddPrettyFunctionResults(const LangOptions &LangOpts,
3879 ResultBuilder &Results) {
3880 typedef CodeCompletionResult Result;
3881
3882 Results.EnterNewScope();
3883
3884 Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
3885 Results.AddResult(Result("__FUNCTION__", CCP_Constant));
3886 if (LangOpts.C99 || LangOpts.CPlusPlus11)
3887 Results.AddResult(Result("__func__", CCP_Constant));
3888 Results.ExitScope();
3889}
3890
3891static void HandleCodeCompleteResults(Sema *S,
3892 CodeCompleteConsumer *CodeCompleter,
3893 CodeCompletionContext Context,
3894 CodeCompletionResult *Results,
3895 unsigned NumResults) {
3896 if (CodeCompleter)
3897 CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
3898}
3899
3900static CodeCompletionContext
3901mapCodeCompletionContext(Sema &S, Sema::ParserCompletionContext PCC) {
3902 switch (PCC) {
3903 case Sema::PCC_Namespace:
3904 return CodeCompletionContext::CCC_TopLevel;
3905
3906 case Sema::PCC_Class:
3907 return CodeCompletionContext::CCC_ClassStructUnion;
3908
3909 case Sema::PCC_ObjCInterface:
3910 return CodeCompletionContext::CCC_ObjCInterface;
3911
3912 case Sema::PCC_ObjCImplementation:
3913 return CodeCompletionContext::CCC_ObjCImplementation;
3914
3915 case Sema::PCC_ObjCInstanceVariableList:
3916 return CodeCompletionContext::CCC_ObjCIvarList;
3917
3918 case Sema::PCC_Template:
3919 case Sema::PCC_MemberTemplate:
3920 if (S.CurContext->isFileContext())
3921 return CodeCompletionContext::CCC_TopLevel;
3922 if (S.CurContext->isRecord())
3923 return CodeCompletionContext::CCC_ClassStructUnion;
3924 return CodeCompletionContext::CCC_Other;
3925
3926 case Sema::PCC_RecoveryInFunction:
3927 return CodeCompletionContext::CCC_Recovery;
3928
3929 case Sema::PCC_ForInit:
3930 if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
3931 S.getLangOpts().ObjC)
3932 return CodeCompletionContext::CCC_ParenthesizedExpression;
3933 else
3934 return CodeCompletionContext::CCC_Expression;
3935
3936 case Sema::PCC_Expression:
3937 return CodeCompletionContext::CCC_Expression;
3938 case Sema::PCC_Condition:
3939 return CodeCompletionContext(CodeCompletionContext::CCC_Expression,
3940 S.getASTContext().BoolTy);
3941
3942 case Sema::PCC_Statement:
3943 return CodeCompletionContext::CCC_Statement;
3944
3945 case Sema::PCC_Type:
3946 return CodeCompletionContext::CCC_Type;
3947
3948 case Sema::PCC_ParenthesizedExpression:
3949 return CodeCompletionContext::CCC_ParenthesizedExpression;
3950
3951 case Sema::PCC_LocalDeclarationSpecifiers:
3952 return CodeCompletionContext::CCC_Type;
3953 }
3954
3955 llvm_unreachable("Invalid ParserCompletionContext!")::llvm::llvm_unreachable_internal("Invalid ParserCompletionContext!"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 3955)
;
3956}
3957
3958/// If we're in a C++ virtual member function, add completion results
3959/// that invoke the functions we override, since it's common to invoke the
3960/// overridden function as well as adding new functionality.
3961///
3962/// \param S The semantic analysis object for which we are generating results.
3963///
3964/// \param InContext This context in which the nested-name-specifier preceding
3965/// the code-completion point
3966static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
3967 ResultBuilder &Results) {
3968 // Look through blocks.
3969 DeclContext *CurContext = S.CurContext;
3970 while (isa<BlockDecl>(CurContext))
3971 CurContext = CurContext->getParent();
3972
3973 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
3974 if (!Method || !Method->isVirtual())
3975 return;
3976
3977 // We need to have names for all of the parameters, if we're going to
3978 // generate a forwarding call.
3979 for (auto P : Method->parameters())
3980 if (!P->getDeclName())
3981 return;
3982
3983 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3984 for (const CXXMethodDecl *Overridden : Method->overridden_methods()) {
3985 CodeCompletionBuilder Builder(Results.getAllocator(),
3986 Results.getCodeCompletionTUInfo());
3987 if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
3988 continue;
3989
3990 // If we need a nested-name-specifier, add one now.
3991 if (!InContext) {
3992 NestedNameSpecifier *NNS = getRequiredQualification(
3993 S.Context, CurContext, Overridden->getDeclContext());
3994 if (NNS) {
3995 std::string Str;
3996 llvm::raw_string_ostream OS(Str);
3997 NNS->print(OS, Policy);
3998 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
3999 }
4000 } else if (!InContext->Equals(Overridden->getDeclContext()))
4001 continue;
4002
4003 Builder.AddTypedTextChunk(
4004 Results.getAllocator().CopyString(Overridden->getNameAsString()));
4005 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4006 bool FirstParam = true;
4007 for (auto P : Method->parameters()) {
4008 if (FirstParam)
4009 FirstParam = false;
4010 else
4011 Builder.AddChunk(CodeCompletionString::CK_Comma);
4012
4013 Builder.AddPlaceholderChunk(
4014 Results.getAllocator().CopyString(P->getIdentifier()->getName()));
4015 }
4016 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4017 Results.AddResult(CodeCompletionResult(
4018 Builder.TakeString(), CCP_SuperCompletion, CXCursor_CXXMethod,
4019 CXAvailability_Available, Overridden));
4020 Results.Ignore(Overridden);
4021 }
4022}
4023
4024void Sema::CodeCompleteModuleImport(SourceLocation ImportLoc,
4025 ModuleIdPath Path) {
4026 typedef CodeCompletionResult Result;
4027 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4028 CodeCompleter->getCodeCompletionTUInfo(),
4029 CodeCompletionContext::CCC_Other);
4030 Results.EnterNewScope();
4031
4032 CodeCompletionAllocator &Allocator = Results.getAllocator();
4033 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
4034 typedef CodeCompletionResult Result;
4035 if (Path.empty()) {
4036 // Enumerate all top-level modules.
4037 SmallVector<Module *, 8> Modules;
4038 PP.getHeaderSearchInfo().collectAllModules(Modules);
4039 for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
4040 Builder.AddTypedTextChunk(
4041 Builder.getAllocator().CopyString(Modules[I]->Name));
4042 Results.AddResult(Result(
4043 Builder.TakeString(), CCP_Declaration, CXCursor_ModuleImportDecl,
4044 Modules[I]->isAvailable() ? CXAvailability_Available
4045 : CXAvailability_NotAvailable));
4046 }
4047 } else if (getLangOpts().Modules) {
4048 // Load the named module.
4049 Module *Mod =
4050 PP.getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible,
4051 /*IsInclusionDirective=*/false);
4052 // Enumerate submodules.
4053 if (Mod) {
4054 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
4055 SubEnd = Mod->submodule_end();
4056 Sub != SubEnd; ++Sub) {
4057
4058 Builder.AddTypedTextChunk(
4059 Builder.getAllocator().CopyString((*Sub)->Name));
4060 Results.AddResult(Result(
4061 Builder.TakeString(), CCP_Declaration, CXCursor_ModuleImportDecl,
4062 (*Sub)->isAvailable() ? CXAvailability_Available
4063 : CXAvailability_NotAvailable));
4064 }
4065 }
4066 }
4067 Results.ExitScope();
4068 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4069 Results.data(), Results.size());
4070}
4071
4072void Sema::CodeCompleteOrdinaryName(Scope *S,
4073 ParserCompletionContext CompletionContext) {
4074 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4075 CodeCompleter->getCodeCompletionTUInfo(),
4076 mapCodeCompletionContext(*this, CompletionContext));
4077 Results.EnterNewScope();
4078
4079 // Determine how to filter results, e.g., so that the names of
4080 // values (functions, enumerators, function templates, etc.) are
4081 // only allowed where we can have an expression.
4082 switch (CompletionContext) {
4083 case PCC_Namespace:
4084 case PCC_Class:
4085 case PCC_ObjCInterface:
4086 case PCC_ObjCImplementation:
4087 case PCC_ObjCInstanceVariableList:
4088 case PCC_Template:
4089 case PCC_MemberTemplate:
4090 case PCC_Type:
4091 case PCC_LocalDeclarationSpecifiers:
4092 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
4093 break;
4094
4095 case PCC_Statement:
4096 case PCC_ParenthesizedExpression:
4097 case PCC_Expression:
4098 case PCC_ForInit:
4099 case PCC_Condition:
4100 if (WantTypesInContext(CompletionContext, getLangOpts()))
4101 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4102 else
4103 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
4104
4105 if (getLangOpts().CPlusPlus)
4106 MaybeAddOverrideCalls(*this, /*InContext=*/nullptr, Results);
4107 break;
4108
4109 case PCC_RecoveryInFunction:
4110 // Unfiltered
4111 break;
4112 }
4113
4114 // If we are in a C++ non-static member function, check the qualifiers on
4115 // the member function to filter/prioritize the results list.
4116 auto ThisType = getCurrentThisType();
4117 if (!ThisType.isNull())
4118 Results.setObjectTypeQualifiers(ThisType->getPointeeType().getQualifiers(),
4119 VK_LValue);
4120
4121 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4122 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4123 CodeCompleter->includeGlobals(),
4124 CodeCompleter->loadExternal());
4125
4126 AddOrdinaryNameResults(CompletionContext, S, *this, Results);
4127 Results.ExitScope();
4128
4129 switch (CompletionContext) {
4130 case PCC_ParenthesizedExpression:
4131 case PCC_Expression:
4132 case PCC_Statement:
4133 case PCC_RecoveryInFunction:
4134 if (S->getFnParent())
4135 AddPrettyFunctionResults(getLangOpts(), Results);
4136 break;
4137
4138 case PCC_Namespace:
4139 case PCC_Class:
4140 case PCC_ObjCInterface:
4141 case PCC_ObjCImplementation:
4142 case PCC_ObjCInstanceVariableList:
4143 case PCC_Template:
4144 case PCC_MemberTemplate:
4145 case PCC_ForInit:
4146 case PCC_Condition:
4147 case PCC_Type:
4148 case PCC_LocalDeclarationSpecifiers:
4149 break;
4150 }
4151
4152 if (CodeCompleter->includeMacros())
4153 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
4154
4155 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4156 Results.data(), Results.size());
4157}
4158
4159static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
4160 ParsedType Receiver,
4161 ArrayRef<IdentifierInfo *> SelIdents,
4162 bool AtArgumentExpression, bool IsSuper,
4163 ResultBuilder &Results);
4164
4165void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
4166 bool AllowNonIdentifiers,
4167 bool AllowNestedNameSpecifiers) {
4168 typedef CodeCompletionResult Result;
4169 ResultBuilder Results(
4170 *this, CodeCompleter->getAllocator(),
4171 CodeCompleter->getCodeCompletionTUInfo(),
4172 AllowNestedNameSpecifiers
4173 // FIXME: Try to separate codepath leading here to deduce whether we
4174 // need an existing symbol or a new one.
4175 ? CodeCompletionContext::CCC_SymbolOrNewName
4176 : CodeCompletionContext::CCC_NewName);
4177 Results.EnterNewScope();
4178
4179 // Type qualifiers can come after names.
4180 Results.AddResult(Result("const"));
4181 Results.AddResult(Result("volatile"));
4182 if (getLangOpts().C99)
4183 Results.AddResult(Result("restrict"));
4184
4185 if (getLangOpts().CPlusPlus) {
4186 if (getLangOpts().CPlusPlus11 &&
4187 (DS.getTypeSpecType() == DeclSpec::TST_class ||
4188 DS.getTypeSpecType() == DeclSpec::TST_struct))
4189 Results.AddResult("final");
4190
4191 if (AllowNonIdentifiers) {
4192 Results.AddResult(Result("operator"));
4193 }
4194
4195 // Add nested-name-specifiers.
4196 if (AllowNestedNameSpecifiers) {
4197 Results.allowNestedNameSpecifiers();
4198 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
4199 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4200 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
4201 CodeCompleter->includeGlobals(),
4202 CodeCompleter->loadExternal());
4203 Results.setFilter(nullptr);
4204 }
4205 }
4206 Results.ExitScope();
4207
4208 // If we're in a context where we might have an expression (rather than a
4209 // declaration), and what we've seen so far is an Objective-C type that could
4210 // be a receiver of a class message, this may be a class message send with
4211 // the initial opening bracket '[' missing. Add appropriate completions.
4212 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
4213 DS.getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier &&
4214 DS.getTypeSpecType() == DeclSpec::TST_typename &&
4215 DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified &&
4216 DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
4217 !DS.isTypeAltiVecVector() && S &&
4218 (S->getFlags() & Scope::DeclScope) != 0 &&
4219 (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope |
4220 Scope::FunctionPrototypeScope | Scope::AtCatchScope)) ==
4221 0) {
4222 ParsedType T = DS.getRepAsType();
4223 if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
4224 AddClassMessageCompletions(*this, S, T, None, false, false, Results);
4225 }
4226
4227 // Note that we intentionally suppress macro results here, since we do not
4228 // encourage using macros to produce the names of entities.
4229
4230 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4231 Results.data(), Results.size());
4232}
4233
4234struct Sema::CodeCompleteExpressionData {
4235 CodeCompleteExpressionData(QualType PreferredType = QualType(),
4236 bool IsParenthesized = false)
4237 : PreferredType(PreferredType), IntegralConstantExpression(false),
4238 ObjCCollection(false), IsParenthesized(IsParenthesized) {}
4239
4240 QualType PreferredType;
4241 bool IntegralConstantExpression;
4242 bool ObjCCollection;
4243 bool IsParenthesized;
4244 SmallVector<Decl *, 4> IgnoreDecls;
4245};
4246
4247namespace {
4248/// Information that allows to avoid completing redundant enumerators.
4249struct CoveredEnumerators {
4250 llvm::SmallPtrSet<EnumConstantDecl *, 8> Seen;
4251 NestedNameSpecifier *SuggestedQualifier = nullptr;
4252};
4253} // namespace
4254
4255static void AddEnumerators(ResultBuilder &Results, ASTContext &Context,
4256 EnumDecl *Enum, DeclContext *CurContext,
4257 const CoveredEnumerators &Enumerators) {
4258 NestedNameSpecifier *Qualifier = Enumerators.SuggestedQualifier;
4259 if (Context.getLangOpts().CPlusPlus && !Qualifier && Enumerators.Seen.empty()) {
4260 // If there are no prior enumerators in C++, check whether we have to
4261 // qualify the names of the enumerators that we suggest, because they
4262 // may not be visible in this scope.
4263 Qualifier = getRequiredQualification(Context, CurContext, Enum);
4264 }
4265
4266 Results.EnterNewScope();
4267 for (auto *E : Enum->enumerators()) {
4268 if (Enumerators.Seen.count(E))
4269 continue;
4270
4271 CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);
4272 Results.AddResult(R, CurContext, nullptr, false);
4273 }
4274 Results.ExitScope();
4275}
4276
4277/// Try to find a corresponding FunctionProtoType for function-like types (e.g.
4278/// function pointers, std::function, etc).
4279static const FunctionProtoType *TryDeconstructFunctionLike(QualType T) {
4280 assert(!T.isNull())((!T.isNull()) ? static_cast<void> (0) : __assert_fail (
"!T.isNull()", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 4280, __PRETTY_FUNCTION__))
;
4281 // Try to extract first template argument from std::function<> and similar.
4282 // Note we only handle the sugared types, they closely match what users wrote.
4283 // We explicitly choose to not handle ClassTemplateSpecializationDecl.
4284 if (auto *Specialization = T->getAs<TemplateSpecializationType>()) {
4285 if (Specialization->getNumArgs() != 1)
4286 return nullptr;
4287 const TemplateArgument &Argument = Specialization->getArg(0);
4288 if (Argument.getKind() != TemplateArgument::Type)
4289 return nullptr;
4290 return Argument.getAsType()->getAs<FunctionProtoType>();
4291 }
4292 // Handle other cases.
4293 if (T->isPointerType())
4294 T = T->getPointeeType();
4295 return T->getAs<FunctionProtoType>();
4296}
4297
4298/// Adds a pattern completion for a lambda expression with the specified
4299/// parameter types and placeholders for parameter names.
4300static void AddLambdaCompletion(ResultBuilder &Results,
4301 llvm::ArrayRef<QualType> Parameters,
4302 const LangOptions &LangOpts) {
4303 if (!Results.includeCodePatterns())
4304 return;
4305 CodeCompletionBuilder Completion(Results.getAllocator(),
4306 Results.getCodeCompletionTUInfo());
4307 // [](<parameters>) {}
4308 Completion.AddChunk(CodeCompletionString::CK_LeftBracket);
4309 Completion.AddPlaceholderChunk("=");
4310 Completion.AddChunk(CodeCompletionString::CK_RightBracket);
4311 if (!Parameters.empty()) {
4312 Completion.AddChunk(CodeCompletionString::CK_LeftParen);
4313 bool First = true;
4314 for (auto Parameter : Parameters) {
4315 if (!First)
4316 Completion.AddChunk(CodeCompletionString::ChunkKind::CK_Comma);
4317 else
4318 First = false;
4319
4320 constexpr llvm::StringLiteral NamePlaceholder = "!#!NAME_GOES_HERE!#!";
4321 std::string Type = NamePlaceholder;
4322 Parameter.getAsStringInternal(Type, PrintingPolicy(LangOpts));
4323 llvm::StringRef Prefix, Suffix;
4324 std::tie(Prefix, Suffix) = llvm::StringRef(Type).split(NamePlaceholder);
4325 Prefix = Prefix.rtrim();
4326 Suffix = Suffix.ltrim();
4327
4328 Completion.AddTextChunk(Completion.getAllocator().CopyString(Prefix));
4329 Completion.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4330 Completion.AddPlaceholderChunk("parameter");
4331 Completion.AddTextChunk(Completion.getAllocator().CopyString(Suffix));
4332 };
4333 Completion.AddChunk(CodeCompletionString::CK_RightParen);
4334 }
4335 Completion.AddChunk(clang::CodeCompletionString::CK_HorizontalSpace);
4336 Completion.AddChunk(CodeCompletionString::CK_LeftBrace);
4337 Completion.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4338 Completion.AddPlaceholderChunk("body");
4339 Completion.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4340 Completion.AddChunk(CodeCompletionString::CK_RightBrace);
4341
4342 Results.AddResult(Completion.TakeString());
4343}
4344
4345/// Perform code-completion in an expression context when we know what
4346/// type we're looking for.
4347void Sema::CodeCompleteExpression(Scope *S,
4348 const CodeCompleteExpressionData &Data) {
4349 ResultBuilder Results(
4350 *this, CodeCompleter->getAllocator(),
4351 CodeCompleter->getCodeCompletionTUInfo(),
4352 CodeCompletionContext(
4353 Data.IsParenthesized
4354 ? CodeCompletionContext::CCC_ParenthesizedExpression
4355 : CodeCompletionContext::CCC_Expression,
4356 Data.PreferredType));
4357 auto PCC =
4358 Data.IsParenthesized ? PCC_ParenthesizedExpression : PCC_Expression;
4359 if (Data.ObjCCollection)
4360 Results.setFilter(&ResultBuilder::IsObjCCollection);
4361 else if (Data.IntegralConstantExpression)
4362 Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
4363 else if (WantTypesInContext(PCC, getLangOpts()))
4364 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4365 else
4366 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
4367
4368 if (!Data.PreferredType.isNull())
4369 Results.setPreferredType(Data.PreferredType.getNonReferenceType());
4370
4371 // Ignore any declarations that we were told that we don't care about.
4372 for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
4373 Results.Ignore(Data.IgnoreDecls[I]);
4374
4375 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4376 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4377 CodeCompleter->includeGlobals(),
4378 CodeCompleter->loadExternal());
4379
4380 Results.EnterNewScope();
4381 AddOrdinaryNameResults(PCC, S, *this, Results);
4382 Results.ExitScope();
4383
4384 bool PreferredTypeIsPointer = false;
4385 if (!Data.PreferredType.isNull()) {
4386 PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType() ||
4387 Data.PreferredType->isMemberPointerType() ||
4388 Data.PreferredType->isBlockPointerType();
4389 if (Data.PreferredType->isEnumeralType()) {
4390 EnumDecl *Enum = Data.PreferredType->castAs<EnumType>()->getDecl();
4391 if (auto *Def = Enum->getDefinition())
4392 Enum = Def;
4393 // FIXME: collect covered enumerators in cases like:
4394 // if (x == my_enum::one) { ... } else if (x == ^) {}
4395 AddEnumerators(Results, Context, Enum, CurContext, CoveredEnumerators());
4396 }
4397 }
4398
4399 if (S->getFnParent() && !Data.ObjCCollection &&
4400 !Data.IntegralConstantExpression)
4401 AddPrettyFunctionResults(getLangOpts(), Results);
4402
4403 if (CodeCompleter->includeMacros())
4404 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false,
4405 PreferredTypeIsPointer);
4406
4407 // Complete a lambda expression when preferred type is a function.
4408 if (!Data.PreferredType.isNull() && getLangOpts().CPlusPlus11) {
4409 if (const FunctionProtoType *F =
4410 TryDeconstructFunctionLike(Data.PreferredType))
4411 AddLambdaCompletion(Results, F->getParamTypes(), getLangOpts());
4412 }
4413
4414 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4415 Results.data(), Results.size());
4416}
4417
4418void Sema::CodeCompleteExpression(Scope *S, QualType PreferredType,
4419 bool IsParenthesized) {
4420 return CodeCompleteExpression(
4421 S, CodeCompleteExpressionData(PreferredType, IsParenthesized));
4422}
4423
4424void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E,
4425 QualType PreferredType) {
4426 if (E.isInvalid())
4427 CodeCompleteExpression(S, PreferredType);
4428 else if (getLangOpts().ObjC)
4429 CodeCompleteObjCInstanceMessage(S, E.get(), None, false);
4430}
4431
4432/// The set of properties that have already been added, referenced by
4433/// property name.
4434typedef llvm::SmallPtrSet<IdentifierInfo *, 16> AddedPropertiesSet;
4435
4436/// Retrieve the container definition, if any?
4437static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) {
4438 if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
4439 if (Interface->hasDefinition())
4440 return Interface->getDefinition();
4441
4442 return Interface;
4443 }
4444
4445 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
4446 if (Protocol->hasDefinition())
4447 return Protocol->getDefinition();
4448
4449 return Protocol;
4450 }
4451 return Container;
4452}
4453
4454/// Adds a block invocation code completion result for the given block
4455/// declaration \p BD.
4456static void AddObjCBlockCall(ASTContext &Context, const PrintingPolicy &Policy,
4457 CodeCompletionBuilder &Builder,
4458 const NamedDecl *BD,
4459 const FunctionTypeLoc &BlockLoc,
4460 const FunctionProtoTypeLoc &BlockProtoLoc) {
4461 Builder.AddResultTypeChunk(
4462 GetCompletionTypeString(BlockLoc.getReturnLoc().getType(), Context,
4463 Policy, Builder.getAllocator()));
4464
4465 AddTypedNameChunk(Context, Policy, BD, Builder);
4466 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4467
4468 if (BlockProtoLoc && BlockProtoLoc.getTypePtr()->isVariadic()) {
4469 Builder.AddPlaceholderChunk("...");
4470 } else {
4471 for (unsigned I = 0, N = BlockLoc.getNumParams(); I != N; ++I) {
4472 if (I)
4473 Builder.AddChunk(CodeCompletionString::CK_Comma);
4474
4475 // Format the placeholder string.
4476 std::string PlaceholderStr =
4477 FormatFunctionParameter(Policy, BlockLoc.getParam(I));
4478
4479 if (I == N - 1 && BlockProtoLoc &&
4480 BlockProtoLoc.getTypePtr()->isVariadic())
4481 PlaceholderStr += ", ...";
4482
4483 // Add the placeholder string.
4484 Builder.AddPlaceholderChunk(
4485 Builder.getAllocator().CopyString(PlaceholderStr));
4486 }
4487 }
4488
4489 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4490}
4491
4492static void
4493AddObjCProperties(const CodeCompletionContext &CCContext,
4494 ObjCContainerDecl *Container, bool AllowCategories,
4495 bool AllowNullaryMethods, DeclContext *CurContext,
4496 AddedPropertiesSet &AddedProperties, ResultBuilder &Results,
4497 bool IsBaseExprStatement = false,
4498 bool IsClassProperty = false, bool InOriginalClass = true) {
4499 typedef CodeCompletionResult Result;
4500
4501 // Retrieve the definition.
4502 Container = getContainerDef(Container);
4503
4504 // Add properties in this container.
4505 const auto AddProperty = [&](const ObjCPropertyDecl *P) {
4506 if (!AddedProperties.insert(P->getIdentifier()).second)
4507 return;
4508
4509 // FIXME: Provide block invocation completion for non-statement
4510 // expressions.
4511 if (!P->getType().getTypePtr()->isBlockPointerType() ||
4512 !IsBaseExprStatement) {
4513 Result R = Result(P, Results.getBasePriority(P), nullptr);
4514 if (!InOriginalClass)
4515 setInBaseClass(R);
4516 Results.MaybeAddResult(R, CurContext);
4517 return;
4518 }
4519
4520 // Block setter and invocation completion is provided only when we are able
4521 // to find the FunctionProtoTypeLoc with parameter names for the block.
4522 FunctionTypeLoc BlockLoc;
4523 FunctionProtoTypeLoc BlockProtoLoc;
4524 findTypeLocationForBlockDecl(P->getTypeSourceInfo(), BlockLoc,
4525 BlockProtoLoc);
4526 if (!BlockLoc) {
4527 Result R = Result(P, Results.getBasePriority(P), nullptr);
4528 if (!InOriginalClass)
4529 setInBaseClass(R);
4530 Results.MaybeAddResult(R, CurContext);
4531 return;
4532 }
4533
4534 // The default completion result for block properties should be the block
4535 // invocation completion when the base expression is a statement.
4536 CodeCompletionBuilder Builder(Results.getAllocator(),
4537 Results.getCodeCompletionTUInfo());
4538 AddObjCBlockCall(Container->getASTContext(),
4539 getCompletionPrintingPolicy(Results.getSema()), Builder, P,
4540 BlockLoc, BlockProtoLoc);
4541 Result R = Result(Builder.TakeString(), P, Results.getBasePriority(P));
4542 if (!InOriginalClass)
4543 setInBaseClass(R);
4544 Results.MaybeAddResult(R, CurContext);
4545
4546 // Provide additional block setter completion iff the base expression is a
4547 // statement and the block property is mutable.
4548 if (!P->isReadOnly()) {
4549 CodeCompletionBuilder Builder(Results.getAllocator(),
4550 Results.getCodeCompletionTUInfo());
4551 AddResultTypeChunk(Container->getASTContext(),
4552 getCompletionPrintingPolicy(Results.getSema()), P,
4553 CCContext.getBaseType(), Builder);
4554 Builder.AddTypedTextChunk(
4555 Results.getAllocator().CopyString(P->getName()));
4556 Builder.AddChunk(CodeCompletionString::CK_Equal);
4557
4558 std::string PlaceholderStr = formatBlockPlaceholder(
4559 getCompletionPrintingPolicy(Results.getSema()), P, BlockLoc,
4560 BlockProtoLoc, /*SuppressBlockName=*/true);
4561 // Add the placeholder string.
4562 Builder.AddPlaceholderChunk(
4563 Builder.getAllocator().CopyString(PlaceholderStr));
4564
4565 // When completing blocks properties that return void the default
4566 // property completion result should show up before the setter,
4567 // otherwise the setter completion should show up before the default
4568 // property completion, as we normally want to use the result of the
4569 // call.
4570 Result R =
4571 Result(Builder.TakeString(), P,
4572 Results.getBasePriority(P) +
4573 (BlockLoc.getTypePtr()->getReturnType()->isVoidType()
4574 ? CCD_BlockPropertySetter
4575 : -CCD_BlockPropertySetter));
4576 if (!InOriginalClass)
4577 setInBaseClass(R);
4578 Results.MaybeAddResult(R, CurContext);
4579 }
4580 };
4581
4582 if (IsClassProperty) {
4583 for (const auto *P : Container->class_properties())
4584 AddProperty(P);
4585 } else {
4586 for (const auto *P : Container->instance_properties())
4587 AddProperty(P);
4588 }
4589
4590 // Add nullary methods or implicit class properties
4591 if (AllowNullaryMethods) {
4592 ASTContext &Context = Container->getASTContext();
4593 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
4594 // Adds a method result
4595 const auto AddMethod = [&](const ObjCMethodDecl *M) {
4596 IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0);
4597 if (!Name)
4598 return;
4599 if (!AddedProperties.insert(Name).second)
4600 return;
4601 CodeCompletionBuilder Builder(Results.getAllocator(),
4602 Results.getCodeCompletionTUInfo());
4603 AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(), Builder);
4604 Builder.AddTypedTextChunk(
4605 Results.getAllocator().CopyString(Name->getName()));
4606 Result R = Result(Builder.TakeString(), M,
4607 CCP_MemberDeclaration + CCD_MethodAsProperty);
4608 if (!InOriginalClass)
4609 setInBaseClass(R);
4610 Results.MaybeAddResult(R, CurContext);
4611 };
4612
4613 if (IsClassProperty) {
4614 for (const auto *M : Container->methods()) {
4615 // Gather the class method that can be used as implicit property
4616 // getters. Methods with arguments or methods that return void aren't
4617 // added to the results as they can't be used as a getter.
4618 if (!M->getSelector().isUnarySelector() ||
4619 M->getReturnType()->isVoidType() || M->isInstanceMethod())
4620 continue;
4621 AddMethod(M);
4622 }
4623 } else {
4624 for (auto *M : Container->methods()) {
4625 if (M->getSelector().isUnarySelector())
4626 AddMethod(M);
4627 }
4628 }
4629 }
4630
4631 // Add properties in referenced protocols.
4632 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
4633 for (auto *P : Protocol->protocols())
4634 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
4635 CurContext, AddedProperties, Results,
4636 IsBaseExprStatement, IsClassProperty,
4637 /*InOriginalClass*/ false);
4638 } else if (ObjCInterfaceDecl *IFace =
4639 dyn_cast<ObjCInterfaceDecl>(Container)) {
4640 if (AllowCategories) {
4641 // Look through categories.
4642 for (auto *Cat : IFace->known_categories())
4643 AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods,
4644 CurContext, AddedProperties, Results,
4645 IsBaseExprStatement, IsClassProperty,
4646 InOriginalClass);
4647 }
4648
4649 // Look through protocols.
4650 for (auto *I : IFace->all_referenced_protocols())
4651 AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods,
4652 CurContext, AddedProperties, Results,
4653 IsBaseExprStatement, IsClassProperty,
4654 /*InOriginalClass*/ false);
4655
4656 // Look in the superclass.
4657 if (IFace->getSuperClass())
4658 AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories,
4659 AllowNullaryMethods, CurContext, AddedProperties,
4660 Results, IsBaseExprStatement, IsClassProperty,
4661 /*InOriginalClass*/ false);
4662 } else if (const auto *Category =
4663 dyn_cast<ObjCCategoryDecl>(Container)) {
4664 // Look through protocols.
4665 for (auto *P : Category->protocols())
4666 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
4667 CurContext, AddedProperties, Results,
4668 IsBaseExprStatement, IsClassProperty,
4669 /*InOriginalClass*/ false);
4670 }
4671}
4672
4673static void AddRecordMembersCompletionResults(
4674 Sema &SemaRef, ResultBuilder &Results, Scope *S, QualType BaseType,
4675 ExprValueKind BaseKind, RecordDecl *RD, Optional<FixItHint> AccessOpFixIt) {
4676 // Indicate that we are performing a member access, and the cv-qualifiers
4677 // for the base object type.
4678 Results.setObjectTypeQualifiers(BaseType.getQualifiers(), BaseKind);
4679
4680 // Access to a C/C++ class, struct, or union.
4681 Results.allowNestedNameSpecifiers();
4682 std::vector<FixItHint> FixIts;
4683 if (AccessOpFixIt)
4684 FixIts.emplace_back(AccessOpFixIt.getValue());
4685 CodeCompletionDeclConsumer Consumer(Results, RD, BaseType, std::move(FixIts));
4686 SemaRef.LookupVisibleDecls(RD, Sema::LookupMemberName, Consumer,
4687 SemaRef.CodeCompleter->includeGlobals(),
4688 /*IncludeDependentBases=*/true,
4689 SemaRef.CodeCompleter->loadExternal());
4690
4691 if (SemaRef.getLangOpts().CPlusPlus) {
4692 if (!Results.empty()) {
4693 // The "template" keyword can follow "->" or "." in the grammar.
4694 // However, we only want to suggest the template keyword if something
4695 // is dependent.
4696 bool IsDependent = BaseType->isDependentType();
4697 if (!IsDependent) {
4698 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
4699 if (DeclContext *Ctx = DepScope->getEntity()) {
4700 IsDependent = Ctx->isDependentContext();
4701 break;
4702 }
4703 }
4704
4705 if (IsDependent)
4706 Results.AddResult(CodeCompletionResult("template"));
4707 }
4708 }
4709}
4710
4711void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
4712 Expr *OtherOpBase,
4713 SourceLocation OpLoc, bool IsArrow,
4714 bool IsBaseExprStatement,
4715 QualType PreferredType) {
4716 if (!Base || !CodeCompleter)
1
Assuming 'Base' is non-null
2
Assuming field 'CodeCompleter' is non-null
3
Taking false branch
4717 return;
4718
4719 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
4720 if (ConvertedBase.isInvalid())
4
Assuming the condition is false
5
Taking false branch
4721 return;
4722 QualType ConvertedBaseType = ConvertedBase.get()->getType();
4723
4724 enum CodeCompletionContext::Kind contextKind;
4725
4726 if (IsArrow) {
6
Assuming 'IsArrow' is false
7
Taking false branch
4727 if (const auto *Ptr = ConvertedBaseType->getAs<PointerType>())
4728 ConvertedBaseType = Ptr->getPointeeType();
4729 }
4730
4731 if (IsArrow
7.1
'IsArrow' is false
7.1
'IsArrow' is false
) {
8
Taking false branch
4732 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess;
4733 } else {
4734 if (ConvertedBaseType->isObjCObjectPointerType() ||
4735 ConvertedBaseType->isObjCObjectOrInterfaceType()) {
4736 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
4737 } else {
4738 contextKind = CodeCompletionContext::CCC_DotMemberAccess;
4739 }
4740 }
4741
4742 CodeCompletionContext CCContext(contextKind, ConvertedBaseType);
4743 CCContext.setPreferredType(PreferredType);
4744 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4745 CodeCompleter->getCodeCompletionTUInfo(), CCContext,
4746 &ResultBuilder::IsMember);
4747
4748 auto DoCompletion = [&](Expr *Base, bool IsArrow,
4749 Optional<FixItHint> AccessOpFixIt) -> bool {
4750 if (!Base
9.1
'Base' is non-null
9.1
'Base' is non-null
)
10
Taking false branch
4751 return false;
4752
4753 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
4754 if (ConvertedBase.isInvalid())
11
Assuming the condition is false
12
Taking false branch
4755 return false;
4756 Base = ConvertedBase.get();
4757
4758 QualType BaseType = Base->getType();
4759 ExprValueKind BaseKind = Base->getValueKind();
4760
4761 if (IsArrow
12.1
'IsArrow' is false
12.1
'IsArrow' is false
) {
13
Taking false branch
4762 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
4763 BaseType = Ptr->getPointeeType();
4764 BaseKind = VK_LValue;
4765 } else if (BaseType->isObjCObjectPointerType())
4766 /*Do nothing*/;
4767 else
4768 return false;
4769 }
4770
4771 if (const RecordType *Record
14.1
'Record' is null
14.1
'Record' is null
= BaseType->getAs<RecordType>()) {
14
Assuming the object is not a 'RecordType'
15
Taking false branch
4772 AddRecordMembersCompletionResults(*this, Results, S, BaseType, BaseKind,
4773 Record->getDecl(),
4774 std::move(AccessOpFixIt));
4775 } else if (const auto *TST
16.1
'TST' is null
16.1
'TST' is null
=
17
Taking false branch
4776 BaseType->getAs<TemplateSpecializationType>()) {
16
Assuming the object is not a 'TemplateSpecializationType'
4777 TemplateName TN = TST->getTemplateName();
4778 if (const auto *TD =
4779 dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl())) {
4780 CXXRecordDecl *RD = TD->getTemplatedDecl();
4781 AddRecordMembersCompletionResults(*this, Results, S, BaseType, BaseKind,
4782 RD, std::move(AccessOpFixIt));
4783 }
4784 } else if (const auto *ICNT
18.1
'ICNT' is null
18.1
'ICNT' is null
= BaseType->getAs<InjectedClassNameType>()) {
18
Assuming the object is not a 'InjectedClassNameType'
19
Taking false branch
4785 if (auto *RD = ICNT->getDecl())
4786 AddRecordMembersCompletionResults(*this, Results, S, BaseType, BaseKind,
4787 RD, std::move(AccessOpFixIt));
4788 } else if (!IsArrow
19.1
'IsArrow' is false
19.1
'IsArrow' is false
&& BaseType->isObjCObjectPointerType()) {
20
Calling 'Type::isObjCObjectPointerType'
23
Returning from 'Type::isObjCObjectPointerType'
24
Taking true branch
4789 // Objective-C property reference.
4790 AddedPropertiesSet AddedProperties;
4791
4792 if (const ObjCObjectPointerType *ObjCPtr =
25
Assuming 'ObjCPtr' is null
26
Taking false branch
4793 BaseType->getAsObjCInterfacePointerType()) {
4794 // Add property results based on our interface.
4795 assert(ObjCPtr && "Non-NULL pointer guaranteed above!")((ObjCPtr && "Non-NULL pointer guaranteed above!") ? static_cast
<void> (0) : __assert_fail ("ObjCPtr && \"Non-NULL pointer guaranteed above!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 4795, __PRETTY_FUNCTION__))
;
4796 AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true,
4797 /*AllowNullaryMethods=*/true, CurContext,
4798 AddedProperties, Results, IsBaseExprStatement);
4799 }
4800
4801 // Add properties from the protocols in a qualified interface.
4802 for (auto *I : BaseType->getAs<ObjCObjectPointerType>()->quals())
27
Assuming the object is not a 'ObjCObjectPointerType'
28
Called C++ object pointer is null
4803 AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true,
4804 CurContext, AddedProperties, Results,
4805 IsBaseExprStatement, /*IsClassProperty*/ false,
4806 /*InOriginalClass*/ false);
4807 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
4808 (!IsArrow && BaseType->isObjCObjectType())) {
4809 // Objective-C instance variable access.
4810 ObjCInterfaceDecl *Class = nullptr;
4811 if (const ObjCObjectPointerType *ObjCPtr =
4812 BaseType->getAs<ObjCObjectPointerType>())
4813 Class = ObjCPtr->getInterfaceDecl();
4814 else
4815 Class = BaseType->getAs<ObjCObjectType>()->getInterface();
4816
4817 // Add all ivars from this class and its superclasses.
4818 if (Class) {
4819 CodeCompletionDeclConsumer Consumer(Results, Class, BaseType);
4820 Results.setFilter(&ResultBuilder::IsObjCIvar);
4821 LookupVisibleDecls(
4822 Class, LookupMemberName, Consumer, CodeCompleter->includeGlobals(),
4823 /*IncludeDependentBases=*/false, CodeCompleter->loadExternal());
4824 }
4825 }
4826
4827 // FIXME: How do we cope with isa?
4828 return true;
4829 };
4830
4831 Results.EnterNewScope();
4832
4833 bool CompletionSucceded = DoCompletion(Base, IsArrow, None);
9
Calling 'operator()'
4834 if (CodeCompleter->includeFixIts()) {
4835 const CharSourceRange OpRange =
4836 CharSourceRange::getTokenRange(OpLoc, OpLoc);
4837 CompletionSucceded |= DoCompletion(
4838 OtherOpBase, !IsArrow,
4839 FixItHint::CreateReplacement(OpRange, IsArrow ? "." : "->"));
4840 }
4841
4842 Results.ExitScope();
4843
4844 if (!CompletionSucceded)
4845 return;
4846
4847 // Hand off the results found for code completion.
4848 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4849 Results.data(), Results.size());
4850}
4851
4852void Sema::CodeCompleteObjCClassPropertyRefExpr(Scope *S,
4853 IdentifierInfo &ClassName,
4854 SourceLocation ClassNameLoc,
4855 bool IsBaseExprStatement) {
4856 IdentifierInfo *ClassNamePtr = &ClassName;
4857 ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(ClassNamePtr, ClassNameLoc);
4858 if (!IFace)
4859 return;
4860 CodeCompletionContext CCContext(
4861 CodeCompletionContext::CCC_ObjCPropertyAccess);
4862 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4863 CodeCompleter->getCodeCompletionTUInfo(), CCContext,
4864 &ResultBuilder::IsMember);
4865 Results.EnterNewScope();
4866 AddedPropertiesSet AddedProperties;
4867 AddObjCProperties(CCContext, IFace, true,
4868 /*AllowNullaryMethods=*/true, CurContext, AddedProperties,
4869 Results, IsBaseExprStatement,
4870 /*IsClassProperty=*/true);
4871 Results.ExitScope();
4872 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4873 Results.data(), Results.size());
4874}
4875
4876void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
4877 if (!CodeCompleter)
4878 return;
4879
4880 ResultBuilder::LookupFilter Filter = nullptr;
4881 enum CodeCompletionContext::Kind ContextKind =
4882 CodeCompletionContext::CCC_Other;
4883 switch ((DeclSpec::TST)TagSpec) {
4884 case DeclSpec::TST_enum:
4885 Filter = &ResultBuilder::IsEnum;
4886 ContextKind = CodeCompletionContext::CCC_EnumTag;
4887 break;
4888
4889 case DeclSpec::TST_union:
4890 Filter = &ResultBuilder::IsUnion;
4891 ContextKind = CodeCompletionContext::CCC_UnionTag;
4892 break;
4893
4894 case DeclSpec::TST_struct:
4895 case DeclSpec::TST_class:
4896 case DeclSpec::TST_interface:
4897 Filter = &ResultBuilder::IsClassOrStruct;
4898 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag;
4899 break;
4900
4901 default:
4902 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag")::llvm::llvm_unreachable_internal("Unknown type specifier kind in CodeCompleteTag"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/Sema/SemaCodeComplete.cpp"
, 4902)
;
4903 }
4904
4905 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4906 CodeCompleter->getCodeCompletionTUInfo(), ContextKind);
4907 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4908
4909 // First pass: look for tags.
4910 Results.setFilter(Filter);
4911 LookupVisibleDecls(S, LookupTagName, Consumer,
4912 CodeCompleter->includeGlobals(),
4913 CodeCompleter->loadExternal());
4914
4915 if (CodeCompleter->includeGlobals()) {
4916 // Second pass: look for nested name specifiers.
4917 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
4918 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
4919 CodeCompleter->includeGlobals(),
4920 CodeCompleter->loadExternal());
4921 }
4922
4923 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4924 Results.data(), Results.size());
4925}
4926
4927static void AddTypeQualifierResults(DeclSpec &DS, ResultBuilder &Results,
4928 const LangOptions &LangOpts) {
4929 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
4930 Results.AddResult("const");
4931 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
4932 Results.AddResult("volatile");
4933 if (LangOpts.C99 && !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
4934 Results.AddResult("restrict");
4935 if (LangOpts.C11 && !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic))
4936 Results.AddResult("_Atomic");
4937 if (LangOpts.MSVCCompat && !(DS.getTypeQualifiers() & DeclSpec::TQ_unaligned))
4938 Results.AddResult("__unaligned");
4939}
4940
4941void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) {
4942 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4943 CodeCompleter->getCodeCompletionTUInfo(),
4944 CodeCompletionContext::CCC_TypeQualifiers);
4945 Results.EnterNewScope();
4946 AddTypeQualifierResults(DS, Results, LangOpts);
4947 Results.ExitScope();
4948 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4949 Results.data(), Results.size());
4950}
4951
4952void Sema::CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
4953 const VirtSpecifiers *VS) {
4954 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4955 CodeCompleter->getCodeCompletionTUInfo(),
4956 CodeCompletionContext::CCC_TypeQualifiers);
4957 Results.EnterNewScope();
4958 AddTypeQualifierResults(DS, Results, LangOpts);
4959 if (LangOpts.CPlusPlus11) {
4960 Results.AddResult("noexcept");
4961 if (D.getContext() == DeclaratorContext::MemberContext &&
4962 !D.isCtorOrDtor() && !D.isStaticMember()) {
4963 if (!VS || !VS->isFinalSpecified())
4964 Results.AddResult("final");
4965 if (!VS || !VS->isOverrideSpecified())
4966 Results.AddResult("override");
4967 }
4968 }
4969 Results.ExitScope();
4970 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4971 Results.data(), Results.size());
4972}
4973
4974void Sema::CodeCompleteBracketDeclarator(Scope *S) {
4975 CodeCompleteExpression(S, QualType(getASTContext().getSizeType()));
4976}
4977
4978void Sema::CodeCompleteCase(Scope *S) {
4979 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
4980 return;
4981
4982 SwitchStmt *Switch = getCurFunction()->SwitchStack.back().getPointer();
4983 // Condition expression might be invalid, do not continue in this case.
4984 if (!Switch->getCond())
4985 return;
4986 QualType type = Switch->getCond()->IgnoreImplicit()->getType();
4987 if (!type->isEnumeralType()) {
4988 CodeCompleteExpressionData Data(type);
4989 Data.IntegralConstantExpression = true;
4990 CodeCompleteExpression(S, Data);
4991 return;
4992 }
4993
4994 // Code-complete the cases of a switch statement over an enumeration type
4995 // by providing the list of
4996 EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
4997 if (EnumDecl *Def = Enum->getDefinition())
4998 Enum = Def;
4999
5000 // Determine which enumerators we have already seen in the switch statement.
5001 // FIXME: Ideally, we would also be able to look *past* the code-completion
5002 // token, in case we are code-completing in the middle of the switch and not
5003 // at the end. However, we aren't able to do so at the moment.
5004 CoveredEnumerators Enumerators;
5005 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
5006 SC = SC->getNextSwitchCase()) {
5007 CaseStmt *Case = dyn_cast<CaseStmt>(SC);
5008 if (!Case)
5009 continue;
5010
5011 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
5012 if (auto *DRE = dyn_cast<DeclRefExpr>(CaseVal))
5013 if (auto *Enumerator =
5014 dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
5015 // We look into the AST of the case statement to determine which
5016 // enumerator was named. Alternatively, we could compute the value of
5017 // the integral constant expression, then compare it against the
5018 // values of each enumerator. However, value-based approach would not
5019 // work as well with C++ templates where enumerators declared within a
5020 // template are type- and value-dependent.
5021 Enumerators.Seen.insert(Enumerator);
5022
5023 // If this is a qualified-id, keep track of the nested-name-specifier
5024 // so that we can reproduce it as part of code completion, e.g.,
5025 //
5026 // switch (TagD.getKind()) {
5027 // case TagDecl::TK_enum:
5028 // break;
5029 // case XXX
5030 //
5031 // At the XXX, our completions are TagDecl::TK_union,
5032 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
5033 // TK_struct, and TK_class.
5034 Enumerators.SuggestedQualifier = DRE->getQualifier();
5035 }
5036 }
5037
5038 // Add any enumerators that have not yet been mentioned.
5039 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5040 CodeCompleter->getCodeCompletionTUInfo(),
5041 CodeCompletionContext::CCC_Expression);
5042 AddEnumerators(Results, Context, Enum, CurContext, Enumerators);
5043
5044 if (CodeCompleter->includeMacros()) {
5045 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
5046 }
5047 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5048 Results.data(), Results.size());
5049}
5050
5051static bool anyNullArguments(ArrayRef<Expr *> Args) {
5052 if (Args.size() && !Args.data())
5053 return true;
5054
5055 for (unsigned I = 0; I != Args.size(); ++I)
5056 if (!Args[I])
5057 return true;
5058
5059 return false;
5060}
5061
5062typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate;
5063
5064static void mergeCandidatesWithResults(
5065 Sema &SemaRef, SmallVectorImpl<ResultCandidate> &Results,
5066 OverloadCandidateSet &CandidateSet, SourceLocation Loc) {
5067 // Sort the overload candidate set by placing the best overloads first.
5068 llvm::stable_sort(CandidateSet, [&](const OverloadCandidate &X,
5069 const OverloadCandidate &Y) {
5070 return isBetterOverloadCandidate(SemaRef, X, Y, Loc,
5071 CandidateSet.getKind());
5072 });
5073
5074 // Add the remaining viable overload candidates as code-completion results.
5075 for (OverloadCandidate &Candidate : CandidateSet) {
5076 if (Candidate.Function && Candidate.Function->isDeleted())
5077 continue;
5078 if (Candidate.Viable)
5079 Results.push_back(ResultCandidate(Candidate.Function));
5080 }
5081}
5082
5083/// Get the type of the Nth parameter from a given set of overload
5084/// candidates.
5085static QualType getParamType(Sema &SemaRef,
5086 ArrayRef<ResultCandidate> Candidates, unsigned N) {
5087
5088 // Given the overloads 'Candidates' for a function call matching all arguments
5089 // up to N, return the type of the Nth parameter if it is the same for all
5090 // overload candidates.
5091 QualType ParamType;
5092 for (auto &Candidate : Candidates) {
5093 if (const auto *FType = Candidate.getFunctionType())
5094 if (const auto *Proto = dyn_cast<FunctionProtoType>(FType))
5095 if (N < Proto->getNumParams()) {
5096 if (ParamType.isNull())
5097 ParamType = Proto->getParamType(N);
5098 else if (!SemaRef.Context.hasSameUnqualifiedType(
5099 ParamType.getNonReferenceType(),
5100 Proto->getParamType(N).getNonReferenceType()))
5101 // Otherwise return a default-constructed QualType.
5102 return QualType();
5103 }
5104 }
5105
5106 return ParamType;
5107}
5108
5109static QualType
5110ProduceSignatureHelp(Sema &SemaRef, Scope *S,
5111 MutableArrayRef<ResultCandidate> Candidates,
5112 unsigned CurrentArg, SourceLocation OpenParLoc) {
5113 if (Candidates.empty())
5114 return QualType();
5115 SemaRef.CodeCompleter->ProcessOverloadCandidates(
5116 SemaRef, CurrentArg, Candidates.data(), Candidates.size(), OpenParLoc);
5117 return getParamType(SemaRef, Candidates, CurrentArg);
5118}
5119
5120QualType Sema::ProduceCallSignatureHelp(Scope *S, Expr *Fn,
5121 ArrayRef<Expr *> Args,
5122 SourceLocation OpenParLoc) {
5123 if (!CodeCompleter)
5124 return QualType();
5125
5126 // FIXME: Provide support for variadic template functions.
5127 // Ignore type-dependent call expressions entirely.
5128 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
5129 Expr::hasAnyTypeDependentArguments(Args)) {
5130 return QualType();
5131 }
5132
5133 // Build an overload candidate set based on the functions we find.
5134 SourceLocation Loc = Fn->getExprLoc();
5135 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
5136
5137 SmallVector<ResultCandidate, 8> Results;
5138
5139 Expr *NakedFn = Fn->IgnoreParenCasts();
5140 if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
5141 AddOverloadedCallCandidates(ULE, Args, CandidateSet,
5142 /*PartialOverloading=*/true);
5143 else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
5144 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
5145 if (UME->hasExplicitTemplateArgs()) {
5146 UME->copyTemplateArgumentsInto(TemplateArgsBuffer);
5147 TemplateArgs = &TemplateArgsBuffer;
5148 }
5149
5150 // Add the base as first argument (use a nullptr if the base is implicit).
5151 SmallVector<Expr *, 12> ArgExprs(
5152 1, UME->isImplicitAccess() ? nullptr : UME->getBase());
5153 ArgExprs.append(Args.begin(), Args.end());
5154 UnresolvedSet<8> Decls;
5155 Decls.append(UME->decls_begin(), UME->decls_end());
5156 const bool FirstArgumentIsBase = !UME->isImplicitAccess() && UME->getBase();
5157 AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs,
5158 /*SuppressUserConversions=*/false,
5159 /*PartialOverloading=*/true, FirstArgumentIsBase);
5160 } else {
5161 FunctionDecl *FD = nullptr;
5162 if (auto *MCE = dyn_cast<MemberExpr>(NakedFn))
5163 FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl());
5164 else if (auto *DRE = dyn_cast<DeclRefExpr>(NakedFn))
5165 FD = dyn_cast<FunctionDecl>(DRE->getDecl());
5166 if (FD) { // We check whether it's a resolved function declaration.
5167 if (!getLangOpts().CPlusPlus ||
5168 !FD->getType()->getAs<FunctionProtoType>())
5169 Results.push_back(ResultCandidate(FD));
5170 else
5171 AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()),
5172 Args, CandidateSet,
5173 /*SuppressUserConversions=*/false,
5174 /*PartialOverloading=*/true);
5175
5176 } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) {
5177 // If expression's type is CXXRecordDecl, it may overload the function
5178 // call operator, so we check if it does and add them as candidates.
5179 // A complete type is needed to lookup for member function call operators.
5180 if (isCompleteType(Loc, NakedFn->getType())) {
5181 DeclarationName OpName =
5182 Context.DeclarationNames.getCXXOperatorName(OO_Call);
5183 LookupResult R(*this, OpName, Loc, LookupOrdinaryName);
5184 LookupQualifiedName(R, DC);
5185 R.suppressDiagnostics();
5186 SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
5187 ArgExprs.append(Args.begin(), Args.end());
5188 AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet,
5189 /*ExplicitArgs=*/nullptr,
5190 /*SuppressUserConversions=*/false,
5191 /*PartialOverloading=*/true);
5192 }
5193 } else {
5194 // Lastly we check whether expression's type is function pointer or
5195 // function.
5196 QualType T = NakedFn->getType();
5197 if (!T->getPointeeType().isNull())
5198 T = T->getPointeeType();
5199
5200 if (auto FP = T->getAs<FunctionProtoType>()) {
5201 if (!TooManyArguments(FP->getNumParams(), Args.size(),
5202 /*PartialOverloading=*/true) ||
5203 FP->isVariadic())
5204 Results.push_back(ResultCandidate(FP));
5205 } else if (auto FT = T->getAs<FunctionType>())
5206 // No prototype and declaration, it may be a K & R style function.
5207 Results.push_back(ResultCandidate(FT));
5208 }
5209 }
5210 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
5211 QualType ParamType =
5212 ProduceSignatureHelp(*this, S, Results, Args.size(), OpenParLoc);
5213 return !CandidateSet.empty() ? ParamType : QualType();
5214}
5215
5216QualType Sema::ProduceConstructorSignatureHelp(Scope *S, QualType Type,
5217 SourceLocation Loc,
5218 ArrayRef<Expr *> Args,
5219 SourceLocation OpenParLoc) {
5220 if (!CodeCompleter)
5221 return QualType();
5222
5223 // A complete type is needed to lookup for constructors.
5224 CXXRecordDecl *RD =
5225 isCompleteType(Loc, Type) ? Type->getAsCXXRecordDecl() : nullptr;
5226 if (!RD)
5227 return Type;
5228
5229 // FIXME: Provide support for member initializers.
5230 // FIXME: Provide support for variadic template constructors.
5231
5232 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
5233
5234 for (NamedDecl *C : LookupConstructors(RD)) {
5235 if (auto *FD = dyn_cast<FunctionDecl>(C)) {
5236 AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()), Args,
5237 CandidateSet,
5238 /*SuppressUserConversions=*/false,
5239 /*PartialOverloading=*/true,
5240 /*AllowExplicit*/ true);
5241 } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(C)) {
5242 AddTemplateOverloadCandidate(
5243 FTD, DeclAccessPair::make(FTD, C->getAccess()),
5244 /*ExplicitTemplateArgs=*/nullptr, Args, CandidateSet,
5245 /*SuppressUserConversions=*/false,
5246 /*PartialOverloading=*/true);
5247 }
5248 }
5249
5250 SmallVector<ResultCandidate, 8> Results;
5251 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
5252 return ProduceSignatureHelp(*this, S, Results, Args.size(), OpenParLoc);
5253}
5254
5255QualType Sema::ProduceCtorInitMemberSignatureHelp(
5256 Scope *S, Decl *ConstructorDecl, CXXScopeSpec SS, ParsedType TemplateTypeTy,
5257 ArrayRef<Expr *> ArgExprs, IdentifierInfo *II, SourceLocation OpenParLoc) {
5258 if (!CodeCompleter)
5259 return QualType();
5260
5261 CXXConstructorDecl *Constructor =
5262 dyn_cast<CXXConstructorDecl>(ConstructorDecl);
5263 if (!Constructor)
5264 return QualType();
5265 // FIXME: Add support for Base class constructors as well.
5266 if (ValueDecl *MemberDecl = tryLookupCtorInitMemberDecl(
5267 Constructor->getParent(), SS, TemplateTypeTy, II))
5268 return ProduceConstructorSignatureHelp(getCurScope(), MemberDecl->getType(),
5269 MemberDecl->getLocation(), ArgExprs,
5270 OpenParLoc);
5271 return QualType();
5272}
5273
5274void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
5275 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
5276 if (!VD) {
5277 CodeCompleteOrdinaryName(S, PCC_Expression);
5278 return;
5279 }
5280
5281 CodeCompleteExpressionData Data;
5282 Data.PreferredType = VD->getType();
5283 // Ignore VD to avoid completing the variable itself, e.g. in 'int foo = ^'.
5284 Data.IgnoreDecls.push_back(VD);
5285
5286 CodeCompleteExpression(S, Data);
5287}
5288
5289void Sema::CodeCompleteAfterIf(Scope *S) {
5290 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5291 CodeCompleter->getCodeCompletionTUInfo(),
5292 mapCodeCompletionContext(*this, PCC_Statement));
5293 Results.setFilter(&ResultBuilder::IsOrdinaryName);
5294 Results.EnterNewScope();
5295
5296 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5297 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5298 CodeCompleter->includeGlobals(),
5299 CodeCompleter->loadExternal());
5300
5301 AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
5302
5303 // "else" block
5304 CodeCompletionBuilder Builder(Results.getAllocator(),
5305 Results.getCodeCompletionTUInfo());
5306 Builder.AddTypedTextChunk("else");
5307 if (Results.includeCodePatterns()) {
5308 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5309 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5310 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
5311 Builder.AddPlaceholderChunk("statements");
5312 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
5313 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5314 }
5315 Results.AddResult(Builder.TakeString());
5316
5317 // "else if" block
5318 Builder.AddTypedTextChunk("else if");
5319 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5320 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5321 if (getLangOpts().CPlusPlus)
5322 Builder.AddPlaceholderChunk("condition");
5323 else
5324 Builder.AddPlaceholderChunk("expression");
5325 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5326 if (Results.includeCodePatterns()) {
5327 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5328 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5329 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
5330 Builder.AddPlaceholderChunk("statements");
5331 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
5332 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5333 }
5334 Results.AddResult(Builder.TakeString());
5335
5336 Results.ExitScope();
5337
5338 if (S->getFnParent())
5339 AddPrettyFunctionResults(getLangOpts(), Results);
5340
5341 if (CodeCompleter->includeMacros())
5342 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
5343
5344 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5345 Results.data(), Results.size());
5346}
5347
5348void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
5349 bool EnteringContext,
5350 bool IsUsingDeclaration, QualType BaseType,
5351 QualType PreferredType) {
5352 if (SS.isEmpty() || !CodeCompleter)
5353 return;
5354
5355 CodeCompletionContext CC(CodeCompletionContext::CCC_Symbol, PreferredType);
5356 CC.setIsUsingDeclaration(IsUsingDeclaration);
5357 CC.setCXXScopeSpecifier(SS);
5358
5359 // We want to keep the scope specifier even if it's invalid (e.g. the scope
5360 // "a::b::" is not corresponding to any context/namespace in the AST), since
5361 // it can be useful for global code completion which have information about
5362 // contexts/symbols that are not in the AST.
5363 if (SS.isInvalid()) {
5364 // As SS is invalid, we try to collect accessible contexts from the current
5365 // scope with a dummy lookup so that the completion consumer can try to
5366 // guess what the specified scope is.
5367 ResultBuilder DummyResults(*this, CodeCompleter->getAllocator(),
5368 CodeCompleter->getCodeCompletionTUInfo(), CC);
5369 if (!PreferredType.isNull())
5370 DummyResults.setPreferredType(PreferredType);
5371 if (S->getEntity()) {
5372 CodeCompletionDeclConsumer Consumer(DummyResults, S->getEntity(),
5373 BaseType);
5374 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5375 /*IncludeGlobalScope=*/false,
5376 /*LoadExternal=*/false);
5377 }
5378 HandleCodeCompleteResults(this, CodeCompleter,
5379 DummyResults.getCompletionContext(), nullptr, 0);
5380 return;
5381 }
5382 // Always pretend to enter a context to ensure that a dependent type
5383 // resolves to a dependent record.
5384 DeclContext *Ctx = computeDeclContext(SS, /*EnteringContext=*/true);
5385 if (!Ctx)
5386 return;
5387
5388 // Try to instantiate any non-dependent declaration contexts before
5389 // we look in them.
5390 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
5391 return;
5392
5393 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5394 CodeCompleter->getCodeCompletionTUInfo(), CC);
5395 if (!PreferredType.isNull())
5396 Results.setPreferredType(PreferredType);
5397 Results.EnterNewScope();
5398
5399 // The "template" keyword can follow "::" in the grammar, but only
5400 // put it into the grammar if the nested-name-specifier is dependent.
5401 NestedNameSpecifier *NNS = SS.getScopeRep();
5402 if (!Results.empty() && NNS->isDependent())
5403 Results.AddResult("template");
5404
5405 // Add calls to overridden virtual functions, if there are any.
5406 //
5407 // FIXME: This isn't wonderful, because we don't know whether we're actually
5408 // in a context that permits expressions. This is a general issue with
5409 // qualified-id completions.
5410 if (!EnteringContext)
5411 MaybeAddOverrideCalls(*this, Ctx, Results);
5412 Results.ExitScope();
5413
5414 if (CodeCompleter->includeNamespaceLevelDecls() ||
5415 (!Ctx->isNamespace() && !Ctx->isTranslationUnit())) {
5416 CodeCompletionDeclConsumer Consumer(Results, Ctx, BaseType);
5417 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer,
5418 /*IncludeGlobalScope=*/true,
5419 /*IncludeDependentBases=*/true,
5420 CodeCompleter->loadExternal());
5421 }
5422
5423 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5424 Results.data(), Results.size());
5425}
5426
5427void Sema::CodeCompleteUsing(Scope *S) {
5428 if (!CodeCompleter)
5429 return;
5430
5431 // This can be both a using alias or using declaration, in the former we
5432 // expect a new name and a symbol in the latter case.
5433 CodeCompletionContext Context(CodeCompletionContext::CCC_SymbolOrNewName);
5434 Context.setIsUsingDeclaration(true);
5435
5436 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5437 CodeCompleter->getCodeCompletionTUInfo(), Context,
5438 &ResultBuilder::IsNestedNameSpecifier);
5439 Results.EnterNewScope();
5440
5441 // If we aren't in class scope, we could see the "namespace" keyword.
5442 if (!S->isClassScope())
5443 Results.AddResult(CodeCompletionResult("namespace"));
5444
5445 // After "using", we can see anything that would start a
5446 // nested-name-specifier.
5447 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5448 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5449 CodeCompleter->includeGlobals(),
5450 CodeCompleter->loadExternal());
5451 Results.ExitScope();
5452
5453 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5454 Results.data(), Results.size());
5455}
5456
5457void Sema::CodeCompleteUsingDirective(Scope *S) {
5458 if (!CodeCompleter)
5459 return;
5460
5461 // After "using namespace", we expect to see a namespace name or namespace
5462 // alias.
5463 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5464 CodeCompleter->getCodeCompletionTUInfo(),
5465 CodeCompletionContext::CCC_Namespace,
5466 &ResultBuilder::IsNamespaceOrAlias);
5467 Results.EnterNewScope();
5468 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5469 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5470 CodeCompleter->includeGlobals(),
5471 CodeCompleter->loadExternal());
5472 Results.ExitScope();
5473 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5474 Results.data(), Results.size());
5475}
5476
5477void Sema::CodeCompleteNamespaceDecl(Scope *S) {
5478 if (!CodeCompleter)
5479 return;
5480
5481 DeclContext *Ctx = S->getEntity();
5482 if (!S->getParent())
5483 Ctx = Context.getTranslationUnitDecl();
5484
5485 bool SuppressedGlobalResults =
5486 Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
5487
5488 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5489 CodeCompleter->getCodeCompletionTUInfo(),
5490 SuppressedGlobalResults
5491 ? CodeCompletionContext::CCC_Namespace
5492 : CodeCompletionContext::CCC_Other,
5493 &ResultBuilder::IsNamespace);
5494
5495 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
5496 // We only want to see those namespaces that have already been defined
5497 // within this scope, because its likely that the user is creating an
5498 // extended namespace declaration. Keep track of the most recent
5499 // definition of each namespace.
5500 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
5501 for (DeclContext::specific_decl_iterator<NamespaceDecl>
5502 NS(Ctx->decls_begin()),
5503 NSEnd(Ctx->decls_end());
5504 NS != NSEnd; ++NS)
5505 OrigToLatest[NS->getOriginalNamespace()] = *NS;
5506
5507 // Add the most recent definition (or extended definition) of each
5508 // namespace to the list of results.
5509 Results.EnterNewScope();
5510 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
5511 NS = OrigToLatest.begin(),
5512 NSEnd = OrigToLatest.end();
5513 NS != NSEnd; ++NS)
5514 Results.AddResult(
5515 CodeCompletionResult(NS->second, Results.getBasePriority(NS->second),
5516 nullptr),
5517 CurContext, nullptr, false);
5518 Results.ExitScope();
5519 }
5520
5521 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5522 Results.data(), Results.size());
5523}
5524
5525void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) {
5526 if (!CodeCompleter)
5527 return;
5528
5529 // After "namespace", we expect to see a namespace or alias.
5530 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5531 CodeCompleter->getCodeCompletionTUInfo(),
5532 CodeCompletionContext::CCC_Namespace,
5533 &ResultBuilder::IsNamespaceOrAlias);
5534 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5535 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5536 CodeCompleter->includeGlobals(),
5537 CodeCompleter->loadExternal());
5538 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5539 Results.data(), Results.size());
5540}
5541
5542void Sema::CodeCompleteOperatorName(Scope *S) {
5543 if (!CodeCompleter)
5544 return;
5545
5546 typedef CodeCompletionResult Result;
5547 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5548 CodeCompleter->getCodeCompletionTUInfo(),
5549 CodeCompletionContext::CCC_Type,
5550 &ResultBuilder::IsType);
5551 Results.EnterNewScope();
5552
5553 // Add the names of overloadable operators. Note that OO_Conditional is not
5554 // actually overloadable.
5555#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
5556 if (OO_##Name != OO_Conditional) \
5557 Results.AddResult(Result(Spelling));
5558#include "clang/Basic/OperatorKinds.def"
5559
5560 // Add any type names visible from the current scope
5561 Results.allowNestedNameSpecifiers();
5562 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5563 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5564 CodeCompleter->includeGlobals(),
5565 CodeCompleter->loadExternal());
5566
5567 // Add any type specifiers
5568 AddTypeSpecifierResults(getLangOpts(), Results);
5569 Results.ExitScope();
5570
5571 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5572 Results.data(), Results.size());
5573}
5574
5575void Sema::CodeCompleteConstructorInitializer(
5576 Decl *ConstructorD, ArrayRef<CXXCtorInitializer *> Initializers) {
5577 if (!ConstructorD)
5578 return;
5579
5580 AdjustDeclIfTemplate(ConstructorD);
5581
5582 auto *Constructor = dyn_cast<CXXConstructorDecl>(ConstructorD);
5583 if (!Constructor)
5584 return;
5585
5586 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5587 CodeCompleter->getCodeCompletionTUInfo(),
5588 CodeCompletionContext::CCC_Symbol);
5589 Results.EnterNewScope();
5590
5591 // Fill in any already-initialized fields or base classes.
5592 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
5593 llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
5594 for (unsigned I = 0, E = Initializers.size(); I != E; ++I) {
5595 if (Initializers[I]->isBaseInitializer())
5596 InitializedBases.insert(Context.getCanonicalType(
5597 QualType(Initializers[I]->getBaseClass(), 0)));
5598 else
5599 InitializedFields.insert(
5600 cast<FieldDecl>(Initializers[I]->getAnyMember()));
5601 }
5602
5603 // Add completions for base classes.
5604 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
5605 bool SawLastInitializer = Initializers.empty();
5606 CXXRecordDecl *ClassDecl = Constructor->getParent();
5607
5608 auto GenerateCCS = [&](const NamedDecl *ND, const char *Name) {
5609 CodeCompletionBuilder Builder(Results.getAllocator(),
5610 Results.getCodeCompletionTUInfo());
5611 Builder.AddTypedTextChunk(Name);
5612 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5613 if (const auto *Function = dyn_cast<FunctionDecl>(ND))
5614 AddFunctionParameterChunks(PP, Policy, Function, Builder);
5615 else if (const auto *FunTemplDecl = dyn_cast<FunctionTemplateDecl>(ND))
5616 AddFunctionParameterChunks(PP, Policy, FunTemplDecl->getTemplatedDecl(),
5617 Builder);
5618 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5619 return Builder.TakeString();
5620 };
5621 auto AddDefaultCtorInit = [&](const char *Name, const char *Type,
5622 const NamedDecl *ND) {
5623 CodeCompletionBuilder Builder(Results.getAllocator(),
5624 Results.getCodeCompletionTUInfo());
5625 Builder.AddTypedTextChunk(Name);
5626 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5627 Builder.AddPlaceholderChunk(Type);
5628 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5629 if (ND) {
5630 auto CCR = CodeCompletionResult(
5631 Builder.TakeString(), ND,
5632 SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration);
5633 if (isa<FieldDecl>(ND))
5634 CCR.CursorKind = CXCursor_MemberRef;
5635 return Results.AddResult(CCR);
5636 }
5637 return Results.AddResult(CodeCompletionResult(
5638 Builder.TakeString(),
5639 SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration));
5640 };
5641 auto AddCtorsWithName = [&](const CXXRecordDecl *RD, unsigned int Priority,
5642 const char *Name, const FieldDecl *FD) {
5643 if (!RD)
5644 return AddDefaultCtorInit(Name,
5645 FD ? Results.getAllocator().CopyString(
5646 FD->getType().getAsString(Policy))
5647 : Name,
5648 FD);
5649 auto Ctors = getConstructors(Context, RD);
5650 if (Ctors.begin() == Ctors.end())
5651 return AddDefaultCtorInit(Name, Name, RD);
5652 for (const NamedDecl *Ctor : Ctors) {
5653 auto CCR = CodeCompletionResult(GenerateCCS(Ctor, Name), RD, Priority);
5654 CCR.CursorKind = getCursorKindForDecl(Ctor);
5655 Results.AddResult(CCR);
5656 }
5657 };
5658 auto AddBase = [&](const CXXBaseSpecifier &Base) {
5659 const char *BaseName =
5660 Results.getAllocator().CopyString(Base.getType().getAsString(Policy));
5661 const auto *RD = Base.getType()->getAsCXXRecordDecl();
5662 AddCtorsWithName(
5663 RD, SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration,
5664 BaseName, nullptr);
5665 };
5666 auto AddField = [&](const FieldDecl *FD) {
5667 const char *FieldName =
5668 Results.getAllocator().CopyString(FD->getIdentifier()->getName());
5669 const CXXRecordDecl *RD = FD->getType()->getAsCXXRecordDecl();
5670 AddCtorsWithName(
5671 RD, SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration,
5672 FieldName, FD);
5673 };
5674
5675 for (const auto &Base : ClassDecl->bases()) {
5676 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
5677 .second) {
5678 SawLastInitializer =
5679 !Initializers.empty() && Initializers.back()->isBaseInitializer() &&
5680 Context.hasSameUnqualifiedType(
5681 Base.getType(), QualType(Initializers.back()->getBaseClass(), 0));
5682 continue;
5683 }
5684
5685 AddBase(Base);
5686 SawLastInitializer = false;
5687 }
5688
5689 // Add completions for virtual base classes.
5690 for (const auto &Base : ClassDecl->vbases()) {
5691 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
5692 .second) {
5693 SawLastInitializer =
5694 !Initializers.empty() && Initializers.back()->isBaseInitializer() &&
5695 Context.hasSameUnqualifiedType(
5696 Base.getType(), QualType(Initializers.back()->getBaseClass(), 0));
5697 continue;
5698 }
5699
5700 AddBase(Base);
5701 SawLastInitializer = false;
5702 }
5703
5704 // Add completions for members.
5705 for (auto *Field : ClassDecl->fields()) {
5706 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))
5707 .second) {
5708 SawLastInitializer = !Initializers.empty() &&
5709 Initializers.back()->isAnyMemberInitializer() &&
5710 Initializers.back()->getAnyMember() == Field;
5711 continue;
5712 }
5713
5714 if (!Field->getDeclName())
5715 continue;
5716
5717 AddField(Field);
5718 SawLastInitializer = false;
5719 }
5720 Results.ExitScope();
5721
5722 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5723 Results.data(), Results.size());
5724}
5725
5726/// Determine whether this scope denotes a namespace.
5727static bool isNamespaceScope(Scope *S) {
5728 DeclContext *DC = S->getEntity();
5729 if (!DC)
5730 return false;
5731
5732 return DC->isFileContext();
5733}
5734
5735void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
5736 bool AfterAmpersand) {
5737 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5738 CodeCompleter->getCodeCompletionTUInfo(),
5739 CodeCompletionContext::CCC_Other);
5740 Results.EnterNewScope();
5741
5742 // Note what has already been captured.
5743 llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
5744 bool IncludedThis = false;
5745 for (const auto &C : Intro.Captures) {
5746 if (C.Kind == LCK_This) {
5747 IncludedThis = true;
5748 continue;
5749 }
5750
5751 Known.insert(C.Id);
5752 }
5753
5754 // Look for other capturable variables.
5755 for (; S && !isNamespaceScope(S); S = S->getParent()) {
5756 for (const auto *D : S->decls()) {
5757 const auto *Var = dyn_cast<VarDecl>(D);
5758 if (!Var || !Var->hasLocalStorage() || Var->hasAttr<BlocksAttr>())
5759 continue;
5760
5761 if (Known.insert(Var->getIdentifier()).second)
5762 Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration),
5763 CurContext, nullptr, false);
5764 }
5765 }
5766
5767 // Add 'this', if it would be valid.
5768 if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
5769 addThisCompletion(*this, Results);
5770
5771 Results.ExitScope();
5772
5773 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5774 Results.data(), Results.size());
5775}
5776
5777/// Macro that optionally prepends an "@" to the string literal passed in via
5778/// Keyword, depending on whether NeedAt is true or false.
5779#define OBJC_AT_KEYWORD_NAME(NeedAt, Keyword)((NeedAt) ? "@" Keyword : Keyword) ((NeedAt) ? "@" Keyword : Keyword)
5780
5781static void AddObjCImplementationResults(const LangOptions &LangOpts,
5782 ResultBuilder &Results, bool NeedAt) {
5783 typedef CodeCompletionResult Result;
5784 // Since we have an implementation, we can end it.
5785 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "end")((NeedAt) ? "@" "end" : "end")));
5786
5787 CodeCompletionBuilder Builder(Results.getAllocator(),
5788 Results.getCodeCompletionTUInfo());
5789 if (LangOpts.ObjC) {
5790 // @dynamic
5791 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "dynamic")((NeedAt) ? "@" "dynamic" : "dynamic"));
5792 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5793 Builder.AddPlaceholderChunk("property");
5794 Results.AddResult(Result(Builder.TakeString()));
5795
5796 // @synthesize
5797 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "synthesize")((NeedAt) ? "@" "synthesize" : "synthesize"));
5798 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5799 Builder.AddPlaceholderChunk("property");
5800 Results.AddResult(Result(Builder.TakeString()));
5801 }
5802}
5803
5804static void AddObjCInterfaceResults(const LangOptions &LangOpts,
5805 ResultBuilder &Results, bool NeedAt) {
5806 typedef CodeCompletionResult Result;
5807
5808 // Since we have an interface or protocol, we can end it.
5809 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "end")((NeedAt) ? "@" "end" : "end")));
5810
5811 if (LangOpts.ObjC) {
5812 // @property
5813 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "property")((NeedAt) ? "@" "property" : "property")));
5814
5815 // @required
5816 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "required")((NeedAt) ? "@" "required" : "required")));
5817
5818 // @optional
5819 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "optional")((NeedAt) ? "@" "optional" : "optional")));
5820 }
5821}
5822
5823static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
5824 typedef CodeCompletionResult Result;
5825 CodeCompletionBuilder Builder(Results.getAllocator(),
5826 Results.getCodeCompletionTUInfo());
5827
5828 // @class name ;
5829 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "class")((NeedAt) ? "@" "class" : "class"));
5830 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5831 Builder.AddPlaceholderChunk("name");
5832 Results.AddResult(Result(Builder.TakeString()));
5833
5834 if (Results.includeCodePatterns()) {
5835 // @interface name
5836 // FIXME: Could introduce the whole pattern, including superclasses and
5837 // such.
5838 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "interface")((NeedAt) ? "@" "interface" : "interface"));
5839 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5840 Builder.AddPlaceholderChunk("class");
5841 Results.AddResult(Result(Builder.TakeString()));
5842
5843 // @protocol name
5844 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "protocol")((NeedAt) ? "@" "protocol" : "protocol"));
5845 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5846 Builder.AddPlaceholderChunk("protocol");
5847 Results.AddResult(Result(Builder.TakeString()));
5848
5849 // @implementation name
5850 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "implementation")((NeedAt) ? "@" "implementation" : "implementation"));
5851 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5852 Builder.AddPlaceholderChunk("class");
5853 Results.AddResult(Result(Builder.TakeString()));
5854 }
5855
5856 // @compatibility_alias name
5857 Builder.AddTypedTextChunk(
5858 OBJC_AT_KEYWORD_NAME(NeedAt, "compatibility_alias")((NeedAt) ? "@" "compatibility_alias" : "compatibility_alias"
)
);
5859 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5860 Builder.AddPlaceholderChunk("alias");
5861 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5862 Builder.AddPlaceholderChunk("class");
5863 Results.AddResult(Result(Builder.TakeString()));
5864
5865 if (Results.getSema().getLangOpts().Modules) {
5866 // @import name
5867 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import")((NeedAt) ? "@" "import" : "import"));
5868 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5869 Builder.AddPlaceholderChunk("module");
5870 Results.AddResult(Result(Builder.TakeString()));
5871 }
5872}
5873
5874void Sema::CodeCompleteObjCAtDirective(Scope *S) {
5875 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5876 CodeCompleter->getCodeCompletionTUInfo(),
5877 CodeCompletionContext::CCC_Other);
5878 Results.EnterNewScope();
5879 if (isa<ObjCImplDecl>(CurContext))
5880 AddObjCImplementationResults(getLangOpts(), Results, false);
5881 else if (CurContext->isObjCContainer())
5882 AddObjCInterfaceResults(getLangOpts(), Results, false);
5883 else
5884 AddObjCTopLevelResults(Results, false);
5885 Results.ExitScope();
5886 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5887 Results.data(), Results.size());
5888}
5889
5890static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
5891 typedef CodeCompletionResult Result;
5892 CodeCompletionBuilder Builder(Results.getAllocator(),
5893 Results.getCodeCompletionTUInfo());
5894
5895 // @encode ( type-name )
5896 const char *EncodeType = "char[]";
5897 if (Results.getSema().getLangOpts().CPlusPlus ||
5898 Results.getSema().getLangOpts().ConstStrings)
5899 EncodeType = "const char[]";
5900 Builder.AddResultTypeChunk(EncodeType);
5901 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "encode")((NeedAt) ? "@" "encode" : "encode"));
5902 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5903 Builder.AddPlaceholderChunk("type-name");
5904 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5905 Results.AddResult(Result(Builder.TakeString()));
5906
5907 // @protocol ( protocol-name )
5908 Builder.AddResultTypeChunk("Protocol *");
5909 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "protocol")((NeedAt) ? "@" "protocol" : "protocol"));
5910 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5911 Builder.AddPlaceholderChunk("protocol-name");
5912 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5913 Results.AddResult(Result(Builder.TakeString()));
5914
5915 // @selector ( selector )
5916 Builder.AddResultTypeChunk("SEL");
5917 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "selector")((NeedAt) ? "@" "selector" : "selector"));
5918 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5919 Builder.AddPlaceholderChunk("selector");
5920 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5921 Results.AddResult(Result(Builder.TakeString()));
5922
5923 // @"string"
5924 Builder.AddResultTypeChunk("NSString *");
5925 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "\"")((NeedAt) ? "@" "\"" : "\""));
5926 Builder.AddPlaceholderChunk("string");
5927 Builder.AddTextChunk("\"");
5928 Results.AddResult(Result(Builder.TakeString()));
5929
5930 // @[objects, ...]
5931 Builder.AddResultTypeChunk("NSArray *");
5932 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "[")((NeedAt) ? "@" "[" : "["));
5933 Builder.AddPlaceholderChunk("objects, ...");
5934 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
5935 Results.AddResult(Result(Builder.TakeString()));
5936
5937 // @{key : object, ...}
5938 Builder.AddResultTypeChunk("NSDictionary *");
5939 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "{")((NeedAt) ? "@" "{" : "{"));
5940 Builder.AddPlaceholderChunk("key");
5941 Builder.AddChunk(CodeCompletionString::CK_Colon);
5942 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5943 Builder.AddPlaceholderChunk("object, ...");
5944 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5945 Results.AddResult(Result(Builder.TakeString()));
5946
5947 // @(expression)
5948 Builder.AddResultTypeChunk("id");
5949 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "(")((NeedAt) ? "@" "(" : "("));
5950 Builder.AddPlaceholderChunk("expression");
5951 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5952 Results.AddResult(Result(Builder.TakeString()));
5953}
5954
5955static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
5956 typedef CodeCompletionResult Result;
5957 CodeCompletionBuilder Builder(Results.getAllocator(),
5958 Results.getCodeCompletionTUInfo());
5959
5960 if (Results.includeCodePatterns()) {
5961 // @try { statements } @catch ( declaration ) { statements } @finally
5962 // { statements }
5963 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "try")((NeedAt) ? "@" "try" : "try"));
5964 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5965 Builder.AddPlaceholderChunk("statements");
5966 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5967 Builder.AddTextChunk("@catch");
5968 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5969 Builder.AddPlaceholderChunk("parameter");
5970 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5971 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5972 Builder.AddPlaceholderChunk("statements");
5973 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5974 Builder.AddTextChunk("@finally");
5975 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5976 Builder.AddPlaceholderChunk("statements");
5977 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5978 Results.AddResult(Result(Builder.TakeString()));
5979 }
5980
5981 // @throw
5982 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "throw")((NeedAt) ? "@" "throw" : "throw"));
5983 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5984 Builder.AddPlaceholderChunk("expression");
5985 Results.AddResult(Result(Builder.TakeString()));
5986
5987 if (Results.includeCodePatterns()) {
5988 // @synchronized ( expression ) { statements }
5989 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "synchronized")((NeedAt) ? "@" "synchronized" : "synchronized"));
5990 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5991 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5992 Builder.AddPlaceholderChunk("expression");
5993 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5994 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5995 Builder.AddPlaceholderChunk("statements");
5996 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5997 Results.AddResult(Result(Builder.TakeString()));
5998 }
5999}
6000
6001static void AddObjCVisibilityResults(const LangOptions &LangOpts,
6002 ResultBuilder &Results, bool NeedAt) {
6003 typedef CodeCompletionResult Result;
6004 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "private")((NeedAt) ? "@" "private" : "private")));
6005 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "protected")((NeedAt) ? "@" "protected" : "protected")));
6006 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "public")((NeedAt) ? "@" "public" : "public")));
6007 if (LangOpts.ObjC)
6008 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "package")((NeedAt) ? "@" "package" : "package")));
6009}
6010
6011void Sema::CodeCompleteObjCAtVisibility(Scope *S) {
6012 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6013 CodeCompleter->getCodeCompletionTUInfo(),
6014 CodeCompletionContext::CCC_Other);
6015 Results.EnterNewScope();
6016 AddObjCVisibilityResults(getLangOpts(), Results, false);
6017 Results.ExitScope();
6018 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6019 Results.data(), Results.size());
6020}
6021
6022void Sema::CodeCompleteObjCAtStatement(Scope *S) {
6023 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6024 CodeCompleter->getCodeCompletionTUInfo(),
6025 CodeCompletionContext::CCC_Other);
6026 Results.EnterNewScope();
6027 AddObjCStatementResults(Results, false);
6028 AddObjCExpressionResults(Results, false);
6029 Results.ExitScope();
6030 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6031 Results.data(), Results.size());
6032}
6033
6034void Sema::CodeCompleteObjCAtExpression(Scope *S) {
6035 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6036 CodeCompleter->getCodeCompletionTUInfo(),
6037 CodeCompletionContext::CCC_Other);
6038 Results.EnterNewScope();
6039 AddObjCExpressionResults(Results, false);
6040 Results.ExitScope();
6041 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6042 Results.data(), Results.size());
6043}
6044
6045/// Determine whether the addition of the given flag to an Objective-C
6046/// property's attributes will cause a conflict.
6047static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
6048 // Check if we've already added this flag.
6049 if (Attributes & NewFlag)
6050 return true;
6051
6052 Attributes |= NewFlag;
6053
6054 // Check for collisions with "readonly".
6055 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
6056 (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
6057 return true;
6058
6059 // Check for more than one of { assign, copy, retain, strong, weak }.
6060 unsigned AssignCopyRetMask =
6061 Attributes &
6062 (ObjCDeclSpec::DQ_PR_assign | ObjCDeclSpec::DQ_PR_unsafe_unretained |
6063 ObjCDeclSpec::DQ_PR_copy | ObjCDeclSpec::DQ_PR_retain |
6064 ObjCDeclSpec::DQ_PR_strong | ObjCDeclSpec::DQ_PR_weak);
6065 if (AssignCopyRetMask && AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
6066 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
6067 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
6068 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
6069 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong &&
6070 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_weak)
6071 return true;
6072
6073 return false;
6074}
6075
6076void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) {
6077 if (!CodeCompleter)
6078 return;
6079
6080 unsigned Attributes = ODS.getPropertyAttributes();
6081
6082 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6083 CodeCompleter->getCodeCompletionTUInfo(),
6084 CodeCompletionContext::CCC_Other);
6085 Results.EnterNewScope();
6086 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly))
6087 Results.AddResult(CodeCompletionResult("readonly"));
6088 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign))
6089 Results.AddResult(CodeCompletionResult("assign"));
6090 if (!ObjCPropertyFlagConflicts(Attributes,
6091 ObjCDeclSpec::DQ_PR_unsafe_unretained))
6092 Results.AddResult(CodeCompletionResult("unsafe_unretained"));
6093 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite))
6094 Results.AddResult(CodeCompletionResult(