Bug Summary

File:clang/lib/Sema/SemaCodeComplete.cpp
Warning:line 8127, column 9
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)
4717 return;
4718
4719 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
4720 if (ConvertedBase.isInvalid())
4721 return;
4722 QualType ConvertedBaseType = ConvertedBase.get()->getType();
4723
4724 enum CodeCompletionContext::Kind contextKind;
4725
4726 if (IsArrow) {
4727 if (const auto *Ptr = ConvertedBaseType->getAs<PointerType>())
4728 ConvertedBaseType = Ptr->getPointeeType();
4729 }
4730
4731 if (IsArrow) {
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)
4751 return false;
4752
4753 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
4754 if (ConvertedBase.isInvalid())
4755 return false;
4756 Base = ConvertedBase.get();
4757
4758 QualType BaseType = Base->getType();
4759 ExprValueKind BaseKind = Base->getValueKind();
4760
4761 if (IsArrow) {
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 = BaseType->getAs<RecordType>()) {
4772 AddRecordMembersCompletionResults(*this, Results, S, BaseType, BaseKind,
4773 Record->getDecl(),
4774 std::move(AccessOpFixIt));
4775 } else if (const auto *TST =
4776 BaseType->getAs<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 = BaseType->getAs<InjectedClassNameType>()) {
4785 if (auto *RD = ICNT->getDecl())
4786 AddRecordMembersCompletionResults(*this, Results, S, BaseType, BaseKind,
4787 RD, std::move(AccessOpFixIt));
4788 } else if (!IsArrow && BaseType->isObjCObjectPointerType()) {
4789 // Objective-C property reference.
4790 AddedPropertiesSet AddedProperties;
4791
4792 if (const ObjCObjectPointerType *ObjCPtr =
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())
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);
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("readwrite"));
6095 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain))
6096 Results.AddResult(CodeCompletionResult("retain"));
6097 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_strong))
6098 Results.AddResult(CodeCompletionResult("strong"));
6099 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy))
6100 Results.AddResult(CodeCompletionResult("copy"));
6101 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic))
6102 Results.AddResult(CodeCompletionResult("nonatomic"));
6103 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_atomic))
6104 Results.AddResult(CodeCompletionResult("atomic"));
6105
6106 // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
6107 if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC)
6108 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_weak))
6109 Results.AddResult(CodeCompletionResult("weak"));
6110
6111 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) {
6112 CodeCompletionBuilder Setter(Results.getAllocator(),
6113 Results.getCodeCompletionTUInfo());
6114 Setter.AddTypedTextChunk("setter");
6115 Setter.AddTextChunk("=");
6116 Setter.AddPlaceholderChunk("method");
6117 Results.AddResult(CodeCompletionResult(Setter.TakeString()));
6118 }
6119 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) {
6120 CodeCompletionBuilder Getter(Results.getAllocator(),
6121 Results.getCodeCompletionTUInfo());
6122 Getter.AddTypedTextChunk("getter");
6123 Getter.AddTextChunk("=");
6124 Getter.AddPlaceholderChunk("method");
6125 Results.AddResult(CodeCompletionResult(Getter.TakeString()));
6126 }
6127 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nullability)) {
6128 Results.AddResult(CodeCompletionResult("nonnull"));
6129 Results.AddResult(CodeCompletionResult("nullable"));
6130 Results.AddResult(CodeCompletionResult("null_unspecified"));
6131 Results.AddResult(CodeCompletionResult("null_resettable"));
6132 }
6133 Results.ExitScope();
6134 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6135 Results.data(), Results.size());
6136}
6137
6138/// Describes the kind of Objective-C method that we want to find
6139/// via code completion.
6140enum ObjCMethodKind {
6141 MK_Any, ///< Any kind of method, provided it means other specified criteria.
6142 MK_ZeroArgSelector, ///< Zero-argument (unary) selector.
6143 MK_OneArgSelector ///< One-argument selector.
6144};
6145
6146static bool isAcceptableObjCSelector(Selector Sel, ObjCMethodKind WantKind,
6147 ArrayRef<IdentifierInfo *> SelIdents,
6148 bool AllowSameLength = true) {
6149 unsigned NumSelIdents = SelIdents.size();
6150 if (NumSelIdents > Sel.getNumArgs())
6151 return false;
6152
6153 switch (WantKind) {
6154 case MK_Any:
6155 break;
6156 case MK_ZeroArgSelector:
6157 return Sel.isUnarySelector();
6158 case MK_OneArgSelector:
6159 return Sel.getNumArgs() == 1;
6160 }
6161
6162 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
6163 return false;
6164
6165 for (unsigned I = 0; I != NumSelIdents; ++I)
6166 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
6167 return false;
6168
6169 return true;
6170}
6171
6172static bool isAcceptableObjCMethod(ObjCMethodDecl *Method,
6173 ObjCMethodKind WantKind,
6174 ArrayRef<IdentifierInfo *> SelIdents,
6175 bool AllowSameLength = true) {
6176 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
6177 AllowSameLength);
6178}
6179
6180/// A set of selectors, which is used to avoid introducing multiple
6181/// completions with the same selector into the result set.
6182typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
6183
6184/// Add all of the Objective-C methods in the given Objective-C
6185/// container to the set of results.
6186///
6187/// The container will be a class, protocol, category, or implementation of
6188/// any of the above. This mether will recurse to include methods from
6189/// the superclasses of classes along with their categories, protocols, and
6190/// implementations.
6191///
6192/// \param Container the container in which we'll look to find methods.
6193///
6194/// \param WantInstanceMethods Whether to add instance methods (only); if
6195/// false, this routine will add factory methods (only).
6196///
6197/// \param CurContext the context in which we're performing the lookup that
6198/// finds methods.
6199///
6200/// \param AllowSameLength Whether we allow a method to be added to the list
6201/// when it has the same number of parameters as we have selector identifiers.
6202///
6203/// \param Results the structure into which we'll add results.
6204static void AddObjCMethods(ObjCContainerDecl *Container,
6205 bool WantInstanceMethods, ObjCMethodKind WantKind,
6206 ArrayRef<IdentifierInfo *> SelIdents,
6207 DeclContext *CurContext,
6208 VisitedSelectorSet &Selectors, bool AllowSameLength,
6209 ResultBuilder &Results, bool InOriginalClass = true,
6210 bool IsRootClass = false) {
6211 typedef CodeCompletionResult Result;
6212 Container = getContainerDef(Container);
6213 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
6214 IsRootClass = IsRootClass || (IFace && !IFace->getSuperClass());
6215 for (ObjCMethodDecl *M : Container->methods()) {
6216 // The instance methods on the root class can be messaged via the
6217 // metaclass.
6218 if (M->isInstanceMethod() == WantInstanceMethods ||
6219 (IsRootClass && !WantInstanceMethods)) {
6220 // Check whether the selector identifiers we've been given are a
6221 // subset of the identifiers for this particular method.
6222 if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength))
6223 continue;
6224
6225 if (!Selectors.insert(M->getSelector()).second)
6226 continue;
6227
6228 Result R = Result(M, Results.getBasePriority(M), nullptr);
6229 R.StartParameter = SelIdents.size();
6230 R.AllParametersAreInformative = (WantKind != MK_Any);
6231 if (!InOriginalClass)
6232 setInBaseClass(R);
6233 Results.MaybeAddResult(R, CurContext);
6234 }
6235 }
6236
6237 // Visit the protocols of protocols.
6238 if (const auto *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
6239 if (Protocol->hasDefinition()) {
6240 const ObjCList<ObjCProtocolDecl> &Protocols =
6241 Protocol->getReferencedProtocols();
6242 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6243 E = Protocols.end();
6244 I != E; ++I)
6245 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
6246 Selectors, AllowSameLength, Results, false, IsRootClass);
6247 }
6248 }
6249
6250 if (!IFace || !IFace->hasDefinition())
6251 return;
6252
6253 // Add methods in protocols.
6254 for (ObjCProtocolDecl *I : IFace->protocols())
6255 AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents, CurContext,
6256 Selectors, AllowSameLength, Results, false, IsRootClass);
6257
6258 // Add methods in categories.
6259 for (ObjCCategoryDecl *CatDecl : IFace->known_categories()) {
6260 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
6261 CurContext, Selectors, AllowSameLength, Results,
6262 InOriginalClass, IsRootClass);
6263
6264 // Add a categories protocol methods.
6265 const ObjCList<ObjCProtocolDecl> &Protocols =
6266 CatDecl->getReferencedProtocols();
6267 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6268 E = Protocols.end();
6269 I != E; ++I)
6270 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
6271 Selectors, AllowSameLength, Results, false, IsRootClass);
6272
6273 // Add methods in category implementations.
6274 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
6275 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
6276 Selectors, AllowSameLength, Results, InOriginalClass,
6277 IsRootClass);
6278 }
6279
6280 // Add methods in superclass.
6281 // Avoid passing in IsRootClass since root classes won't have super classes.
6282 if (IFace->getSuperClass())
6283 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
6284 SelIdents, CurContext, Selectors, AllowSameLength, Results,
6285 /*IsRootClass=*/false);
6286
6287 // Add methods in our implementation, if any.
6288 if (ObjCImplementationDecl *Impl = IFace->getImplementation())
6289 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
6290 Selectors, AllowSameLength, Results, InOriginalClass,
6291 IsRootClass);
6292}
6293
6294void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
6295 // Try to find the interface where getters might live.
6296 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
6297 if (!Class) {
6298 if (ObjCCategoryDecl *Category =
6299 dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
6300 Class = Category->getClassInterface();
6301
6302 if (!Class)
6303 return;
6304 }
6305
6306 // Find all of the potential getters.
6307 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6308 CodeCompleter->getCodeCompletionTUInfo(),
6309 CodeCompletionContext::CCC_Other);
6310 Results.EnterNewScope();
6311
6312 VisitedSelectorSet Selectors;
6313 AddObjCMethods(Class, true, MK_ZeroArgSelector, None, CurContext, Selectors,
6314 /*AllowSameLength=*/true, Results);
6315 Results.ExitScope();
6316 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6317 Results.data(), Results.size());
6318}
6319
6320void Sema::CodeCompleteObjCPropertySetter(Scope *S) {
6321 // Try to find the interface where setters might live.
6322 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
6323 if (!Class) {
6324 if (ObjCCategoryDecl *Category =
6325 dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
6326 Class = Category->getClassInterface();
6327
6328 if (!Class)
6329 return;
6330 }
6331
6332 // Find all of the potential getters.
6333 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6334 CodeCompleter->getCodeCompletionTUInfo(),
6335 CodeCompletionContext::CCC_Other);
6336 Results.EnterNewScope();
6337
6338 VisitedSelectorSet Selectors;
6339 AddObjCMethods(Class, true, MK_OneArgSelector, None, CurContext, Selectors,
6340 /*AllowSameLength=*/true, Results);
6341
6342 Results.ExitScope();
6343 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6344 Results.data(), Results.size());
6345}
6346
6347void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
6348 bool IsParameter) {
6349 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6350 CodeCompleter->getCodeCompletionTUInfo(),
6351 CodeCompletionContext::CCC_Type);
6352 Results.EnterNewScope();
6353
6354 // Add context-sensitive, Objective-C parameter-passing keywords.
6355 bool AddedInOut = false;
6356 if ((DS.getObjCDeclQualifier() &
6357 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) {
6358 Results.AddResult("in");
6359 Results.AddResult("inout");
6360 AddedInOut = true;
6361 }
6362 if ((DS.getObjCDeclQualifier() &
6363 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) {
6364 Results.AddResult("out");
6365 if (!AddedInOut)
6366 Results.AddResult("inout");
6367 }
6368 if ((DS.getObjCDeclQualifier() &
6369 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref |
6370 ObjCDeclSpec::DQ_Oneway)) == 0) {
6371 Results.AddResult("bycopy");
6372 Results.AddResult("byref");
6373 Results.AddResult("oneway");
6374 }
6375 if ((DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) == 0) {
6376 Results.AddResult("nonnull");
6377 Results.AddResult("nullable");
6378 Results.AddResult("null_unspecified");
6379 }
6380
6381 // If we're completing the return type of an Objective-C method and the
6382 // identifier IBAction refers to a macro, provide a completion item for
6383 // an action, e.g.,
6384 // IBAction)<#selector#>:(id)sender
6385 if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
6386 PP.isMacroDefined("IBAction")) {
6387 CodeCompletionBuilder Builder(Results.getAllocator(),
6388 Results.getCodeCompletionTUInfo(),
6389 CCP_CodePattern, CXAvailability_Available);
6390 Builder.AddTypedTextChunk("IBAction");
6391 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6392 Builder.AddPlaceholderChunk("selector");
6393 Builder.AddChunk(CodeCompletionString::CK_Colon);
6394 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6395 Builder.AddTextChunk("id");
6396 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6397 Builder.AddTextChunk("sender");
6398 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
6399 }
6400
6401 // If we're completing the return type, provide 'instancetype'.
6402 if (!IsParameter) {
6403 Results.AddResult(CodeCompletionResult("instancetype"));
6404 }
6405
6406 // Add various builtin type names and specifiers.
6407 AddOrdinaryNameResults(PCC_Type, S, *this, Results);
6408 Results.ExitScope();
6409
6410 // Add the various type names
6411 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
6412 CodeCompletionDeclConsumer Consumer(Results, CurContext);
6413 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
6414 CodeCompleter->includeGlobals(),
6415 CodeCompleter->loadExternal());
6416
6417 if (CodeCompleter->includeMacros())
6418 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
6419
6420 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6421 Results.data(), Results.size());
6422}
6423
6424/// When we have an expression with type "id", we may assume
6425/// that it has some more-specific class type based on knowledge of
6426/// common uses of Objective-C. This routine returns that class type,
6427/// or NULL if no better result could be determined.
6428static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
6429 auto *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
6430 if (!Msg)
6431 return nullptr;
6432
6433 Selector Sel = Msg->getSelector();
6434 if (Sel.isNull())
6435 return nullptr;
6436
6437 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0);
6438 if (!Id)
6439 return nullptr;
6440
6441 ObjCMethodDecl *Method = Msg->getMethodDecl();
6442 if (!Method)
6443 return nullptr;
6444
6445 // Determine the class that we're sending the message to.
6446 ObjCInterfaceDecl *IFace = nullptr;
6447 switch (Msg->getReceiverKind()) {
6448 case ObjCMessageExpr::Class:
6449 if (const ObjCObjectType *ObjType =
6450 Msg->getClassReceiver()->getAs<ObjCObjectType>())
6451 IFace = ObjType->getInterface();
6452 break;
6453
6454 case ObjCMessageExpr::Instance: {
6455 QualType T = Msg->getInstanceReceiver()->getType();
6456 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
6457 IFace = Ptr->getInterfaceDecl();
6458 break;
6459 }
6460
6461 case ObjCMessageExpr::SuperInstance:
6462 case ObjCMessageExpr::SuperClass:
6463 break;
6464 }
6465
6466 if (!IFace)
6467 return nullptr;
6468
6469 ObjCInterfaceDecl *Super = IFace->getSuperClass();
6470 if (Method->isInstanceMethod())
6471 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
6472 .Case("retain", IFace)
6473 .Case("strong", IFace)
6474 .Case("autorelease", IFace)
6475 .Case("copy", IFace)
6476 .Case("copyWithZone", IFace)
6477 .Case("mutableCopy", IFace)
6478 .Case("mutableCopyWithZone", IFace)
6479 .Case("awakeFromCoder", IFace)
6480 .Case("replacementObjectFromCoder", IFace)
6481 .Case("class", IFace)
6482 .Case("classForCoder", IFace)
6483 .Case("superclass", Super)
6484 .Default(nullptr);
6485
6486 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
6487 .Case("new", IFace)
6488 .Case("alloc", IFace)
6489 .Case("allocWithZone", IFace)
6490 .Case("class", IFace)
6491 .Case("superclass", Super)
6492 .Default(nullptr);
6493}
6494
6495// Add a special completion for a message send to "super", which fills in the
6496// most likely case of forwarding all of our arguments to the superclass
6497// function.
6498///
6499/// \param S The semantic analysis object.
6500///
6501/// \param NeedSuperKeyword Whether we need to prefix this completion with
6502/// the "super" keyword. Otherwise, we just need to provide the arguments.
6503///
6504/// \param SelIdents The identifiers in the selector that have already been
6505/// provided as arguments for a send to "super".
6506///
6507/// \param Results The set of results to augment.
6508///
6509/// \returns the Objective-C method declaration that would be invoked by
6510/// this "super" completion. If NULL, no completion was added.
6511static ObjCMethodDecl *
6512AddSuperSendCompletion(Sema &S, bool NeedSuperKeyword,
6513 ArrayRef<IdentifierInfo *> SelIdents,
6514 ResultBuilder &Results) {
6515 ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
6516 if (!CurMethod)
6517 return nullptr;
6518
6519 ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
6520 if (!Class)
6521 return nullptr;
6522
6523 // Try to find a superclass method with the same selector.
6524 ObjCMethodDecl *SuperMethod = nullptr;
6525 while ((Class = Class->getSuperClass()) && !SuperMethod) {
6526 // Check in the class
6527 SuperMethod = Class->getMethod(CurMethod->getSelector(),
6528 CurMethod->isInstanceMethod());
6529
6530 // Check in categories or class extensions.
6531 if (!SuperMethod) {
6532 for (const auto *Cat : Class->known_categories()) {
6533 if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(),
6534 CurMethod->isInstanceMethod())))
6535 break;
6536 }
6537 }
6538 }
6539
6540 if (!SuperMethod)
6541 return nullptr;
6542
6543 // Check whether the superclass method has the same signature.
6544 if (CurMethod->param_size() != SuperMethod->param_size() ||
6545 CurMethod->isVariadic() != SuperMethod->isVariadic())
6546 return nullptr;
6547
6548 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
6549 CurPEnd = CurMethod->param_end(),
6550 SuperP = SuperMethod->param_begin();
6551 CurP != CurPEnd; ++CurP, ++SuperP) {
6552 // Make sure the parameter types are compatible.
6553 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
6554 (*SuperP)->getType()))
6555 return nullptr;
6556
6557 // Make sure we have a parameter name to forward!
6558 if (!(*CurP)->getIdentifier())
6559 return nullptr;
6560 }
6561
6562 // We have a superclass method. Now, form the send-to-super completion.
6563 CodeCompletionBuilder Builder(Results.getAllocator(),
6564 Results.getCodeCompletionTUInfo());
6565
6566 // Give this completion a return type.
6567 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod,
6568 Results.getCompletionContext().getBaseType(), Builder);
6569
6570 // If we need the "super" keyword, add it (plus some spacing).
6571 if (NeedSuperKeyword) {
6572 Builder.AddTypedTextChunk("super");
6573 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6574 }
6575
6576 Selector Sel = CurMethod->getSelector();
6577 if (Sel.isUnarySelector()) {
6578 if (NeedSuperKeyword)
6579 Builder.AddTextChunk(
6580 Builder.getAllocator().CopyString(Sel.getNameForSlot(0)));
6581 else
6582 Builder.AddTypedTextChunk(
6583 Builder.getAllocator().CopyString(Sel.getNameForSlot(0)));
6584 } else {
6585 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
6586 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
6587 if (I > SelIdents.size())
6588 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6589
6590 if (I < SelIdents.size())
6591 Builder.AddInformativeChunk(
6592 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
6593 else if (NeedSuperKeyword || I > SelIdents.size()) {
6594 Builder.AddTextChunk(
6595 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
6596 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
6597 (*CurP)->getIdentifier()->getName()));
6598 } else {
6599 Builder.AddTypedTextChunk(
6600 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
6601 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
6602 (*CurP)->getIdentifier()->getName()));
6603 }
6604 }
6605 }
6606
6607 Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod,
6608 CCP_SuperCompletion));
6609 return SuperMethod;
6610}
6611
6612void Sema::CodeCompleteObjCMessageReceiver(Scope *S) {
6613 typedef CodeCompletionResult Result;
6614 ResultBuilder Results(
6615 *this, CodeCompleter->getAllocator(),
6616 CodeCompleter->getCodeCompletionTUInfo(),
6617 CodeCompletionContext::CCC_ObjCMessageReceiver,
6618 getLangOpts().CPlusPlus11
6619 ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture
6620 : &ResultBuilder::IsObjCMessageReceiver);
6621
6622 CodeCompletionDeclConsumer Consumer(Results, CurContext);
6623 Results.EnterNewScope();
6624 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
6625 CodeCompleter->includeGlobals(),
6626 CodeCompleter->loadExternal());
6627
6628 // If we are in an Objective-C method inside a class that has a superclass,
6629 // add "super" as an option.
6630 if (ObjCMethodDecl *Method = getCurMethodDecl())
6631 if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
6632 if (Iface->getSuperClass()) {
6633 Results.AddResult(Result("super"));
6634
6635 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, None, Results);
6636 }
6637
6638 if (getLangOpts().CPlusPlus11)
6639 addThisCompletion(*this, Results);
6640
6641 Results.ExitScope();
6642
6643 if (CodeCompleter->includeMacros())
6644 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
6645 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6646 Results.data(), Results.size());
6647}
6648
6649void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
6650 ArrayRef<IdentifierInfo *> SelIdents,
6651 bool AtArgumentExpression) {
6652 ObjCInterfaceDecl *CDecl = nullptr;
6653 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
6654 // Figure out which interface we're in.
6655 CDecl = CurMethod->getClassInterface();
6656 if (!CDecl)
6657 return;
6658
6659 // Find the superclass of this class.
6660 CDecl = CDecl->getSuperClass();
6661 if (!CDecl)
6662 return;
6663
6664 if (CurMethod->isInstanceMethod()) {
6665 // We are inside an instance method, which means that the message
6666 // send [super ...] is actually calling an instance method on the
6667 // current object.
6668 return CodeCompleteObjCInstanceMessage(S, nullptr, SelIdents,
6669 AtArgumentExpression, CDecl);
6670 }
6671
6672 // Fall through to send to the superclass in CDecl.
6673 } else {
6674 // "super" may be the name of a type or variable. Figure out which
6675 // it is.
6676 IdentifierInfo *Super = getSuperIdentifier();
6677 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc, LookupOrdinaryName);
6678 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
6679 // "super" names an interface. Use it.
6680 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
6681 if (const ObjCObjectType *Iface =
6682 Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
6683 CDecl = Iface->getInterface();
6684 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
6685 // "super" names an unresolved type; we can't be more specific.
6686 } else {
6687 // Assume that "super" names some kind of value and parse that way.
6688 CXXScopeSpec SS;
6689 SourceLocation TemplateKWLoc;
6690 UnqualifiedId id;
6691 id.setIdentifier(Super, SuperLoc);
6692 ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id,
6693 /*HasTrailingLParen=*/false,
6694 /*IsAddressOfOperand=*/false);
6695 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
6696 SelIdents, AtArgumentExpression);
6697 }
6698
6699 // Fall through
6700 }
6701
6702 ParsedType Receiver;
6703 if (CDecl)
6704 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
6705 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
6706 AtArgumentExpression,
6707 /*IsSuper=*/true);
6708}
6709
6710/// Given a set of code-completion results for the argument of a message
6711/// send, determine the preferred type (if any) for that argument expression.
6712static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
6713 unsigned NumSelIdents) {
6714 typedef CodeCompletionResult Result;
6715 ASTContext &Context = Results.getSema().Context;
6716
6717 QualType PreferredType;
6718 unsigned BestPriority = CCP_Unlikely * 2;
6719 Result *ResultsData = Results.data();
6720 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
6721 Result &R = ResultsData[I];
6722 if (R.Kind == Result::RK_Declaration &&
6723 isa<ObjCMethodDecl>(R.Declaration)) {
6724 if (R.Priority <= BestPriority) {
6725 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
6726 if (NumSelIdents <= Method->param_size()) {
6727 QualType MyPreferredType =
6728 Method->parameters()[NumSelIdents - 1]->getType();
6729 if (R.Priority < BestPriority || PreferredType.isNull()) {
6730 BestPriority = R.Priority;
6731 PreferredType = MyPreferredType;
6732 } else if (!Context.hasSameUnqualifiedType(PreferredType,
6733 MyPreferredType)) {
6734 PreferredType = QualType();
6735 }
6736 }
6737 }
6738 }
6739 }
6740
6741 return PreferredType;
6742}
6743
6744static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
6745 ParsedType Receiver,
6746 ArrayRef<IdentifierInfo *> SelIdents,
6747 bool AtArgumentExpression, bool IsSuper,
6748 ResultBuilder &Results) {
6749 typedef CodeCompletionResult Result;
6750 ObjCInterfaceDecl *CDecl = nullptr;
6751
6752 // If the given name refers to an interface type, retrieve the
6753 // corresponding declaration.
6754 if (Receiver) {
6755 QualType T = SemaRef.GetTypeFromParser(Receiver, nullptr);
6756 if (!T.isNull())
6757 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
6758 CDecl = Interface->getInterface();
6759 }
6760
6761 // Add all of the factory methods in this Objective-C class, its protocols,
6762 // superclasses, categories, implementation, etc.
6763 Results.EnterNewScope();
6764
6765 // If this is a send-to-super, try to add the special "super" send
6766 // completion.
6767 if (IsSuper) {
6768 if (ObjCMethodDecl *SuperMethod =
6769 AddSuperSendCompletion(SemaRef, false, SelIdents, Results))
6770 Results.Ignore(SuperMethod);
6771 }
6772
6773 // If we're inside an Objective-C method definition, prefer its selector to
6774 // others.
6775 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
6776 Results.setPreferredSelector(CurMethod->getSelector());
6777
6778 VisitedSelectorSet Selectors;
6779 if (CDecl)
6780 AddObjCMethods(CDecl, false, MK_Any, SelIdents, SemaRef.CurContext,
6781 Selectors, AtArgumentExpression, Results);
6782 else {
6783 // We're messaging "id" as a type; provide all class/factory methods.
6784
6785 // If we have an external source, load the entire class method
6786 // pool from the AST file.
6787 if (SemaRef.getExternalSource()) {
6788 for (uint32_t I = 0,
6789 N = SemaRef.getExternalSource()->GetNumExternalSelectors();
6790 I != N; ++I) {
6791 Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I);
6792 if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
6793 continue;
6794
6795 SemaRef.ReadMethodPool(Sel);
6796 }
6797 }
6798
6799 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
6800 MEnd = SemaRef.MethodPool.end();
6801 M != MEnd; ++M) {
6802 for (ObjCMethodList *MethList = &M->second.second;
6803 MethList && MethList->getMethod(); MethList = MethList->getNext()) {
6804 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
6805 continue;
6806
6807 Result R(MethList->getMethod(),
6808 Results.getBasePriority(MethList->getMethod()), nullptr);
6809 R.StartParameter = SelIdents.size();
6810 R.AllParametersAreInformative = false;
6811 Results.MaybeAddResult(R, SemaRef.CurContext);
6812 }
6813 }
6814 }
6815
6816 Results.ExitScope();
6817}
6818
6819void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
6820 ArrayRef<IdentifierInfo *> SelIdents,
6821 bool AtArgumentExpression,
6822 bool IsSuper) {
6823
6824 QualType T = this->GetTypeFromParser(Receiver);
6825
6826 ResultBuilder Results(
6827 *this, CodeCompleter->getAllocator(),
6828 CodeCompleter->getCodeCompletionTUInfo(),
6829 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage, T,
6830 SelIdents));
6831
6832 AddClassMessageCompletions(*this, S, Receiver, SelIdents,
6833 AtArgumentExpression, IsSuper, Results);
6834
6835 // If we're actually at the argument expression (rather than prior to the
6836 // selector), we're actually performing code completion for an expression.
6837 // Determine whether we have a single, best method. If so, we can
6838 // code-complete the expression using the corresponding parameter type as
6839 // our preferred type, improving completion results.
6840 if (AtArgumentExpression) {
6841 QualType PreferredType =
6842 getPreferredArgumentTypeForMessageSend(Results, SelIdents.size());
6843 if (PreferredType.isNull())
6844 CodeCompleteOrdinaryName(S, PCC_Expression);
6845 else
6846 CodeCompleteExpression(S, PreferredType);
6847 return;
6848 }
6849
6850 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6851 Results.data(), Results.size());
6852}
6853
6854void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
6855 ArrayRef<IdentifierInfo *> SelIdents,
6856 bool AtArgumentExpression,
6857 ObjCInterfaceDecl *Super) {
6858 typedef CodeCompletionResult Result;
6859
6860 Expr *RecExpr = static_cast<Expr *>(Receiver);
6861
6862 // If necessary, apply function/array conversion to the receiver.
6863 // C99 6.7.5.3p[7,8].
6864 if (RecExpr) {
6865 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
6866 if (Conv.isInvalid()) // conversion failed. bail.
6867 return;
6868 RecExpr = Conv.get();
6869 }
6870 QualType ReceiverType = RecExpr
6871 ? RecExpr->getType()
6872 : Super ? Context.getObjCObjectPointerType(
6873 Context.getObjCInterfaceType(Super))
6874 : Context.getObjCIdType();
6875
6876 // If we're messaging an expression with type "id" or "Class", check
6877 // whether we know something special about the receiver that allows
6878 // us to assume a more-specific receiver type.
6879 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) {
6880 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
6881 if (ReceiverType->isObjCClassType())
6882 return CodeCompleteObjCClassMessage(
6883 S, ParsedType::make(Context.getObjCInterfaceType(IFace)), SelIdents,
6884 AtArgumentExpression, Super);
6885
6886 ReceiverType =
6887 Context.getObjCObjectPointerType(Context.getObjCInterfaceType(IFace));
6888 }
6889 } else if (RecExpr && getLangOpts().CPlusPlus) {
6890 ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr);
6891 if (Conv.isUsable()) {
6892 RecExpr = Conv.get();
6893 ReceiverType = RecExpr->getType();
6894 }
6895 }
6896
6897 // Build the set of methods we can see.
6898 ResultBuilder Results(
6899 *this, CodeCompleter->getAllocator(),
6900 CodeCompleter->getCodeCompletionTUInfo(),
6901 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage,
6902 ReceiverType, SelIdents));
6903
6904 Results.EnterNewScope();
6905
6906 // If this is a send-to-super, try to add the special "super" send
6907 // completion.
6908 if (Super) {
6909 if (ObjCMethodDecl *SuperMethod =
6910 AddSuperSendCompletion(*this, false, SelIdents, Results))
6911 Results.Ignore(SuperMethod);
6912 }
6913
6914 // If we're inside an Objective-C method definition, prefer its selector to
6915 // others.
6916 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
6917 Results.setPreferredSelector(CurMethod->getSelector());
6918
6919 // Keep track of the selectors we've already added.
6920 VisitedSelectorSet Selectors;
6921
6922 // Handle messages to Class. This really isn't a message to an instance
6923 // method, so we treat it the same way we would treat a message send to a
6924 // class method.
6925 if (ReceiverType->isObjCClassType() ||
6926 ReceiverType->isObjCQualifiedClassType()) {
6927 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
6928 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
6929 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents, CurContext,
6930 Selectors, AtArgumentExpression, Results);
6931 }
6932 }
6933 // Handle messages to a qualified ID ("id<foo>").
6934 else if (const ObjCObjectPointerType *QualID =
6935 ReceiverType->getAsObjCQualifiedIdType()) {
6936 // Search protocols for instance methods.
6937 for (auto *I : QualID->quals())
6938 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext, Selectors,
6939 AtArgumentExpression, Results);
6940 }
6941 // Handle messages to a pointer to interface type.
6942 else if (const ObjCObjectPointerType *IFacePtr =
6943 ReceiverType->getAsObjCInterfacePointerType()) {
6944 // Search the class, its superclasses, etc., for instance methods.
6945 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
6946 CurContext, Selectors, AtArgumentExpression, Results);
6947
6948 // Search protocols for instance methods.
6949 for (auto *I : IFacePtr->quals())
6950 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext, Selectors,
6951 AtArgumentExpression, Results);
6952 }
6953 // Handle messages to "id".
6954 else if (ReceiverType->isObjCIdType()) {
6955 // We're messaging "id", so provide all instance methods we know
6956 // about as code-completion results.
6957
6958 // If we have an external source, load the entire class method
6959 // pool from the AST file.
6960 if (ExternalSource) {
6961 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6962 I != N; ++I) {
6963 Selector Sel = ExternalSource->GetExternalSelector(I);
6964 if (Sel.isNull() || MethodPool.count(Sel))
6965 continue;
6966
6967 ReadMethodPool(Sel);
6968 }
6969 }
6970
6971 for (GlobalMethodPool::iterator M = MethodPool.begin(),
6972 MEnd = MethodPool.end();
6973 M != MEnd; ++M) {
6974 for (ObjCMethodList *MethList = &M->second.first;
6975 MethList && MethList->getMethod(); MethList = MethList->getNext()) {
6976 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
6977 continue;
6978
6979 if (!Selectors.insert(MethList->getMethod()->getSelector()).second)
6980 continue;
6981
6982 Result R(MethList->getMethod(),
6983 Results.getBasePriority(MethList->getMethod()), nullptr);
6984 R.StartParameter = SelIdents.size();
6985 R.AllParametersAreInformative = false;
6986 Results.MaybeAddResult(R, CurContext);
6987 }
6988 }
6989 }
6990 Results.ExitScope();
6991
6992 // If we're actually at the argument expression (rather than prior to the
6993 // selector), we're actually performing code completion for an expression.
6994 // Determine whether we have a single, best method. If so, we can
6995 // code-complete the expression using the corresponding parameter type as
6996 // our preferred type, improving completion results.
6997 if (AtArgumentExpression) {
6998 QualType PreferredType =
6999 getPreferredArgumentTypeForMessageSend(Results, SelIdents.size());
7000 if (PreferredType.isNull())
7001 CodeCompleteOrdinaryName(S, PCC_Expression);
7002 else
7003 CodeCompleteExpression(S, PreferredType);
7004 return;
7005 }
7006
7007 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7008 Results.data(), Results.size());
7009}
7010
7011void Sema::CodeCompleteObjCForCollection(Scope *S,
7012 DeclGroupPtrTy IterationVar) {
7013 CodeCompleteExpressionData Data;
7014 Data.ObjCCollection = true;
7015
7016 if (IterationVar.getAsOpaquePtr()) {
7017 DeclGroupRef DG = IterationVar.get();
7018 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
7019 if (*I)
7020 Data.IgnoreDecls.push_back(*I);
7021 }
7022 }
7023
7024 CodeCompleteExpression(S, Data);
7025}
7026
7027void Sema::CodeCompleteObjCSelector(Scope *S,
7028 ArrayRef<IdentifierInfo *> SelIdents) {
7029 // If we have an external source, load the entire class method
7030 // pool from the AST file.
7031 if (ExternalSource) {
7032 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); I != N;
7033 ++I) {
7034 Selector Sel = ExternalSource->GetExternalSelector(I);
7035 if (Sel.isNull() || MethodPool.count(Sel))
7036 continue;
7037
7038 ReadMethodPool(Sel);
7039 }
7040 }
7041
7042 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7043 CodeCompleter->getCodeCompletionTUInfo(),
7044 CodeCompletionContext::CCC_SelectorName);
7045 Results.EnterNewScope();
7046 for (GlobalMethodPool::iterator M = MethodPool.begin(),
7047 MEnd = MethodPool.end();
7048 M != MEnd; ++M) {
7049
7050 Selector Sel = M->first;
7051 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents))
7052 continue;
7053
7054 CodeCompletionBuilder Builder(Results.getAllocator(),
7055 Results.getCodeCompletionTUInfo());
7056 if (Sel.isUnarySelector()) {
7057 Builder.AddTypedTextChunk(
7058 Builder.getAllocator().CopyString(Sel.getNameForSlot(0)));
7059 Results.AddResult(Builder.TakeString());
7060 continue;
7061 }
7062
7063 std::string Accumulator;
7064 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
7065 if (I == SelIdents.size()) {
7066 if (!Accumulator.empty()) {
7067 Builder.AddInformativeChunk(
7068 Builder.getAllocator().CopyString(Accumulator));
7069 Accumulator.clear();
7070 }
7071 }
7072
7073 Accumulator += Sel.getNameForSlot(I);
7074 Accumulator += ':';
7075 }
7076 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(Accumulator));
7077 Results.AddResult(Builder.TakeString());
7078 }
7079 Results.ExitScope();
7080
7081 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7082 Results.data(), Results.size());
7083}
7084
7085/// Add all of the protocol declarations that we find in the given
7086/// (translation unit) context.
7087static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
7088 bool OnlyForwardDeclarations,
7089 ResultBuilder &Results) {
7090 typedef CodeCompletionResult Result;
7091
7092 for (const auto *D : Ctx->decls()) {
7093 // Record any protocols we find.
7094 if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(D))
7095 if (!OnlyForwardDeclarations || !Proto->hasDefinition())
7096 Results.AddResult(
7097 Result(Proto, Results.getBasePriority(Proto), nullptr), CurContext,
7098 nullptr, false);
7099 }
7100}
7101
7102void Sema::CodeCompleteObjCProtocolReferences(
7103 ArrayRef<IdentifierLocPair> Protocols) {
7104 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7105 CodeCompleter->getCodeCompletionTUInfo(),
7106 CodeCompletionContext::CCC_ObjCProtocolName);
7107
7108 if (CodeCompleter->includeGlobals()) {
7109 Results.EnterNewScope();
7110
7111 // Tell the result set to ignore all of the protocols we have
7112 // already seen.
7113 // FIXME: This doesn't work when caching code-completion results.
7114 for (const IdentifierLocPair &Pair : Protocols)
7115 if (ObjCProtocolDecl *Protocol = LookupProtocol(Pair.first, Pair.second))
7116 Results.Ignore(Protocol);
7117
7118 // Add all protocols.
7119 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
7120 Results);
7121
7122 Results.ExitScope();
7123 }
7124
7125 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7126 Results.data(), Results.size());
7127}
7128
7129void Sema::CodeCompleteObjCProtocolDecl(Scope *) {
7130 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7131 CodeCompleter->getCodeCompletionTUInfo(),
7132 CodeCompletionContext::CCC_ObjCProtocolName);
7133
7134 if (CodeCompleter->includeGlobals()) {
7135 Results.EnterNewScope();
7136
7137 // Add all protocols.
7138 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
7139 Results);
7140
7141 Results.ExitScope();
7142 }
7143
7144 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7145 Results.data(), Results.size());
7146}
7147
7148/// Add all of the Objective-C interface declarations that we find in
7149/// the given (translation unit) context.
7150static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
7151 bool OnlyForwardDeclarations,
7152 bool OnlyUnimplemented,
7153 ResultBuilder &Results) {
7154 typedef CodeCompletionResult Result;
7155
7156 for (const auto *D : Ctx->decls()) {
7157 // Record any interfaces we find.
7158 if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(D))
7159 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
7160 (!OnlyUnimplemented || !Class->getImplementation()))
7161 Results.AddResult(
7162 Result(Class, Results.getBasePriority(Class), nullptr), CurContext,
7163 nullptr, false);
7164 }
7165}
7166
7167void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) {
7168 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7169 CodeCompleter->getCodeCompletionTUInfo(),
7170 CodeCompletionContext::CCC_ObjCInterfaceName);
7171 Results.EnterNewScope();
7172
7173 if (CodeCompleter->includeGlobals()) {
7174 // Add all classes.
7175 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
7176 false, Results);
7177 }
7178
7179 Results.ExitScope();
7180
7181 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7182 Results.data(), Results.size());
7183}
7184
7185void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName,
7186 SourceLocation ClassNameLoc) {
7187 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7188 CodeCompleter->getCodeCompletionTUInfo(),
7189 CodeCompletionContext::CCC_ObjCInterfaceName);
7190 Results.EnterNewScope();
7191
7192 // Make sure that we ignore the class we're currently defining.
7193 NamedDecl *CurClass =
7194 LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
7195 if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
7196 Results.Ignore(CurClass);
7197
7198 if (CodeCompleter->includeGlobals()) {
7199 // Add all classes.
7200 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
7201 false, Results);
7202 }
7203
7204 Results.ExitScope();
7205
7206 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7207 Results.data(), Results.size());
7208}
7209
7210void Sema::CodeCompleteObjCImplementationDecl(Scope *S) {
7211 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7212 CodeCompleter->getCodeCompletionTUInfo(),
7213 CodeCompletionContext::CCC_ObjCImplementation);
7214 Results.EnterNewScope();
7215
7216 if (CodeCompleter->includeGlobals()) {
7217 // Add all unimplemented classes.
7218 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
7219 true, Results);
7220 }
7221
7222 Results.ExitScope();
7223
7224 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7225 Results.data(), Results.size());
7226}
7227
7228void Sema::CodeCompleteObjCInterfaceCategory(Scope *S,
7229 IdentifierInfo *ClassName,
7230 SourceLocation ClassNameLoc) {
7231 typedef CodeCompletionResult Result;
7232
7233 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7234 CodeCompleter->getCodeCompletionTUInfo(),
7235 CodeCompletionContext::CCC_ObjCCategoryName);
7236
7237 // Ignore any categories we find that have already been implemented by this
7238 // interface.
7239 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
7240 NamedDecl *CurClass =
7241 LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
7242 if (ObjCInterfaceDecl *Class =
7243 dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)) {
7244 for (const auto *Cat : Class->visible_categories())
7245 CategoryNames.insert(Cat->getIdentifier());
7246 }
7247
7248 // Add all of the categories we know about.
7249 Results.EnterNewScope();
7250 TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
7251 for (const auto *D : TU->decls())
7252 if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D))
7253 if (CategoryNames.insert(Category->getIdentifier()).second)
7254 Results.AddResult(
7255 Result(Category, Results.getBasePriority(Category), nullptr),
7256 CurContext, nullptr, false);
7257 Results.ExitScope();
7258
7259 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7260 Results.data(), Results.size());
7261}
7262
7263void Sema::CodeCompleteObjCImplementationCategory(Scope *S,
7264 IdentifierInfo *ClassName,
7265 SourceLocation ClassNameLoc) {
7266 typedef CodeCompletionResult Result;
7267
7268 // Find the corresponding interface. If we couldn't find the interface, the
7269 // program itself is ill-formed. However, we'll try to be helpful still by
7270 // providing the list of all of the categories we know about.
7271 NamedDecl *CurClass =
7272 LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
7273 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
7274 if (!Class)
7275 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
7276
7277 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7278 CodeCompleter->getCodeCompletionTUInfo(),
7279 CodeCompletionContext::CCC_ObjCCategoryName);
7280
7281 // Add all of the categories that have have corresponding interface
7282 // declarations in this class and any of its superclasses, except for
7283 // already-implemented categories in the class itself.
7284 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
7285 Results.EnterNewScope();
7286 bool IgnoreImplemented = true;
7287 while (Class) {
7288 for (const auto *Cat : Class->visible_categories()) {
7289 if ((!IgnoreImplemented || !Cat->getImplementation()) &&
7290 CategoryNames.insert(Cat->getIdentifier()).second)
7291 Results.AddResult(Result(Cat, Results.getBasePriority(Cat), nullptr),
7292 CurContext, nullptr, false);
7293 }
7294
7295 Class = Class->getSuperClass();
7296 IgnoreImplemented = false;
7297 }
7298 Results.ExitScope();
7299
7300 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7301 Results.data(), Results.size());
7302}
7303
7304void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) {
7305 CodeCompletionContext CCContext(CodeCompletionContext::CCC_Other);
7306 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7307 CodeCompleter->getCodeCompletionTUInfo(), CCContext);
7308
7309 // Figure out where this @synthesize lives.
7310 ObjCContainerDecl *Container =
7311 dyn_cast_or_null<ObjCContainerDecl>(CurContext);
7312 if (!Container || (!isa<ObjCImplementationDecl>(Container) &&
7313 !isa<ObjCCategoryImplDecl>(Container)))
7314 return;
7315
7316 // Ignore any properties that have already been implemented.
7317 Container = getContainerDef(Container);
7318 for (const auto *D : Container->decls())
7319 if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D))
7320 Results.Ignore(PropertyImpl->getPropertyDecl());
7321
7322 // Add any properties that we find.
7323 AddedPropertiesSet AddedProperties;
7324 Results.EnterNewScope();
7325 if (ObjCImplementationDecl *ClassImpl =
7326 dyn_cast<ObjCImplementationDecl>(Container))
7327 AddObjCProperties(CCContext, ClassImpl->getClassInterface(), false,
7328 /*AllowNullaryMethods=*/false, CurContext,
7329 AddedProperties, Results);
7330 else
7331 AddObjCProperties(CCContext,
7332 cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
7333 false, /*AllowNullaryMethods=*/false, CurContext,
7334 AddedProperties, Results);
7335 Results.ExitScope();
7336
7337 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7338 Results.data(), Results.size());
7339}
7340
7341void Sema::CodeCompleteObjCPropertySynthesizeIvar(
7342 Scope *S, IdentifierInfo *PropertyName) {
7343 typedef CodeCompletionResult Result;
7344 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7345 CodeCompleter->getCodeCompletionTUInfo(),
7346 CodeCompletionContext::CCC_Other);
7347
7348 // Figure out where this @synthesize lives.
7349 ObjCContainerDecl *Container =
7350 dyn_cast_or_null<ObjCContainerDecl>(CurContext);
7351 if (!Container || (!isa<ObjCImplementationDecl>(Container) &&
7352 !isa<ObjCCategoryImplDecl>(Container)))
7353 return;
7354
7355 // Figure out which interface we're looking into.
7356 ObjCInterfaceDecl *Class = nullptr;
7357 if (ObjCImplementationDecl *ClassImpl =
7358 dyn_cast<ObjCImplementationDecl>(Container))
7359 Class = ClassImpl->getClassInterface();
7360 else
7361 Class = cast<ObjCCategoryImplDecl>(Container)
7362 ->getCategoryDecl()
7363 ->getClassInterface();
7364
7365 // Determine the type of the property we're synthesizing.
7366 QualType PropertyType = Context.getObjCIdType();
7367 if (Class) {
7368 if (ObjCPropertyDecl *Property = Class->FindPropertyDeclaration(
7369 PropertyName, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
7370 PropertyType =
7371 Property->getType().getNonReferenceType().getUnqualifiedType();
7372
7373 // Give preference to ivars
7374 Results.setPreferredType(PropertyType);
7375 }
7376 }
7377
7378 // Add all of the instance variables in this class and its superclasses.
7379 Results.EnterNewScope();
7380 bool SawSimilarlyNamedIvar = false;
7381 std::string NameWithPrefix;
7382 NameWithPrefix += '_';
7383 NameWithPrefix += PropertyName->getName();
7384 std::string NameWithSuffix = PropertyName->getName().str();
7385 NameWithSuffix += '_';
7386 for (; Class; Class = Class->getSuperClass()) {
7387 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
7388 Ivar = Ivar->getNextIvar()) {
7389 Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), nullptr),
7390 CurContext, nullptr, false);
7391
7392 // Determine whether we've seen an ivar with a name similar to the
7393 // property.
7394 if ((PropertyName == Ivar->getIdentifier() ||
7395 NameWithPrefix == Ivar->getName() ||
7396 NameWithSuffix == Ivar->getName())) {
7397 SawSimilarlyNamedIvar = true;
7398
7399 // Reduce the priority of this result by one, to give it a slight
7400 // advantage over other results whose names don't match so closely.
7401 if (Results.size() &&
7402 Results.data()[Results.size() - 1].Kind ==
7403 CodeCompletionResult::RK_Declaration &&
7404 Results.data()[Results.size() - 1].Declaration == Ivar)
7405 Results.data()[Results.size() - 1].Priority--;
7406 }
7407 }
7408 }
7409
7410 if (!SawSimilarlyNamedIvar) {
7411 // Create ivar result _propName, that the user can use to synthesize
7412 // an ivar of the appropriate type.
7413 unsigned Priority = CCP_MemberDeclaration + 1;
7414 typedef CodeCompletionResult Result;
7415 CodeCompletionAllocator &Allocator = Results.getAllocator();
7416 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(),
7417 Priority, CXAvailability_Available);
7418
7419 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
7420 Builder.AddResultTypeChunk(
7421 GetCompletionTypeString(PropertyType, Context, Policy, Allocator));
7422 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
7423 Results.AddResult(
7424 Result(Builder.TakeString(), Priority, CXCursor_ObjCIvarDecl));
7425 }
7426
7427 Results.ExitScope();
7428
7429 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7430 Results.data(), Results.size());
7431}
7432
7433// Mapping from selectors to the methods that implement that selector, along
7434// with the "in original class" flag.
7435typedef llvm::DenseMap<Selector,
7436 llvm::PointerIntPair<ObjCMethodDecl *, 1, bool>>
7437 KnownMethodsMap;
7438
7439/// Find all of the methods that reside in the given container
7440/// (and its superclasses, protocols, etc.) that meet the given
7441/// criteria. Insert those methods into the map of known methods,
7442/// indexed by selector so they can be easily found.
7443static void FindImplementableMethods(ASTContext &Context,
7444 ObjCContainerDecl *Container,
7445 Optional<bool> WantInstanceMethods,
7446 QualType ReturnType,
7447 KnownMethodsMap &KnownMethods,
7448 bool InOriginalClass = true) {
7449 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
7450 // Make sure we have a definition; that's what we'll walk.
7451 if (!IFace->hasDefinition())
7452 return;
7453
7454 IFace = IFace->getDefinition();
7455 Container = IFace;
7456
7457 const ObjCList<ObjCProtocolDecl> &Protocols =
7458 IFace->getReferencedProtocols();
7459 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
7460 E = Protocols.end();
7461 I != E; ++I)
7462 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
7463 KnownMethods, InOriginalClass);
7464
7465 // Add methods from any class extensions and categories.
7466 for (auto *Cat : IFace->visible_categories()) {
7467 FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType,
7468 KnownMethods, false);
7469 }
7470
7471 // Visit the superclass.
7472 if (IFace->getSuperClass())
7473 FindImplementableMethods(Context, IFace->getSuperClass(),
7474 WantInstanceMethods, ReturnType, KnownMethods,
7475 false);
7476 }
7477
7478 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
7479 // Recurse into protocols.
7480 const ObjCList<ObjCProtocolDecl> &Protocols =
7481 Category->getReferencedProtocols();
7482 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
7483 E = Protocols.end();
7484 I != E; ++I)
7485 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
7486 KnownMethods, InOriginalClass);
7487
7488 // If this category is the original class, jump to the interface.
7489 if (InOriginalClass && Category->getClassInterface())
7490 FindImplementableMethods(Context, Category->getClassInterface(),
7491 WantInstanceMethods, ReturnType, KnownMethods,
7492 false);
7493 }
7494
7495 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
7496 // Make sure we have a definition; that's what we'll walk.
7497 if (!Protocol->hasDefinition())
7498 return;
7499 Protocol = Protocol->getDefinition();
7500 Container = Protocol;
7501
7502 // Recurse into protocols.
7503 const ObjCList<ObjCProtocolDecl> &Protocols =
7504 Protocol->getReferencedProtocols();
7505 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
7506 E = Protocols.end();
7507 I != E; ++I)
7508 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
7509 KnownMethods, false);
7510 }
7511
7512 // Add methods in this container. This operation occurs last because
7513 // we want the methods from this container to override any methods
7514 // we've previously seen with the same selector.
7515 for (auto *M : Container->methods()) {
7516 if (!WantInstanceMethods || M->isInstanceMethod() == *WantInstanceMethods) {
7517 if (!ReturnType.isNull() &&
7518 !Context.hasSameUnqualifiedType(ReturnType, M->getReturnType()))
7519 continue;
7520
7521 KnownMethods[M->getSelector()] =
7522 KnownMethodsMap::mapped_type(M, InOriginalClass);
7523 }
7524 }
7525}
7526
7527/// Add the parenthesized return or parameter type chunk to a code
7528/// completion string.
7529static void AddObjCPassingTypeChunk(QualType Type, unsigned ObjCDeclQuals,
7530 ASTContext &Context,
7531 const PrintingPolicy &Policy,
7532 CodeCompletionBuilder &Builder) {
7533 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7534 std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals, Type);
7535 if (!Quals.empty())
7536 Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals));
7537 Builder.AddTextChunk(
7538 GetCompletionTypeString(Type, Context, Policy, Builder.getAllocator()));
7539 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7540}
7541
7542/// Determine whether the given class is or inherits from a class by
7543/// the given name.
7544static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class, StringRef Name) {
7545 if (!Class)
7546 return false;
7547
7548 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
7549 return true;
7550
7551 return InheritsFromClassNamed(Class->getSuperClass(), Name);
7552}
7553
7554/// Add code completions for Objective-C Key-Value Coding (KVC) and
7555/// Key-Value Observing (KVO).
7556static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property,
7557 bool IsInstanceMethod,
7558 QualType ReturnType, ASTContext &Context,
7559 VisitedSelectorSet &KnownSelectors,
7560 ResultBuilder &Results) {
7561 IdentifierInfo *PropName = Property->getIdentifier();
7562 if (!PropName || PropName->getLength() == 0)
1
Assuming 'PropName' is non-null
2
Assuming the condition is false
3
Taking false branch
7563 return;
7564
7565 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
7566
7567 // Builder that will create each code completion.
7568 typedef CodeCompletionResult Result;
7569 CodeCompletionAllocator &Allocator = Results.getAllocator();
7570 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
7571
7572 // The selector table.
7573 SelectorTable &Selectors = Context.Selectors;
7574
7575 // The property name, copied into the code completion allocation region
7576 // on demand.
7577 struct KeyHolder {
7578 CodeCompletionAllocator &Allocator;
7579 StringRef Key;
7580 const char *CopiedKey;
7581
7582 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
7583 : Allocator(Allocator), Key(Key), CopiedKey(nullptr) {}
7584
7585 operator const char *() {
7586 if (CopiedKey)
7587 return CopiedKey;
7588
7589 return CopiedKey = Allocator.CopyString(Key);
7590 }
7591 } Key(Allocator, PropName->getName());
7592
7593 // The uppercased name of the property name.
7594 std::string UpperKey = PropName->getName();
7595 if (!UpperKey.empty())
4
Assuming the condition is false
5
Taking false branch
7596 UpperKey[0] = toUppercase(UpperKey[0]);
7597
7598 bool ReturnTypeMatchesProperty =
7599 ReturnType.isNull() ||
7600 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
7601 Property->getType());
7602 bool ReturnTypeMatchesVoid = ReturnType.isNull() || ReturnType->isVoidType();
7603
7604 // Add the normal accessor -(type)key.
7605 if (IsInstanceMethod &&
6
Assuming 'IsInstanceMethod' is false
7
Taking false branch
7606 KnownSelectors.insert(Selectors.getNullarySelector(PropName)).second &&
7607 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
7608 if (ReturnType.isNull())
7609 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0, Context, Policy,
7610 Builder);
7611
7612 Builder.AddTypedTextChunk(Key);
7613 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7614 CXCursor_ObjCInstanceMethodDecl));
7615 }
7616
7617 // If we have an integral or boolean property (or the user has provided
7618 // an integral or boolean return type), add the accessor -(type)isKey.
7619 if (IsInstanceMethod
7.1
'IsInstanceMethod' is false
7.1
'IsInstanceMethod' is false
7.1
'IsInstanceMethod' is false
&&
8
Taking false branch
7620 ((!ReturnType.isNull() &&
7621 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
7622 (ReturnType.isNull() && (Property->getType()->isIntegerType() ||
7623 Property->getType()->isBooleanType())))) {
7624 std::string SelectorName = (Twine("is") + UpperKey).str();
7625 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7626 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7627 .second) {
7628 if (ReturnType.isNull()) {
7629 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7630 Builder.AddTextChunk("BOOL");
7631 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7632 }
7633
7634 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorId->getName()));
7635 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7636 CXCursor_ObjCInstanceMethodDecl));
7637 }
7638 }
7639
7640 // Add the normal mutator.
7641 if (IsInstanceMethod
8.1
'IsInstanceMethod' is false
8.1
'IsInstanceMethod' is false
8.1
'IsInstanceMethod' is false
&& ReturnTypeMatchesVoid &&
7642 !Property->getSetterMethodDecl()) {
7643 std::string SelectorName = (Twine("set") + UpperKey).str();
7644 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7645 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7646 if (ReturnType.isNull()) {
7647 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7648 Builder.AddTextChunk("void");
7649 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7650 }
7651
7652 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorId->getName()));
7653 Builder.AddTypedTextChunk(":");
7654 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0, Context, Policy,
7655 Builder);
7656 Builder.AddTextChunk(Key);
7657 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7658 CXCursor_ObjCInstanceMethodDecl));
7659 }
7660 }
7661
7662 // Indexed and unordered accessors
7663 unsigned IndexedGetterPriority = CCP_CodePattern;
7664 unsigned IndexedSetterPriority = CCP_CodePattern;
7665 unsigned UnorderedGetterPriority = CCP_CodePattern;
7666 unsigned UnorderedSetterPriority = CCP_CodePattern;
7667 if (const auto *ObjCPointer
9.1
'ObjCPointer' is null
9.1
'ObjCPointer' is null
9.1
'ObjCPointer' is null
=
10
Taking false branch
7668 Property->getType()->getAs<ObjCObjectPointerType>()) {
9
Assuming the object is not a 'ObjCObjectPointerType'
7669 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
7670 // If this interface type is not provably derived from a known
7671 // collection, penalize the corresponding completions.
7672 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
7673 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
7674 if (!InheritsFromClassNamed(IFace, "NSArray"))
7675 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
7676 }
7677
7678 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
7679 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
7680 if (!InheritsFromClassNamed(IFace, "NSSet"))
7681 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
7682 }
7683 }
7684 } else {
7685 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
7686 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
7687 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
7688 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
7689 }
7690
7691 // Add -(NSUInteger)countOf<key>
7692 if (IsInstanceMethod
10.1
'IsInstanceMethod' is false
10.1
'IsInstanceMethod' is false
10.1
'IsInstanceMethod' is false
&&
7693 (ReturnType.isNull() || ReturnType->isIntegerType())) {
7694 std::string SelectorName = (Twine("countOf") + UpperKey).str();
7695 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7696 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7697 .second) {
7698 if (ReturnType.isNull()) {
7699 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7700 Builder.AddTextChunk("NSUInteger");
7701 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7702 }
7703
7704 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorId->getName()));
7705 Results.AddResult(
7706 Result(Builder.TakeString(),
7707 std::min(IndexedGetterPriority, UnorderedGetterPriority),
7708 CXCursor_ObjCInstanceMethodDecl));
7709 }
7710 }
7711
7712 // Indexed getters
7713 // Add -(id)objectInKeyAtIndex:(NSUInteger)index
7714 if (IsInstanceMethod
10.2
'IsInstanceMethod' is false
10.2
'IsInstanceMethod' is false
10.2
'IsInstanceMethod' is false
&&
7715 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
7716 std::string SelectorName = (Twine("objectIn") + UpperKey + "AtIndex").str();
7717 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7718 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7719 if (ReturnType.isNull()) {
7720 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7721 Builder.AddTextChunk("id");
7722 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7723 }
7724
7725 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7726 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7727 Builder.AddTextChunk("NSUInteger");
7728 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7729 Builder.AddTextChunk("index");
7730 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
7731 CXCursor_ObjCInstanceMethodDecl));
7732 }
7733 }
7734
7735 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
7736 if (IsInstanceMethod
10.3
'IsInstanceMethod' is false
10.3
'IsInstanceMethod' is false
10.3
'IsInstanceMethod' is false
&&
11
Taking false branch
7737 (ReturnType.isNull() ||
7738 (ReturnType->isObjCObjectPointerType() &&
7739 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7740 ReturnType->getAs<ObjCObjectPointerType>()
7741 ->getInterfaceDecl()
7742 ->getName() == "NSArray"))) {
7743 std::string SelectorName = (Twine(Property->getName()) + "AtIndexes").str();
7744 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7745 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7746 if (ReturnType.isNull()) {
7747 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7748 Builder.AddTextChunk("NSArray *");
7749 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7750 }
7751
7752 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7753 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7754 Builder.AddTextChunk("NSIndexSet *");
7755 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7756 Builder.AddTextChunk("indexes");
7757 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
7758 CXCursor_ObjCInstanceMethodDecl));
7759 }
7760 }
7761
7762 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
7763 if (IsInstanceMethod
11.1
'IsInstanceMethod' is false
11.1
'IsInstanceMethod' is false
11.1
'IsInstanceMethod' is false
&& ReturnTypeMatchesVoid) {
7764 std::string SelectorName = (Twine("get") + UpperKey).str();
7765 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName),
7766 &Context.Idents.get("range")};
7767
7768 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7769 if (ReturnType.isNull()) {
7770 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7771 Builder.AddTextChunk("void");
7772 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7773 }
7774
7775 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7776 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7777 Builder.AddPlaceholderChunk("object-type");
7778 Builder.AddTextChunk(" **");
7779 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7780 Builder.AddTextChunk("buffer");
7781 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7782 Builder.AddTypedTextChunk("range:");
7783 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7784 Builder.AddTextChunk("NSRange");
7785 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7786 Builder.AddTextChunk("inRange");
7787 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
7788 CXCursor_ObjCInstanceMethodDecl));
7789 }
7790 }
7791
7792 // Mutable indexed accessors
7793
7794 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
7795 if (IsInstanceMethod
11.2
'IsInstanceMethod' is false
11.2
'IsInstanceMethod' is false
11.2
'IsInstanceMethod' is false
&& ReturnTypeMatchesVoid) {
7796 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
7797 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get("insertObject"),
7798 &Context.Idents.get(SelectorName)};
7799
7800 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7801 if (ReturnType.isNull()) {
7802 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7803 Builder.AddTextChunk("void");
7804 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7805 }
7806
7807 Builder.AddTypedTextChunk("insertObject:");
7808 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7809 Builder.AddPlaceholderChunk("object-type");
7810 Builder.AddTextChunk(" *");
7811 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7812 Builder.AddTextChunk("object");
7813 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7814 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7815 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7816 Builder.AddPlaceholderChunk("NSUInteger");
7817 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7818 Builder.AddTextChunk("index");
7819 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7820 CXCursor_ObjCInstanceMethodDecl));
7821 }
7822 }
7823
7824 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
7825 if (IsInstanceMethod
11.3
'IsInstanceMethod' is false
11.3
'IsInstanceMethod' is false
11.3
'IsInstanceMethod' is false
&& ReturnTypeMatchesVoid) {
7826 std::string SelectorName = (Twine("insert") + UpperKey).str();
7827 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName),
7828 &Context.Idents.get("atIndexes")};
7829
7830 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7831 if (ReturnType.isNull()) {
7832 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7833 Builder.AddTextChunk("void");
7834 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7835 }
7836
7837 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7838 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7839 Builder.AddTextChunk("NSArray *");
7840 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7841 Builder.AddTextChunk("array");
7842 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7843 Builder.AddTypedTextChunk("atIndexes:");
7844 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7845 Builder.AddPlaceholderChunk("NSIndexSet *");
7846 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7847 Builder.AddTextChunk("indexes");
7848 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7849 CXCursor_ObjCInstanceMethodDecl));
7850 }
7851 }
7852
7853 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
7854 if (IsInstanceMethod
11.4
'IsInstanceMethod' is false
11.4
'IsInstanceMethod' is false
11.4
'IsInstanceMethod' is false
&& ReturnTypeMatchesVoid) {
7855 std::string SelectorName =
7856 (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
7857 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7858 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7859 if (ReturnType.isNull()) {
7860 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7861 Builder.AddTextChunk("void");
7862 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7863 }
7864
7865 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7866 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7867 Builder.AddTextChunk("NSUInteger");
7868 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7869 Builder.AddTextChunk("index");
7870 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7871 CXCursor_ObjCInstanceMethodDecl));
7872 }
7873 }
7874
7875 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
7876 if (IsInstanceMethod
11.5
'IsInstanceMethod' is false
11.5
'IsInstanceMethod' is false
11.5
'IsInstanceMethod' is false
&& ReturnTypeMatchesVoid) {
7877 std::string SelectorName = (Twine("remove") + UpperKey + "AtIndexes").str();
7878 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7879 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7880 if (ReturnType.isNull()) {
7881 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7882 Builder.AddTextChunk("void");
7883 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7884 }
7885
7886 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7887 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7888 Builder.AddTextChunk("NSIndexSet *");
7889 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7890 Builder.AddTextChunk("indexes");
7891 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7892 CXCursor_ObjCInstanceMethodDecl));
7893 }
7894 }
7895
7896 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
7897 if (IsInstanceMethod
11.6
'IsInstanceMethod' is false
11.6
'IsInstanceMethod' is false
11.6
'IsInstanceMethod' is false
&& ReturnTypeMatchesVoid) {
7898 std::string SelectorName =
7899 (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
7900 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName),
7901 &Context.Idents.get("withObject")};
7902
7903 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7904 if (ReturnType.isNull()) {
7905 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7906 Builder.AddTextChunk("void");
7907 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7908 }
7909
7910 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7911 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7912 Builder.AddPlaceholderChunk("NSUInteger");
7913 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7914 Builder.AddTextChunk("index");
7915 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7916 Builder.AddTypedTextChunk("withObject:");
7917 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7918 Builder.AddTextChunk("id");
7919 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7920 Builder.AddTextChunk("object");
7921 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7922 CXCursor_ObjCInstanceMethodDecl));
7923 }
7924 }
7925
7926 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
7927 if (IsInstanceMethod
11.7
'IsInstanceMethod' is false
11.7
'IsInstanceMethod' is false
11.7
'IsInstanceMethod' is false
&& ReturnTypeMatchesVoid) {
7928 std::string SelectorName1 =
7929 (Twine("replace") + UpperKey + "AtIndexes").str();
7930 std::string SelectorName2 = (Twine("with") + UpperKey).str();
7931 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName1),
7932 &Context.Idents.get(SelectorName2)};
7933
7934 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7935 if (ReturnType.isNull()) {
7936 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7937 Builder.AddTextChunk("void");
7938 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7939 }
7940
7941 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
7942 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7943 Builder.AddPlaceholderChunk("NSIndexSet *");
7944 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7945 Builder.AddTextChunk("indexes");
7946 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7947 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
7948 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7949 Builder.AddTextChunk("NSArray *");
7950 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7951 Builder.AddTextChunk("array");
7952 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7953 CXCursor_ObjCInstanceMethodDecl));
7954 }
7955 }
7956
7957 // Unordered getters
7958 // - (NSEnumerator *)enumeratorOfKey
7959 if (IsInstanceMethod
11.8
'IsInstanceMethod' is false
11.8
'IsInstanceMethod' is false
11.8
'IsInstanceMethod' is false
&&
12
Taking false branch
7960 (ReturnType.isNull() ||
7961 (ReturnType->isObjCObjectPointerType() &&
7962 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7963 ReturnType->getAs<ObjCObjectPointerType>()
7964 ->getInterfaceDecl()
7965 ->getName() == "NSEnumerator"))) {
7966 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
7967 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7968 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7969 .second) {
7970 if (ReturnType.isNull()) {
7971 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7972 Builder.AddTextChunk("NSEnumerator *");
7973 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7974 }
7975
7976 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7977 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
7978 CXCursor_ObjCInstanceMethodDecl));
7979 }
7980 }
7981
7982 // - (type *)memberOfKey:(type *)object
7983 if (IsInstanceMethod
12.1
'IsInstanceMethod' is false
12.1
'IsInstanceMethod' is false
12.1
'IsInstanceMethod' is false
&&
7984 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
7985 std::string SelectorName = (Twine("memberOf") + UpperKey).str();
7986 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7987 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7988 if (ReturnType.isNull()) {
7989 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7990 Builder.AddPlaceholderChunk("object-type");
7991 Builder.AddTextChunk(" *");
7992 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7993 }
7994
7995 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7996 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7997 if (ReturnType.isNull()) {
7998 Builder.AddPlaceholderChunk("object-type");
7999 Builder.AddTextChunk(" *");
8000 } else {
8001 Builder.AddTextChunk(GetCompletionTypeString(
8002 ReturnType, Context, Policy, Builder.getAllocator()));
8003 }
8004 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8005 Builder.AddTextChunk("object");
8006 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
8007 CXCursor_ObjCInstanceMethodDecl));
8008 }
8009 }
8010
8011 // Mutable unordered accessors
8012 // - (void)addKeyObject:(type *)object
8013 if (IsInstanceMethod
12.2
'IsInstanceMethod' is false
12.2
'IsInstanceMethod' is false
12.2
'IsInstanceMethod' is false
&& ReturnTypeMatchesVoid) {
8014 std::string SelectorName =
8015 (Twine("add") + UpperKey + Twine("Object")).str();
8016 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8017 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8018 if (ReturnType.isNull()) {
8019 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8020 Builder.AddTextChunk("void");
8021 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8022 }
8023
8024 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8025 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8026 Builder.AddPlaceholderChunk("object-type");
8027 Builder.AddTextChunk(" *");
8028 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8029 Builder.AddTextChunk("object");
8030 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
8031 CXCursor_ObjCInstanceMethodDecl));
8032 }
8033 }
8034
8035 // - (void)addKey:(NSSet *)objects
8036 if (IsInstanceMethod
12.3
'IsInstanceMethod' is false
12.3
'IsInstanceMethod' is false
12.3
'IsInstanceMethod' is false
&& ReturnTypeMatchesVoid) {
8037 std::string SelectorName = (Twine("add") + UpperKey).str();
8038 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8039 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8040 if (ReturnType.isNull()) {
8041 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8042 Builder.AddTextChunk("void");
8043 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8044 }
8045
8046 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8047 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8048 Builder.AddTextChunk("NSSet *");
8049 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8050 Builder.AddTextChunk("objects");
8051 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
8052 CXCursor_ObjCInstanceMethodDecl));
8053 }
8054 }
8055
8056 // - (void)removeKeyObject:(type *)object
8057 if (IsInstanceMethod
12.4
'IsInstanceMethod' is false
12.4
'IsInstanceMethod' is false
12.4
'IsInstanceMethod' is false
&& ReturnTypeMatchesVoid) {
8058 std::string SelectorName =
8059 (Twine("remove") + UpperKey + Twine("Object")).str();
8060 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8061 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8062 if (ReturnType.isNull()) {
8063 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8064 Builder.AddTextChunk("void");
8065 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8066 }
8067
8068 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8069 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8070 Builder.AddPlaceholderChunk("object-type");
8071 Builder.AddTextChunk(" *");
8072 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8073 Builder.AddTextChunk("object");
8074 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
8075 CXCursor_ObjCInstanceMethodDecl));
8076 }
8077 }
8078
8079 // - (void)removeKey:(NSSet *)objects
8080 if (IsInstanceMethod
12.5
'IsInstanceMethod' is false
12.5
'IsInstanceMethod' is false
12.5
'IsInstanceMethod' is false
&& ReturnTypeMatchesVoid) {
8081 std::string SelectorName = (Twine("remove") + UpperKey).str();
8082 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8083 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8084 if (ReturnType.isNull()) {
8085 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8086 Builder.AddTextChunk("void");
8087 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8088 }
8089
8090 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8091 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8092 Builder.AddTextChunk("NSSet *");
8093 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8094 Builder.AddTextChunk("objects");
8095 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
8096 CXCursor_ObjCInstanceMethodDecl));
8097 }
8098 }
8099
8100 // - (void)intersectKey:(NSSet *)objects
8101 if (IsInstanceMethod
12.6
'IsInstanceMethod' is false
12.6
'IsInstanceMethod' is false
12.6
'IsInstanceMethod' is false
&& ReturnTypeMatchesVoid) {
8102 std::string SelectorName = (Twine("intersect") + UpperKey).str();
8103 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8104 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8105 if (ReturnType.isNull()) {
8106 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8107 Builder.AddTextChunk("void");
8108 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8109 }
8110
8111 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8112 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8113 Builder.AddTextChunk("NSSet *");
8114 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8115 Builder.AddTextChunk("objects");
8116 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
8117 CXCursor_ObjCInstanceMethodDecl));
8118 }
8119 }
8120
8121 // Key-Value Observing
8122 // + (NSSet *)keyPathsForValuesAffectingKey
8123 if (!IsInstanceMethod
12.7
'IsInstanceMethod' is false
12.7
'IsInstanceMethod' is false
12.7
'IsInstanceMethod' is false
&&
8124 (ReturnType.isNull() ||
13
Calling 'QualType::isNull'
19
Returning from 'QualType::isNull'
8125 (ReturnType->isObjCObjectPointerType() &&
20
Calling 'Type::isObjCObjectPointerType'
23
Returning from 'Type::isObjCObjectPointerType'
8126 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
24
Assuming the object is a 'ObjCObjectPointerType'
25
Assuming the condition is true
8127 ReturnType->getAs<ObjCObjectPointerType>()
26
Assuming the object is not a 'ObjCObjectPointerType'
27
Called C++ object pointer is null
8128 ->getInterfaceDecl()
8129 ->getName() == "NSSet"))) {
8130 std::string SelectorName =
8131 (Twine("keyPathsForValuesAffecting") + UpperKey).str();
8132 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8133 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
8134 .second) {
8135 if (ReturnType.isNull()) {
8136 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8137 Builder.AddTextChunk("NSSet<NSString *> *");
8138 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8139 }
8140
8141 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
8142 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
8143 CXCursor_ObjCClassMethodDecl));
8144 }
8145 }
8146
8147 // + (BOOL)automaticallyNotifiesObserversForKey
8148 if (!IsInstanceMethod &&
8149 (ReturnType.isNull() || ReturnType->isIntegerType() ||
8150 ReturnType->isBooleanType())) {
8151 std::string SelectorName =
8152 (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
8153 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8154 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
8155 .second) {
8156 if (ReturnType.isNull()) {
8157 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8158 Builder.AddTextChunk("BOOL");
8159 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8160 }
8161
8162 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
8163 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
8164 CXCursor_ObjCClassMethodDecl));
8165 }
8166 }
8167}
8168
8169void Sema::CodeCompleteObjCMethodDecl(Scope *S, Optional<bool> IsInstanceMethod,
8170 ParsedType ReturnTy) {
8171 // Determine the return type of the method we're declaring, if
8172 // provided.
8173 QualType ReturnType = GetTypeFromParser(ReturnTy);
8174 Decl *IDecl = nullptr;
8175 if (CurContext->isObjCContainer()) {
8176 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
8177 IDecl = OCD;
8178 }
8179 // Determine where we should start searching for methods.
8180 ObjCContainerDecl *SearchDecl = nullptr;
8181 bool IsInImplementation = false;
8182 if (Decl *D = IDecl) {
8183 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
8184 SearchDecl = Impl->getClassInterface();
8185 IsInImplementation = true;
8186 } else if (ObjCCategoryImplDecl *CatImpl =
8187 dyn_cast<ObjCCategoryImplDecl>(D)) {
8188 SearchDecl = CatImpl->getCategoryDecl();
8189 IsInImplementation = true;
8190 } else
8191 SearchDecl = dyn_cast<ObjCContainerDecl>(D);
8192 }
8193
8194 if (!SearchDecl && S) {
8195 if (DeclContext *DC = S->getEntity())
8196 SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
8197 }
8198
8199 if (!SearchDecl) {
8200 HandleCodeCompleteResults(this, CodeCompleter,
8201 CodeCompletionContext::CCC_Other, nullptr, 0);
8202 return;
8203 }
8204
8205 // Find all of the methods that we could declare/implement here.
8206 KnownMethodsMap KnownMethods;
8207 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod, ReturnType,
8208 KnownMethods);
8209
8210 // Add declarations or definitions for each of the known methods.
8211 typedef CodeCompletionResult Result;
8212 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8213 CodeCompleter->getCodeCompletionTUInfo(),
8214 CodeCompletionContext::CCC_Other);
8215 Results.EnterNewScope();
8216 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
8217 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
8218 MEnd = KnownMethods.end();
8219 M != MEnd; ++M) {
8220 ObjCMethodDecl *Method = M->second.getPointer();
8221 CodeCompletionBuilder Builder(Results.getAllocator(),
8222 Results.getCodeCompletionTUInfo());
8223
8224 // Add the '-'/'+' prefix if it wasn't provided yet.
8225 if (!IsInstanceMethod) {
8226 Builder.AddTextChunk(Method->isInstanceMethod() ? "-" : "+");
8227 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8228 }
8229
8230 // If the result type was not already provided, add it to the
8231 // pattern as (type).
8232 if (ReturnType.isNull()) {
8233 QualType ResTy = Method->getSendResultType().stripObjCKindOfType(Context);
8234 AttributedType::stripOuterNullability(ResTy);
8235 AddObjCPassingTypeChunk(ResTy, Method->getObjCDeclQualifier(), Context,
8236 Policy, Builder);
8237 }
8238
8239 Selector Sel = Method->getSelector();
8240
8241 // Add the first part of the selector to the pattern.
8242 Builder.AddTypedTextChunk(
8243 Builder.getAllocator().CopyString(Sel.getNameForSlot(0)));
8244
8245 // Add parameters to the pattern.
8246 unsigned I = 0;
8247 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
8248 PEnd = Method->param_end();
8249 P != PEnd; (void)++P, ++I) {
8250 // Add the part of the selector name.
8251 if (I == 0)
8252 Builder.AddTypedTextChunk(":");
8253 else if (I < Sel.getNumArgs()) {
8254 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8255 Builder.AddTypedTextChunk(
8256 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
8257 } else
8258 break;
8259
8260 // Add the parameter type.
8261 QualType ParamType;
8262 if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
8263 ParamType = (*P)->getType();
8264 else
8265 ParamType = (*P)->getOriginalType();
8266 ParamType = ParamType.substObjCTypeArgs(
8267 Context, {}, ObjCSubstitutionContext::Parameter);
8268 AttributedType::stripOuterNullability(ParamType);
8269 AddObjCPassingTypeChunk(ParamType, (*P)->getObjCDeclQualifier(), Context,
8270 Policy, Builder);
8271
8272 if (IdentifierInfo *Id = (*P)->getIdentifier())
8273 Builder.AddTextChunk(Builder.getAllocator().CopyString(Id->getName()));
8274 }
8275
8276 if (Method->isVariadic()) {
8277 if (Method->param_size() > 0)
8278 Builder.AddChunk(CodeCompletionString::CK_Comma);
8279 Builder.AddTextChunk("...");
8280 }
8281
8282 if (IsInImplementation && Results.includeCodePatterns()) {
8283 // We will be defining the method here, so add a compound statement.
8284 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8285 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
8286 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
8287 if (!Method->getReturnType()->isVoidType()) {
8288 // If the result type is not void, add a return clause.
8289 Builder.AddTextChunk("return");
8290 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8291 Builder.AddPlaceholderChunk("expression");
8292 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
8293 } else
8294 Builder.AddPlaceholderChunk("statements");
8295
8296 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
8297 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
8298 }
8299
8300 unsigned Priority = CCP_CodePattern;
8301 auto R = Result(Builder.TakeString(), Method, Priority);
8302 if (!M->second.getInt())
8303 setInBaseClass(R);
8304 Results.AddResult(std::move(R));
8305 }
8306
8307 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
8308 // the properties in this class and its categories.
8309 if (Context.getLangOpts().ObjC) {
8310 SmallVector<ObjCContainerDecl *, 4> Containers;
8311 Containers.push_back(SearchDecl);
8312
8313 VisitedSelectorSet KnownSelectors;
8314 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
8315 MEnd = KnownMethods.end();
8316 M != MEnd; ++M)
8317 KnownSelectors.insert(M->first);
8318
8319 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
8320 if (!IFace)
8321 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
8322 IFace = Category->getClassInterface();
8323
8324 if (IFace)
8325 for (auto *Cat : IFace->visible_categories())
8326 Containers.push_back(Cat);
8327
8328 if (IsInstanceMethod) {
8329 for (unsigned I = 0, N = Containers.size(); I != N; ++I)
8330 for (auto *P : Containers[I]->instance_properties())
8331 AddObjCKeyValueCompletions(P, *IsInstanceMethod, ReturnType, Context,
8332 KnownSelectors, Results);
8333 }
8334 }
8335
8336 Results.ExitScope();
8337
8338 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8339 Results.data(), Results.size());
8340}
8341
8342void Sema::CodeCompleteObjCMethodDeclSelector(
8343 Scope *S, bool IsInstanceMethod, bool AtParameterName, ParsedType ReturnTy,
8344 ArrayRef<IdentifierInfo *> SelIdents) {
8345 // If we have an external source, load the entire class method
8346 // pool from the AST file.
8347 if (ExternalSource) {
8348 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); I != N;
8349 ++I) {
8350 Selector Sel = ExternalSource->GetExternalSelector(I);
8351 if (Sel.isNull() || MethodPool.count(Sel))
8352 continue;
8353
8354 ReadMethodPool(Sel);
8355 }
8356 }
8357
8358 // Build the set of methods we can see.
8359 typedef CodeCompletionResult Result;
8360 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8361 CodeCompleter->getCodeCompletionTUInfo(),
8362 CodeCompletionContext::CCC_Other);
8363
8364 if (ReturnTy)
8365 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
8366
8367 Results.EnterNewScope();
8368 for (GlobalMethodPool::iterator M = MethodPool.begin(),
8369 MEnd = MethodPool.end();
8370 M != MEnd; ++M) {
8371 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first
8372 : &M->second.second;
8373 MethList && MethList->getMethod(); MethList = MethList->getNext()) {
8374 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
8375 continue;
8376
8377 if (AtParameterName) {
8378 // Suggest parameter names we've seen before.
8379 unsigned NumSelIdents = SelIdents.size();
8380 if (NumSelIdents &&
8381 NumSelIdents <= MethList->getMethod()->param_size()) {
8382 ParmVarDecl *Param =
8383 MethList->getMethod()->parameters()[NumSelIdents - 1];
8384 if (Param->getIdentifier()) {
8385 CodeCompletionBuilder Builder(Results.getAllocator(),
8386 Results.getCodeCompletionTUInfo());
8387 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
8388 Param->getIdentifier()->getName()));
8389 Results.AddResult(Builder.TakeString());
8390 }
8391 }
8392
8393 continue;
8394 }
8395
8396 Result R(MethList->getMethod(),
8397 Results.getBasePriority(MethList->getMethod()), nullptr);
8398 R.StartParameter = SelIdents.size();
8399 R.AllParametersAreInformative = false;
8400 R.DeclaringEntity = true;
8401 Results.MaybeAddResult(R, CurContext);
8402 }
8403 }
8404
8405 Results.ExitScope();
8406
8407 if (!AtParameterName && !SelIdents.empty() &&
8408 SelIdents.front()->getName().startswith("init")) {
8409 for (const auto &M : PP.macros()) {
8410 if (M.first->getName() != "NS_DESIGNATED_INITIALIZER")
8411 continue;
8412 Results.EnterNewScope();
8413 CodeCompletionBuilder Builder(Results.getAllocator(),
8414 Results.getCodeCompletionTUInfo());
8415 Builder.AddTypedTextChunk(
8416 Builder.getAllocator().CopyString(M.first->getName()));
8417 Results.AddResult(CodeCompletionResult(Builder.TakeString(), CCP_Macro,
8418 CXCursor_MacroDefinition));
8419 Results.ExitScope();
8420 }
8421 }
8422
8423 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8424 Results.data(), Results.size());
8425}
8426
8427void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
8428 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8429 CodeCompleter->getCodeCompletionTUInfo(),
8430 CodeCompletionContext::CCC_PreprocessorDirective);
8431 Results.EnterNewScope();
8432
8433 // #if <condition>
8434 CodeCompletionBuilder Builder(Results.getAllocator(),
8435 Results.getCodeCompletionTUInfo());
8436 Builder.AddTypedTextChunk("if");
8437 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8438 Builder.AddPlaceholderChunk("condition");
8439 Results.AddResult(Builder.TakeString());
8440
8441 // #ifdef <macro>
8442 Builder.AddTypedTextChunk("ifdef");
8443 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8444 Builder.AddPlaceholderChunk("macro");
8445 Results.AddResult(Builder.TakeString());
8446
8447 // #ifndef <macro>
8448 Builder.AddTypedTextChunk("ifndef");
8449 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8450 Builder.AddPlaceholderChunk("macro");
8451 Results.AddResult(Builder.TakeString());
8452
8453 if (InConditional) {
8454 // #elif <condition>
8455 Builder.AddTypedTextChunk("elif");
8456 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8457 Builder.AddPlaceholderChunk("condition");
8458 Results.AddResult(Builder.TakeString());
8459
8460 // #else
8461 Builder.AddTypedTextChunk("else");
8462 Results.AddResult(Builder.TakeString());
8463
8464 // #endif
8465 Builder.AddTypedTextChunk("endif");
8466 Results.AddResult(Builder.TakeString());
8467 }
8468
8469 // #include "header"
8470 Builder.AddTypedTextChunk("include");
8471 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8472 Builder.AddTextChunk("\"");
8473 Builder.AddPlaceholderChunk("header");
8474 Builder.AddTextChunk("\"");
8475 Results.AddResult(Builder.TakeString());
8476
8477 // #include <header>
8478 Builder.AddTypedTextChunk("include");
8479 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8480 Builder.AddTextChunk("<");
8481 Builder.AddPlaceholderChunk("header");
8482 Builder.AddTextChunk(">");
8483 Results.AddResult(Builder.TakeString());
8484
8485 // #define <macro>
8486 Builder.AddTypedTextChunk("define");
8487 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8488 Builder.AddPlaceholderChunk("macro");
8489 Results.AddResult(Builder.TakeString());
8490
8491 // #define <macro>(<args>)
8492 Builder.AddTypedTextChunk("define");
8493 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8494 Builder.AddPlaceholderChunk("macro");
8495 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8496 Builder.AddPlaceholderChunk("args");
8497 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8498 Results.AddResult(Builder.TakeString());
8499
8500 // #undef <macro>
8501 Builder.AddTypedTextChunk("undef");
8502 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8503 Builder.AddPlaceholderChunk("macro");
8504 Results.AddResult(Builder.TakeString());
8505
8506 // #line <number>
8507 Builder.AddTypedTextChunk("line");
8508 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8509 Builder.AddPlaceholderChunk("number");
8510 Results.AddResult(Builder.TakeString());
8511
8512 // #line <number> "filename"
8513 Builder.AddTypedTextChunk("line");
8514 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8515 Builder.AddPlaceholderChunk("number");
8516 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8517 Builder.AddTextChunk("\"");
8518 Builder.AddPlaceholderChunk("filename");
8519 Builder.AddTextChunk("\"");
8520 Results.AddResult(Builder.TakeString());
8521
8522 // #error <message>
8523 Builder.AddTypedTextChunk("error");
8524 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8525 Builder.AddPlaceholderChunk("message");
8526 Results.AddResult(Builder.TakeString());
8527
8528 // #pragma <arguments>
8529 Builder.AddTypedTextChunk("pragma");
8530 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8531 Builder.AddPlaceholderChunk("arguments");
8532 Results.AddResult(Builder.TakeString());
8533
8534 if (getLangOpts().ObjC) {
8535 // #import "header"
8536 Builder.AddTypedTextChunk("import");
8537 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8538 Builder.AddTextChunk("\"");
8539 Builder.AddPlaceholderChunk("header");
8540 Builder.AddTextChunk("\"");
8541 Results.AddResult(Builder.TakeString());
8542
8543 // #import <header>
8544 Builder.AddTypedTextChunk("import");
8545 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8546 Builder.AddTextChunk("<");
8547 Builder.AddPlaceholderChunk("header");
8548 Builder.AddTextChunk(">");
8549 Results.AddResult(Builder.TakeString());
8550 }
8551
8552 // #include_next "header"
8553 Builder.AddTypedTextChunk("include_next");
8554 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8555 Builder.AddTextChunk("\"");
8556 Builder.AddPlaceholderChunk("header");
8557 Builder.AddTextChunk("\"");
8558 Results.AddResult(Builder.TakeString());
8559
8560 // #include_next <header>
8561 Builder.AddTypedTextChunk("include_next");
8562 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8563 Builder.AddTextChunk("<");
8564 Builder.AddPlaceholderChunk("header");
8565 Builder.AddTextChunk(">");
8566 Results.AddResult(Builder.TakeString());
8567
8568 // #warning <message>
8569 Builder.AddTypedTextChunk("warning");
8570 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8571 Builder.AddPlaceholderChunk("message");
8572 Results.AddResult(Builder.TakeString());
8573
8574 // Note: #ident and #sccs are such crazy anachronisms that we don't provide
8575 // completions for them. And __include_macros is a Clang-internal extension
8576 // that we don't want to encourage anyone to use.
8577
8578 // FIXME: we don't support #assert or #unassert, so don't suggest them.
8579 Results.ExitScope();
8580
8581 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8582 Results.data(), Results.size());
8583}
8584
8585void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
8586 CodeCompleteOrdinaryName(S, S->getFnParent() ? Sema::PCC_RecoveryInFunction
8587 : Sema::PCC_Namespace);
8588}
8589
8590void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
8591 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8592 CodeCompleter->getCodeCompletionTUInfo(),
8593 IsDefinition ? CodeCompletionContext::CCC_MacroName
8594 : CodeCompletionContext::CCC_MacroNameUse);
8595 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
8596 // Add just the names of macros, not their arguments.
8597 CodeCompletionBuilder Builder(Results.getAllocator(),
8598 Results.getCodeCompletionTUInfo());
8599 Results.EnterNewScope();
8600 for (Preprocessor::macro_iterator M = PP.macro_begin(),
8601 MEnd = PP.macro_end();
8602 M != MEnd; ++M) {
8603 Builder.AddTypedTextChunk(
8604 Builder.getAllocator().CopyString(M->first->getName()));
8605 Results.AddResult(CodeCompletionResult(
8606 Builder.TakeString(), CCP_CodePattern, CXCursor_MacroDefinition));
8607 }
8608 Results.ExitScope();
8609 } else if (IsDefinition) {
8610 // FIXME: Can we detect when the user just wrote an include guard above?
8611 }
8612
8613 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8614 Results.data(), Results.size());
8615}
8616
8617void Sema::CodeCompletePreprocessorExpression() {
8618 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8619 CodeCompleter->getCodeCompletionTUInfo(),
8620 CodeCompletionContext::CCC_PreprocessorExpression);
8621
8622 if (!CodeCompleter || CodeCompleter->includeMacros())
8623 AddMacroResults(PP, Results,
8624 !CodeCompleter || CodeCompleter->loadExternal(), true);
8625
8626 // defined (<macro>)
8627 Results.EnterNewScope();
8628 CodeCompletionBuilder Builder(Results.getAllocator(),
8629 Results.getCodeCompletionTUInfo());
8630 Builder.AddTypedTextChunk("defined");
8631 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8632 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8633 Builder.AddPlaceholderChunk("macro");
8634 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8635 Results.AddResult(Builder.TakeString());
8636 Results.ExitScope();
8637
8638 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8639 Results.data(), Results.size());
8640}
8641
8642void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
8643 IdentifierInfo *Macro,
8644 MacroInfo *MacroInfo,
8645 unsigned Argument) {
8646 // FIXME: In the future, we could provide "overload" results, much like we
8647 // do for function calls.
8648
8649 // Now just ignore this. There will be another code-completion callback
8650 // for the expanded tokens.
8651}
8652
8653// This handles completion inside an #include filename, e.g. #include <foo/ba
8654// We look for the directory "foo" under each directory on the include path,
8655// list its files, and reassemble the appropriate #include.
8656void Sema::CodeCompleteIncludedFile(llvm::StringRef Dir, bool Angled) {
8657 // RelDir should use /, but unescaped \ is possible on windows!
8658 // Our completions will normalize to / for simplicity, this case is rare.
8659 std::string RelDir = llvm::sys::path::convert_to_slash(Dir);
8660 // We need the native slashes for the actual file system interactions.
8661 SmallString<128> NativeRelDir = StringRef(RelDir);
8662 llvm::sys::path::native(NativeRelDir);
8663 llvm::vfs::FileSystem &FS =
8664 getSourceManager().getFileManager().getVirtualFileSystem();
8665
8666 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8667 CodeCompleter->getCodeCompletionTUInfo(),
8668 CodeCompletionContext::CCC_IncludedFile);
8669 llvm::DenseSet<StringRef> SeenResults; // To deduplicate results.
8670
8671 // Helper: adds one file or directory completion result.
8672 auto AddCompletion = [&](StringRef Filename, bool IsDirectory) {
8673 SmallString<64> TypedChunk = Filename;
8674 // Directory completion is up to the slash, e.g. <sys/
8675 TypedChunk.push_back(IsDirectory ? '/' : Angled ? '>' : '"');
8676 auto R = SeenResults.insert(TypedChunk);
8677 if (R.second) { // New completion
8678 const char *InternedTyped = Results.getAllocator().CopyString(TypedChunk);
8679 *R.first = InternedTyped; // Avoid dangling StringRef.
8680 CodeCompletionBuilder Builder(CodeCompleter->getAllocator(),
8681 CodeCompleter->getCodeCompletionTUInfo());
8682 Builder.AddTypedTextChunk(InternedTyped);
8683 // The result is a "Pattern", which is pretty opaque.
8684 // We may want to include the real filename to allow smart ranking.
8685 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
8686 }
8687 };
8688
8689 // Helper: scans IncludeDir for nice files, and adds results for each.
8690 auto AddFilesFromIncludeDir = [&](StringRef IncludeDir,
8691 bool IsSystem,
8692 DirectoryLookup::LookupType_t LookupType) {
8693 llvm::SmallString<128> Dir = IncludeDir;
8694 if (!NativeRelDir.empty()) {
8695 if (LookupType == DirectoryLookup::LT_Framework) {
8696 // For a framework dir, #include <Foo/Bar/> actually maps to
8697 // a path of Foo.framework/Headers/Bar/.
8698 auto Begin = llvm::sys::path::begin(NativeRelDir);
8699 auto End = llvm::sys::path::end(NativeRelDir);
8700
8701 llvm::sys::path::append(Dir, *Begin + ".framework", "Headers");
8702 llvm::sys::path::append(Dir, ++Begin, End);
8703 } else {
8704 llvm::sys::path::append(Dir, NativeRelDir);
8705 }
8706 }
8707
8708 std::error_code EC;
8709 unsigned Count = 0;
8710 for (auto It = FS.dir_begin(Dir, EC);
8711 !EC && It != llvm::vfs::directory_iterator(); It.increment(EC)) {
8712 if (++Count == 2500) // If we happen to hit a huge directory,
8713 break; // bail out early so we're not too slow.
8714 StringRef Filename = llvm::sys::path::filename(It->path());
8715 switch (It->type()) {
8716 case llvm::sys::fs::file_type::directory_file:
8717 // All entries in a framework directory must have a ".framework" suffix,
8718 // but the suffix does not appear in the source code's include/import.
8719 if (LookupType == DirectoryLookup::LT_Framework &&
8720 NativeRelDir.empty() && !Filename.consume_back(".framework"))
8721 break;
8722
8723 AddCompletion(Filename, /*IsDirectory=*/true);
8724 break;
8725 case llvm::sys::fs::file_type::regular_file:
8726 // Only files that really look like headers. (Except in system dirs).
8727 if (!IsSystem) {
8728 // Header extensions from Types.def, which we can't depend on here.
8729 if (!(Filename.endswith_lower(".h") ||
8730 Filename.endswith_lower(".hh") ||
8731 Filename.endswith_lower(".hpp") ||
8732 Filename.endswith_lower(".inc")))
8733 break;
8734 }
8735 AddCompletion(Filename, /*IsDirectory=*/false);
8736 break;
8737 default:
8738 break;
8739 }
8740 }
8741 };
8742
8743 // Helper: adds results relative to IncludeDir, if possible.
8744 auto AddFilesFromDirLookup = [&](const DirectoryLookup &IncludeDir,
8745 bool IsSystem) {
8746 switch (IncludeDir.getLookupType()) {
8747 case DirectoryLookup::LT_HeaderMap:
8748 // header maps are not (currently) enumerable.
8749 break;
8750 case DirectoryLookup::LT_NormalDir:
8751 AddFilesFromIncludeDir(IncludeDir.getDir()->getName(), IsSystem,
8752 DirectoryLookup::LT_NormalDir);
8753 break;
8754 case DirectoryLookup::LT_Framework:
8755 AddFilesFromIncludeDir(IncludeDir.getFrameworkDir()->getName(), IsSystem,
8756 DirectoryLookup::LT_Framework);
8757 break;
8758 }
8759 };
8760
8761 // Finally with all our helpers, we can scan the include path.
8762 // Do this in standard order so deduplication keeps the right file.
8763 // (In case we decide to add more details to the results later).
8764 const auto &S = PP.getHeaderSearchInfo();
8765 using llvm::make_range;
8766 if (!Angled) {
8767 // The current directory is on the include path for "quoted" includes.
8768 auto *CurFile = PP.getCurrentFileLexer()->getFileEntry();
8769 if (CurFile && CurFile->getDir())
8770 AddFilesFromIncludeDir(CurFile->getDir()->getName(), false,
8771 DirectoryLookup::LT_NormalDir);
8772 for (const auto &D : make_range(S.quoted_dir_begin(), S.quoted_dir_end()))
8773 AddFilesFromDirLookup(D, false);
8774 }
8775 for (const auto &D : make_range(S.angled_dir_begin(), S.angled_dir_end()))
8776 AddFilesFromDirLookup(D, false);
8777 for (const auto &D : make_range(S.system_dir_begin(), S.system_dir_end()))
8778 AddFilesFromDirLookup(D, true);
8779
8780 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8781 Results.data(), Results.size());
8782}
8783
8784void Sema::CodeCompleteNaturalLanguage() {
8785 HandleCodeCompleteResults(this, CodeCompleter,
8786 CodeCompletionContext::CCC_NaturalLanguage, nullptr,
8787 0);
8788}
8789
8790void Sema::CodeCompleteAvailabilityPlatformName() {
8791 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8792 CodeCompleter->getCodeCompletionTUInfo(),
8793 CodeCompletionContext::CCC_Other);
8794 Results.EnterNewScope();
8795 static const char *Platforms[] = {"macOS", "iOS", "watchOS", "tvOS"};
8796 for (const char *Platform : llvm::makeArrayRef(Platforms)) {
8797 Results.AddResult(CodeCompletionResult(Platform));
8798 Results.AddResult(CodeCompletionResult(Results.getAllocator().CopyString(
8799 Twine(Platform) + "ApplicationExtension")));
8800 }
8801 Results.ExitScope();
8802 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8803 Results.data(), Results.size());
8804}
8805
8806void Sema::GatherGlobalCodeCompletions(
8807 CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo,
8808 SmallVectorImpl<CodeCompletionResult> &Results) {
8809 ResultBuilder Builder(*this, Allocator, CCTUInfo,
8810 CodeCompletionContext::CCC_Recovery);
8811 if (!CodeCompleter || CodeCompleter->includeGlobals()) {
8812 CodeCompletionDeclConsumer Consumer(Builder,
8813 Context.getTranslationUnitDecl());
8814 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
8815 Consumer,
8816 !CodeCompleter || CodeCompleter->loadExternal());
8817 }
8818
8819 if (!CodeCompleter || CodeCompleter->includeMacros())
8820 AddMacroResults(PP, Builder,
8821 !CodeCompleter || CodeCompleter->loadExternal(), true);
8822
8823 Results.clear();
8824 Results.insert(Results.end(), Builder.data(),
8825 Builder.data() + Builder.size());
8826}

/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h

1//===- Type.h - C Language Family Type Representation -----------*- 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/// \file
10/// C Language Family Type Representation
11///
12/// This file defines the clang::Type interface and subclasses, used to
13/// represent types for languages in the C family.
14//
15//===----------------------------------------------------------------------===//
16
17#ifndef LLVM_CLANG_AST_TYPE_H
18#define LLVM_CLANG_AST_TYPE_H
19
20#include "clang/AST/NestedNameSpecifier.h"
21#include "clang/AST/TemplateName.h"
22#include "clang/Basic/AddressSpaces.h"
23#include "clang/Basic/AttrKinds.h"
24#include "clang/Basic/Diagnostic.h"
25#include "clang/Basic/ExceptionSpecificationType.h"
26#include "clang/Basic/LLVM.h"
27#include "clang/Basic/Linkage.h"
28#include "clang/Basic/PartialDiagnostic.h"
29#include "clang/Basic/SourceLocation.h"
30#include "clang/Basic/Specifiers.h"
31#include "clang/Basic/Visibility.h"
32#include "llvm/ADT/APInt.h"
33#include "llvm/ADT/APSInt.h"
34#include "llvm/ADT/ArrayRef.h"
35#include "llvm/ADT/FoldingSet.h"
36#include "llvm/ADT/None.h"
37#include "llvm/ADT/Optional.h"
38#include "llvm/ADT/PointerIntPair.h"
39#include "llvm/ADT/PointerUnion.h"
40#include "llvm/ADT/StringRef.h"
41#include "llvm/ADT/Twine.h"
42#include "llvm/ADT/iterator_range.h"
43#include "llvm/Support/Casting.h"
44#include "llvm/Support/Compiler.h"
45#include "llvm/Support/ErrorHandling.h"
46#include "llvm/Support/PointerLikeTypeTraits.h"
47#include "llvm/Support/type_traits.h"
48#include "llvm/Support/TrailingObjects.h"
49#include <cassert>
50#include <cstddef>
51#include <cstdint>
52#include <cstring>
53#include <string>
54#include <type_traits>
55#include <utility>
56
57namespace clang {
58
59class ExtQuals;
60class QualType;
61class TagDecl;
62class Type;
63
64enum {
65 TypeAlignmentInBits = 4,
66 TypeAlignment = 1 << TypeAlignmentInBits
67};
68
69namespace serialization {
70 template <class T> class AbstractTypeReader;
71 template <class T> class AbstractTypeWriter;
72}
73
74} // namespace clang
75
76namespace llvm {
77
78 template <typename T>
79 struct PointerLikeTypeTraits;
80 template<>
81 struct PointerLikeTypeTraits< ::clang::Type*> {
82 static inline void *getAsVoidPointer(::clang::Type *P) { return P; }
83
84 static inline ::clang::Type *getFromVoidPointer(void *P) {
85 return static_cast< ::clang::Type*>(P);
86 }
87
88 enum { NumLowBitsAvailable = clang::TypeAlignmentInBits };
89 };
90
91 template<>
92 struct PointerLikeTypeTraits< ::clang::ExtQuals*> {
93 static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; }
94
95 static inline ::clang::ExtQuals *getFromVoidPointer(void *P) {
96 return static_cast< ::clang::ExtQuals*>(P);
97 }
98
99 enum { NumLowBitsAvailable = clang::TypeAlignmentInBits };
100 };
101
102} // namespace llvm
103
104namespace clang {
105
106class ASTContext;
107template <typename> class CanQual;
108class CXXRecordDecl;
109class DeclContext;
110class EnumDecl;
111class Expr;
112class ExtQualsTypeCommonBase;
113class FunctionDecl;
114class IdentifierInfo;
115class NamedDecl;
116class ObjCInterfaceDecl;
117class ObjCProtocolDecl;
118class ObjCTypeParamDecl;
119struct PrintingPolicy;
120class RecordDecl;
121class Stmt;
122class TagDecl;
123class TemplateArgument;
124class TemplateArgumentListInfo;
125class TemplateArgumentLoc;
126class TemplateTypeParmDecl;
127class TypedefNameDecl;
128class UnresolvedUsingTypenameDecl;
129
130using CanQualType = CanQual<Type>;
131
132// Provide forward declarations for all of the *Type classes.
133#define TYPE(Class, Base) class Class##Type;
134#include "clang/AST/TypeNodes.inc"
135
136/// The collection of all-type qualifiers we support.
137/// Clang supports five independent qualifiers:
138/// * C99: const, volatile, and restrict
139/// * MS: __unaligned
140/// * Embedded C (TR18037): address spaces
141/// * Objective C: the GC attributes (none, weak, or strong)
142class Qualifiers {
143public:
144 enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ.
145 Const = 0x1,
146 Restrict = 0x2,
147 Volatile = 0x4,
148 CVRMask = Const | Volatile | Restrict
149 };
150
151 enum GC {
152 GCNone = 0,
153 Weak,
154 Strong
155 };
156
157 enum ObjCLifetime {
158 /// There is no lifetime qualification on this type.
159 OCL_None,
160
161 /// This object can be modified without requiring retains or
162 /// releases.
163 OCL_ExplicitNone,
164
165 /// Assigning into this object requires the old value to be
166 /// released and the new value to be retained. The timing of the
167 /// release of the old value is inexact: it may be moved to
168 /// immediately after the last known point where the value is
169 /// live.
170 OCL_Strong,
171
172 /// Reading or writing from this object requires a barrier call.
173 OCL_Weak,
174
175 /// Assigning into this object requires a lifetime extension.
176 OCL_Autoreleasing
177 };
178
179 enum {
180 /// The maximum supported address space number.
181 /// 23 bits should be enough for anyone.
182 MaxAddressSpace = 0x7fffffu,
183
184 /// The width of the "fast" qualifier mask.
185 FastWidth = 3,
186
187 /// The fast qualifier mask.
188 FastMask = (1 << FastWidth) - 1
189 };
190
191 /// Returns the common set of qualifiers while removing them from
192 /// the given sets.
193 static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) {
194 // If both are only CVR-qualified, bit operations are sufficient.
195 if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) {
196 Qualifiers Q;
197 Q.Mask = L.Mask & R.Mask;
198 L.Mask &= ~Q.Mask;
199 R.Mask &= ~Q.Mask;
200 return Q;
201 }
202
203 Qualifiers Q;
204 unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers();
205 Q.addCVRQualifiers(CommonCRV);
206 L.removeCVRQualifiers(CommonCRV);
207 R.removeCVRQualifiers(CommonCRV);
208
209 if (L.getObjCGCAttr() == R.getObjCGCAttr()) {
210 Q.setObjCGCAttr(L.getObjCGCAttr());
211 L.removeObjCGCAttr();
212 R.removeObjCGCAttr();
213 }
214
215 if (L.getObjCLifetime() == R.getObjCLifetime()) {
216 Q.setObjCLifetime(L.getObjCLifetime());
217 L.removeObjCLifetime();
218 R.removeObjCLifetime();
219 }
220
221 if (L.getAddressSpace() == R.getAddressSpace()) {
222 Q.setAddressSpace(L.getAddressSpace());
223 L.removeAddressSpace();
224 R.removeAddressSpace();
225 }
226 return Q;
227 }
228
229 static Qualifiers fromFastMask(unsigned Mask) {
230 Qualifiers Qs;
231 Qs.addFastQualifiers(Mask);
232 return Qs;
233 }
234
235 static Qualifiers fromCVRMask(unsigned CVR) {
236 Qualifiers Qs;
237 Qs.addCVRQualifiers(CVR);
238 return Qs;
239 }
240
241 static Qualifiers fromCVRUMask(unsigned CVRU) {
242 Qualifiers Qs;
243 Qs.addCVRUQualifiers(CVRU);
244 return Qs;
245 }
246
247 // Deserialize qualifiers from an opaque representation.
248 static Qualifiers fromOpaqueValue(unsigned opaque) {
249 Qualifiers Qs;
250 Qs.Mask = opaque;
251 return Qs;
252 }
253
254 // Serialize these qualifiers into an opaque representation.
255 unsigned getAsOpaqueValue() const {
256 return Mask;
257 }
258
259 bool hasConst() const { return Mask & Const; }
260 bool hasOnlyConst() const { return Mask == Const; }
261 void removeConst() { Mask &= ~Const; }
262 void addConst() { Mask |= Const; }
263
264 bool hasVolatile() const { return Mask & Volatile; }
265 bool hasOnlyVolatile() const { return Mask == Volatile; }
266 void removeVolatile() { Mask &= ~Volatile; }
267 void addVolatile() { Mask |= Volatile; }
268
269 bool hasRestrict() const { return Mask & Restrict; }
270 bool hasOnlyRestrict() const { return Mask == Restrict; }
271 void removeRestrict() { Mask &= ~Restrict; }
272 void addRestrict() { Mask |= Restrict; }
273
274 bool hasCVRQualifiers() const { return getCVRQualifiers(); }
275 unsigned getCVRQualifiers() const { return Mask & CVRMask; }
276 unsigned getCVRUQualifiers() const { return Mask & (CVRMask | UMask); }
277
278 void setCVRQualifiers(unsigned mask) {
279 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 279, __PRETTY_FUNCTION__))
;
280 Mask = (Mask & ~CVRMask) | mask;
281 }
282 void removeCVRQualifiers(unsigned mask) {
283 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 283, __PRETTY_FUNCTION__))
;
284 Mask &= ~mask;
285 }
286 void removeCVRQualifiers() {
287 removeCVRQualifiers(CVRMask);
288 }
289 void addCVRQualifiers(unsigned mask) {
290 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 290, __PRETTY_FUNCTION__))
;
291 Mask |= mask;
292 }
293 void addCVRUQualifiers(unsigned mask) {
294 assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits")((!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask & ~UMask) && \"bitmask contains non-CVRU bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 294, __PRETTY_FUNCTION__))
;
295 Mask |= mask;
296 }
297
298 bool hasUnaligned() const { return Mask & UMask; }
299 void setUnaligned(bool flag) {
300 Mask = (Mask & ~UMask) | (flag ? UMask : 0);
301 }
302 void removeUnaligned() { Mask &= ~UMask; }
303 void addUnaligned() { Mask |= UMask; }
304
305 bool hasObjCGCAttr() const { return Mask & GCAttrMask; }
306 GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); }
307 void setObjCGCAttr(GC type) {
308 Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift);
309 }
310 void removeObjCGCAttr() { setObjCGCAttr(GCNone); }
311 void addObjCGCAttr(GC type) {
312 assert(type)((type) ? static_cast<void> (0) : __assert_fail ("type"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 312, __PRETTY_FUNCTION__))
;
313 setObjCGCAttr(type);
314 }
315 Qualifiers withoutObjCGCAttr() const {
316 Qualifiers qs = *this;
317 qs.removeObjCGCAttr();
318 return qs;
319 }
320 Qualifiers withoutObjCLifetime() const {
321 Qualifiers qs = *this;
322 qs.removeObjCLifetime();
323 return qs;
324 }
325 Qualifiers withoutAddressSpace() const {
326 Qualifiers qs = *this;
327 qs.removeAddressSpace();
328 return qs;
329 }
330
331 bool hasObjCLifetime() const { return Mask & LifetimeMask; }
332 ObjCLifetime getObjCLifetime() const {
333 return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
334 }
335 void setObjCLifetime(ObjCLifetime type) {
336 Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift);
337 }
338 void removeObjCLifetime() { setObjCLifetime(OCL_None); }
339 void addObjCLifetime(ObjCLifetime type) {
340 assert(type)((type) ? static_cast<void> (0) : __assert_fail ("type"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 340, __PRETTY_FUNCTION__))
;
341 assert(!hasObjCLifetime())((!hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail
("!hasObjCLifetime()", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 341, __PRETTY_FUNCTION__))
;
342 Mask |= (type << LifetimeShift);
343 }
344
345 /// True if the lifetime is neither None or ExplicitNone.
346 bool hasNonTrivialObjCLifetime() const {
347 ObjCLifetime lifetime = getObjCLifetime();
348 return (lifetime > OCL_ExplicitNone);
349 }
350
351 /// True if the lifetime is either strong or weak.
352 bool hasStrongOrWeakObjCLifetime() const {
353 ObjCLifetime lifetime = getObjCLifetime();
354 return (lifetime == OCL_Strong || lifetime == OCL_Weak);
355 }
356
357 bool hasAddressSpace() const { return Mask & AddressSpaceMask; }
358 LangAS getAddressSpace() const {
359 return static_cast<LangAS>(Mask >> AddressSpaceShift);
360 }
361 bool hasTargetSpecificAddressSpace() const {
362 return isTargetAddressSpace(getAddressSpace());
363 }
364 /// Get the address space attribute value to be printed by diagnostics.
365 unsigned getAddressSpaceAttributePrintValue() const {
366 auto Addr = getAddressSpace();
367 // This function is not supposed to be used with language specific
368 // address spaces. If that happens, the diagnostic message should consider
369 // printing the QualType instead of the address space value.
370 assert(Addr == LangAS::Default || hasTargetSpecificAddressSpace())((Addr == LangAS::Default || hasTargetSpecificAddressSpace())
? static_cast<void> (0) : __assert_fail ("Addr == LangAS::Default || hasTargetSpecificAddressSpace()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 370, __PRETTY_FUNCTION__))
;
371 if (Addr != LangAS::Default)
372 return toTargetAddressSpace(Addr);
373 // TODO: The diagnostic messages where Addr may be 0 should be fixed
374 // since it cannot differentiate the situation where 0 denotes the default
375 // address space or user specified __attribute__((address_space(0))).
376 return 0;
377 }
378 void setAddressSpace(LangAS space) {
379 assert((unsigned)space <= MaxAddressSpace)(((unsigned)space <= MaxAddressSpace) ? static_cast<void
> (0) : __assert_fail ("(unsigned)space <= MaxAddressSpace"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 379, __PRETTY_FUNCTION__))
;
380 Mask = (Mask & ~AddressSpaceMask)
381 | (((uint32_t) space) << AddressSpaceShift);
382 }
383 void removeAddressSpace() { setAddressSpace(LangAS::Default); }
384 void addAddressSpace(LangAS space) {
385 assert(space != LangAS::Default)((space != LangAS::Default) ? static_cast<void> (0) : __assert_fail
("space != LangAS::Default", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 385, __PRETTY_FUNCTION__))
;
386 setAddressSpace(space);
387 }
388
389 // Fast qualifiers are those that can be allocated directly
390 // on a QualType object.
391 bool hasFastQualifiers() const { return getFastQualifiers(); }
392 unsigned getFastQualifiers() const { return Mask & FastMask; }
393 void setFastQualifiers(unsigned mask) {
394 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 394, __PRETTY_FUNCTION__))
;
395 Mask = (Mask & ~FastMask) | mask;
396 }
397 void removeFastQualifiers(unsigned mask) {
398 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 398, __PRETTY_FUNCTION__))
;
399 Mask &= ~mask;
400 }
401 void removeFastQualifiers() {
402 removeFastQualifiers(FastMask);
403 }
404 void addFastQualifiers(unsigned mask) {
405 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 405, __PRETTY_FUNCTION__))
;
406 Mask |= mask;
407 }
408
409 /// Return true if the set contains any qualifiers which require an ExtQuals
410 /// node to be allocated.
411 bool hasNonFastQualifiers() const { return Mask & ~FastMask; }
412 Qualifiers getNonFastQualifiers() const {
413 Qualifiers Quals = *this;
414 Quals.setFastQualifiers(0);
415 return Quals;
416 }
417
418 /// Return true if the set contains any qualifiers.
419 bool hasQualifiers() const { return Mask; }
420 bool empty() const { return !Mask; }
421
422 /// Add the qualifiers from the given set to this set.
423 void addQualifiers(Qualifiers Q) {
424 // If the other set doesn't have any non-boolean qualifiers, just
425 // bit-or it in.
426 if (!(Q.Mask & ~CVRMask))
427 Mask |= Q.Mask;
428 else {
429 Mask |= (Q.Mask & CVRMask);
430 if (Q.hasAddressSpace())
431 addAddressSpace(Q.getAddressSpace());
432 if (Q.hasObjCGCAttr())
433 addObjCGCAttr(Q.getObjCGCAttr());
434 if (Q.hasObjCLifetime())
435 addObjCLifetime(Q.getObjCLifetime());
436 }
437 }
438
439 /// Remove the qualifiers from the given set from this set.
440 void removeQualifiers(Qualifiers Q) {
441 // If the other set doesn't have any non-boolean qualifiers, just
442 // bit-and the inverse in.
443 if (!(Q.Mask & ~CVRMask))
444 Mask &= ~Q.Mask;
445 else {
446 Mask &= ~(Q.Mask & CVRMask);
447 if (getObjCGCAttr() == Q.getObjCGCAttr())
448 removeObjCGCAttr();
449 if (getObjCLifetime() == Q.getObjCLifetime())
450 removeObjCLifetime();
451 if (getAddressSpace() == Q.getAddressSpace())
452 removeAddressSpace();
453 }
454 }
455
456 /// Add the qualifiers from the given set to this set, given that
457 /// they don't conflict.
458 void addConsistentQualifiers(Qualifiers qs) {
459 assert(getAddressSpace() == qs.getAddressSpace() ||((getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace
() || !qs.hasAddressSpace()) ? static_cast<void> (0) : __assert_fail
("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 460, __PRETTY_FUNCTION__))
460 !hasAddressSpace() || !qs.hasAddressSpace())((getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace
() || !qs.hasAddressSpace()) ? static_cast<void> (0) : __assert_fail
("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 460, __PRETTY_FUNCTION__))
;
461 assert(getObjCGCAttr() == qs.getObjCGCAttr() ||((getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() ||
!qs.hasObjCGCAttr()) ? static_cast<void> (0) : __assert_fail
("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 462, __PRETTY_FUNCTION__))
462 !hasObjCGCAttr() || !qs.hasObjCGCAttr())((getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() ||
!qs.hasObjCGCAttr()) ? static_cast<void> (0) : __assert_fail
("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 462, __PRETTY_FUNCTION__))
;
463 assert(getObjCLifetime() == qs.getObjCLifetime() ||((getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime
() || !qs.hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail
("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 464, __PRETTY_FUNCTION__))
464 !hasObjCLifetime() || !qs.hasObjCLifetime())((getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime
() || !qs.hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail
("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 464, __PRETTY_FUNCTION__))
;
465 Mask |= qs.Mask;
466 }
467
468 /// Returns true if address space A is equal to or a superset of B.
469 /// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
470 /// overlapping address spaces.
471 /// CL1.1 or CL1.2:
472 /// every address space is a superset of itself.
473 /// CL2.0 adds:
474 /// __generic is a superset of any address space except for __constant.
475 static bool isAddressSpaceSupersetOf(LangAS A, LangAS B) {
476 // Address spaces must match exactly.
477 return A == B ||
478 // Otherwise in OpenCLC v2.0 s6.5.5: every address space except
479 // for __constant can be used as __generic.
480 (A == LangAS::opencl_generic && B != LangAS::opencl_constant) ||
481 // Consider pointer size address spaces to be equivalent to default.
482 ((isPtrSizeAddressSpace(A) || A == LangAS::Default) &&
483 (isPtrSizeAddressSpace(B) || B == LangAS::Default));
484 }
485
486 /// Returns true if the address space in these qualifiers is equal to or
487 /// a superset of the address space in the argument qualifiers.
488 bool isAddressSpaceSupersetOf(Qualifiers other) const {
489 return isAddressSpaceSupersetOf(getAddressSpace(), other.getAddressSpace());
490 }
491
492 /// Determines if these qualifiers compatibly include another set.
493 /// Generally this answers the question of whether an object with the other
494 /// qualifiers can be safely used as an object with these qualifiers.
495 bool compatiblyIncludes(Qualifiers other) const {
496 return isAddressSpaceSupersetOf(other) &&
497 // ObjC GC qualifiers can match, be added, or be removed, but can't
498 // be changed.
499 (getObjCGCAttr() == other.getObjCGCAttr() || !hasObjCGCAttr() ||
500 !other.hasObjCGCAttr()) &&
501 // ObjC lifetime qualifiers must match exactly.
502 getObjCLifetime() == other.getObjCLifetime() &&
503 // CVR qualifiers may subset.
504 (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask)) &&
505 // U qualifier may superset.
506 (!other.hasUnaligned() || hasUnaligned());
507 }
508
509 /// Determines if these qualifiers compatibly include another set of
510 /// qualifiers from the narrow perspective of Objective-C ARC lifetime.
511 ///
512 /// One set of Objective-C lifetime qualifiers compatibly includes the other
513 /// if the lifetime qualifiers match, or if both are non-__weak and the
514 /// including set also contains the 'const' qualifier, or both are non-__weak
515 /// and one is None (which can only happen in non-ARC modes).
516 bool compatiblyIncludesObjCLifetime(Qualifiers other) const {
517 if (getObjCLifetime() == other.getObjCLifetime())
518 return true;
519
520 if (getObjCLifetime() == OCL_Weak || other.getObjCLifetime() == OCL_Weak)
521 return false;
522
523 if (getObjCLifetime() == OCL_None || other.getObjCLifetime() == OCL_None)
524 return true;
525
526 return hasConst();
527 }
528
529 /// Determine whether this set of qualifiers is a strict superset of
530 /// another set of qualifiers, not considering qualifier compatibility.
531 bool isStrictSupersetOf(Qualifiers Other) const;
532
533 bool operator==(Qualifiers Other) const { return Mask == Other.Mask; }
534 bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; }
535
536 explicit operator bool() const { return hasQualifiers(); }
537
538 Qualifiers &operator+=(Qualifiers R) {
539 addQualifiers(R);
540 return *this;
541 }
542
543 // Union two qualifier sets. If an enumerated qualifier appears
544 // in both sets, use the one from the right.
545 friend Qualifiers operator+(Qualifiers L, Qualifiers R) {
546 L += R;
547 return L;
548 }
549
550 Qualifiers &operator-=(Qualifiers R) {
551 removeQualifiers(R);
552 return *this;
553 }
554
555 /// Compute the difference between two qualifier sets.
556 friend Qualifiers operator-(Qualifiers L, Qualifiers R) {
557 L -= R;
558 return L;
559 }
560
561 std::string getAsString() const;
562 std::string getAsString(const PrintingPolicy &Policy) const;
563
564 static std::string getAddrSpaceAsString(LangAS AS);
565
566 bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const;
567 void print(raw_ostream &OS, const PrintingPolicy &Policy,
568 bool appendSpaceIfNonEmpty = false) const;
569
570 void Profile(llvm::FoldingSetNodeID &ID) const {
571 ID.AddInteger(Mask);
572 }
573
574private:
575 // bits: |0 1 2|3|4 .. 5|6 .. 8|9 ... 31|
576 // |C R V|U|GCAttr|Lifetime|AddressSpace|
577 uint32_t Mask = 0;
578
579 static const uint32_t UMask = 0x8;
580 static const uint32_t UShift = 3;
581 static const uint32_t GCAttrMask = 0x30;
582 static const uint32_t GCAttrShift = 4;
583 static const uint32_t LifetimeMask = 0x1C0;
584 static const uint32_t LifetimeShift = 6;
585 static const uint32_t AddressSpaceMask =
586 ~(CVRMask | UMask | GCAttrMask | LifetimeMask);
587 static const uint32_t AddressSpaceShift = 9;
588};
589
590/// A std::pair-like structure for storing a qualified type split
591/// into its local qualifiers and its locally-unqualified type.
592struct SplitQualType {
593 /// The locally-unqualified type.
594 const Type *Ty = nullptr;
595
596 /// The local qualifiers.
597 Qualifiers Quals;
598
599 SplitQualType() = default;
600 SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {}
601
602 SplitQualType getSingleStepDesugaredType() const; // end of this file
603
604 // Make std::tie work.
605 std::pair<const Type *,Qualifiers> asPair() const {
606 return std::pair<const Type *, Qualifiers>(Ty, Quals);
607 }
608
609 friend bool operator==(SplitQualType a, SplitQualType b) {
610 return a.Ty == b.Ty && a.Quals == b.Quals;
611 }
612 friend bool operator!=(SplitQualType a, SplitQualType b) {
613 return a.Ty != b.Ty || a.Quals != b.Quals;
614 }
615};
616
617/// The kind of type we are substituting Objective-C type arguments into.
618///
619/// The kind of substitution affects the replacement of type parameters when
620/// no concrete type information is provided, e.g., when dealing with an
621/// unspecialized type.
622enum class ObjCSubstitutionContext {
623 /// An ordinary type.
624 Ordinary,
625
626 /// The result type of a method or function.
627 Result,
628
629 /// The parameter type of a method or function.
630 Parameter,
631
632 /// The type of a property.
633 Property,
634
635 /// The superclass of a type.
636 Superclass,
637};
638
639/// A (possibly-)qualified type.
640///
641/// For efficiency, we don't store CV-qualified types as nodes on their
642/// own: instead each reference to a type stores the qualifiers. This
643/// greatly reduces the number of nodes we need to allocate for types (for
644/// example we only need one for 'int', 'const int', 'volatile int',
645/// 'const volatile int', etc).
646///
647/// As an added efficiency bonus, instead of making this a pair, we
648/// just store the two bits we care about in the low bits of the
649/// pointer. To handle the packing/unpacking, we make QualType be a
650/// simple wrapper class that acts like a smart pointer. A third bit
651/// indicates whether there are extended qualifiers present, in which
652/// case the pointer points to a special structure.
653class QualType {
654 friend class QualifierCollector;
655
656 // Thankfully, these are efficiently composable.
657 llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
658 Qualifiers::FastWidth> Value;
659
660 const ExtQuals *getExtQualsUnsafe() const {
661 return Value.getPointer().get<const ExtQuals*>();
662 }
663
664 const Type *getTypePtrUnsafe() const {
665 return Value.getPointer().get<const Type*>();
666 }
667
668 const ExtQualsTypeCommonBase *getCommonPtr() const {
669 assert(!isNull() && "Cannot retrieve a NULL type pointer")((!isNull() && "Cannot retrieve a NULL type pointer")
? static_cast<void> (0) : __assert_fail ("!isNull() && \"Cannot retrieve a NULL type pointer\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 669, __PRETTY_FUNCTION__))
;
670 auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
671 CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
672 return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
673 }
674
675public:
676 QualType() = default;
677 QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
678 QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
679
680 unsigned getLocalFastQualifiers() const { return Value.getInt(); }
681 void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); }
682
683 /// Retrieves a pointer to the underlying (unqualified) type.
684 ///
685 /// This function requires that the type not be NULL. If the type might be
686 /// NULL, use the (slightly less efficient) \c getTypePtrOrNull().
687 const Type *getTypePtr() const;
688
689 const Type *getTypePtrOrNull() const;
690
691 /// Retrieves a pointer to the name of the base type.
692 const IdentifierInfo *getBaseTypeIdentifier() const;
693
694 /// Divides a QualType into its unqualified type and a set of local
695 /// qualifiers.
696 SplitQualType split() const;
697
698 void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }
699
700 static QualType getFromOpaquePtr(const void *Ptr) {
701 QualType T;
702 T.Value.setFromOpaqueValue(const_cast<void*>(Ptr));
703 return T;
704 }
705
706 const Type &operator*() const {
707 return *getTypePtr();
708 }
709
710 const Type *operator->() const {
711 return getTypePtr();
712 }
713
714 bool isCanonical() const;
715 bool isCanonicalAsParam() const;
716
717 /// Return true if this QualType doesn't point to a type yet.
718 bool isNull() const {
719 return Value.getPointer().isNull();
14
Calling 'PointerUnion::isNull'
17
Returning from 'PointerUnion::isNull'
18
Returning zero, which participates in a condition later
720 }
721
722 /// Determine whether this particular QualType instance has the
723 /// "const" qualifier set, without looking through typedefs that may have
724 /// added "const" at a different level.
725 bool isLocalConstQualified() const {
726 return (getLocalFastQualifiers() & Qualifiers::Const);
727 }
728
729 /// Determine whether this type is const-qualified.
730 bool isConstQualified() const;
731
732 /// Determine whether this particular QualType instance has the
733 /// "restrict" qualifier set, without looking through typedefs that may have
734 /// added "restrict" at a different level.
735 bool isLocalRestrictQualified() const {
736 return (getLocalFastQualifiers() & Qualifiers::Restrict);
737 }
738
739 /// Determine whether this type is restrict-qualified.
740 bool isRestrictQualified() const;
741
742 /// Determine whether this particular QualType instance has the
743 /// "volatile" qualifier set, without looking through typedefs that may have
744 /// added "volatile" at a different level.
745 bool isLocalVolatileQualified() const {
746 return (getLocalFastQualifiers() & Qualifiers::Volatile);
747 }
748
749 /// Determine whether this type is volatile-qualified.
750 bool isVolatileQualified() const;
751
752 /// Determine whether this particular QualType instance has any
753 /// qualifiers, without looking through any typedefs that might add
754 /// qualifiers at a different level.
755 bool hasLocalQualifiers() const {
756 return getLocalFastQualifiers() || hasLocalNonFastQualifiers();
757 }
758
759 /// Determine whether this type has any qualifiers.
760 bool hasQualifiers() const;
761
762 /// Determine whether this particular QualType instance has any
763 /// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType
764 /// instance.
765 bool hasLocalNonFastQualifiers() const {
766 return Value.getPointer().is<const ExtQuals*>();
767 }
768
769 /// Retrieve the set of qualifiers local to this particular QualType
770 /// instance, not including any qualifiers acquired through typedefs or
771 /// other sugar.
772 Qualifiers getLocalQualifiers() const;
773
774 /// Retrieve the set of qualifiers applied to this type.
775 Qualifiers getQualifiers() const;
776
777 /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
778 /// local to this particular QualType instance, not including any qualifiers
779 /// acquired through typedefs or other sugar.
780 unsigned getLocalCVRQualifiers() const {
781 return getLocalFastQualifiers();
782 }
783
784 /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
785 /// applied to this type.
786 unsigned getCVRQualifiers() const;
787
788 bool isConstant(const ASTContext& Ctx) const {
789 return QualType::isConstant(*this, Ctx);
790 }
791
792 /// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
793 bool isPODType(const ASTContext &Context) const;
794
795 /// Return true if this is a POD type according to the rules of the C++98
796 /// standard, regardless of the current compilation's language.
797 bool isCXX98PODType(const ASTContext &Context) const;
798
799 /// Return true if this is a POD type according to the more relaxed rules
800 /// of the C++11 standard, regardless of the current compilation's language.
801 /// (C++0x [basic.types]p9). Note that, unlike
802 /// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account.
803 bool isCXX11PODType(const ASTContext &Context) const;
804
805 /// Return true if this is a trivial type per (C++0x [basic.types]p9)
806 bool isTrivialType(const ASTContext &Context) const;
807
808 /// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
809 bool isTriviallyCopyableType(const ASTContext &Context) const;
810
811
812 /// Returns true if it is a class and it might be dynamic.
813 bool mayBeDynamicClass() const;
814
815 /// Returns true if it is not a class or if the class might not be dynamic.
816 bool mayBeNotDynamicClass() const;
817
818 // Don't promise in the API that anything besides 'const' can be
819 // easily added.
820
821 /// Add the `const` type qualifier to this QualType.
822 void addConst() {
823 addFastQualifiers(Qualifiers::Const);
824 }
825 QualType withConst() const {
826 return withFastQualifiers(Qualifiers::Const);
827 }
828
829 /// Add the `volatile` type qualifier to this QualType.
830 void addVolatile() {
831 addFastQualifiers(Qualifiers::Volatile);
832 }
833 QualType withVolatile() const {
834 return withFastQualifiers(Qualifiers::Volatile);
835 }
836
837 /// Add the `restrict` qualifier to this QualType.
838 void addRestrict() {
839 addFastQualifiers(Qualifiers::Restrict);
840 }
841 QualType withRestrict() const {
842 return withFastQualifiers(Qualifiers::Restrict);
843 }
844
845 QualType withCVRQualifiers(unsigned CVR) const {
846 return withFastQualifiers(CVR);
847 }
848
849 void addFastQualifiers(unsigned TQs) {
850 assert(!(TQs & ~Qualifiers::FastMask)((!(TQs & ~Qualifiers::FastMask) && "non-fast qualifier bits set in mask!"
) ? static_cast<void> (0) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 851, __PRETTY_FUNCTION__))
851 && "non-fast qualifier bits set in mask!")((!(TQs & ~Qualifiers::FastMask) && "non-fast qualifier bits set in mask!"
) ? static_cast<void> (0) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 851, __PRETTY_FUNCTION__))
;
852 Value.setInt(Value.getInt() | TQs);
853 }
854
855 void removeLocalConst();
856 void removeLocalVolatile();
857 void removeLocalRestrict();
858 void removeLocalCVRQualifiers(unsigned Mask);
859
860 void removeLocalFastQualifiers() { Value.setInt(0); }
861 void removeLocalFastQualifiers(unsigned Mask) {
862 assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers")((!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("!(Mask & ~Qualifiers::FastMask) && \"mask has non-fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 862, __PRETTY_FUNCTION__))
;
863 Value.setInt(Value.getInt() & ~Mask);
864 }
865
866 // Creates a type with the given qualifiers in addition to any
867 // qualifiers already on this type.
868 QualType withFastQualifiers(unsigned TQs) const {
869 QualType T = *this;
870 T.addFastQualifiers(TQs);
871 return T;
872 }
873
874 // Creates a type with exactly the given fast qualifiers, removing
875 // any existing fast qualifiers.
876 QualType withExactLocalFastQualifiers(unsigned TQs) const {
877 return withoutLocalFastQualifiers().withFastQualifiers(TQs);
878 }
879
880 // Removes fast qualifiers, but leaves any extended qualifiers in place.
881 QualType withoutLocalFastQualifiers() const {
882 QualType T = *this;
883 T.removeLocalFastQualifiers();
884 return T;
885 }
886
887 QualType getCanonicalType() const;
888
889 /// Return this type with all of the instance-specific qualifiers
890 /// removed, but without removing any qualifiers that may have been applied
891 /// through typedefs.
892 QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); }
893
894 /// Retrieve the unqualified variant of the given type,
895 /// removing as little sugar as possible.
896 ///
897 /// This routine looks through various kinds of sugar to find the
898 /// least-desugared type that is unqualified. For example, given:
899 ///
900 /// \code
901 /// typedef int Integer;
902 /// typedef const Integer CInteger;
903 /// typedef CInteger DifferenceType;
904 /// \endcode
905 ///
906 /// Executing \c getUnqualifiedType() on the type \c DifferenceType will
907 /// desugar until we hit the type \c Integer, which has no qualifiers on it.
908 ///
909 /// The resulting type might still be qualified if it's sugar for an array
910 /// type. To strip qualifiers even from within a sugared array type, use
911 /// ASTContext::getUnqualifiedArrayType.
912 inline QualType getUnqualifiedType() const;
913
914 /// Retrieve the unqualified variant of the given type, removing as little
915 /// sugar as possible.
916 ///
917 /// Like getUnqualifiedType(), but also returns the set of
918 /// qualifiers that were built up.
919 ///
920 /// The resulting type might still be qualified if it's sugar for an array
921 /// type. To strip qualifiers even from within a sugared array type, use
922 /// ASTContext::getUnqualifiedArrayType.
923 inline SplitQualType getSplitUnqualifiedType() const;
924
925 /// Determine whether this type is more qualified than the other
926 /// given type, requiring exact equality for non-CVR qualifiers.
927 bool isMoreQualifiedThan(QualType Other) const;
928
929 /// Determine whether this type is at least as qualified as the other
930 /// given type, requiring exact equality for non-CVR qualifiers.
931 bool isAtLeastAsQualifiedAs(QualType Other) const;
932
933 QualType getNonReferenceType() const;
934
935 /// Determine the type of a (typically non-lvalue) expression with the
936 /// specified result type.
937 ///
938 /// This routine should be used for expressions for which the return type is
939 /// explicitly specified (e.g., in a cast or call) and isn't necessarily
940 /// an lvalue. It removes a top-level reference (since there are no
941 /// expressions of reference type) and deletes top-level cvr-qualifiers
942 /// from non-class types (in C++) or all types (in C).
943 QualType getNonLValueExprType(const ASTContext &Context) const;
944
945 /// Return the specified type with any "sugar" removed from
946 /// the type. This takes off typedefs, typeof's etc. If the outer level of
947 /// the type is already concrete, it returns it unmodified. This is similar
948 /// to getting the canonical type, but it doesn't remove *all* typedefs. For
949 /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
950 /// concrete.
951 ///
952 /// Qualifiers are left in place.
953 QualType getDesugaredType(const ASTContext &Context) const {
954 return getDesugaredType(*this, Context);
955 }
956
957 SplitQualType getSplitDesugaredType() const {
958 return getSplitDesugaredType(*this);
959 }
960
961 /// Return the specified type with one level of "sugar" removed from
962 /// the type.
963 ///
964 /// This routine takes off the first typedef, typeof, etc. If the outer level
965 /// of the type is already concrete, it returns it unmodified.
966 QualType getSingleStepDesugaredType(const ASTContext &Context) const {
967 return getSingleStepDesugaredTypeImpl(*this, Context);
968 }
969
970 /// Returns the specified type after dropping any
971 /// outer-level parentheses.
972 QualType IgnoreParens() const {
973 if (isa<ParenType>(*this))
974 return QualType::IgnoreParens(*this);
975 return *this;
976 }
977
978 /// Indicate whether the specified types and qualifiers are identical.
979 friend bool operator==(const QualType &LHS, const QualType &RHS) {
980 return LHS.Value == RHS.Value;
981 }
982 friend bool operator!=(const QualType &LHS, const QualType &RHS) {
983 return LHS.Value != RHS.Value;
984 }
985 friend bool operator<(const QualType &LHS, const QualType &RHS) {
986 return LHS.Value < RHS.Value;
987 }
988
989 static std::string getAsString(SplitQualType split,
990 const PrintingPolicy &Policy) {
991 return getAsString(split.Ty, split.Quals, Policy);
992 }
993 static std::string getAsString(const Type *ty, Qualifiers qs,
994 const PrintingPolicy &Policy);
995
996 std::string getAsString() const;
997 std::string getAsString(const PrintingPolicy &Policy) const;
998
999 void print(raw_ostream &OS, const PrintingPolicy &Policy,
1000 const Twine &PlaceHolder = Twine(),
1001 unsigned Indentation = 0) const;
1002
1003 static void print(SplitQualType split, raw_ostream &OS,
1004 const PrintingPolicy &policy, const Twine &PlaceHolder,
1005 unsigned Indentation = 0) {
1006 return print(split.Ty, split.Quals, OS, policy, PlaceHolder, Indentation);
1007 }
1008
1009 static void print(const Type *ty, Qualifiers qs,
1010 raw_ostream &OS, const PrintingPolicy &policy,
1011 const Twine &PlaceHolder,
1012 unsigned Indentation = 0);
1013
1014 void getAsStringInternal(std::string &Str,
1015 const PrintingPolicy &Policy) const;
1016
1017 static void getAsStringInternal(SplitQualType split, std::string &out,
1018 const PrintingPolicy &policy) {
1019 return getAsStringInternal(split.Ty, split.Quals, out, policy);
1020 }
1021
1022 static void getAsStringInternal(const Type *ty, Qualifiers qs,
1023 std::string &out,
1024 const PrintingPolicy &policy);
1025
1026 class StreamedQualTypeHelper {
1027 const QualType &T;
1028 const PrintingPolicy &Policy;
1029 const Twine &PlaceHolder;
1030 unsigned Indentation;
1031
1032 public:
1033 StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy,
1034 const Twine &PlaceHolder, unsigned Indentation)
1035 : T(T), Policy(Policy), PlaceHolder(PlaceHolder),
1036 Indentation(Indentation) {}
1037
1038 friend raw_ostream &operator<<(raw_ostream &OS,
1039 const StreamedQualTypeHelper &SQT) {
1040 SQT.T.print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
1041 return OS;
1042 }
1043 };
1044
1045 StreamedQualTypeHelper stream(const PrintingPolicy &Policy,
1046 const Twine &PlaceHolder = Twine(),
1047 unsigned Indentation = 0) const {
1048 return StreamedQualTypeHelper(*this, Policy, PlaceHolder, Indentation);
1049 }
1050
1051 void dump(const char *s) const;
1052 void dump() const;
1053 void dump(llvm::raw_ostream &OS) const;
1054
1055 void Profile(llvm::FoldingSetNodeID &ID) const {
1056 ID.AddPointer(getAsOpaquePtr());
1057 }
1058
1059 /// Check if this type has any address space qualifier.
1060 inline bool hasAddressSpace() const;
1061
1062 /// Return the address space of this type.
1063 inline LangAS getAddressSpace() const;
1064
1065 /// Returns gc attribute of this type.
1066 inline Qualifiers::GC getObjCGCAttr() const;
1067
1068 /// true when Type is objc's weak.
1069 bool isObjCGCWeak() const {
1070 return getObjCGCAttr() == Qualifiers::Weak;
1071 }
1072
1073 /// true when Type is objc's strong.
1074 bool isObjCGCStrong() const {
1075 return getObjCGCAttr() == Qualifiers::Strong;
1076 }
1077
1078 /// Returns lifetime attribute of this type.
1079 Qualifiers::ObjCLifetime getObjCLifetime() const {
1080 return getQualifiers().getObjCLifetime();
1081 }
1082
1083 bool hasNonTrivialObjCLifetime() const {
1084 return getQualifiers().hasNonTrivialObjCLifetime();
1085 }
1086
1087 bool hasStrongOrWeakObjCLifetime() const {
1088 return getQualifiers().hasStrongOrWeakObjCLifetime();
1089 }
1090
1091 // true when Type is objc's weak and weak is enabled but ARC isn't.
1092 bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const;
1093
1094 enum PrimitiveDefaultInitializeKind {
1095 /// The type does not fall into any of the following categories. Note that
1096 /// this case is zero-valued so that values of this enum can be used as a
1097 /// boolean condition for non-triviality.
1098 PDIK_Trivial,
1099
1100 /// The type is an Objective-C retainable pointer type that is qualified
1101 /// with the ARC __strong qualifier.
1102 PDIK_ARCStrong,
1103
1104 /// The type is an Objective-C retainable pointer type that is qualified
1105 /// with the ARC __weak qualifier.
1106 PDIK_ARCWeak,
1107
1108 /// The type is a struct containing a field whose type is not PCK_Trivial.
1109 PDIK_Struct
1110 };
1111
1112 /// Functions to query basic properties of non-trivial C struct types.
1113
1114 /// Check if this is a non-trivial type that would cause a C struct
1115 /// transitively containing this type to be non-trivial to default initialize
1116 /// and return the kind.
1117 PrimitiveDefaultInitializeKind
1118 isNonTrivialToPrimitiveDefaultInitialize() const;
1119
1120 enum PrimitiveCopyKind {
1121 /// The type does not fall into any of the following categories. Note that
1122 /// this case is zero-valued so that values of this enum can be used as a
1123 /// boolean condition for non-triviality.
1124 PCK_Trivial,
1125
1126 /// The type would be trivial except that it is volatile-qualified. Types
1127 /// that fall into one of the other non-trivial cases may additionally be
1128 /// volatile-qualified.
1129 PCK_VolatileTrivial,
1130
1131 /// The type is an Objective-C retainable pointer type that is qualified
1132 /// with the ARC __strong qualifier.
1133 PCK_ARCStrong,
1134
1135 /// The type is an Objective-C retainable pointer type that is qualified
1136 /// with the ARC __weak qualifier.
1137 PCK_ARCWeak,
1138
1139 /// The type is a struct containing a field whose type is neither
1140 /// PCK_Trivial nor PCK_VolatileTrivial.
1141 /// Note that a C++ struct type does not necessarily match this; C++ copying
1142 /// semantics are too complex to express here, in part because they depend
1143 /// on the exact constructor or assignment operator that is chosen by
1144 /// overload resolution to do the copy.
1145 PCK_Struct
1146 };
1147
1148 /// Check if this is a non-trivial type that would cause a C struct
1149 /// transitively containing this type to be non-trivial to copy and return the
1150 /// kind.
1151 PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const;
1152
1153 /// Check if this is a non-trivial type that would cause a C struct
1154 /// transitively containing this type to be non-trivial to destructively
1155 /// move and return the kind. Destructive move in this context is a C++-style
1156 /// move in which the source object is placed in a valid but unspecified state
1157 /// after it is moved, as opposed to a truly destructive move in which the
1158 /// source object is placed in an uninitialized state.
1159 PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const;
1160
1161 enum DestructionKind {
1162 DK_none,
1163 DK_cxx_destructor,
1164 DK_objc_strong_lifetime,
1165 DK_objc_weak_lifetime,
1166 DK_nontrivial_c_struct
1167 };
1168
1169 /// Returns a nonzero value if objects of this type require
1170 /// non-trivial work to clean up after. Non-zero because it's
1171 /// conceivable that qualifiers (objc_gc(weak)?) could make
1172 /// something require destruction.
1173 DestructionKind isDestructedType() const {
1174 return isDestructedTypeImpl(*this);
1175 }
1176
1177 /// Check if this is or contains a C union that is non-trivial to
1178 /// default-initialize, which is a union that has a member that is non-trivial
1179 /// to default-initialize. If this returns true,
1180 /// isNonTrivialToPrimitiveDefaultInitialize returns PDIK_Struct.
1181 bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const;
1182
1183 /// Check if this is or contains a C union that is non-trivial to destruct,
1184 /// which is a union that has a member that is non-trivial to destruct. If
1185 /// this returns true, isDestructedType returns DK_nontrivial_c_struct.
1186 bool hasNonTrivialToPrimitiveDestructCUnion() const;
1187
1188 /// Check if this is or contains a C union that is non-trivial to copy, which
1189 /// is a union that has a member that is non-trivial to copy. If this returns
1190 /// true, isNonTrivialToPrimitiveCopy returns PCK_Struct.
1191 bool hasNonTrivialToPrimitiveCopyCUnion() const;
1192
1193 /// Determine whether expressions of the given type are forbidden
1194 /// from being lvalues in C.
1195 ///
1196 /// The expression types that are forbidden to be lvalues are:
1197 /// - 'void', but not qualified void
1198 /// - function types
1199 ///
1200 /// The exact rule here is C99 6.3.2.1:
1201 /// An lvalue is an expression with an object type or an incomplete
1202 /// type other than void.
1203 bool isCForbiddenLValueType() const;
1204
1205 /// Substitute type arguments for the Objective-C type parameters used in the
1206 /// subject type.
1207 ///
1208 /// \param ctx ASTContext in which the type exists.
1209 ///
1210 /// \param typeArgs The type arguments that will be substituted for the
1211 /// Objective-C type parameters in the subject type, which are generally
1212 /// computed via \c Type::getObjCSubstitutions. If empty, the type
1213 /// parameters will be replaced with their bounds or id/Class, as appropriate
1214 /// for the context.
1215 ///
1216 /// \param context The context in which the subject type was written.
1217 ///
1218 /// \returns the resulting type.
1219 QualType substObjCTypeArgs(ASTContext &ctx,
1220 ArrayRef<QualType> typeArgs,
1221 ObjCSubstitutionContext context) const;
1222
1223 /// Substitute type arguments from an object type for the Objective-C type
1224 /// parameters used in the subject type.
1225 ///
1226 /// This operation combines the computation of type arguments for
1227 /// substitution (\c Type::getObjCSubstitutions) with the actual process of
1228 /// substitution (\c QualType::substObjCTypeArgs) for the convenience of
1229 /// callers that need to perform a single substitution in isolation.
1230 ///
1231 /// \param objectType The type of the object whose member type we're
1232 /// substituting into. For example, this might be the receiver of a message
1233 /// or the base of a property access.
1234 ///
1235 /// \param dc The declaration context from which the subject type was
1236 /// retrieved, which indicates (for example) which type parameters should
1237 /// be substituted.
1238 ///
1239 /// \param context The context in which the subject type was written.
1240 ///
1241 /// \returns the subject type after replacing all of the Objective-C type
1242 /// parameters with their corresponding arguments.
1243 QualType substObjCMemberType(QualType objectType,
1244 const DeclContext *dc,
1245 ObjCSubstitutionContext context) const;
1246
1247 /// Strip Objective-C "__kindof" types from the given type.
1248 QualType stripObjCKindOfType(const ASTContext &ctx) const;
1249
1250 /// Remove all qualifiers including _Atomic.
1251 QualType getAtomicUnqualifiedType() const;
1252
1253private:
1254 // These methods are implemented in a separate translation unit;
1255 // "static"-ize them to avoid creating temporary QualTypes in the
1256 // caller.
1257 static bool isConstant(QualType T, const ASTContext& Ctx);
1258 static QualType getDesugaredType(QualType T, const ASTContext &Context);
1259 static SplitQualType getSplitDesugaredType(QualType T);
1260 static SplitQualType getSplitUnqualifiedTypeImpl(QualType type);
1261 static QualType getSingleStepDesugaredTypeImpl(QualType type,
1262 const ASTContext &C);
1263 static QualType IgnoreParens(QualType T);
1264 static DestructionKind isDestructedTypeImpl(QualType type);
1265
1266 /// Check if \param RD is or contains a non-trivial C union.
1267 static bool hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD);
1268 static bool hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD);
1269 static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD);
1270};
1271
1272} // namespace clang
1273
1274namespace llvm {
1275
1276/// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1277/// to a specific Type class.
1278template<> struct simplify_type< ::clang::QualType> {
1279 using SimpleType = const ::clang::Type *;
1280
1281 static SimpleType getSimplifiedValue(::clang::QualType Val) {
1282 return Val.getTypePtr();
1283 }
1284};
1285
1286// Teach SmallPtrSet that QualType is "basically a pointer".
1287template<>
1288struct PointerLikeTypeTraits<clang::QualType> {
1289 static inline void *getAsVoidPointer(clang::QualType P) {
1290 return P.getAsOpaquePtr();
1291 }
1292
1293 static inline clang::QualType getFromVoidPointer(void *P) {
1294 return clang::QualType::getFromOpaquePtr(P);
1295 }
1296
1297 // Various qualifiers go in low bits.
1298 enum { NumLowBitsAvailable = 0 };
1299};
1300
1301} // namespace llvm
1302
1303namespace clang {
1304
1305/// Base class that is common to both the \c ExtQuals and \c Type
1306/// classes, which allows \c QualType to access the common fields between the
1307/// two.
1308class ExtQualsTypeCommonBase {
1309 friend class ExtQuals;
1310 friend class QualType;
1311 friend class Type;
1312
1313 /// The "base" type of an extended qualifiers type (\c ExtQuals) or
1314 /// a self-referential pointer (for \c Type).
1315 ///
1316 /// This pointer allows an efficient mapping from a QualType to its
1317 /// underlying type pointer.
1318 const Type *const BaseType;
1319
1320 /// The canonical type of this type. A QualType.
1321 QualType CanonicalType;
1322
1323 ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
1324 : BaseType(baseType), CanonicalType(canon) {}
1325};
1326
1327/// We can encode up to four bits in the low bits of a
1328/// type pointer, but there are many more type qualifiers that we want
1329/// to be able to apply to an arbitrary type. Therefore we have this
1330/// struct, intended to be heap-allocated and used by QualType to
1331/// store qualifiers.
1332///
1333/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1334/// in three low bits on the QualType pointer; a fourth bit records whether
1335/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1336/// Objective-C GC attributes) are much more rare.
1337class ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode {
1338 // NOTE: changing the fast qualifiers should be straightforward as
1339 // long as you don't make 'const' non-fast.
1340 // 1. Qualifiers:
1341 // a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ).
1342 // Fast qualifiers must occupy the low-order bits.
1343 // b) Update Qualifiers::FastWidth and FastMask.
1344 // 2. QualType:
1345 // a) Update is{Volatile,Restrict}Qualified(), defined inline.
1346 // b) Update remove{Volatile,Restrict}, defined near the end of
1347 // this header.
1348 // 3. ASTContext:
1349 // a) Update get{Volatile,Restrict}Type.
1350
1351 /// The immutable set of qualifiers applied by this node. Always contains
1352 /// extended qualifiers.
1353 Qualifiers Quals;
1354
1355 ExtQuals *this_() { return this; }
1356
1357public:
1358 ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
1359 : ExtQualsTypeCommonBase(baseType,
1360 canon.isNull() ? QualType(this_(), 0) : canon),
1361 Quals(quals) {
1362 assert(Quals.hasNonFastQualifiers()((Quals.hasNonFastQualifiers() && "ExtQuals created with no fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("Quals.hasNonFastQualifiers() && \"ExtQuals created with no fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 1363, __PRETTY_FUNCTION__))
1363 && "ExtQuals created with no fast qualifiers")((Quals.hasNonFastQualifiers() && "ExtQuals created with no fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("Quals.hasNonFastQualifiers() && \"ExtQuals created with no fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 1363, __PRETTY_FUNCTION__))
;
1364 assert(!Quals.hasFastQualifiers()((!Quals.hasFastQualifiers() && "ExtQuals created with fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasFastQualifiers() && \"ExtQuals created with fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 1365, __PRETTY_FUNCTION__))
1365 && "ExtQuals created with fast qualifiers")((!Quals.hasFastQualifiers() && "ExtQuals created with fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasFastQualifiers() && \"ExtQuals created with fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 1365, __PRETTY_FUNCTION__))
;
1366 }
1367
1368 Qualifiers getQualifiers() const { return Quals; }
1369
1370 bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); }
1371 Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); }
1372
1373 bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); }
1374 Qualifiers::ObjCLifetime getObjCLifetime() const {
1375 return Quals.getObjCLifetime();
1376 }
1377
1378 bool hasAddressSpace() const { return Quals.hasAddressSpace(); }
1379 LangAS getAddressSpace() const { return Quals.getAddressSpace(); }
1380
1381 const Type *getBaseType() const { return BaseType; }
1382
1383public:
1384 void Profile(llvm::FoldingSetNodeID &ID) const {
1385 Profile(ID, getBaseType(), Quals);
1386 }
1387
1388 static void Profile(llvm::FoldingSetNodeID &ID,
1389 const Type *BaseType,
1390 Qualifiers Quals) {
1391 assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!")((!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasFastQualifiers() && \"fast qualifiers in ExtQuals hash!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 1391, __PRETTY_FUNCTION__))
;
1392 ID.AddPointer(BaseType);
1393 Quals.Profile(ID);
1394 }
1395};
1396
1397/// The kind of C++11 ref-qualifier associated with a function type.
1398/// This determines whether a member function's "this" object can be an
1399/// lvalue, rvalue, or neither.
1400enum RefQualifierKind {
1401 /// No ref-qualifier was provided.
1402 RQ_None = 0,
1403
1404 /// An lvalue ref-qualifier was provided (\c &).
1405 RQ_LValue,
1406
1407 /// An rvalue ref-qualifier was provided (\c &&).
1408 RQ_RValue
1409};
1410
1411/// Which keyword(s) were used to create an AutoType.
1412enum class AutoTypeKeyword {
1413 /// auto
1414 Auto,
1415
1416 /// decltype(auto)
1417 DecltypeAuto,
1418
1419 /// __auto_type (GNU extension)
1420 GNUAutoType
1421};
1422
1423/// The base class of the type hierarchy.
1424///
1425/// A central concept with types is that each type always has a canonical
1426/// type. A canonical type is the type with any typedef names stripped out
1427/// of it or the types it references. For example, consider:
1428///
1429/// typedef int foo;
1430/// typedef foo* bar;
1431/// 'int *' 'foo *' 'bar'
1432///
1433/// There will be a Type object created for 'int'. Since int is canonical, its
1434/// CanonicalType pointer points to itself. There is also a Type for 'foo' (a
1435/// TypedefType). Its CanonicalType pointer points to the 'int' Type. Next
1436/// there is a PointerType that represents 'int*', which, like 'int', is
1437/// canonical. Finally, there is a PointerType type for 'foo*' whose canonical
1438/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1439/// is also 'int*'.
1440///
1441/// Non-canonical types are useful for emitting diagnostics, without losing
1442/// information about typedefs being used. Canonical types are useful for type
1443/// comparisons (they allow by-pointer equality tests) and useful for reasoning
1444/// about whether something has a particular form (e.g. is a function type),
1445/// because they implicitly, recursively, strip all typedefs out of a type.
1446///
1447/// Types, once created, are immutable.
1448///
1449class alignas(8) Type : public ExtQualsTypeCommonBase {
1450public:
1451 enum TypeClass {
1452#define TYPE(Class, Base) Class,
1453#define LAST_TYPE(Class) TypeLast = Class
1454#define ABSTRACT_TYPE(Class, Base)
1455#include "clang/AST/TypeNodes.inc"
1456 };
1457
1458private:
1459 /// Bitfields required by the Type class.
1460 class TypeBitfields {
1461 friend class Type;
1462 template <class T> friend class TypePropertyCache;
1463
1464 /// TypeClass bitfield - Enum that specifies what subclass this belongs to.
1465 unsigned TC : 8;
1466
1467 /// Whether this type is a dependent type (C++ [temp.dep.type]).
1468 unsigned Dependent : 1;
1469
1470 /// Whether this type somehow involves a template parameter, even
1471 /// if the resolution of the type does not depend on a template parameter.
1472 unsigned InstantiationDependent : 1;
1473
1474 /// Whether this type is a variably-modified type (C99 6.7.5).
1475 unsigned VariablyModified : 1;
1476
1477 /// Whether this type contains an unexpanded parameter pack
1478 /// (for C++11 variadic templates).
1479 unsigned ContainsUnexpandedParameterPack : 1;
1480
1481 /// True if the cache (i.e. the bitfields here starting with
1482 /// 'Cache') is valid.
1483 mutable unsigned CacheValid : 1;
1484
1485 /// Linkage of this type.
1486 mutable unsigned CachedLinkage : 3;
1487
1488 /// Whether this type involves and local or unnamed types.
1489 mutable unsigned CachedLocalOrUnnamed : 1;
1490
1491 /// Whether this type comes from an AST file.
1492 mutable unsigned FromAST : 1;
1493
1494 bool isCacheValid() const {
1495 return CacheValid;
1496 }
1497
1498 Linkage getLinkage() const {
1499 assert(isCacheValid() && "getting linkage from invalid cache")((isCacheValid() && "getting linkage from invalid cache"
) ? static_cast<void> (0) : __assert_fail ("isCacheValid() && \"getting linkage from invalid cache\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 1499, __PRETTY_FUNCTION__))
;
1500 return static_cast<Linkage>(CachedLinkage);
1501 }
1502
1503 bool hasLocalOrUnnamedType() const {
1504 assert(isCacheValid() && "getting linkage from invalid cache")((isCacheValid() && "getting linkage from invalid cache"
) ? static_cast<void> (0) : __assert_fail ("isCacheValid() && \"getting linkage from invalid cache\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 1504, __PRETTY_FUNCTION__))
;
1505 return CachedLocalOrUnnamed;
1506 }
1507 };
1508 enum { NumTypeBits = 18 };
1509
1510protected:
1511 // These classes allow subclasses to somewhat cleanly pack bitfields
1512 // into Type.
1513
1514 class ArrayTypeBitfields {
1515 friend class ArrayType;
1516
1517 unsigned : NumTypeBits;
1518
1519 /// CVR qualifiers from declarations like
1520 /// 'int X[static restrict 4]'. For function parameters only.
1521 unsigned IndexTypeQuals : 3;
1522
1523 /// Storage class qualifiers from declarations like
1524 /// 'int X[static restrict 4]'. For function parameters only.
1525 /// Actually an ArrayType::ArraySizeModifier.
1526 unsigned SizeModifier : 3;
1527 };
1528
1529 class ConstantArrayTypeBitfields {
1530 friend class ConstantArrayType;
1531
1532 unsigned : NumTypeBits + 3 + 3;
1533
1534 /// Whether we have a stored size expression.
1535 unsigned HasStoredSizeExpr : 1;
1536 };
1537
1538 class BuiltinTypeBitfields {
1539 friend class BuiltinType;
1540
1541 unsigned : NumTypeBits;
1542
1543 /// The kind (BuiltinType::Kind) of builtin type this is.
1544 unsigned Kind : 8;
1545 };
1546
1547 /// FunctionTypeBitfields store various bits belonging to FunctionProtoType.
1548 /// Only common bits are stored here. Additional uncommon bits are stored
1549 /// in a trailing object after FunctionProtoType.
1550 class FunctionTypeBitfields {
1551 friend class FunctionProtoType;
1552 friend class FunctionType;
1553
1554 unsigned : NumTypeBits;
1555
1556 /// Extra information which affects how the function is called, like
1557 /// regparm and the calling convention.
1558 unsigned ExtInfo : 12;
1559
1560 /// The ref-qualifier associated with a \c FunctionProtoType.
1561 ///
1562 /// This is a value of type \c RefQualifierKind.
1563 unsigned RefQualifier : 2;
1564
1565 /// Used only by FunctionProtoType, put here to pack with the
1566 /// other bitfields.
1567 /// The qualifiers are part of FunctionProtoType because...
1568 ///
1569 /// C++ 8.3.5p4: The return type, the parameter type list and the
1570 /// cv-qualifier-seq, [...], are part of the function type.
1571 unsigned FastTypeQuals : Qualifiers::FastWidth;
1572 /// Whether this function has extended Qualifiers.
1573 unsigned HasExtQuals : 1;
1574
1575 /// The number of parameters this function has, not counting '...'.
1576 /// According to [implimits] 8 bits should be enough here but this is
1577 /// somewhat easy to exceed with metaprogramming and so we would like to
1578 /// keep NumParams as wide as reasonably possible.
1579 unsigned NumParams : 16;
1580
1581 /// The type of exception specification this function has.
1582 unsigned ExceptionSpecType : 4;
1583
1584 /// Whether this function has extended parameter information.
1585 unsigned HasExtParameterInfos : 1;
1586
1587 /// Whether the function is variadic.
1588 unsigned Variadic : 1;
1589
1590 /// Whether this function has a trailing return type.
1591 unsigned HasTrailingReturn : 1;
1592 };
1593
1594 class ObjCObjectTypeBitfields {
1595 friend class ObjCObjectType;
1596
1597 unsigned : NumTypeBits;
1598
1599 /// The number of type arguments stored directly on this object type.
1600 unsigned NumTypeArgs : 7;
1601
1602 /// The number of protocols stored directly on this object type.
1603 unsigned NumProtocols : 6;
1604
1605 /// Whether this is a "kindof" type.
1606 unsigned IsKindOf : 1;
1607 };
1608
1609 class ReferenceTypeBitfields {
1610 friend class ReferenceType;
1611
1612 unsigned : NumTypeBits;
1613
1614 /// True if the type was originally spelled with an lvalue sigil.
1615 /// This is never true of rvalue references but can also be false
1616 /// on lvalue references because of C++0x [dcl.typedef]p9,
1617 /// as follows:
1618 ///
1619 /// typedef int &ref; // lvalue, spelled lvalue
1620 /// typedef int &&rvref; // rvalue
1621 /// ref &a; // lvalue, inner ref, spelled lvalue
1622 /// ref &&a; // lvalue, inner ref
1623 /// rvref &a; // lvalue, inner ref, spelled lvalue
1624 /// rvref &&a; // rvalue, inner ref
1625 unsigned SpelledAsLValue : 1;
1626
1627 /// True if the inner type is a reference type. This only happens
1628 /// in non-canonical forms.
1629 unsigned InnerRef : 1;
1630 };
1631
1632 class TypeWithKeywordBitfields {
1633 friend class TypeWithKeyword;
1634
1635 unsigned : NumTypeBits;
1636
1637 /// An ElaboratedTypeKeyword. 8 bits for efficient access.
1638 unsigned Keyword : 8;
1639 };
1640
1641 enum { NumTypeWithKeywordBits = 8 };
1642
1643 class ElaboratedTypeBitfields {
1644 friend class ElaboratedType;
1645
1646 unsigned : NumTypeBits;
1647 unsigned : NumTypeWithKeywordBits;
1648
1649 /// Whether the ElaboratedType has a trailing OwnedTagDecl.
1650 unsigned HasOwnedTagDecl : 1;
1651 };
1652
1653 class VectorTypeBitfields {
1654 friend class VectorType;
1655 friend class DependentVectorType;
1656
1657 unsigned : NumTypeBits;
1658
1659 /// The kind of vector, either a generic vector type or some
1660 /// target-specific vector type such as for AltiVec or Neon.
1661 unsigned VecKind : 3;
1662
1663 /// The number of elements in the vector.
1664 unsigned NumElements : 29 - NumTypeBits;
1665
1666 enum { MaxNumElements = (1 << (29 - NumTypeBits)) - 1 };
1667 };
1668
1669 class AttributedTypeBitfields {
1670 friend class AttributedType;
1671
1672 unsigned : NumTypeBits;
1673
1674 /// An AttributedType::Kind
1675 unsigned AttrKind : 32 - NumTypeBits;
1676 };
1677
1678 class AutoTypeBitfields {
1679 friend class AutoType;
1680
1681 unsigned : NumTypeBits;
1682
1683 /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
1684 /// or '__auto_type'? AutoTypeKeyword value.
1685 unsigned Keyword : 2;
1686 };
1687
1688 class SubstTemplateTypeParmPackTypeBitfields {
1689 friend class SubstTemplateTypeParmPackType;
1690
1691 unsigned : NumTypeBits;
1692
1693 /// The number of template arguments in \c Arguments, which is
1694 /// expected to be able to hold at least 1024 according to [implimits].
1695 /// However as this limit is somewhat easy to hit with template
1696 /// metaprogramming we'd prefer to keep it as large as possible.
1697 /// At the moment it has been left as a non-bitfield since this type
1698 /// safely fits in 64 bits as an unsigned, so there is no reason to
1699 /// introduce the performance impact of a bitfield.
1700 unsigned NumArgs;
1701 };
1702
1703 class TemplateSpecializationTypeBitfields {
1704 friend class TemplateSpecializationType;
1705
1706 unsigned : NumTypeBits;
1707
1708 /// Whether this template specialization type is a substituted type alias.
1709 unsigned TypeAlias : 1;
1710
1711 /// The number of template arguments named in this class template
1712 /// specialization, which is expected to be able to hold at least 1024
1713 /// according to [implimits]. However, as this limit is somewhat easy to
1714 /// hit with template metaprogramming we'd prefer to keep it as large
1715 /// as possible. At the moment it has been left as a non-bitfield since
1716 /// this type safely fits in 64 bits as an unsigned, so there is no reason
1717 /// to introduce the performance impact of a bitfield.
1718 unsigned NumArgs;
1719 };
1720
1721 class DependentTemplateSpecializationTypeBitfields {
1722 friend class DependentTemplateSpecializationType;
1723
1724 unsigned : NumTypeBits;
1725 unsigned : NumTypeWithKeywordBits;
1726
1727 /// The number of template arguments named in this class template
1728 /// specialization, which is expected to be able to hold at least 1024
1729 /// according to [implimits]. However, as this limit is somewhat easy to
1730 /// hit with template metaprogramming we'd prefer to keep it as large
1731 /// as possible. At the moment it has been left as a non-bitfield since
1732 /// this type safely fits in 64 bits as an unsigned, so there is no reason
1733 /// to introduce the performance impact of a bitfield.
1734 unsigned NumArgs;
1735 };
1736
1737 class PackExpansionTypeBitfields {
1738 friend class PackExpansionType;
1739
1740 unsigned : NumTypeBits;
1741
1742 /// The number of expansions that this pack expansion will
1743 /// generate when substituted (+1), which is expected to be able to
1744 /// hold at least 1024 according to [implimits]. However, as this limit
1745 /// is somewhat easy to hit with template metaprogramming we'd prefer to
1746 /// keep it as large as possible. At the moment it has been left as a
1747 /// non-bitfield since this type safely fits in 64 bits as an unsigned, so
1748 /// there is no reason to introduce the performance impact of a bitfield.
1749 ///
1750 /// This field will only have a non-zero value when some of the parameter
1751 /// packs that occur within the pattern have been substituted but others
1752 /// have not.
1753 unsigned NumExpansions;
1754 };
1755
1756 union {
1757 TypeBitfields TypeBits;
1758 ArrayTypeBitfields ArrayTypeBits;
1759 ConstantArrayTypeBitfields ConstantArrayTypeBits;
1760 AttributedTypeBitfields AttributedTypeBits;
1761 AutoTypeBitfields AutoTypeBits;
1762 BuiltinTypeBitfields BuiltinTypeBits;
1763 FunctionTypeBitfields FunctionTypeBits;
1764 ObjCObjectTypeBitfields ObjCObjectTypeBits;
1765 ReferenceTypeBitfields ReferenceTypeBits;
1766 TypeWithKeywordBitfields TypeWithKeywordBits;
1767 ElaboratedTypeBitfields ElaboratedTypeBits;
1768 VectorTypeBitfields VectorTypeBits;
1769 SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;
1770 TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
1771 DependentTemplateSpecializationTypeBitfields
1772 DependentTemplateSpecializationTypeBits;
1773 PackExpansionTypeBitfields PackExpansionTypeBits;
1774
1775 static_assert(sizeof(TypeBitfields) <= 8,
1776 "TypeBitfields is larger than 8 bytes!");
1777 static_assert(sizeof(ArrayTypeBitfields) <= 8,
1778 "ArrayTypeBitfields is larger than 8 bytes!");
1779 static_assert(sizeof(AttributedTypeBitfields) <= 8,
1780 "AttributedTypeBitfields is larger than 8 bytes!");
1781 static_assert(sizeof(AutoTypeBitfields) <= 8,
1782 "AutoTypeBitfields is larger than 8 bytes!");
1783 static_assert(sizeof(BuiltinTypeBitfields) <= 8,
1784 "BuiltinTypeBitfields is larger than 8 bytes!");
1785 static_assert(sizeof(FunctionTypeBitfields) <= 8,
1786 "FunctionTypeBitfields is larger than 8 bytes!");
1787 static_assert(sizeof(ObjCObjectTypeBitfields) <= 8,
1788 "ObjCObjectTypeBitfields is larger than 8 bytes!");
1789 static_assert(sizeof(ReferenceTypeBitfields) <= 8,
1790 "ReferenceTypeBitfields is larger than 8 bytes!");
1791 static_assert(sizeof(TypeWithKeywordBitfields) <= 8,
1792 "TypeWithKeywordBitfields is larger than 8 bytes!");
1793 static_assert(sizeof(ElaboratedTypeBitfields) <= 8,
1794 "ElaboratedTypeBitfields is larger than 8 bytes!");
1795 static_assert(sizeof(VectorTypeBitfields) <= 8,
1796 "VectorTypeBitfields is larger than 8 bytes!");
1797 static_assert(sizeof(SubstTemplateTypeParmPackTypeBitfields) <= 8,
1798 "SubstTemplateTypeParmPackTypeBitfields is larger"
1799 " than 8 bytes!");
1800 static_assert(sizeof(TemplateSpecializationTypeBitfields) <= 8,
1801 "TemplateSpecializationTypeBitfields is larger"
1802 " than 8 bytes!");
1803 static_assert(sizeof(DependentTemplateSpecializationTypeBitfields) <= 8,
1804 "DependentTemplateSpecializationTypeBitfields is larger"
1805 " than 8 bytes!");
1806 static_assert(sizeof(PackExpansionTypeBitfields) <= 8,
1807 "PackExpansionTypeBitfields is larger than 8 bytes");
1808 };
1809
1810private:
1811 template <class T> friend class TypePropertyCache;
1812
1813 /// Set whether this type comes from an AST file.
1814 void setFromAST(bool V = true) const {
1815 TypeBits.FromAST = V;
1816 }
1817
1818protected:
1819 friend class ASTContext;
1820
1821 Type(TypeClass tc, QualType canon, bool Dependent,
1822 bool InstantiationDependent, bool VariablyModified,
1823 bool ContainsUnexpandedParameterPack)
1824 : ExtQualsTypeCommonBase(this,
1825 canon.isNull() ? QualType(this_(), 0) : canon) {
1826 TypeBits.TC = tc;
1827 TypeBits.Dependent = Dependent;
1828 TypeBits.InstantiationDependent = Dependent || InstantiationDependent;
1829 TypeBits.VariablyModified = VariablyModified;
1830 TypeBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
1831 TypeBits.CacheValid = false;
1832 TypeBits.CachedLocalOrUnnamed = false;
1833 TypeBits.CachedLinkage = NoLinkage;
1834 TypeBits.FromAST = false;
1835 }
1836
1837 // silence VC++ warning C4355: 'this' : used in base member initializer list
1838 Type *this_() { return this; }
1839
1840 void setDependent(bool D = true) {
1841 TypeBits.Dependent = D;
1842 if (D)
1843 TypeBits.InstantiationDependent = true;
1844 }
1845
1846 void setInstantiationDependent(bool D = true) {
1847 TypeBits.InstantiationDependent = D; }
1848
1849 void setVariablyModified(bool VM = true) { TypeBits.VariablyModified = VM; }
1850
1851 void setContainsUnexpandedParameterPack(bool PP = true) {
1852 TypeBits.ContainsUnexpandedParameterPack = PP;
1853 }
1854
1855public:
1856 friend class ASTReader;
1857 friend class ASTWriter;
1858 template <class T> friend class serialization::AbstractTypeReader;
1859 template <class T> friend class serialization::AbstractTypeWriter;
1860
1861 Type(const Type &) = delete;
1862 Type(Type &&) = delete;
1863 Type &operator=(const Type &) = delete;
1864 Type &operator=(Type &&) = delete;
1865
1866 TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }
1867
1868 /// Whether this type comes from an AST file.
1869 bool isFromAST() const { return TypeBits.FromAST; }
1870
1871 /// Whether this type is or contains an unexpanded parameter
1872 /// pack, used to support C++0x variadic templates.
1873 ///
1874 /// A type that contains a parameter pack shall be expanded by the
1875 /// ellipsis operator at some point. For example, the typedef in the
1876 /// following example contains an unexpanded parameter pack 'T':
1877 ///
1878 /// \code
1879 /// template<typename ...T>
1880 /// struct X {
1881 /// typedef T* pointer_types; // ill-formed; T is a parameter pack.
1882 /// };
1883 /// \endcode
1884 ///
1885 /// Note that this routine does not specify which
1886 bool containsUnexpandedParameterPack() const {
1887 return TypeBits.ContainsUnexpandedParameterPack;
1888 }
1889
1890 /// Determines if this type would be canonical if it had no further
1891 /// qualification.
1892 bool isCanonicalUnqualified() const {
1893 return CanonicalType == QualType(this, 0);
1894 }
1895
1896 /// Pull a single level of sugar off of this locally-unqualified type.
1897 /// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
1898 /// or QualType::getSingleStepDesugaredType(const ASTContext&).
1899 QualType getLocallyUnqualifiedSingleStepDesugaredType() const;
1900
1901 /// Types are partitioned into 3 broad categories (C99 6.2.5p1):
1902 /// object types, function types, and incomplete types.
1903
1904 /// Return true if this is an incomplete type.
1905 /// A type that can describe objects, but which lacks information needed to
1906 /// determine its size (e.g. void, or a fwd declared struct). Clients of this
1907 /// routine will need to determine if the size is actually required.
1908 ///
1909 /// Def If non-null, and the type refers to some kind of declaration
1910 /// that can be completed (such as a C struct, C++ class, or Objective-C
1911 /// class), will be set to the declaration.
1912 bool isIncompleteType(NamedDecl **Def = nullptr) const;
1913
1914 /// Return true if this is an incomplete or object
1915 /// type, in other words, not a function type.
1916 bool isIncompleteOrObjectType() const {
1917 return !isFunctionType();
1918 }
1919
1920 /// Determine whether this type is an object type.
1921 bool isObjectType() const {
1922 // C++ [basic.types]p8:
1923 // An object type is a (possibly cv-qualified) type that is not a
1924 // function type, not a reference type, and not a void type.
1925 return !isReferenceType() && !isFunctionType() && !isVoidType();
1926 }
1927
1928 /// Return true if this is a literal type
1929 /// (C++11 [basic.types]p10)
1930 bool isLiteralType(const ASTContext &Ctx) const;
1931
1932 /// Test if this type is a standard-layout type.
1933 /// (C++0x [basic.type]p9)
1934 bool isStandardLayoutType() const;
1935
1936 /// Helper methods to distinguish type categories. All type predicates
1937 /// operate on the canonical type, ignoring typedefs and qualifiers.
1938
1939 /// Returns true if the type is a builtin type.
1940 bool isBuiltinType() const;
1941
1942 /// Test for a particular builtin type.
1943 bool isSpecificBuiltinType(unsigned K) const;
1944
1945 /// Test for a type which does not represent an actual type-system type but
1946 /// is instead used as a placeholder for various convenient purposes within
1947 /// Clang. All such types are BuiltinTypes.
1948 bool isPlaceholderType() const;
1949 const BuiltinType *getAsPlaceholderType() const;
1950
1951 /// Test for a specific placeholder type.
1952 bool isSpecificPlaceholderType(unsigned K) const;
1953
1954 /// Test for a placeholder type other than Overload; see
1955 /// BuiltinType::isNonOverloadPlaceholderType.
1956 bool isNonOverloadPlaceholderType() const;
1957
1958 /// isIntegerType() does *not* include complex integers (a GCC extension).
1959 /// isComplexIntegerType() can be used to test for complex integers.
1960 bool isIntegerType() const; // C99 6.2.5p17 (int, char, bool, enum)
1961 bool isEnumeralType() const;
1962
1963 /// Determine whether this type is a scoped enumeration type.
1964 bool isScopedEnumeralType() const;
1965 bool isBooleanType() const;
1966 bool isCharType() const;
1967 bool isWideCharType() const;
1968 bool isChar8Type() const;
1969 bool isChar16Type() const;
1970 bool isChar32Type() const;
1971 bool isAnyCharacterType() const;
1972 bool isIntegralType(const ASTContext &Ctx) const;
1973
1974 /// Determine whether this type is an integral or enumeration type.
1975 bool isIntegralOrEnumerationType() const;
1976
1977 /// Determine whether this type is an integral or unscoped enumeration type.
1978 bool isIntegralOrUnscopedEnumerationType() const;
1979 bool isUnscopedEnumerationType() const;
1980
1981 /// Floating point categories.
1982 bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
1983 /// isComplexType() does *not* include complex integers (a GCC extension).
1984 /// isComplexIntegerType() can be used to test for complex integers.
1985 bool isComplexType() const; // C99 6.2.5p11 (complex)
1986 bool isAnyComplexType() const; // C99 6.2.5p11 (complex) + Complex Int.
1987 bool isFloatingType() const; // C99 6.2.5p11 (real floating + complex)
1988 bool isHalfType() const; // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
1989 bool isFloat16Type() const; // C11 extension ISO/IEC TS 18661
1990 bool isFloat128Type() const;
1991 bool isRealType() const; // C99 6.2.5p17 (real floating + integer)
1992 bool isArithmeticType() const; // C99 6.2.5p18 (integer + floating)
1993 bool isVoidType() const; // C99 6.2.5p19
1994 bool isScalarType() const; // C99 6.2.5p21 (arithmetic + pointers)
1995 bool isAggregateType() const;
1996 bool isFundamentalType() const;
1997 bool isCompoundType() const;
1998
1999 // Type Predicates: Check to see if this type is structurally the specified
2000 // type, ignoring typedefs and qualifiers.
2001 bool isFunctionType() const;
2002 bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); }
2003 bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
2004 bool isPointerType() const;
2005 bool isAnyPointerType() const; // Any C pointer or ObjC object pointer
2006 bool isBlockPointerType() const;
2007 bool isVoidPointerType() const;
2008 bool isReferenceType() const;
2009 bool isLValueReferenceType() const;
2010 bool isRValueReferenceType() const;
2011 bool isObjectPointerType() const;
2012 bool isFunctionPointerType() const;
2013 bool isFunctionReferenceType() const;
2014 bool isMemberPointerType() const;
2015 bool isMemberFunctionPointerType() const;
2016 bool isMemberDataPointerType() const;
2017 bool isArrayType() const;
2018 bool isConstantArrayType() const;
2019 bool isIncompleteArrayType() const;
2020 bool isVariableArrayType() const;
2021 bool isDependentSizedArrayType() const;
2022 bool isRecordType() const;
2023 bool isClassType() const;
2024 bool isStructureType() const;
2025 bool isObjCBoxableRecordType() const;
2026 bool isInterfaceType() const;
2027 bool isStructureOrClassType() const;
2028 bool isUnionType() const;
2029 bool isComplexIntegerType() const; // GCC _Complex integer type.
2030 bool isVectorType() const; // GCC vector type.
2031 bool isExtVectorType() const; // Extended vector type.
2032 bool isDependentAddressSpaceType() const; // value-dependent address space qualifier
2033 bool isObjCObjectPointerType() const; // pointer to ObjC object
2034 bool isObjCRetainableType() const; // ObjC object or block pointer
2035 bool isObjCLifetimeType() const; // (array of)* retainable type
2036 bool isObjCIndirectLifetimeType() const; // (pointer to)* lifetime type
2037 bool isObjCNSObjectType() const; // __attribute__((NSObject))
2038 bool isObjCIndependentClassType() const; // __attribute__((objc_independent_class))
2039 // FIXME: change this to 'raw' interface type, so we can used 'interface' type
2040 // for the common case.
2041 bool isObjCObjectType() const; // NSString or typeof(*(id)0)
2042 bool isObjCQualifiedInterfaceType() const; // NSString<foo>
2043 bool isObjCQualifiedIdType() const; // id<foo>
2044 bool isObjCQualifiedClassType() const; // Class<foo>
2045 bool isObjCObjectOrInterfaceType() const;
2046 bool isObjCIdType() const; // id
2047 bool isDecltypeType() const;
2048 /// Was this type written with the special inert-in-ARC __unsafe_unretained
2049 /// qualifier?
2050 ///
2051 /// This approximates the answer to the following question: if this
2052 /// translation unit were compiled in ARC, would this type be qualified
2053 /// with __unsafe_unretained?
2054 bool isObjCInertUnsafeUnretainedType() const {
2055 return hasAttr(attr::ObjCInertUnsafeUnretained);
2056 }
2057
2058 /// Whether the type is Objective-C 'id' or a __kindof type of an
2059 /// object type, e.g., __kindof NSView * or __kindof id
2060 /// <NSCopying>.
2061 ///
2062 /// \param bound Will be set to the bound on non-id subtype types,
2063 /// which will be (possibly specialized) Objective-C class type, or
2064 /// null for 'id.
2065 bool isObjCIdOrObjectKindOfType(const ASTContext &ctx,
2066 const ObjCObjectType *&bound) const;
2067
2068 bool isObjCClassType() const; // Class
2069
2070 /// Whether the type is Objective-C 'Class' or a __kindof type of an
2071 /// Class type, e.g., __kindof Class <NSCopying>.
2072 ///
2073 /// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
2074 /// here because Objective-C's type system cannot express "a class
2075 /// object for a subclass of NSFoo".
2076 bool isObjCClassOrClassKindOfType() const;
2077
2078 bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const;
2079 bool isObjCSelType() const; // Class
2080 bool isObjCBuiltinType() const; // 'id' or 'Class'
2081 bool isObjCARCBridgableType() const;
2082 bool isCARCBridgableType() const;
2083 bool isTemplateTypeParmType() const; // C++ template type parameter
2084 bool isNullPtrType() const; // C++11 std::nullptr_t
2085 bool isNothrowT() const; // C++ std::nothrow_t
2086 bool isAlignValT() const; // C++17 std::align_val_t
2087 bool isStdByteType() const; // C++17 std::byte
2088 bool isAtomicType() const; // C11 _Atomic()
2089 bool isUndeducedAutoType() const; // C++11 auto or
2090 // C++14 decltype(auto)
2091
2092#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2093 bool is##Id##Type() const;
2094#include "clang/Basic/OpenCLImageTypes.def"
2095
2096 bool isImageType() const; // Any OpenCL image type
2097
2098 bool isSamplerT() const; // OpenCL sampler_t
2099 bool isEventT() const; // OpenCL event_t
2100 bool isClkEventT() const; // OpenCL clk_event_t
2101 bool isQueueT() const; // OpenCL queue_t
2102 bool isReserveIDT() const; // OpenCL reserve_id_t
2103
2104#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2105 bool is##Id##Type() const;
2106#include "clang/Basic/OpenCLExtensionTypes.def"
2107 // Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension
2108 bool isOCLIntelSubgroupAVCType() const;
2109 bool isOCLExtOpaqueType() const; // Any OpenCL extension type
2110
2111 bool isPipeType() const; // OpenCL pipe type
2112 bool isOpenCLSpecificType() const; // Any OpenCL specific type
2113
2114 /// Determines if this type, which must satisfy
2115 /// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
2116 /// than implicitly __strong.
2117 bool isObjCARCImplicitlyUnretainedType() const;
2118
2119 /// Return the implicit lifetime for this type, which must not be dependent.
2120 Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const;
2121
2122 enum ScalarTypeKind {
2123 STK_CPointer,
2124 STK_BlockPointer,
2125 STK_ObjCObjectPointer,
2126 STK_MemberPointer,
2127 STK_Bool,
2128 STK_Integral,
2129 STK_Floating,
2130 STK_IntegralComplex,
2131 STK_FloatingComplex,
2132 STK_FixedPoint
2133 };
2134
2135 /// Given that this is a scalar type, classify it.
2136 ScalarTypeKind getScalarTypeKind() const;
2137
2138 /// Whether this type is a dependent type, meaning that its definition
2139 /// somehow depends on a template parameter (C++ [temp.dep.type]).
2140 bool isDependentType() const { return TypeBits.Dependent; }
2141
2142 /// Determine whether this type is an instantiation-dependent type,
2143 /// meaning that the type involves a template parameter (even if the
2144 /// definition does not actually depend on the type substituted for that
2145 /// template parameter).
2146 bool isInstantiationDependentType() const {
2147 return TypeBits.InstantiationDependent;
2148 }
2149
2150 /// Determine whether this type is an undeduced type, meaning that
2151 /// it somehow involves a C++11 'auto' type or similar which has not yet been
2152 /// deduced.
2153 bool isUndeducedType() const;
2154
2155 /// Whether this type is a variably-modified type (C99 6.7.5).
2156 bool isVariablyModifiedType() const { return TypeBits.VariablyModified; }
2157
2158 /// Whether this type involves a variable-length array type
2159 /// with a definite size.
2160 bool hasSizedVLAType() const;
2161
2162 /// Whether this type is or contains a local or unnamed type.
2163 bool hasUnnamedOrLocalType() const;
2164
2165 bool isOverloadableType() const;
2166
2167 /// Determine wither this type is a C++ elaborated-type-specifier.
2168 bool isElaboratedTypeSpecifier() const;
2169
2170 bool canDecayToPointerType() const;
2171
2172 /// Whether this type is represented natively as a pointer. This includes
2173 /// pointers, references, block pointers, and Objective-C interface,
2174 /// qualified id, and qualified interface types, as well as nullptr_t.
2175 bool hasPointerRepresentation() const;
2176
2177 /// Whether this type can represent an objective pointer type for the
2178 /// purpose of GC'ability
2179 bool hasObjCPointerRepresentation() const;
2180
2181 /// Determine whether this type has an integer representation
2182 /// of some sort, e.g., it is an integer type or a vector.
2183 bool hasIntegerRepresentation() const;
2184
2185 /// Determine whether this type has an signed integer representation
2186 /// of some sort, e.g., it is an signed integer type or a vector.
2187 bool hasSignedIntegerRepresentation() const;
2188
2189 /// Determine whether this type has an unsigned integer representation
2190 /// of some sort, e.g., it is an unsigned integer type or a vector.
2191 bool hasUnsignedIntegerRepresentation() const;
2192
2193 /// Determine whether this type has a floating-point representation
2194 /// of some sort, e.g., it is a floating-point type or a vector thereof.
2195 bool hasFloatingRepresentation() const;
2196
2197 // Type Checking Functions: Check to see if this type is structurally the
2198 // specified type, ignoring typedefs and qualifiers, and return a pointer to
2199 // the best type we can.
2200 const RecordType *getAsStructureType() const;
2201 /// NOTE: getAs*ArrayType are methods on ASTContext.
2202 const RecordType *getAsUnionType() const;
2203 const ComplexType *getAsComplexIntegerType() const; // GCC complex int type.
2204 const ObjCObjectType *getAsObjCInterfaceType() const;
2205
2206 // The following is a convenience method that returns an ObjCObjectPointerType
2207 // for object declared using an interface.
2208 const ObjCObjectPointerType *getAsObjCInterfacePointerType() const;
2209 const ObjCObjectPointerType *getAsObjCQualifiedIdType() const;
2210 const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
2211 const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;
2212
2213 /// Retrieves the CXXRecordDecl that this type refers to, either
2214 /// because the type is a RecordType or because it is the injected-class-name
2215 /// type of a class template or class template partial specialization.
2216 CXXRecordDecl *getAsCXXRecordDecl() const;
2217
2218 /// Retrieves the RecordDecl this type refers to.
2219 RecordDecl *getAsRecordDecl() const;
2220
2221 /// Retrieves the TagDecl that this type refers to, either
2222 /// because the type is a TagType or because it is the injected-class-name
2223 /// type of a class template or class template partial specialization.
2224 TagDecl *getAsTagDecl() const;
2225
2226 /// If this is a pointer or reference to a RecordType, return the
2227 /// CXXRecordDecl that the type refers to.
2228 ///
2229 /// If this is not a pointer or reference, or the type being pointed to does
2230 /// not refer to a CXXRecordDecl, returns NULL.
2231 const CXXRecordDecl *getPointeeCXXRecordDecl() const;
2232
2233 /// Get the DeducedType whose type will be deduced for a variable with
2234 /// an initializer of this type. This looks through declarators like pointer
2235 /// types, but not through decltype or typedefs.
2236 DeducedType *getContainedDeducedType() const;
2237
2238 /// Get the AutoType whose type will be deduced for a variable with
2239 /// an initializer of this type. This looks through declarators like pointer
2240 /// types, but not through decltype or typedefs.
2241 AutoType *getContainedAutoType() const {
2242 return dyn_cast_or_null<AutoType>(getContainedDeducedType());
2243 }
2244
2245 /// Determine whether this type was written with a leading 'auto'
2246 /// corresponding to a trailing return type (possibly for a nested
2247 /// function type within a pointer to function type or similar).
2248 bool hasAutoForTrailingReturnType() const;
2249
2250 /// Member-template getAs<specific type>'. Look through sugar for
2251 /// an instance of \<specific type>. This scheme will eventually
2252 /// replace the specific getAsXXXX methods above.
2253 ///
2254 /// There are some specializations of this member template listed
2255 /// immediately following this class.
2256 template <typename T> const T *getAs() const;
2257
2258 /// Member-template getAsAdjusted<specific type>. Look through specific kinds
2259 /// of sugar (parens, attributes, etc) for an instance of \<specific type>.
2260 /// This is used when you need to walk over sugar nodes that represent some
2261 /// kind of type adjustment from a type that was written as a \<specific type>
2262 /// to another type that is still canonically a \<specific type>.
2263 template <typename T> const T *getAsAdjusted() const;
2264
2265 /// A variant of getAs<> for array types which silently discards
2266 /// qualifiers from the outermost type.
2267 const ArrayType *getAsArrayTypeUnsafe() const;
2268
2269 /// Member-template castAs<specific type>. Look through sugar for
2270 /// the underlying instance of \<specific type>.
2271 ///
2272 /// This method has the same relationship to getAs<T> as cast<T> has
2273 /// to dyn_cast<T>; which is to say, the underlying type *must*
2274 /// have the intended type, and this method will never return null.
2275 template <typename T> const T *castAs() const;
2276
2277 /// A variant of castAs<> for array type which silently discards
2278 /// qualifiers from the outermost type.
2279 const ArrayType *castAsArrayTypeUnsafe() const;
2280
2281 /// Determine whether this type had the specified attribute applied to it
2282 /// (looking through top-level type sugar).
2283 bool hasAttr(attr::Kind AK) const;
2284
2285 /// Get the base element type of this type, potentially discarding type
2286 /// qualifiers. This should never be used when type qualifiers
2287 /// are meaningful.
2288 const Type *getBaseElementTypeUnsafe() const;
2289
2290 /// If this is an array type, return the element type of the array,
2291 /// potentially with type qualifiers missing.
2292 /// This should never be used when type qualifiers are meaningful.
2293 const Type *getArrayElementTypeNoTypeQual() const;
2294
2295 /// If this is a pointer type, return the pointee type.
2296 /// If this is an array type, return the array element type.
2297 /// This should never be used when type qualifiers are meaningful.
2298 const Type *getPointeeOrArrayElementType() const;
2299
2300 /// If this is a pointer, ObjC object pointer, or block
2301 /// pointer, this returns the respective pointee.
2302 QualType getPointeeType() const;
2303
2304 /// Return the specified type with any "sugar" removed from the type,
2305 /// removing any typedefs, typeofs, etc., as well as any qualifiers.
2306 const Type *getUnqualifiedDesugaredType() const;
2307
2308 /// More type predicates useful for type checking/promotion
2309 bool isPromotableIntegerType() const; // C99 6.3.1.1p2
2310
2311 /// Return true if this is an integer type that is
2312 /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
2313 /// or an enum decl which has a signed representation.
2314 bool isSignedIntegerType() const;
2315
2316 /// Return true if this is an integer type that is
2317 /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
2318 /// or an enum decl which has an unsigned representation.
2319 bool isUnsignedIntegerType() const;
2320
2321 /// Determines whether this is an integer type that is signed or an
2322 /// enumeration types whose underlying type is a signed integer type.
2323 bool isSignedIntegerOrEnumerationType() const;
2324
2325 /// Determines whether this is an integer type that is unsigned or an
2326 /// enumeration types whose underlying type is a unsigned integer type.
2327 bool isUnsignedIntegerOrEnumerationType() const;
2328
2329 /// Return true if this is a fixed point type according to
2330 /// ISO/IEC JTC1 SC22 WG14 N1169.
2331 bool isFixedPointType() const;
2332
2333 /// Return true if this is a fixed point or integer type.
2334 bool isFixedPointOrIntegerType() const;
2335
2336 /// Return true if this is a saturated fixed point type according to
2337 /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
2338 bool isSaturatedFixedPointType() const;
2339
2340 /// Return true if this is a saturated fixed point type according to
2341 /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
2342 bool isUnsaturatedFixedPointType() const;
2343
2344 /// Return true if this is a fixed point type that is signed according
2345 /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
2346 bool isSignedFixedPointType() const;
2347
2348 /// Return true if this is a fixed point type that is unsigned according
2349 /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
2350 bool isUnsignedFixedPointType() const;
2351
2352 /// Return true if this is not a variable sized type,
2353 /// according to the rules of C99 6.7.5p3. It is not legal to call this on
2354 /// incomplete types.
2355 bool isConstantSizeType() const;
2356
2357 /// Returns true if this type can be represented by some
2358 /// set of type specifiers.
2359 bool isSpecifierType() const;
2360
2361 /// Determine the linkage of this type.
2362 Linkage getLinkage() const;
2363
2364 /// Determine the visibility of this type.
2365 Visibility getVisibility() const {
2366 return getLinkageAndVisibility().getVisibility();
2367 }
2368
2369 /// Return true if the visibility was explicitly set is the code.
2370 bool isVisibilityExplicit() const {
2371 return getLinkageAndVisibility().isVisibilityExplicit();
2372 }
2373
2374 /// Determine the linkage and visibility of this type.
2375 LinkageInfo getLinkageAndVisibility() const;
2376
2377 /// True if the computed linkage is valid. Used for consistency
2378 /// checking. Should always return true.
2379 bool isLinkageValid() const;
2380
2381 /// Determine the nullability of the given type.
2382 ///
2383 /// Note that nullability is only captured as sugar within the type
2384 /// system, not as part of the canonical type, so nullability will
2385 /// be lost by canonicalization and desugaring.
2386 Optional<NullabilityKind> getNullability(const ASTContext &context) const;
2387
2388 /// Determine whether the given type can have a nullability
2389 /// specifier applied to it, i.e., if it is any kind of pointer type.
2390 ///
2391 /// \param ResultIfUnknown The value to return if we don't yet know whether
2392 /// this type can have nullability because it is dependent.
2393 bool canHaveNullability(bool ResultIfUnknown = true) const;
2394
2395 /// Retrieve the set of substitutions required when accessing a member
2396 /// of the Objective-C receiver type that is declared in the given context.
2397 ///
2398 /// \c *this is the type of the object we're operating on, e.g., the
2399 /// receiver for a message send or the base of a property access, and is
2400 /// expected to be of some object or object pointer type.
2401 ///
2402 /// \param dc The declaration context for which we are building up a
2403 /// substitution mapping, which should be an Objective-C class, extension,
2404 /// category, or method within.
2405 ///
2406 /// \returns an array of type arguments that can be substituted for
2407 /// the type parameters of the given declaration context in any type described
2408 /// within that context, or an empty optional to indicate that no
2409 /// substitution is required.
2410 Optional<ArrayRef<QualType>>
2411 getObjCSubstitutions(const DeclContext *dc) const;
2412
2413 /// Determines if this is an ObjC interface type that may accept type
2414 /// parameters.
2415 bool acceptsObjCTypeParams() const;
2416
2417 const char *getTypeClassName() const;
2418
2419 QualType getCanonicalTypeInternal() const {
2420 return CanonicalType;
2421 }
2422
2423 CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h
2424 void dump() const;
2425 void dump(llvm::raw_ostream &OS) const;
2426};
2427
2428/// This will check for a TypedefType by removing any existing sugar
2429/// until it reaches a TypedefType or a non-sugared type.
2430template <> const TypedefType *Type::getAs() const;
2431
2432/// This will check for a TemplateSpecializationType by removing any
2433/// existing sugar until it reaches a TemplateSpecializationType or a
2434/// non-sugared type.
2435template <> const TemplateSpecializationType *Type::getAs() const;
2436
2437/// This will check for an AttributedType by removing any existing sugar
2438/// until it reaches an AttributedType or a non-sugared type.
2439template <> const AttributedType *Type::getAs() const;
2440
2441// We can do canonical leaf types faster, because we don't have to
2442// worry about preserving child type decoration.
2443#define TYPE(Class, Base)
2444#define LEAF_TYPE(Class) \
2445template <> inline const Class##Type *Type::getAs() const { \
2446 return dyn_cast<Class##Type>(CanonicalType); \
2447} \
2448template <> inline const Class##Type *Type::castAs() const { \
2449 return cast<Class##Type>(CanonicalType); \
2450}
2451#include "clang/AST/TypeNodes.inc"
2452
2453/// This class is used for builtin types like 'int'. Builtin
2454/// types are always canonical and have a literal name field.
2455class BuiltinType : public Type {
2456public:
2457 enum Kind {
2458// OpenCL image types
2459#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2460#include "clang/Basic/OpenCLImageTypes.def"
2461// OpenCL extension types
2462#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2463#include "clang/Basic/OpenCLExtensionTypes.def"
2464// SVE Types
2465#define SVE_TYPE(Name, Id, SingletonId) Id,
2466#include "clang/Basic/AArch64SVEACLETypes.def"
2467// All other builtin types
2468#define BUILTIN_TYPE(Id, SingletonId) Id,
2469#define LAST_BUILTIN_TYPE(Id) LastKind = Id
2470#include "clang/AST/BuiltinTypes.def"
2471 };
2472
2473private:
2474 friend class ASTContext; // ASTContext creates these.
2475
2476 BuiltinType(Kind K)
2477 : Type(Builtin, QualType(), /*Dependent=*/(K == Dependent),
2478 /*InstantiationDependent=*/(K == Dependent),
2479 /*VariablyModified=*/false,
2480 /*Unexpanded parameter pack=*/false) {
2481 BuiltinTypeBits.Kind = K;
2482 }
2483
2484public:
2485 Kind getKind() const { return static_cast<Kind>(BuiltinTypeBits.Kind); }
2486 StringRef getName(const PrintingPolicy &Policy) const;
2487
2488 const char *getNameAsCString(const PrintingPolicy &Policy) const {
2489 // The StringRef is null-terminated.
2490 StringRef str = getName(Policy);
2491 assert(!str.empty() && str.data()[str.size()] == '\0')((!str.empty() && str.data()[str.size()] == '\0') ? static_cast
<void> (0) : __assert_fail ("!str.empty() && str.data()[str.size()] == '\\0'"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 2491, __PRETTY_FUNCTION__))
;
2492 return str.data();
2493 }
2494
2495 bool isSugared() const { return false; }
2496 QualType desugar() const { return QualType(this, 0); }
2497
2498 bool isInteger() const {
2499 return getKind() >= Bool && getKind() <= Int128;
2500 }
2501
2502 bool isSignedInteger() const {
2503 return getKind() >= Char_S && getKind() <= Int128;
2504 }
2505
2506 bool isUnsignedInteger() const {
2507 return getKind() >= Bool && getKind() <= UInt128;
2508 }
2509
2510 bool isFloatingPoint() const {
2511 return getKind() >= Half && getKind() <= Float128;
2512 }
2513
2514 /// Determines whether the given kind corresponds to a placeholder type.
2515 static bool isPlaceholderTypeKind(Kind K) {
2516 return K >= Overload;
2517 }
2518
2519 /// Determines whether this type is a placeholder type, i.e. a type
2520 /// which cannot appear in arbitrary positions in a fully-formed
2521 /// expression.
2522 bool isPlaceholderType() const {
2523 return isPlaceholderTypeKind(getKind());
2524 }
2525
2526 /// Determines whether this type is a placeholder type other than
2527 /// Overload. Most placeholder types require only syntactic
2528 /// information about their context in order to be resolved (e.g.
2529 /// whether it is a call expression), which means they can (and
2530 /// should) be resolved in an earlier "phase" of analysis.
2531 /// Overload expressions sometimes pick up further information
2532 /// from their context, like whether the context expects a
2533 /// specific function-pointer type, and so frequently need
2534 /// special treatment.
2535 bool isNonOverloadPlaceholderType() const {
2536 return getKind() > Overload;
2537 }
2538
2539 static bool classof(const Type *T) { return T->getTypeClass() == Builtin; }
2540};
2541
2542/// Complex values, per C99 6.2.5p11. This supports the C99 complex
2543/// types (_Complex float etc) as well as the GCC integer complex extensions.
2544class ComplexType : public Type, public llvm::FoldingSetNode {
2545 friend class ASTContext; // ASTContext creates these.
2546
2547 QualType ElementType;
2548
2549 ComplexType(QualType Element, QualType CanonicalPtr)
2550 : Type(Complex, CanonicalPtr, Element->isDependentType(),
2551 Element->isInstantiationDependentType(),
2552 Element->isVariablyModifiedType(),
2553 Element->containsUnexpandedParameterPack()),
2554 ElementType(Element) {}
2555
2556public:
2557 QualType getElementType() const { return ElementType; }
2558
2559 bool isSugared() const { return false; }
2560 QualType desugar() const { return QualType(this, 0); }
2561
2562 void Profile(llvm::FoldingSetNodeID &ID) {
2563 Profile(ID, getElementType());
2564 }
2565
2566 static void Profile(llvm::FoldingSetNodeID &ID, QualType Element) {
2567 ID.AddPointer(Element.getAsOpaquePtr());
2568 }
2569
2570 static bool classof(const Type *T) { return T->getTypeClass() == Complex; }
2571};
2572
2573/// Sugar for parentheses used when specifying types.
2574class ParenType : public Type, public llvm::FoldingSetNode {
2575 friend class ASTContext; // ASTContext creates these.
2576
2577 QualType Inner;
2578
2579 ParenType(QualType InnerType, QualType CanonType)
2580 : Type(Paren, CanonType, InnerType->isDependentType(),
2581 InnerType->isInstantiationDependentType(),
2582 InnerType->isVariablyModifiedType(),
2583 InnerType->containsUnexpandedParameterPack()),
2584 Inner(InnerType) {}
2585
2586public:
2587 QualType getInnerType() const { return Inner; }
2588
2589 bool isSugared() const { return true; }
2590 QualType desugar() const { return getInnerType(); }
2591
2592 void Profile(llvm::FoldingSetNodeID &ID) {
2593 Profile(ID, getInnerType());
2594 }
2595
2596 static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner) {
2597 Inner.Profile(ID);
2598 }
2599
2600 static bool classof(const Type *T) { return T->getTypeClass() == Paren; }
2601};
2602
2603/// PointerType - C99 6.7.5.1 - Pointer Declarators.
2604class PointerType : public Type, public llvm::FoldingSetNode {
2605 friend class ASTContext; // ASTContext creates these.
2606
2607 QualType PointeeType;
2608
2609 PointerType(QualType Pointee, QualType CanonicalPtr)
2610 : Type(Pointer, CanonicalPtr, Pointee->isDependentType(),
2611 Pointee->isInstantiationDependentType(),
2612 Pointee->isVariablyModifiedType(),
2613 Pointee->containsUnexpandedParameterPack()),
2614 PointeeType(Pointee) {}
2615
2616public:
2617 QualType getPointeeType() const { return PointeeType; }
2618
2619 /// Returns true if address spaces of pointers overlap.
2620 /// OpenCL v2.0 defines conversion rules for pointers to different
2621 /// address spaces (OpenCLC v2.0 s6.5.5) and notion of overlapping
2622 /// address spaces.
2623 /// CL1.1 or CL1.2:
2624 /// address spaces overlap iff they are they same.
2625 /// CL2.0 adds:
2626 /// __generic overlaps with any address space except for __constant.
2627 bool isAddressSpaceOverlapping(const PointerType &other) const {
2628 Qualifiers thisQuals = PointeeType.getQualifiers();
2629 Qualifiers otherQuals = other.getPointeeType().getQualifiers();
2630 // Address spaces overlap if at least one of them is a superset of another
2631 return thisQuals.isAddressSpaceSupersetOf(otherQuals) ||
2632 otherQuals.isAddressSpaceSupersetOf(thisQuals);
2633 }
2634
2635 bool isSugared() const { return false; }
2636 QualType desugar() const { return QualType(this, 0); }
2637
2638 void Profile(llvm::FoldingSetNodeID &ID) {
2639 Profile(ID, getPointeeType());
2640 }
2641
2642 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
2643 ID.AddPointer(Pointee.getAsOpaquePtr());
2644 }
2645
2646 static bool classof(const Type *T) { return T->getTypeClass() == Pointer; }
2647};
2648
2649/// Represents a type which was implicitly adjusted by the semantic
2650/// engine for arbitrary reasons. For example, array and function types can
2651/// decay, and function types can have their calling conventions adjusted.
2652class AdjustedType : public Type, public llvm::FoldingSetNode {
2653 QualType OriginalTy;
2654 QualType AdjustedTy;
2655
2656protected:
2657 friend class ASTContext; // ASTContext creates these.
2658
2659 AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy,
2660 QualType CanonicalPtr)
2661 : Type(TC, CanonicalPtr, OriginalTy->isDependentType(),
2662 OriginalTy->isInstantiationDependentType(),
2663 OriginalTy->isVariablyModifiedType(),
2664 OriginalTy->containsUnexpandedParameterPack()),
2665 OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}
2666
2667public:
2668 QualType getOriginalType() const { return OriginalTy; }
2669 QualType getAdjustedType() const { return AdjustedTy; }
2670
2671 bool isSugared() const { return true; }
2672 QualType desugar() const { return AdjustedTy; }
2673
2674 void Profile(llvm::FoldingSetNodeID &ID) {
2675 Profile(ID, OriginalTy, AdjustedTy);
2676 }
2677
2678 static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New) {
2679 ID.AddPointer(Orig.getAsOpaquePtr());
2680 ID.AddPointer(New.getAsOpaquePtr());
2681 }
2682
2683 static bool classof(const Type *T) {
2684 return T->getTypeClass() == Adjusted || T->getTypeClass() == Decayed;
2685 }
2686};
2687
2688/// Represents a pointer type decayed from an array or function type.
2689class DecayedType : public AdjustedType {
2690 friend class ASTContext; // ASTContext creates these.
2691
2692 inline
2693 DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical);
2694
2695public:
2696 QualType getDecayedType() const { return getAdjustedType(); }
2697
2698 inline QualType getPointeeType() const;
2699
2700 static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
2701};
2702
2703/// Pointer to a block type.
2704/// This type is to represent types syntactically represented as
2705/// "void (^)(int)", etc. Pointee is required to always be a function type.
2706class BlockPointerType : public Type, public llvm::FoldingSetNode {
2707 friend class ASTContext; // ASTContext creates these.
2708
2709 // Block is some kind of pointer type
2710 QualType PointeeType;
2711
2712 BlockPointerType(QualType Pointee, QualType CanonicalCls)
2713 : Type(BlockPointer, CanonicalCls, Pointee->isDependentType(),
2714 Pointee->isInstantiationDependentType(),
2715 Pointee->isVariablyModifiedType(),
2716 Pointee->containsUnexpandedParameterPack()),
2717 PointeeType(Pointee) {}
2718
2719public:
2720 // Get the pointee type. Pointee is required to always be a function type.
2721 QualType getPointeeType() const { return PointeeType; }
2722
2723 bool isSugared() const { return false; }
2724 QualType desugar() const { return QualType(this, 0); }
2725
2726 void Profile(llvm::FoldingSetNodeID &ID) {
2727 Profile(ID, getPointeeType());
2728 }
2729
2730 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
2731 ID.AddPointer(Pointee.getAsOpaquePtr());
2732 }
2733
2734 static bool classof(const Type *T) {
2735 return T->getTypeClass() == BlockPointer;
2736 }
2737};
2738
2739/// Base for LValueReferenceType and RValueReferenceType
2740class ReferenceType : public Type, public llvm::FoldingSetNode {
2741 QualType PointeeType;
2742
2743protected:
2744 ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef,
2745 bool SpelledAsLValue)
2746 : Type(tc, CanonicalRef, Referencee->isDependentType(),
2747 Referencee->isInstantiationDependentType(),
2748 Referencee->isVariablyModifiedType(),
2749 Referencee->containsUnexpandedParameterPack()),
2750 PointeeType(Referencee) {
2751 ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
2752 ReferenceTypeBits.InnerRef = Referencee->isReferenceType();
2753 }
2754
2755public:
2756 bool isSpelledAsLValue() const { return ReferenceTypeBits.SpelledAsLValue; }
2757 bool isInnerRef() const { return ReferenceTypeBits.InnerRef; }
2758
2759 QualType getPointeeTypeAsWritten() const { return PointeeType; }
2760
2761 QualType getPointeeType() const {
2762 // FIXME: this might strip inner qualifiers; okay?
2763 const ReferenceType *T = this;
2764 while (T->isInnerRef())
2765 T = T->PointeeType->castAs<ReferenceType>();
2766 return T->PointeeType;
2767 }
2768
2769 void Profile(llvm::FoldingSetNodeID &ID) {
2770 Profile(ID, PointeeType, isSpelledAsLValue());
2771 }
2772
2773 static void Profile(llvm::FoldingSetNodeID &ID,
2774 QualType Referencee,
2775 bool SpelledAsLValue) {
2776 ID.AddPointer(Referencee.getAsOpaquePtr());
2777 ID.AddBoolean(SpelledAsLValue);
2778 }
2779
2780 static bool classof(const Type *T) {
2781 return T->getTypeClass() == LValueReference ||
2782 T->getTypeClass() == RValueReference;
2783 }
2784};
2785
2786/// An lvalue reference type, per C++11 [dcl.ref].
2787class LValueReferenceType : public ReferenceType {
2788 friend class ASTContext; // ASTContext creates these
2789
2790 LValueReferenceType(QualType Referencee, QualType CanonicalRef,
2791 bool SpelledAsLValue)
2792 : ReferenceType(LValueReference, Referencee, CanonicalRef,
2793 SpelledAsLValue) {}
2794
2795public:
2796 bool isSugared() const { return false; }
2797 QualType desugar() const { return QualType(this, 0); }
2798
2799 static bool classof(const Type *T) {
2800 return T->getTypeClass() == LValueReference;
2801 }
2802};
2803
2804/// An rvalue reference type, per C++11 [dcl.ref].
2805class RValueReferenceType : public ReferenceType {
2806 friend class ASTContext; // ASTContext creates these
2807
2808 RValueReferenceType(QualType Referencee, QualType CanonicalRef)
2809 : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {}
2810
2811public:
2812 bool isSugared() const { return false; }
2813 QualType desugar() const { return QualType(this, 0); }
2814
2815 static bool classof(const Type *T) {
2816 return T->getTypeClass() == RValueReference;
2817 }
2818};
2819
2820/// A pointer to member type per C++ 8.3.3 - Pointers to members.
2821///
2822/// This includes both pointers to data members and pointer to member functions.
2823class MemberPointerType : public Type, public llvm::FoldingSetNode {
2824 friend class ASTContext; // ASTContext creates these.
2825
2826 QualType PointeeType;
2827
2828 /// The class of which the pointee is a member. Must ultimately be a
2829 /// RecordType, but could be a typedef or a template parameter too.
2830 const Type *Class;
2831
2832 MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr)
2833 : Type(MemberPointer, CanonicalPtr,
2834 Cls->isDependentType() || Pointee->isDependentType(),
2835 (Cls->isInstantiationDependentType() ||
2836 Pointee->isInstantiationDependentType()),
2837 Pointee->isVariablyModifiedType(),
2838 (Cls->containsUnexpandedParameterPack() ||
2839 Pointee->containsUnexpandedParameterPack())),
2840 PointeeType(Pointee), Class(Cls) {}
2841
2842public:
2843 QualType getPointeeType() const { return PointeeType; }
2844
2845 /// Returns true if the member type (i.e. the pointee type) is a
2846 /// function type rather than a data-member type.
2847 bool isMemberFunctionPointer() const {
2848 return PointeeType->isFunctionProtoType();
2849 }
2850
2851 /// Returns true if the member type (i.e. the pointee type) is a
2852 /// data type rather than a function type.
2853 bool isMemberDataPointer() const {
2854 return !PointeeType->isFunctionProtoType();
2855 }
2856
2857 const Type *getClass() const { return Class; }
2858 CXXRecordDecl *getMostRecentCXXRecordDecl() const;
2859
2860 bool isSugared() const { return false; }
2861 QualType desugar() const { return QualType(this, 0); }
2862
2863 void Profile(llvm::FoldingSetNodeID &ID) {
2864 Profile(ID, getPointeeType(), getClass());
2865 }
2866
2867 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
2868 const Type *Class) {
2869 ID.AddPointer(Pointee.getAsOpaquePtr());
2870 ID.AddPointer(Class);
2871 }
2872
2873 static bool classof(const Type *T) {
2874 return T->getTypeClass() == MemberPointer;
2875 }
2876};
2877
2878/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
2879class ArrayType : public Type, public llvm::FoldingSetNode {
2880public:
2881 /// Capture whether this is a normal array (e.g. int X[4])
2882 /// an array with a static size (e.g. int X[static 4]), or an array
2883 /// with a star size (e.g. int X[*]).
2884 /// 'static' is only allowed on function parameters.
2885 enum ArraySizeModifier {
2886 Normal, Static, Star
2887 };
2888
2889private:
2890 /// The element type of the array.
2891 QualType ElementType;
2892
2893protected:
2894 friend class ASTContext; // ASTContext creates these.
2895
2896 ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm,
2897 unsigned tq, const Expr *sz = nullptr);
2898
2899public:
2900 QualType getElementType() const { return ElementType; }
2901
2902 ArraySizeModifier getSizeModifier() const {
2903 return ArraySizeModifier(ArrayTypeBits.SizeModifier);
2904 }
2905
2906 Qualifiers getIndexTypeQualifiers() const {
2907 return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers());
2908 }
2909
2910 unsigned getIndexTypeCVRQualifiers() const {
2911 return ArrayTypeBits.IndexTypeQuals;
2912 }
2913
2914 static bool classof(const Type *T) {
2915 return T->getTypeClass() == ConstantArray ||
2916 T->getTypeClass() == VariableArray ||
2917 T->getTypeClass() == IncompleteArray ||
2918 T->getTypeClass() == DependentSizedArray;
2919 }
2920};
2921
2922/// Represents the canonical version of C arrays with a specified constant size.
2923/// For example, the canonical type for 'int A[4 + 4*100]' is a
2924/// ConstantArrayType where the element type is 'int' and the size is 404.
2925class ConstantArrayType final
2926 : public ArrayType,
2927 private llvm::TrailingObjects<ConstantArrayType, const Expr *> {
2928 friend class ASTContext; // ASTContext creates these.
2929 friend TrailingObjects;
2930
2931 llvm::APInt Size; // Allows us to unique the type.
2932
2933 ConstantArrayType(QualType et, QualType can, const llvm::APInt &size,
2934 const Expr *sz, ArraySizeModifier sm, unsigned tq)
2935 : ArrayType(ConstantArray, et, can, sm, tq, sz), Size(size) {
2936 ConstantArrayTypeBits.HasStoredSizeExpr = sz != nullptr;
2937 if (ConstantArrayTypeBits.HasStoredSizeExpr) {
2938 assert(!can.isNull() && "canonical constant array should not have size")((!can.isNull() && "canonical constant array should not have size"
) ? static_cast<void> (0) : __assert_fail ("!can.isNull() && \"canonical constant array should not have size\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 2938, __PRETTY_FUNCTION__))
;
2939 *getTrailingObjects<const Expr*>() = sz;
2940 }
2941 }
2942
2943 unsigned numTrailingObjects(OverloadToken<const Expr*>) const {
2944 return ConstantArrayTypeBits.HasStoredSizeExpr;
2945 }
2946
2947public:
2948 const llvm::APInt &getSize() const { return Size; }
2949 const Expr *getSizeExpr() const {
2950 return ConstantArrayTypeBits.HasStoredSizeExpr
2951 ? *getTrailingObjects<const Expr *>()
2952 : nullptr;
2953 }
2954 bool isSugared() const { return false; }
2955 QualType desugar() const { return QualType(this, 0); }
2956
2957 /// Determine the number of bits required to address a member of
2958 // an array with the given element type and number of elements.
2959 static unsigned getNumAddressingBits(const ASTContext &Context,
2960 QualType ElementType,
2961 const llvm::APInt &NumElements);
2962
2963 /// Determine the maximum number of active bits that an array's size
2964 /// can require, which limits the maximum size of the array.
2965 static unsigned getMaxSizeBits(const ASTContext &Context);
2966
2967 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
2968 Profile(ID, Ctx, getElementType(), getSize(), getSizeExpr(),
2969 getSizeModifier(), getIndexTypeCVRQualifiers());
2970 }
2971
2972 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx,
2973 QualType ET, const llvm::APInt &ArraySize,
2974 const Expr *SizeExpr, ArraySizeModifier SizeMod,
2975 unsigned TypeQuals);
2976
2977 static bool classof(const Type *T) {
2978 return T->getTypeClass() == ConstantArray;
2979 }
2980};
2981
2982/// Represents a C array with an unspecified size. For example 'int A[]' has
2983/// an IncompleteArrayType where the element type is 'int' and the size is
2984/// unspecified.
2985class IncompleteArrayType : public ArrayType {
2986 friend class ASTContext; // ASTContext creates these.
2987
2988 IncompleteArrayType(QualType et, QualType can,
2989 ArraySizeModifier sm, unsigned tq)
2990 : ArrayType(IncompleteArray, et, can, sm, tq) {}
2991
2992public:
2993 friend class StmtIteratorBase;
2994
2995 bool isSugared() const { return false; }
2996 QualType desugar() const { return QualType(this, 0); }
2997
2998 static bool classof(const Type *T) {
2999 return T->getTypeClass() == IncompleteArray;
3000 }
3001
3002 void Profile(llvm::FoldingSetNodeID &ID) {
3003 Profile(ID, getElementType(), getSizeModifier(),
3004 getIndexTypeCVRQualifiers());
3005 }
3006
3007 static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
3008 ArraySizeModifier SizeMod, unsigned TypeQuals) {
3009 ID.AddPointer(ET.getAsOpaquePtr());
3010 ID.AddInteger(SizeMod);
3011 ID.AddInteger(TypeQuals);
3012 }
3013};
3014
3015/// Represents a C array with a specified size that is not an
3016/// integer-constant-expression. For example, 'int s[x+foo()]'.
3017/// Since the size expression is an arbitrary expression, we store it as such.
3018///
3019/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
3020/// should not be: two lexically equivalent variable array types could mean
3021/// different things, for example, these variables do not have the same type
3022/// dynamically:
3023///
3024/// void foo(int x) {
3025/// int Y[x];
3026/// ++x;
3027/// int Z[x];
3028/// }
3029class VariableArrayType : public ArrayType {
3030 friend class ASTContext; // ASTContext creates these.
3031
3032 /// An assignment-expression. VLA's are only permitted within
3033 /// a function block.
3034 Stmt *SizeExpr;
3035
3036 /// The range spanned by the left and right array brackets.
3037 SourceRange Brackets;
3038
3039 VariableArrayType(QualType et, QualType can, Expr *e,
3040 ArraySizeModifier sm, unsigned tq,
3041 SourceRange brackets)
3042 : ArrayType(VariableArray, et, can, sm, tq, e),
3043 SizeExpr((Stmt*) e), Brackets(brackets) {}
3044
3045public:
3046 friend class StmtIteratorBase;
3047
3048 Expr *getSizeExpr() const {
3049 // We use C-style casts instead of cast<> here because we do not wish
3050 // to have a dependency of Type.h on Stmt.h/Expr.h.
3051 return (Expr*) SizeExpr;
3052 }
3053
3054 SourceRange getBracketsRange() const { return Brackets; }
3055 SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
3056 SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }
3057
3058 bool isSugared() const { return false; }
3059 QualType desugar() const { return QualType(this, 0); }
3060
3061 static bool classof(const Type *T) {
3062 return T->getTypeClass() == VariableArray;
3063 }
3064
3065 void Profile(llvm::FoldingSetNodeID &ID) {
3066 llvm_unreachable("Cannot unique VariableArrayTypes.")::llvm::llvm_unreachable_internal("Cannot unique VariableArrayTypes."
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 3066)
;
3067 }
3068};
3069
3070/// Represents an array type in C++ whose size is a value-dependent expression.
3071///
3072/// For example:
3073/// \code
3074/// template<typename T, int Size>
3075/// class array {
3076/// T data[Size];
3077/// };
3078/// \endcode
3079///
3080/// For these types, we won't actually know what the array bound is
3081/// until template instantiation occurs, at which point this will
3082/// become either a ConstantArrayType or a VariableArrayType.
3083class DependentSizedArrayType : public ArrayType {
3084 friend class ASTContext; // ASTContext creates these.
3085
3086 const ASTContext &Context;
3087
3088 /// An assignment expression that will instantiate to the
3089 /// size of the array.
3090 ///
3091 /// The expression itself might be null, in which case the array
3092 /// type will have its size deduced from an initializer.
3093 Stmt *SizeExpr;
3094
3095 /// The range spanned by the left and right array brackets.
3096 SourceRange Brackets;
3097
3098 DependentSizedArrayType(const ASTContext &Context, QualType et, QualType can,
3099 Expr *e, ArraySizeModifier sm, unsigned tq,
3100 SourceRange brackets);
3101
3102public:
3103 friend class StmtIteratorBase;
3104
3105 Expr *getSizeExpr() const {
3106 // We use C-style casts instead of cast<> here because we do not wish
3107 // to have a dependency of Type.h on Stmt.h/Expr.h.
3108 return (Expr*) SizeExpr;
3109 }
3110
3111 SourceRange getBracketsRange() const { return Brackets; }
3112 SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
3113 SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }
3114
3115 bool isSugared() const { return false; }
3116 QualType desugar() const { return QualType(this, 0); }
3117
3118 static bool classof(const Type *T) {
3119 return T->getTypeClass() == DependentSizedArray;
3120 }
3121
3122 void Profile(llvm::FoldingSetNodeID &ID) {
3123 Profile(ID, Context, getElementType(),
3124 getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
3125 }
3126
3127 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3128 QualType ET, ArraySizeModifier SizeMod,
3129 unsigned TypeQuals, Expr *E);
3130};
3131
3132/// Represents an extended address space qualifier where the input address space
3133/// value is dependent. Non-dependent address spaces are not represented with a
3134/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
3135///
3136/// For example:
3137/// \code
3138/// template<typename T, int AddrSpace>
3139/// class AddressSpace {
3140/// typedef T __attribute__((address_space(AddrSpace))) type;
3141/// }
3142/// \endcode
3143class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
3144 friend class ASTContext;
3145
3146 const ASTContext &Context;
3147 Expr *AddrSpaceExpr;
3148 QualType PointeeType;
3149 SourceLocation loc;
3150
3151 DependentAddressSpaceType(const ASTContext &Context, QualType PointeeType,
3152 QualType can, Expr *AddrSpaceExpr,
3153 SourceLocation loc);
3154
3155public:
3156 Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; }
3157 QualType getPointeeType() const { return PointeeType; }
3158 SourceLocation getAttributeLoc() const { return loc; }
3159
3160 bool isSugared() const { return false; }
3161 QualType desugar() const { return QualType(this, 0); }
3162
3163 static bool classof(const Type *T) {
3164 return T->getTypeClass() == DependentAddressSpace;
3165 }
3166
3167 void Profile(llvm::FoldingSetNodeID &ID) {
3168 Profile(ID, Context, getPointeeType(), getAddrSpaceExpr());
3169 }
3170
3171 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3172 QualType PointeeType, Expr *AddrSpaceExpr);
3173};
3174
3175/// Represents an extended vector type where either the type or size is
3176/// dependent.
3177///
3178/// For example:
3179/// \code
3180/// template<typename T, int Size>
3181/// class vector {
3182/// typedef T __attribute__((ext_vector_type(Size))) type;
3183/// }
3184/// \endcode
3185class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
3186 friend class ASTContext;
3187
3188 const ASTContext &Context;
3189 Expr *SizeExpr;
3190
3191 /// The element type of the array.
3192 QualType ElementType;
3193
3194 SourceLocation loc;
3195
3196 DependentSizedExtVectorType(const ASTContext &Context, QualType ElementType,
3197 QualType can, Expr *SizeExpr, SourceLocation loc);
3198
3199public:
3200 Expr *getSizeExpr() const { return SizeExpr; }
3201 QualType getElementType() const { return ElementType; }
3202 SourceLocation getAttributeLoc() const { return loc; }
3203
3204 bool isSugared() const { return false; }
3205 QualType desugar() const { return QualType(this, 0); }
3206
3207 static bool classof(const Type *T) {
3208 return T->getTypeClass() == DependentSizedExtVector;
3209 }
3210
3211 void Profile(llvm::FoldingSetNodeID &ID) {
3212 Profile(ID, Context, getElementType(), getSizeExpr());
3213 }
3214
3215 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3216 QualType ElementType, Expr *SizeExpr);
3217};
3218
3219
3220/// Represents a GCC generic vector type. This type is created using
3221/// __attribute__((vector_size(n)), where "n" specifies the vector size in
3222/// bytes; or from an Altivec __vector or vector declaration.
3223/// Since the constructor takes the number of vector elements, the
3224/// client is responsible for converting the size into the number of elements.
3225class VectorType : public Type, public llvm::FoldingSetNode {
3226public:
3227 enum VectorKind {
3228 /// not a target-specific vector type
3229 GenericVector,
3230
3231 /// is AltiVec vector
3232 AltiVecVector,
3233
3234 /// is AltiVec 'vector Pixel'
3235 AltiVecPixel,
3236
3237 /// is AltiVec 'vector bool ...'
3238 AltiVecBool,
3239
3240 /// is ARM Neon vector
3241 NeonVector,
3242
3243 /// is ARM Neon polynomial vector
3244 NeonPolyVector
3245 };
3246
3247protected:
3248 friend class ASTContext; // ASTContext creates these.
3249
3250 /// The element type of the vector.
3251 QualType ElementType;
3252
3253 VectorType(QualType vecType, unsigned nElements, QualType canonType,
3254 VectorKind vecKind);
3255
3256 VectorType(TypeClass tc, QualType vecType, unsigned nElements,
3257 QualType canonType, VectorKind vecKind);
3258
3259public:
3260 QualType getElementType() const { return ElementType; }
3261 unsigned getNumElements() const { return VectorTypeBits.NumElements; }
3262
3263 static bool isVectorSizeTooLarge(unsigned NumElements) {
3264 return NumElements > VectorTypeBitfields::MaxNumElements;
3265 }
3266
3267 bool isSugared() const { return false; }
3268 QualType desugar() const { return QualType(this, 0); }
3269
3270 VectorKind getVectorKind() const {
3271 return VectorKind(VectorTypeBits.VecKind);
3272 }
3273
3274 void Profile(llvm::FoldingSetNodeID &ID) {
3275 Profile(ID, getElementType(), getNumElements(),
3276 getTypeClass(), getVectorKind());
3277 }
3278
3279 static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
3280 unsigned NumElements, TypeClass TypeClass,
3281 VectorKind VecKind) {
3282 ID.AddPointer(ElementType.getAsOpaquePtr());
3283 ID.AddInteger(NumElements);
3284 ID.AddInteger(TypeClass);
3285 ID.AddInteger(VecKind);
3286 }
3287
3288 static bool classof(const Type *T) {
3289 return T->getTypeClass() == Vector || T->getTypeClass() == ExtVector;
3290 }
3291};
3292
3293/// Represents a vector type where either the type or size is dependent.
3294////
3295/// For example:
3296/// \code
3297/// template<typename T, int Size>
3298/// class vector {
3299/// typedef T __attribute__((vector_size(Size))) type;
3300/// }
3301/// \endcode
3302class DependentVectorType : public Type, public llvm::FoldingSetNode {
3303 friend class ASTContext;
3304
3305 const ASTContext &Context;
3306 QualType ElementType;
3307 Expr *SizeExpr;
3308 SourceLocation Loc;
3309
3310 DependentVectorType(const ASTContext &Context, QualType ElementType,
3311 QualType CanonType, Expr *SizeExpr,
3312 SourceLocation Loc, VectorType::VectorKind vecKind);
3313
3314public:
3315 Expr *getSizeExpr() const { return SizeExpr; }
3316 QualType getElementType() const { return ElementType; }
3317 SourceLocation getAttributeLoc() const { return Loc; }
3318 VectorType::VectorKind getVectorKind() const {
3319 return VectorType::VectorKind(VectorTypeBits.VecKind);
3320 }
3321
3322 bool isSugared() const { return false; }
3323 QualType desugar() const { return QualType(this, 0); }
3324
3325 static bool classof(const Type *T) {
3326 return T->getTypeClass() == DependentVector;
3327 }
3328
3329 void Profile(llvm::FoldingSetNodeID &ID) {
3330 Profile(ID, Context, getElementType(), getSizeExpr(), getVectorKind());
3331 }
3332
3333 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3334 QualType ElementType, const Expr *SizeExpr,
3335 VectorType::VectorKind VecKind);
3336};
3337
3338/// ExtVectorType - Extended vector type. This type is created using
3339/// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
3340/// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
3341/// class enables syntactic extensions, like Vector Components for accessing
3342/// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
3343/// Shading Language).
3344class ExtVectorType : public VectorType {
3345 friend class ASTContext; // ASTContext creates these.
3346
3347 ExtVectorType(QualType vecType, unsigned nElements, QualType canonType)
3348 : VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {}
3349
3350public:
3351 static int getPointAccessorIdx(char c) {
3352 switch (c) {
3353 default: return -1;
3354 case 'x': case 'r': return 0;
3355 case 'y': case 'g': return 1;
3356 case 'z': case 'b': return 2;
3357 case 'w': case 'a': return 3;
3358 }
3359 }
3360
3361 static int getNumericAccessorIdx(char c) {
3362 switch (c) {
3363 default: return -1;
3364 case '0': return 0;
3365 case '1': return 1;
3366 case '2': return 2;
3367 case '3': return 3;
3368 case '4': return 4;
3369 case '5': return 5;
3370 case '6': return 6;
3371 case '7': return 7;
3372 case '8': return 8;
3373 case '9': return 9;
3374 case 'A':
3375 case 'a': return 10;
3376 case 'B':
3377 case 'b': return 11;
3378 case 'C':
3379 case 'c': return 12;
3380 case 'D':
3381 case 'd': return 13;
3382 case 'E':
3383 case 'e': return 14;
3384 case 'F':
3385 case 'f': return 15;
3386 }
3387 }
3388
3389 static int getAccessorIdx(char c, bool isNumericAccessor) {
3390 if (isNumericAccessor)
3391 return getNumericAccessorIdx(c);
3392 else
3393 return getPointAccessorIdx(c);
3394 }
3395
3396 bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const {
3397 if (int idx = getAccessorIdx(c, isNumericAccessor)+1)
3398 return unsigned(idx-1) < getNumElements();
3399 return false;
3400 }
3401
3402 bool isSugared() const { return false; }
3403 QualType desugar() const { return QualType(this, 0); }
3404
3405 static bool classof(const Type *T) {
3406 return T->getTypeClass() == ExtVector;
3407 }
3408};
3409
3410/// FunctionType - C99 6.7.5.3 - Function Declarators. This is the common base
3411/// class of FunctionNoProtoType and FunctionProtoType.
3412class FunctionType : public Type {
3413 // The type returned by the function.
3414 QualType ResultType;
3415
3416public:
3417 /// Interesting information about a specific parameter that can't simply
3418 /// be reflected in parameter's type. This is only used by FunctionProtoType
3419 /// but is in FunctionType to make this class available during the
3420 /// specification of the bases of FunctionProtoType.
3421 ///
3422 /// It makes sense to model language features this way when there's some
3423 /// sort of parameter-specific override (such as an attribute) that
3424 /// affects how the function is called. For example, the ARC ns_consumed
3425 /// attribute changes whether a parameter is passed at +0 (the default)
3426 /// or +1 (ns_consumed). This must be reflected in the function type,
3427 /// but isn't really a change to the parameter type.
3428 ///
3429 /// One serious disadvantage of modelling language features this way is
3430 /// that they generally do not work with language features that attempt
3431 /// to destructure types. For example, template argument deduction will
3432 /// not be able to match a parameter declared as
3433 /// T (*)(U)
3434 /// against an argument of type
3435 /// void (*)(__attribute__((ns_consumed)) id)
3436 /// because the substitution of T=void, U=id into the former will
3437 /// not produce the latter.
3438 class ExtParameterInfo {
3439 enum {
3440 ABIMask = 0x0F,
3441 IsConsumed = 0x10,
3442 HasPassObjSize = 0x20,
3443 IsNoEscape = 0x40,
3444 };
3445 unsigned char Data = 0;
3446
3447 public:
3448 ExtParameterInfo() = default;
3449
3450 /// Return the ABI treatment of this parameter.
3451 ParameterABI getABI() const { return ParameterABI(Data & ABIMask); }
3452 ExtParameterInfo withABI(ParameterABI kind) const {
3453 ExtParameterInfo copy = *this;
3454 copy.Data = (copy.Data & ~ABIMask) | unsigned(kind);
3455 return copy;
3456 }
3457
3458 /// Is this parameter considered "consumed" by Objective-C ARC?
3459 /// Consumed parameters must have retainable object type.
3460 bool isConsumed() const { return (Data & IsConsumed); }
3461 ExtParameterInfo withIsConsumed(bool consumed) const {
3462 ExtParameterInfo copy = *this;
3463 if (consumed)
3464 copy.Data |= IsConsumed;
3465 else
3466 copy.Data &= ~IsConsumed;
3467 return copy;
3468 }
3469
3470 bool hasPassObjectSize() const { return Data & HasPassObjSize; }
3471 ExtParameterInfo withHasPassObjectSize() const {
3472 ExtParameterInfo Copy = *this;
3473 Copy.Data |= HasPassObjSize;
3474 return Copy;
3475 }
3476
3477 bool isNoEscape() const { return Data & IsNoEscape; }
3478 ExtParameterInfo withIsNoEscape(bool NoEscape) const {
3479 ExtParameterInfo Copy = *this;
3480 if (NoEscape)
3481 Copy.Data |= IsNoEscape;
3482 else
3483 Copy.Data &= ~IsNoEscape;
3484 return Copy;
3485 }
3486
3487 unsigned char getOpaqueValue() const { return Data; }
3488 static ExtParameterInfo getFromOpaqueValue(unsigned char data) {
3489 ExtParameterInfo result;
3490 result.Data = data;
3491 return result;
3492 }
3493
3494 friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs) {
3495 return lhs.Data == rhs.Data;
3496 }
3497
3498 friend bool operator!=(ExtParameterInfo lhs, ExtParameterInfo rhs) {
3499 return lhs.Data != rhs.Data;
3500 }
3501 };
3502
3503 /// A class which abstracts out some details necessary for
3504 /// making a call.
3505 ///
3506 /// It is not actually used directly for storing this information in
3507 /// a FunctionType, although FunctionType does currently use the
3508 /// same bit-pattern.
3509 ///
3510 // If you add a field (say Foo), other than the obvious places (both,
3511 // constructors, compile failures), what you need to update is
3512 // * Operator==
3513 // * getFoo
3514 // * withFoo
3515 // * functionType. Add Foo, getFoo.
3516 // * ASTContext::getFooType
3517 // * ASTContext::mergeFunctionTypes
3518 // * FunctionNoProtoType::Profile
3519 // * FunctionProtoType::Profile
3520 // * TypePrinter::PrintFunctionProto
3521 // * AST read and write
3522 // * Codegen
3523 class ExtInfo {
3524 friend class FunctionType;
3525
3526 // Feel free to rearrange or add bits, but if you go over 12,
3527 // you'll need to adjust both the Bits field below and
3528 // Type::FunctionTypeBitfields.
3529
3530 // | CC |noreturn|produces|nocallersavedregs|regparm|nocfcheck|
3531 // |0 .. 4| 5 | 6 | 7 |8 .. 10| 11 |
3532 //
3533 // regparm is either 0 (no regparm attribute) or the regparm value+1.
3534 enum { CallConvMask = 0x1F };
3535 enum { NoReturnMask = 0x20 };
3536 enum { ProducesResultMask = 0x40 };
3537 enum { NoCallerSavedRegsMask = 0x80 };
3538 enum { NoCfCheckMask = 0x800 };
3539 enum {
3540 RegParmMask = ~(CallConvMask | NoReturnMask | ProducesResultMask |
3541 NoCallerSavedRegsMask | NoCfCheckMask),
3542 RegParmOffset = 8
3543 }; // Assumed to be the last field
3544 uint16_t Bits = CC_C;
3545
3546 ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}
3547
3548 public:
3549 // Constructor with no defaults. Use this when you know that you
3550 // have all the elements (when reading an AST file for example).
3551 ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc,
3552 bool producesResult, bool noCallerSavedRegs, bool NoCfCheck) {
3553 assert((!hasRegParm || regParm < 7) && "Invalid regparm value")(((!hasRegParm || regParm < 7) && "Invalid regparm value"
) ? static_cast<void> (0) : __assert_fail ("(!hasRegParm || regParm < 7) && \"Invalid regparm value\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 3553, __PRETTY_FUNCTION__))
;
3554 Bits = ((unsigned)cc) | (noReturn ? NoReturnMask : 0) |
3555 (producesResult ? ProducesResultMask : 0) |
3556 (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
3557 (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
3558 (NoCfCheck ? NoCfCheckMask : 0);
3559 }
3560
3561 // Constructor with all defaults. Use when for example creating a
3562 // function known to use defaults.
3563 ExtInfo() = default;
3564
3565 // Constructor with just the calling convention, which is an important part
3566 // of the canonical type.
3567 ExtInfo(CallingConv CC) : Bits(CC) {}
3568
3569 bool getNoReturn() const { return Bits & NoReturnMask; }
3570 bool getProducesResult() const { return Bits & ProducesResultMask; }
3571 bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; }
3572 bool getNoCfCheck() const { return Bits & NoCfCheckMask; }
3573 bool getHasRegParm() const { return (Bits >> RegParmOffset) != 0; }
3574
3575 unsigned getRegParm() const {
3576 unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
3577 if (RegParm > 0)
3578 --RegParm;
3579 return RegParm;
3580 }
3581
3582 CallingConv getCC() const { return CallingConv(Bits & CallConvMask); }
3583
3584 bool operator==(ExtInfo Other) const {
3585 return Bits == Other.Bits;
3586 }
3587 bool operator!=(ExtInfo Other) const {
3588 return Bits != Other.Bits;
3589 }
3590
3591 // Note that we don't have setters. That is by design, use
3592 // the following with methods instead of mutating these objects.
3593
3594 ExtInfo withNoReturn(bool noReturn) const {
3595 if (noReturn)
3596 return ExtInfo(Bits | NoReturnMask);
3597 else
3598 return ExtInfo(Bits & ~NoReturnMask);
3599 }
3600
3601 ExtInfo withProducesResult(bool producesResult) const {
3602 if (producesResult)
3603 return ExtInfo(Bits | ProducesResultMask);
3604 else
3605 return ExtInfo(Bits & ~ProducesResultMask);
3606 }
3607
3608 ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const {
3609 if (noCallerSavedRegs)
3610 return ExtInfo(Bits | NoCallerSavedRegsMask);
3611 else
3612 return ExtInfo(Bits & ~NoCallerSavedRegsMask);
3613 }
3614
3615 ExtInfo withNoCfCheck(bool noCfCheck) const {
3616 if (noCfCheck)
3617 return ExtInfo(Bits | NoCfCheckMask);
3618 else
3619 return ExtInfo(Bits & ~NoCfCheckMask);
3620 }
3621
3622 ExtInfo withRegParm(unsigned RegParm) const {
3623 assert(RegParm < 7 && "Invalid regparm value")((RegParm < 7 && "Invalid regparm value") ? static_cast
<void> (0) : __assert_fail ("RegParm < 7 && \"Invalid regparm value\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 3623, __PRETTY_FUNCTION__))
;
3624 return ExtInfo((Bits & ~RegParmMask) |
3625 ((RegParm + 1) << RegParmOffset));
3626 }
3627
3628 ExtInfo withCallingConv(CallingConv cc) const {
3629 return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc);
3630 }
3631
3632 void Profile(llvm::FoldingSetNodeID &ID) const {
3633 ID.AddInteger(Bits);
3634 }
3635 };
3636
3637 /// A simple holder for a QualType representing a type in an
3638 /// exception specification. Unfortunately needed by FunctionProtoType
3639 /// because TrailingObjects cannot handle repeated types.
3640 struct ExceptionType { QualType Type; };
3641
3642 /// A simple holder for various uncommon bits which do not fit in
3643 /// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the
3644 /// alignment of subsequent objects in TrailingObjects. You must update
3645 /// hasExtraBitfields in FunctionProtoType after adding extra data here.
3646 struct alignas(void *) FunctionTypeExtraBitfields {
3647 /// The number of types in the exception specification.
3648 /// A whole unsigned is not needed here and according to
3649 /// [implimits] 8 bits would be enough here.
3650 unsigned NumExceptionType;
3651 };
3652
3653protected:
3654 FunctionType(TypeClass tc, QualType res,
3655 QualType Canonical, bool Dependent,
3656 bool InstantiationDependent,
3657 bool VariablyModified, bool ContainsUnexpandedParameterPack,
3658 ExtInfo Info)
3659 : Type(tc, Canonical, Dependent, InstantiationDependent, VariablyModified,
3660 ContainsUnexpandedParameterPack),
3661 ResultType(res) {
3662 FunctionTypeBits.ExtInfo = Info.Bits;
3663 }
3664
3665 Qualifiers getFastTypeQuals() const {
3666 return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
3667 }
3668
3669public:
3670 QualType getReturnType() const { return ResultType; }
3671
3672 bool getHasRegParm() const { return getExtInfo().getHasRegParm(); }
3673 unsigned getRegParmType() const { return getExtInfo().getRegParm(); }
3674
3675 /// Determine whether this function type includes the GNU noreturn
3676 /// attribute. The C++11 [[noreturn]] attribute does not affect the function
3677 /// type.
3678 bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); }
3679
3680 CallingConv getCallConv() const { return getExtInfo().getCC(); }
3681 ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); }
3682
3683 static_assert((~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
3684 "Const, volatile and restrict are assumed to be a subset of "
3685 "the fast qualifiers.");
3686
3687 bool isConst() const { return getFastTypeQuals().hasConst(); }
3688 bool isVolatile() const { return getFastTypeQuals().hasVolatile(); }
3689 bool isRestrict() const { return getFastTypeQuals().hasRestrict(); }
3690
3691 /// Determine the type of an expression that calls a function of
3692 /// this type.
3693 QualType getCallResultType(const ASTContext &Context) const {
3694 return getReturnType().getNonLValueExprType(Context);
3695 }
3696
3697 static StringRef getNameForCallConv(CallingConv CC);
3698
3699 static bool classof(const Type *T) {
3700 return T->getTypeClass() == FunctionNoProto ||
3701 T->getTypeClass() == FunctionProto;
3702 }
3703};
3704
3705/// Represents a K&R-style 'int foo()' function, which has
3706/// no information available about its arguments.
3707class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
3708 friend class ASTContext; // ASTContext creates these.
3709
3710 FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info)
3711 : FunctionType(FunctionNoProto, Result, Canonical,
3712 /*Dependent=*/false, /*InstantiationDependent=*/false,
3713 Result->isVariablyModifiedType(),
3714 /*ContainsUnexpandedParameterPack=*/false, Info) {}
3715
3716public:
3717 // No additional state past what FunctionType provides.
3718
3719 bool isSugared() const { return false; }
3720 QualType desugar() const { return QualType(this, 0); }
3721
3722 void Profile(llvm::FoldingSetNodeID &ID) {
3723 Profile(ID, getReturnType(), getExtInfo());
3724 }
3725
3726 static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType,
3727 ExtInfo Info) {
3728 Info.Profile(ID);
3729 ID.AddPointer(ResultType.getAsOpaquePtr());
3730 }
3731
3732 static bool classof(const Type *T) {
3733 return T->getTypeClass() == FunctionNoProto;
3734 }
3735};
3736
3737/// Represents a prototype with parameter type info, e.g.
3738/// 'int foo(int)' or 'int foo(void)'. 'void' is represented as having no
3739/// parameters, not as having a single void parameter. Such a type can have
3740/// an exception specification, but this specification is not part of the
3741/// canonical type. FunctionProtoType has several trailing objects, some of
3742/// which optional. For more information about the trailing objects see
3743/// the first comment inside FunctionProtoType.
3744class FunctionProtoType final
3745 : public FunctionType,
3746 public llvm::FoldingSetNode,
3747 private llvm::TrailingObjects<
3748 FunctionProtoType, QualType, SourceLocation,
3749 FunctionType::FunctionTypeExtraBitfields, FunctionType::ExceptionType,
3750 Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers> {
3751 friend class ASTContext; // ASTContext creates these.
3752 friend TrailingObjects;
3753
3754 // FunctionProtoType is followed by several trailing objects, some of
3755 // which optional. They are in order:
3756 //
3757 // * An array of getNumParams() QualType holding the parameter types.
3758 // Always present. Note that for the vast majority of FunctionProtoType,
3759 // these will be the only trailing objects.
3760 //
3761 // * Optionally if the function is variadic, the SourceLocation of the
3762 // ellipsis.
3763 //
3764 // * Optionally if some extra data is stored in FunctionTypeExtraBitfields
3765 // (see FunctionTypeExtraBitfields and FunctionTypeBitfields):
3766 // a single FunctionTypeExtraBitfields. Present if and only if
3767 // hasExtraBitfields() is true.
3768 //
3769 // * Optionally exactly one of:
3770 // * an array of getNumExceptions() ExceptionType,
3771 // * a single Expr *,
3772 // * a pair of FunctionDecl *,
3773 // * a single FunctionDecl *
3774 // used to store information about the various types of exception
3775 // specification. See getExceptionSpecSize for the details.
3776 //
3777 // * Optionally an array of getNumParams() ExtParameterInfo holding
3778 // an ExtParameterInfo for each of the parameters. Present if and
3779 // only if hasExtParameterInfos() is true.
3780 //
3781 // * Optionally a Qualifiers object to represent extra qualifiers that can't
3782 // be represented by FunctionTypeBitfields.FastTypeQuals. Present if and only
3783 // if hasExtQualifiers() is true.
3784 //
3785 // The optional FunctionTypeExtraBitfields has to be before the data
3786 // related to the exception specification since it contains the number
3787 // of exception types.
3788 //
3789 // We put the ExtParameterInfos last. If all were equal, it would make
3790 // more sense to put these before the exception specification, because
3791 // it's much easier to skip past them compared to the elaborate switch
3792 // required to skip the exception specification. However, all is not
3793 // equal; ExtParameterInfos are used to model very uncommon features,
3794 // and it's better not to burden the more common paths.
3795
3796public:
3797 /// Holds information about the various types of exception specification.
3798 /// ExceptionSpecInfo is not stored as such in FunctionProtoType but is
3799 /// used to group together the various bits of information about the
3800 /// exception specification.
3801 struct ExceptionSpecInfo {
3802 /// The kind of exception specification this is.
3803 ExceptionSpecificationType Type = EST_None;
3804
3805 /// Explicitly-specified list of exception types.
3806 ArrayRef<QualType> Exceptions;
3807
3808 /// Noexcept expression, if this is a computed noexcept specification.
3809 Expr *NoexceptExpr = nullptr;
3810
3811 /// The function whose exception specification this is, for
3812 /// EST_Unevaluated and EST_Uninstantiated.
3813 FunctionDecl *SourceDecl = nullptr;
3814
3815 /// The function template whose exception specification this is instantiated
3816 /// from, for EST_Uninstantiated.
3817 FunctionDecl *SourceTemplate = nullptr;
3818
3819 ExceptionSpecInfo() = default;
3820
3821 ExceptionSpecInfo(ExceptionSpecificationType EST) : Type(EST) {}
3822 };
3823
3824 /// Extra information about a function prototype. ExtProtoInfo is not
3825 /// stored as such in FunctionProtoType but is used to group together
3826 /// the various bits of extra information about a function prototype.
3827 struct ExtProtoInfo {
3828 FunctionType::ExtInfo ExtInfo;
3829 bool Variadic : 1;
3830 bool HasTrailingReturn : 1;
3831 Qualifiers TypeQuals;
3832 RefQualifierKind RefQualifier = RQ_None;
3833 ExceptionSpecInfo ExceptionSpec;
3834 const ExtParameterInfo *ExtParameterInfos = nullptr;
3835 SourceLocation EllipsisLoc;
3836
3837 ExtProtoInfo() : Variadic(false), HasTrailingReturn(false) {}
3838
3839 ExtProtoInfo(CallingConv CC)
3840 : ExtInfo(CC), Variadic(false), HasTrailingReturn(false) {}
3841
3842 ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI) {
3843 ExtProtoInfo Result(*this);
3844 Result.ExceptionSpec = ESI;
3845 return Result;
3846 }
3847 };
3848
3849private:
3850 unsigned numTrailingObjects(OverloadToken<QualType>) const {
3851 return getNumParams();
3852 }
3853
3854 unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {
3855 return isVariadic();
3856 }
3857
3858 unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>) const {
3859 return hasExtraBitfields();
3860 }
3861
3862 unsigned numTrailingObjects(OverloadToken<ExceptionType>) const {
3863 return getExceptionSpecSize().NumExceptionType;
3864 }
3865
3866 unsigned numTrailingObjects(OverloadToken<Expr *>) const {
3867 return getExceptionSpecSize().NumExprPtr;
3868 }
3869
3870 unsigned numTrailingObjects(OverloadToken<FunctionDecl *>) const {
3871 return getExceptionSpecSize().NumFunctionDeclPtr;
3872 }
3873
3874 unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
3875 return hasExtParameterInfos() ? getNumParams() : 0;
3876 }
3877
3878 /// Determine whether there are any argument types that
3879 /// contain an unexpanded parameter pack.
3880 static bool containsAnyUnexpandedParameterPack(const QualType *ArgArray,
3881 unsigned numArgs) {
3882 for (unsigned Idx = 0; Idx < numArgs; ++Idx)
3883 if (ArgArray[Idx]->containsUnexpandedParameterPack())
3884 return true;
3885
3886 return false;
3887 }
3888
3889 FunctionProtoType(QualType result, ArrayRef<QualType> params,
3890 QualType canonical, const ExtProtoInfo &epi);
3891
3892 /// This struct is returned by getExceptionSpecSize and is used to
3893 /// translate an ExceptionSpecificationType to the number and kind
3894 /// of trailing objects related to the exception specification.
3895 struct ExceptionSpecSizeHolder {
3896 unsigned NumExceptionType;
3897 unsigned NumExprPtr;
3898 unsigned NumFunctionDeclPtr;
3899 };
3900
3901 /// Return the number and kind of trailing objects
3902 /// related to the exception specification.
3903 static ExceptionSpecSizeHolder
3904 getExceptionSpecSize(ExceptionSpecificationType EST, unsigned NumExceptions) {
3905 switch (EST) {
3906 case EST_None:
3907 case EST_DynamicNone:
3908 case EST_MSAny:
3909 case EST_BasicNoexcept:
3910 case EST_Unparsed:
3911 case EST_NoThrow:
3912 return {0, 0, 0};
3913
3914 case EST_Dynamic:
3915 return {NumExceptions, 0, 0};
3916
3917 case EST_DependentNoexcept:
3918 case EST_NoexceptFalse:
3919 case EST_NoexceptTrue:
3920 return {0, 1, 0};
3921
3922 case EST_Uninstantiated:
3923 return {0, 0, 2};
3924
3925 case EST_Unevaluated:
3926 return {0, 0, 1};
3927 }
3928 llvm_unreachable("bad exception specification kind")::llvm::llvm_unreachable_internal("bad exception specification kind"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 3928)
;
3929 }
3930
3931 /// Return the number and kind of trailing objects
3932 /// related to the exception specification.
3933 ExceptionSpecSizeHolder getExceptionSpecSize() const {
3934 return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
3935 }
3936
3937 /// Whether the trailing FunctionTypeExtraBitfields is present.
3938 static bool hasExtraBitfields(ExceptionSpecificationType EST) {
3939 // If the exception spec type is EST_Dynamic then we have > 0 exception
3940 // types and the exact number is stored in FunctionTypeExtraBitfields.
3941 return EST == EST_Dynamic;
3942 }
3943
3944 /// Whether the trailing FunctionTypeExtraBitfields is present.
3945 bool hasExtraBitfields() const {
3946 return hasExtraBitfields(getExceptionSpecType());
3947 }
3948
3949 bool hasExtQualifiers() const {
3950 return FunctionTypeBits.HasExtQuals;
3951 }
3952
3953public:
3954 unsigned getNumParams() const { return FunctionTypeBits.NumParams; }
3955
3956 QualType getParamType(unsigned i) const {
3957 assert(i < getNumParams() && "invalid parameter index")((i < getNumParams() && "invalid parameter index")
? static_cast<void> (0) : __assert_fail ("i < getNumParams() && \"invalid parameter index\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 3957, __PRETTY_FUNCTION__))
;
3958 return param_type_begin()[i];
3959 }
3960
3961 ArrayRef<QualType> getParamTypes() const {
3962 return llvm::makeArrayRef(param_type_begin(), param_type_end());
3963 }
3964
3965 ExtProtoInfo getExtProtoInfo() const {
3966 ExtProtoInfo EPI;
3967 EPI.ExtInfo = getExtInfo();
3968 EPI.Variadic = isVariadic();
3969 EPI.EllipsisLoc = getEllipsisLoc();
3970 EPI.HasTrailingReturn = hasTrailingReturn();
3971 EPI.ExceptionSpec = getExceptionSpecInfo();
3972 EPI.TypeQuals = getMethodQuals();
3973 EPI.RefQualifier = getRefQualifier();
3974 EPI.ExtParameterInfos = getExtParameterInfosOrNull();
3975 return EPI;
3976 }
3977
3978 /// Get the kind of exception specification on this function.
3979 ExceptionSpecificationType getExceptionSpecType() const {
3980 return static_cast<ExceptionSpecificationType>(
3981 FunctionTypeBits.ExceptionSpecType);
3982 }
3983
3984 /// Return whether this function has any kind of exception spec.
3985 bool hasExceptionSpec() const { return getExceptionSpecType() != EST_None; }
3986
3987 /// Return whether this function has a dynamic (throw) exception spec.
3988 bool hasDynamicExceptionSpec() const {
3989 return isDynamicExceptionSpec(getExceptionSpecType());
3990 }
3991
3992 /// Return whether this function has a noexcept exception spec.
3993 bool hasNoexceptExceptionSpec() const {
3994 return isNoexceptExceptionSpec(getExceptionSpecType());
3995 }
3996
3997 /// Return whether this function has a dependent exception spec.
3998 bool hasDependentExceptionSpec() const;
3999
4000 /// Return whether this function has an instantiation-dependent exception
4001 /// spec.
4002 bool hasInstantiationDependentExceptionSpec() const;
4003
4004 /// Return all the available information about this type's exception spec.
4005 ExceptionSpecInfo getExceptionSpecInfo() const {
4006 ExceptionSpecInfo Result;
4007 Result.Type = getExceptionSpecType();
4008 if (Result.Type == EST_Dynamic) {
4009 Result.Exceptions = exceptions();
4010 } else if (isComputedNoexcept(Result.Type)) {
4011 Result.NoexceptExpr = getNoexceptExpr();
4012 } else if (Result.Type == EST_Uninstantiated) {
4013 Result.SourceDecl = getExceptionSpecDecl();
4014 Result.SourceTemplate = getExceptionSpecTemplate();
4015 } else if (Result.Type == EST_Unevaluated) {
4016 Result.SourceDecl = getExceptionSpecDecl();
4017 }
4018 return Result;
4019 }
4020
4021 /// Return the number of types in the exception specification.
4022 unsigned getNumExceptions() const {
4023 return getExceptionSpecType() == EST_Dynamic
4024 ? getTrailingObjects<FunctionTypeExtraBitfields>()
4025 ->NumExceptionType
4026 : 0;
4027 }
4028
4029 /// Return the ith exception type, where 0 <= i < getNumExceptions().
4030 QualType getExceptionType(unsigned i) const {
4031 assert(i < getNumExceptions() && "Invalid exception number!")((i < getNumExceptions() && "Invalid exception number!"
) ? static_cast<void> (0) : __assert_fail ("i < getNumExceptions() && \"Invalid exception number!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4031, __PRETTY_FUNCTION__))
;
4032 return exception_begin()[i];
4033 }
4034
4035 /// Return the expression inside noexcept(expression), or a null pointer
4036 /// if there is none (because the exception spec is not of this form).
4037 Expr *getNoexceptExpr() const {
4038 if (!isComputedNoexcept(getExceptionSpecType()))
4039 return nullptr;
4040 return *getTrailingObjects<Expr *>();
4041 }
4042
4043 /// If this function type has an exception specification which hasn't
4044 /// been determined yet (either because it has not been evaluated or because
4045 /// it has not been instantiated), this is the function whose exception
4046 /// specification is represented by this type.
4047 FunctionDecl *getExceptionSpecDecl() const {
4048 if (getExceptionSpecType() != EST_Uninstantiated &&
4049 getExceptionSpecType() != EST_Unevaluated)
4050 return nullptr;
4051 return getTrailingObjects<FunctionDecl *>()[0];
4052 }
4053
4054 /// If this function type has an uninstantiated exception
4055 /// specification, this is the function whose exception specification
4056 /// should be instantiated to find the exception specification for
4057 /// this type.
4058 FunctionDecl *getExceptionSpecTemplate() const {
4059 if (getExceptionSpecType() != EST_Uninstantiated)
4060 return nullptr;
4061 return getTrailingObjects<FunctionDecl *>()[1];
4062 }
4063
4064 /// Determine whether this function type has a non-throwing exception
4065 /// specification.
4066 CanThrowResult canThrow() const;
4067
4068 /// Determine whether this function type has a non-throwing exception
4069 /// specification. If this depends on template arguments, returns
4070 /// \c ResultIfDependent.
4071 bool isNothrow(bool ResultIfDependent = false) const {
4072 return ResultIfDependent ? canThrow() != CT_Can : canThrow() == CT_Cannot;
4073 }
4074
4075 /// Whether this function prototype is variadic.
4076 bool isVariadic() const { return FunctionTypeBits.Variadic; }
4077
4078 SourceLocation getEllipsisLoc() const {
4079 return isVariadic() ? *getTrailingObjects<SourceLocation>()
4080 : SourceLocation();
4081 }
4082
4083 /// Determines whether this function prototype contains a
4084 /// parameter pack at the end.
4085 ///
4086 /// A function template whose last parameter is a parameter pack can be
4087 /// called with an arbitrary number of arguments, much like a variadic
4088 /// function.
4089 bool isTemplateVariadic() const;
4090
4091 /// Whether this function prototype has a trailing return type.
4092 bool hasTrailingReturn() const { return FunctionTypeBits.HasTrailingReturn; }
4093
4094 Qualifiers getMethodQuals() const {
4095 if (hasExtQualifiers())
4096 return *getTrailingObjects<Qualifiers>();
4097 else
4098 return getFastTypeQuals();
4099 }
4100
4101 /// Retrieve the ref-qualifier associated with this function type.
4102 RefQualifierKind getRefQualifier() const {
4103 return static_cast<RefQualifierKind>(FunctionTypeBits.RefQualifier);
4104 }
4105
4106 using param_type_iterator = const QualType *;
4107 using param_type_range = llvm::iterator_range<param_type_iterator>;
4108
4109 param_type_range param_types() const {
4110 return param_type_range(param_type_begin(), param_type_end());
4111 }
4112
4113 param_type_iterator param_type_begin() const {
4114 return getTrailingObjects<QualType>();
4115 }
4116
4117 param_type_iterator param_type_end() const {
4118 return param_type_begin() + getNumParams();
4119 }
4120
4121 using exception_iterator = const QualType *;
4122
4123 ArrayRef<QualType> exceptions() const {
4124 return llvm::makeArrayRef(exception_begin(), exception_end());
4125 }
4126
4127 exception_iterator exception_begin() const {
4128 return reinterpret_cast<exception_iterator>(
4129 getTrailingObjects<ExceptionType>());
4130 }
4131
4132 exception_iterator exception_end() const {
4133 return exception_begin() + getNumExceptions();
4134 }
4135
4136 /// Is there any interesting extra information for any of the parameters
4137 /// of this function type?
4138 bool hasExtParameterInfos() const {
4139 return FunctionTypeBits.HasExtParameterInfos;
4140 }
4141
4142 ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
4143 assert(hasExtParameterInfos())((hasExtParameterInfos()) ? static_cast<void> (0) : __assert_fail
("hasExtParameterInfos()", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4143, __PRETTY_FUNCTION__))
;
4144 return ArrayRef<ExtParameterInfo>(getTrailingObjects<ExtParameterInfo>(),
4145 getNumParams());
4146 }
4147
4148 /// Return a pointer to the beginning of the array of extra parameter
4149 /// information, if present, or else null if none of the parameters
4150 /// carry it. This is equivalent to getExtProtoInfo().ExtParameterInfos.
4151 const ExtParameterInfo *getExtParameterInfosOrNull() const {
4152 if (!hasExtParameterInfos())
4153 return nullptr;
4154 return getTrailingObjects<ExtParameterInfo>();
4155 }
4156
4157 ExtParameterInfo getExtParameterInfo(unsigned I) const {
4158 assert(I < getNumParams() && "parameter index out of range")((I < getNumParams() && "parameter index out of range"
) ? static_cast<void> (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4158, __PRETTY_FUNCTION__))
;
4159 if (hasExtParameterInfos())
4160 return getTrailingObjects<ExtParameterInfo>()[I];
4161 return ExtParameterInfo();
4162 }
4163
4164 ParameterABI getParameterABI(unsigned I) const {
4165 assert(I < getNumParams() && "parameter index out of range")((I < getNumParams() && "parameter index out of range"
) ? static_cast<void> (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4165, __PRETTY_FUNCTION__))
;
4166 if (hasExtParameterInfos())
4167 return getTrailingObjects<ExtParameterInfo>()[I].getABI();
4168 return ParameterABI::Ordinary;
4169 }
4170
4171 bool isParamConsumed(unsigned I) const {
4172 assert(I < getNumParams() && "parameter index out of range")((I < getNumParams() && "parameter index out of range"
) ? static_cast<void> (0) : __assert_fail ("I < getNumParams() && \"parameter index out of range\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4172, __PRETTY_FUNCTION__))
;
4173 if (hasExtParameterInfos())
4174 return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
4175 return false;
4176 }
4177
4178 bool isSugared() const { return false; }
4179 QualType desugar() const { return QualType(this, 0); }
4180
4181 void printExceptionSpecification(raw_ostream &OS,
4182 const PrintingPolicy &Policy) const;
4183
4184 static bool classof(const Type *T) {
4185 return T->getTypeClass() == FunctionProto;
4186 }
4187
4188 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
4189 static void Profile(llvm::FoldingSetNodeID &ID, QualType Result,
4190 param_type_iterator ArgTys, unsigned NumArgs,
4191 const ExtProtoInfo &EPI, const ASTContext &Context,
4192 bool Canonical);
4193};
4194
4195/// Represents the dependent type named by a dependently-scoped
4196/// typename using declaration, e.g.
4197/// using typename Base<T>::foo;
4198///
4199/// Template instantiation turns these into the underlying type.
4200class UnresolvedUsingType : public Type {
4201 friend class ASTContext; // ASTContext creates these.
4202
4203 UnresolvedUsingTypenameDecl *Decl;
4204
4205 UnresolvedUsingType(const UnresolvedUsingTypenameDecl *D)
4206 : Type(UnresolvedUsing, QualType(), true, true, false,
4207 /*ContainsUnexpandedParameterPack=*/false),
4208 Decl(const_cast<UnresolvedUsingTypenameDecl*>(D)) {}
4209
4210public:
4211 UnresolvedUsingTypenameDecl *getDecl() const { return Decl; }
4212
4213 bool isSugared() const { return false; }
4214 QualType desugar() const { return QualType(this, 0); }
4215
4216 static bool classof(const Type *T) {
4217 return T->getTypeClass() == UnresolvedUsing;
4218 }
4219
4220 void Profile(llvm::FoldingSetNodeID &ID) {
4221 return Profile(ID, Decl);
4222 }
4223
4224 static void Profile(llvm::FoldingSetNodeID &ID,
4225 UnresolvedUsingTypenameDecl *D) {
4226 ID.AddPointer(D);
4227 }
4228};
4229
4230class TypedefType : public Type {
4231 TypedefNameDecl *Decl;
4232
4233protected:
4234 friend class ASTContext; // ASTContext creates these.
4235
4236 TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType can)
4237 : Type(tc, can, can->isDependentType(),
4238 can->isInstantiationDependentType(),
4239 can->isVariablyModifiedType(),
4240 /*ContainsUnexpandedParameterPack=*/false),
4241 Decl(const_cast<TypedefNameDecl*>(D)) {
4242 assert(!isa<TypedefType>(can) && "Invalid canonical type")((!isa<TypedefType>(can) && "Invalid canonical type"
) ? static_cast<void> (0) : __assert_fail ("!isa<TypedefType>(can) && \"Invalid canonical type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4242, __PRETTY_FUNCTION__))
;
4243 }
4244
4245public:
4246 TypedefNameDecl *getDecl() const { return Decl; }
4247
4248 bool isSugared() const { return true; }
4249 QualType desugar() const;
4250
4251 static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
4252};
4253
4254/// Sugar type that represents a type that was qualified by a qualifier written
4255/// as a macro invocation.
4256class MacroQualifiedType : public Type {
4257 friend class ASTContext; // ASTContext creates these.
4258
4259 QualType UnderlyingTy;
4260 const IdentifierInfo *MacroII;
4261
4262 MacroQualifiedType(QualType UnderlyingTy, QualType CanonTy,
4263 const IdentifierInfo *MacroII)
4264 : Type(MacroQualified, CanonTy, UnderlyingTy->isDependentType(),
4265 UnderlyingTy->isInstantiationDependentType(),
4266 UnderlyingTy->isVariablyModifiedType(),
4267 UnderlyingTy->containsUnexpandedParameterPack()),
4268 UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
4269 assert(isa<AttributedType>(UnderlyingTy) &&((isa<AttributedType>(UnderlyingTy) && "Expected a macro qualified type to only wrap attributed types."
) ? static_cast<void> (0) : __assert_fail ("isa<AttributedType>(UnderlyingTy) && \"Expected a macro qualified type to only wrap attributed types.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4270, __PRETTY_FUNCTION__))
4270 "Expected a macro qualified type to only wrap attributed types.")((isa<AttributedType>(UnderlyingTy) && "Expected a macro qualified type to only wrap attributed types."
) ? static_cast<void> (0) : __assert_fail ("isa<AttributedType>(UnderlyingTy) && \"Expected a macro qualified type to only wrap attributed types.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4270, __PRETTY_FUNCTION__))
;
4271 }
4272
4273public:
4274 const IdentifierInfo *getMacroIdentifier() const { return MacroII; }
4275 QualType getUnderlyingType() const { return UnderlyingTy; }
4276
4277 /// Return this attributed type's modified type with no qualifiers attached to
4278 /// it.
4279 QualType getModifiedType() const;
4280
4281 bool isSugared() const { return true; }
4282 QualType desugar() const;
4283
4284 static bool classof(const Type *T) {
4285 return T->getTypeClass() == MacroQualified;
4286 }
4287};
4288
4289/// Represents a `typeof` (or __typeof__) expression (a GCC extension).
4290class TypeOfExprType : public Type {
4291 Expr *TOExpr;
4292
4293protected:
4294 friend class ASTContext; // ASTContext creates these.
4295
4296 TypeOfExprType(Expr *E, QualType can = QualType());
4297
4298public:
4299 Expr *getUnderlyingExpr() const { return TOExpr; }
4300
4301 /// Remove a single level of sugar.
4302 QualType desugar() const;
4303
4304 /// Returns whether this type directly provides sugar.
4305 bool isSugared() const;
4306
4307 static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
4308};
4309
4310/// Internal representation of canonical, dependent
4311/// `typeof(expr)` types.
4312///
4313/// This class is used internally by the ASTContext to manage
4314/// canonical, dependent types, only. Clients will only see instances
4315/// of this class via TypeOfExprType nodes.
4316class DependentTypeOfExprType
4317 : public TypeOfExprType, public llvm::FoldingSetNode {
4318 const ASTContext &Context;
4319
4320public:
4321 DependentTypeOfExprType(const ASTContext &Context, Expr *E)
4322 : TypeOfExprType(E), Context(Context) {}
4323
4324 void Profile(llvm::FoldingSetNodeID &ID) {
4325 Profile(ID, Context, getUnderlyingExpr());
4326 }
4327
4328 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4329 Expr *E);
4330};
4331
4332/// Represents `typeof(type)`, a GCC extension.
4333class TypeOfType : public Type {
4334 friend class ASTContext; // ASTContext creates these.
4335
4336 QualType TOType;
4337
4338 TypeOfType(QualType T, QualType can)
4339 : Type(TypeOf, can, T->isDependentType(),
4340 T->isInstantiationDependentType(),
4341 T->isVariablyModifiedType(),
4342 T->containsUnexpandedParameterPack()),
4343 TOType(T) {
4344 assert(!isa<TypedefType>(can) && "Invalid canonical type")((!isa<TypedefType>(can) && "Invalid canonical type"
) ? static_cast<void> (0) : __assert_fail ("!isa<TypedefType>(can) && \"Invalid canonical type\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4344, __PRETTY_FUNCTION__))
;
4345 }
4346
4347public:
4348 QualType getUnderlyingType() const { return TOType; }
4349
4350 /// Remove a single level of sugar.
4351 QualType desugar() const { return getUnderlyingType(); }
4352
4353 /// Returns whether this type directly provides sugar.
4354 bool isSugared() const { return true; }
4355
4356 static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
4357};
4358
4359/// Represents the type `decltype(expr)` (C++11).
4360class DecltypeType : public Type {
4361 Expr *E;
4362 QualType UnderlyingType;
4363
4364protected:
4365 friend class ASTContext; // ASTContext creates these.
4366
4367 DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());
4368
4369public:
4370 Expr *getUnderlyingExpr() const { return E; }
4371 QualType getUnderlyingType() const { return UnderlyingType; }
4372
4373 /// Remove a single level of sugar.
4374 QualType desugar() const;
4375
4376 /// Returns whether this type directly provides sugar.
4377 bool isSugared() const;
4378
4379 static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
4380};
4381
4382/// Internal representation of canonical, dependent
4383/// decltype(expr) types.
4384///
4385/// This class is used internally by the ASTContext to manage
4386/// canonical, dependent types, only. Clients will only see instances
4387/// of this class via DecltypeType nodes.
4388class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
4389 const ASTContext &Context;
4390
4391public:
4392 DependentDecltypeType(const ASTContext &Context, Expr *E);
4393
4394 void Profile(llvm::FoldingSetNodeID &ID) {
4395 Profile(ID, Context, getUnderlyingExpr());
4396 }
4397
4398 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4399 Expr *E);
4400};
4401
4402/// A unary type transform, which is a type constructed from another.
4403class UnaryTransformType : public Type {
4404public:
4405 enum UTTKind {
4406 EnumUnderlyingType
4407 };
4408
4409private:
4410 /// The untransformed type.
4411 QualType BaseType;
4412
4413 /// The transformed type if not dependent, otherwise the same as BaseType.
4414 QualType UnderlyingType;
4415
4416 UTTKind UKind;
4417
4418protected:
4419 friend class ASTContext;
4420
4421 UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
4422 QualType CanonicalTy);
4423
4424public:
4425 bool isSugared() const { return !isDependentType(); }
4426 QualType desugar() const { return UnderlyingType; }
4427
4428 QualType getUnderlyingType() const { return UnderlyingType; }
4429 QualType getBaseType() const { return BaseType; }
4430
4431 UTTKind getUTTKind() const { return UKind; }
4432
4433 static bool classof(const Type *T) {
4434 return T->getTypeClass() == UnaryTransform;
4435 }
4436};
4437
4438/// Internal representation of canonical, dependent
4439/// __underlying_type(type) types.
4440///
4441/// This class is used internally by the ASTContext to manage
4442/// canonical, dependent types, only. Clients will only see instances
4443/// of this class via UnaryTransformType nodes.
4444class DependentUnaryTransformType : public UnaryTransformType,
4445 public llvm::FoldingSetNode {
4446public:
4447 DependentUnaryTransformType(const ASTContext &C, QualType BaseType,
4448 UTTKind UKind);
4449
4450 void Profile(llvm::FoldingSetNodeID &ID) {
4451 Profile(ID, getBaseType(), getUTTKind());
4452 }
4453
4454 static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
4455 UTTKind UKind) {
4456 ID.AddPointer(BaseType.getAsOpaquePtr());
4457 ID.AddInteger((unsigned)UKind);
4458 }
4459};
4460
4461class TagType : public Type {
4462 friend class ASTReader;
4463 template <class T> friend class serialization::AbstractTypeReader;
4464
4465 /// Stores the TagDecl associated with this type. The decl may point to any
4466 /// TagDecl that declares the entity.
4467 TagDecl *decl;
4468
4469protected:
4470 TagType(TypeClass TC, const TagDecl *D, QualType can);
4471
4472public:
4473 TagDecl *getDecl() const;
4474
4475 /// Determines whether this type is in the process of being defined.
4476 bool isBeingDefined() const;
4477
4478 static bool classof(const Type *T) {
4479 return T->getTypeClass() == Enum || T->getTypeClass() == Record;
4480 }
4481};
4482
4483/// A helper class that allows the use of isa/cast/dyncast
4484/// to detect TagType objects of structs/unions/classes.
4485class RecordType : public TagType {
4486protected:
4487 friend class ASTContext; // ASTContext creates these.
4488
4489 explicit RecordType(const RecordDecl *D)
4490 : TagType(Record, reinterpret_cast<const TagDecl*>(D), QualType()) {}
4491 explicit RecordType(TypeClass TC, RecordDecl *D)
4492 : TagType(TC, reinterpret_cast<const TagDecl*>(D), QualType()) {}
4493
4494public:
4495 RecordDecl *getDecl() const {
4496 return reinterpret_cast<RecordDecl*>(TagType::getDecl());
4497 }
4498
4499 /// Recursively check all fields in the record for const-ness. If any field
4500 /// is declared const, return true. Otherwise, return false.
4501 bool hasConstFields() const;
4502
4503 bool isSugared() const { return false; }
4504 QualType desugar() const { return QualType(this, 0); }
4505
4506 static bool classof(const Type *T) { return T->getTypeClass() == Record; }
4507};
4508
4509/// A helper class that allows the use of isa/cast/dyncast
4510/// to detect TagType objects of enums.
4511class EnumType : public TagType {
4512 friend class ASTContext; // ASTContext creates these.
4513
4514 explicit EnumType(const EnumDecl *D)
4515 : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) {}
4516
4517public:
4518 EnumDecl *getDecl() const {
4519 return reinterpret_cast<EnumDecl*>(TagType::getDecl());
4520 }
4521
4522 bool isSugared() const { return false; }
4523 QualType desugar() const { return QualType(this, 0); }
4524
4525 static bool classof(const Type *T) { return T->getTypeClass() == Enum; }
4526};
4527
4528/// An attributed type is a type to which a type attribute has been applied.
4529///
4530/// The "modified type" is the fully-sugared type to which the attributed
4531/// type was applied; generally it is not canonically equivalent to the
4532/// attributed type. The "equivalent type" is the minimally-desugared type
4533/// which the type is canonically equivalent to.
4534///
4535/// For example, in the following attributed type:
4536/// int32_t __attribute__((vector_size(16)))
4537/// - the modified type is the TypedefType for int32_t
4538/// - the equivalent type is VectorType(16, int32_t)
4539/// - the canonical type is VectorType(16, int)
4540class AttributedType : public Type, public llvm::FoldingSetNode {
4541public:
4542 using Kind = attr::Kind;
4543
4544private:
4545 friend class ASTContext; // ASTContext creates these
4546
4547 QualType ModifiedType;
4548 QualType EquivalentType;
4549
4550 AttributedType(QualType canon, attr::Kind attrKind, QualType modified,
4551 QualType equivalent)
4552 : Type(Attributed, canon, equivalent->isDependentType(),
4553 equivalent->isInstantiationDependentType(),
4554 equivalent->isVariablyModifiedType(),
4555 equivalent->containsUnexpandedParameterPack()),
4556 ModifiedType(modified), EquivalentType(equivalent) {
4557 AttributedTypeBits.AttrKind = attrKind;
4558 }
4559
4560public:
4561 Kind getAttrKind() const {
4562 return static_cast<Kind>(AttributedTypeBits.AttrKind);
4563 }
4564
4565 QualType getModifiedType() const { return ModifiedType; }
4566 QualType getEquivalentType() const { return EquivalentType; }
4567
4568 bool isSugared() const { return true; }
4569 QualType desugar() const { return getEquivalentType(); }
4570
4571 /// Does this attribute behave like a type qualifier?
4572 ///
4573 /// A type qualifier adjusts a type to provide specialized rules for
4574 /// a specific object, like the standard const and volatile qualifiers.
4575 /// This includes attributes controlling things like nullability,
4576 /// address spaces, and ARC ownership. The value of the object is still
4577 /// largely described by the modified type.
4578 ///
4579 /// In contrast, many type attributes "rewrite" their modified type to
4580 /// produce a fundamentally different type, not necessarily related in any
4581 /// formalizable way to the original type. For example, calling convention
4582 /// and vector attributes are not simple type qualifiers.
4583 ///
4584 /// Type qualifiers are often, but not always, reflected in the canonical
4585 /// type.
4586 bool isQualifier() const;
4587
4588 bool isMSTypeSpec() const;
4589
4590 bool isCallingConv() const;
4591
4592 llvm::Optional<NullabilityKind> getImmediateNullability() const;
4593
4594 /// Retrieve the attribute kind corresponding to the given
4595 /// nullability kind.
4596 static Kind getNullabilityAttrKind(NullabilityKind kind) {
4597 switch (kind) {
4598 case NullabilityKind::NonNull:
4599 return attr::TypeNonNull;
4600
4601 case NullabilityKind::Nullable:
4602 return attr::TypeNullable;
4603
4604 case NullabilityKind::Unspecified:
4605 return attr::TypeNullUnspecified;
4606 }
4607 llvm_unreachable("Unknown nullability kind.")::llvm::llvm_unreachable_internal("Unknown nullability kind."
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 4607)
;
4608 }
4609
4610 /// Strip off the top-level nullability annotation on the given
4611 /// type, if it's there.
4612 ///
4613 /// \param T The type to strip. If the type is exactly an
4614 /// AttributedType specifying nullability (without looking through
4615 /// type sugar), the nullability is returned and this type changed
4616 /// to the underlying modified type.
4617 ///
4618 /// \returns the top-level nullability, if present.
4619 static Optional<NullabilityKind> stripOuterNullability(QualType &T);
4620
4621 void Profile(llvm::FoldingSetNodeID &ID) {
4622 Profile(ID, getAttrKind(), ModifiedType, EquivalentType);
4623 }
4624
4625 static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind,
4626 QualType modified, QualType equivalent) {
4627 ID.AddInteger(attrKind);
4628 ID.AddPointer(modified.getAsOpaquePtr());
4629 ID.AddPointer(equivalent.getAsOpaquePtr());
4630 }
4631
4632 static bool classof(const Type *T) {
4633 return T->getTypeClass() == Attributed;
4634 }
4635};
4636
4637class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
4638 friend class ASTContext; // ASTContext creates these
4639
4640 // Helper data collector for canonical types.
4641 struct CanonicalTTPTInfo {
4642 unsigned Depth : 15;
4643 unsigned ParameterPack : 1;
4644 unsigned Index : 16;
4645 };
4646
4647 union {
4648 // Info for the canonical type.
4649 CanonicalTTPTInfo CanTTPTInfo;
4650
4651 // Info for the non-canonical type.
4652 TemplateTypeParmDecl *TTPDecl;
4653 };
4654
4655 /// Build a non-canonical type.
4656 TemplateTypeParmType(TemplateTypeParmDecl *TTPDecl, QualType Canon)
4657 : Type(TemplateTypeParm, Canon, /*Dependent=*/true,
4658 /*InstantiationDependent=*/true,
4659 /*VariablyModified=*/false,
4660 Canon->containsUnexpandedParameterPack()),
4661 TTPDecl(TTPDecl) {}
4662
4663 /// Build the canonical type.
4664 TemplateTypeParmType(unsigned D, unsigned I, bool PP)
4665 : Type(TemplateTypeParm, QualType(this, 0),
4666 /*Dependent=*/true,
4667 /*InstantiationDependent=*/true,
4668 /*VariablyModified=*/false, PP) {
4669 CanTTPTInfo.Depth = D;
4670 CanTTPTInfo.Index = I;
4671 CanTTPTInfo.ParameterPack = PP;
4672 }
4673
4674 const CanonicalTTPTInfo& getCanTTPTInfo() const {
4675 QualType Can = getCanonicalTypeInternal();
4676 return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
4677 }
4678
4679public:
4680 unsigned getDepth() const { return getCanTTPTInfo().Depth; }
4681 unsigned getIndex() const { return getCanTTPTInfo().Index; }
4682 bool isParameterPack() const { return getCanTTPTInfo().ParameterPack; }
4683
4684 TemplateTypeParmDecl *getDecl() const {
4685 return isCanonicalUnqualified() ? nullptr : TTPDecl;
4686 }
4687
4688 IdentifierInfo *getIdentifier() const;
4689
4690 bool isSugared() const { return false; }
4691 QualType desugar() const { return QualType(this, 0); }
4692
4693 void Profile(llvm::FoldingSetNodeID &ID) {
4694 Profile(ID, getDepth(), getIndex(), isParameterPack(), getDecl());
4695 }
4696
4697 static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth,
4698 unsigned Index, bool ParameterPack,
4699 TemplateTypeParmDecl *TTPDecl) {
4700 ID.AddInteger(Depth);
4701 ID.AddInteger(Index);
4702 ID.AddBoolean(ParameterPack);
4703 ID.AddPointer(TTPDecl);
4704 }
4705
4706 static bool classof(const Type *T) {
4707 return T->getTypeClass() == TemplateTypeParm;
4708 }
4709};
4710
4711/// Represents the result of substituting a type for a template
4712/// type parameter.
4713///
4714/// Within an instantiated template, all template type parameters have
4715/// been replaced with these. They are used solely to record that a
4716/// type was originally written as a template type parameter;
4717/// therefore they are never canonical.
4718class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
4719 friend class ASTContext;
4720
4721 // The original type parameter.
4722 const TemplateTypeParmType *Replaced;
4723
4724 SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon)
4725 : Type(SubstTemplateTypeParm, Canon, Canon->isDependentType(),
4726 Canon->isInstantiationDependentType(),
4727 Canon->isVariablyModifiedType(),
4728 Canon->containsUnexpandedParameterPack()),
4729 Replaced(Param) {}
4730
4731public:
4732 /// Gets the template parameter that was substituted for.
4733 const TemplateTypeParmType *getReplacedParameter() const {
4734 return Replaced;
4735 }
4736
4737 /// Gets the type that was substituted for the template
4738 /// parameter.
4739 QualType getReplacementType() const {
4740 return getCanonicalTypeInternal();
4741 }
4742
4743 bool isSugared() const { return true; }
4744 QualType desugar() const { return getReplacementType(); }
4745
4746 void Profile(llvm::FoldingSetNodeID &ID) {
4747 Profile(ID, getReplacedParameter(), getReplacementType());
4748 }
4749
4750 static void Profile(llvm::FoldingSetNodeID &ID,
4751 const TemplateTypeParmType *Replaced,
4752 QualType Replacement) {
4753 ID.AddPointer(Replaced);
4754 ID.AddPointer(Replacement.getAsOpaquePtr());
4755 }
4756
4757 static bool classof(const Type *T) {
4758 return T->getTypeClass() == SubstTemplateTypeParm;
4759 }
4760};
4761
4762/// Represents the result of substituting a set of types for a template
4763/// type parameter pack.
4764///
4765/// When a pack expansion in the source code contains multiple parameter packs
4766/// and those parameter packs correspond to different levels of template
4767/// parameter lists, this type node is used to represent a template type
4768/// parameter pack from an outer level, which has already had its argument pack
4769/// substituted but that still lives within a pack expansion that itself
4770/// could not be instantiated. When actually performing a substitution into
4771/// that pack expansion (e.g., when all template parameters have corresponding
4772/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
4773/// at the current pack substitution index.
4774class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
4775 friend class ASTContext;
4776
4777 /// The original type parameter.
4778 const TemplateTypeParmType *Replaced;
4779
4780 /// A pointer to the set of template arguments that this
4781 /// parameter pack is instantiated with.
4782 const TemplateArgument *Arguments;
4783
4784 SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
4785 QualType Canon,
4786 const TemplateArgument &ArgPack);
4787
4788public:
4789 IdentifierInfo *getIdentifier() const { return Replaced->getIdentifier(); }
4790
4791 /// Gets the template parameter that was substituted for.
4792 const TemplateTypeParmType *getReplacedParameter() const {
4793 return Replaced;
4794 }
4795
4796 unsigned getNumArgs() const {
4797 return SubstTemplateTypeParmPackTypeBits.NumArgs;
4798 }
4799
4800 bool isSugared() const { return false; }
4801 QualType desugar() const { return QualType(this, 0); }
4802
4803 TemplateArgument getArgumentPack() const;
4804
4805 void Profile(llvm::FoldingSetNodeID &ID);
4806 static void Profile(llvm::FoldingSetNodeID &ID,
4807 const TemplateTypeParmType *Replaced,
4808 const TemplateArgument &ArgPack);
4809
4810 static bool classof(const Type *T) {
4811 return T->getTypeClass() == SubstTemplateTypeParmPack;
4812 }
4813};
4814
4815/// Common base class for placeholders for types that get replaced by
4816/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
4817/// class template types, and (eventually) constrained type names from the C++
4818/// Concepts TS.
4819///
4820/// These types are usually a placeholder for a deduced type. However, before
4821/// the initializer is attached, or (usually) if the initializer is
4822/// type-dependent, there is no deduced type and the type is canonical. In
4823/// the latter case, it is also a dependent type.
4824class DeducedType : public Type {
4825protected:
4826 DeducedType(TypeClass TC, QualType DeducedAsType, bool IsDependent,
4827 bool IsInstantiationDependent, bool ContainsParameterPack)
4828 : Type(TC,
4829 // FIXME: Retain the sugared deduced type?
4830 DeducedAsType.isNull() ? QualType(this, 0)
4831 : DeducedAsType.getCanonicalType(),
4832 IsDependent, IsInstantiationDependent,
4833 /*VariablyModified=*/false, ContainsParameterPack) {
4834 if (!DeducedAsType.isNull()) {
4835 if (DeducedAsType->isDependentType())
4836 setDependent();
4837 if (DeducedAsType->isInstantiationDependentType())
4838 setInstantiationDependent();
4839 if (DeducedAsType->containsUnexpandedParameterPack())
4840 setContainsUnexpandedParameterPack();
4841 }
4842 }
4843
4844public:
4845 bool isSugared() const { return !isCanonicalUnqualified(); }
4846 QualType desugar() const { return getCanonicalTypeInternal(); }
4847
4848 /// Get the type deduced for this placeholder type, or null if it's
4849 /// either not been deduced or was deduced to a dependent type.
4850 QualType getDeducedType() const {
4851 return !isCanonicalUnqualified() ? getCanonicalTypeInternal() : QualType();
4852 }
4853 bool isDeduced() const {
4854 return !isCanonicalUnqualified() || isDependentType();
4855 }
4856
4857 static bool classof(const Type *T) {
4858 return T->getTypeClass() == Auto ||
4859 T->getTypeClass() == DeducedTemplateSpecialization;
4860 }
4861};
4862
4863/// Represents a C++11 auto or C++14 decltype(auto) type.
4864class AutoType : public DeducedType, public llvm::FoldingSetNode {
4865 friend class ASTContext; // ASTContext creates these
4866
4867 AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
4868 bool IsDeducedAsDependent, bool IsDeducedAsPack)
4869 : DeducedType(Auto, DeducedAsType, IsDeducedAsDependent,
4870 IsDeducedAsDependent, IsDeducedAsPack) {
4871 AutoTypeBits.Keyword = (unsigned)Keyword;
4872 }
4873
4874public:
4875 bool isDecltypeAuto() const {
4876 return getKeyword() == AutoTypeKeyword::DecltypeAuto;
4877 }
4878
4879 AutoTypeKeyword getKeyword() const {
4880 return (AutoTypeKeyword)AutoTypeBits.Keyword;
4881 }
4882
4883 void Profile(llvm::FoldingSetNodeID &ID) {
4884 Profile(ID, getDeducedType(), getKeyword(), isDependentType(),
4885 containsUnexpandedParameterPack());
4886 }
4887
4888 static void Profile(llvm::FoldingSetNodeID &ID, QualType Deduced,
4889 AutoTypeKeyword Keyword, bool IsDependent, bool IsPack) {
4890 ID.AddPointer(Deduced.getAsOpaquePtr());
4891 ID.AddInteger((unsigned)Keyword);
4892 ID.AddBoolean(IsDependent);
4893 ID.AddBoolean(IsPack);
4894 }
4895
4896 static bool classof(const Type *T) {
4897 return T->getTypeClass() == Auto;
4898 }
4899};
4900
4901/// Represents a C++17 deduced template specialization type.
4902class DeducedTemplateSpecializationType : public DeducedType,
4903 public llvm::FoldingSetNode {
4904 friend class ASTContext; // ASTContext creates these
4905
4906 /// The name of the template whose arguments will be deduced.
4907 TemplateName Template;
4908
4909 DeducedTemplateSpecializationType(TemplateName Template,
4910 QualType DeducedAsType,
4911 bool IsDeducedAsDependent)
4912 : DeducedType(DeducedTemplateSpecialization, DeducedAsType,
4913 IsDeducedAsDependent || Template.isDependent(),
4914 IsDeducedAsDependent || Template.isInstantiationDependent(),
4915 Template.containsUnexpandedParameterPack()),
4916 Template(Template) {}
4917
4918public:
4919 /// Retrieve the name of the template that we are deducing.
4920 TemplateName getTemplateName() const { return Template;}
4921
4922 void Profile(llvm::FoldingSetNodeID &ID) {
4923 Profile(ID, getTemplateName(), getDeducedType(), isDependentType());
4924 }
4925
4926 static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Template,
4927 QualType Deduced, bool IsDependent) {
4928 Template.Profile(ID);
4929 ID.AddPointer(Deduced.getAsOpaquePtr());
4930 ID.AddBoolean(IsDependent);
4931 }
4932
4933 static bool classof(const Type *T) {
4934 return T->getTypeClass() == DeducedTemplateSpecialization;
4935 }
4936};
4937
4938/// Represents a type template specialization; the template
4939/// must be a class template, a type alias template, or a template
4940/// template parameter. A template which cannot be resolved to one of
4941/// these, e.g. because it is written with a dependent scope
4942/// specifier, is instead represented as a
4943/// @c DependentTemplateSpecializationType.
4944///
4945/// A non-dependent template specialization type is always "sugar",
4946/// typically for a \c RecordType. For example, a class template
4947/// specialization type of \c vector<int> will refer to a tag type for
4948/// the instantiation \c std::vector<int, std::allocator<int>>
4949///
4950/// Template specializations are dependent if either the template or
4951/// any of the template arguments are dependent, in which case the
4952/// type may also be canonical.
4953///
4954/// Instances of this type are allocated with a trailing array of
4955/// TemplateArguments, followed by a QualType representing the
4956/// non-canonical aliased type when the template is a type alias
4957/// template.
4958class alignas(8) TemplateSpecializationType
4959 : public Type,
4960 public llvm::FoldingSetNode {
4961 friend class ASTContext; // ASTContext creates these
4962
4963 /// The name of the template being specialized. This is
4964 /// either a TemplateName::Template (in which case it is a
4965 /// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
4966 /// TypeAliasTemplateDecl*), a
4967 /// TemplateName::SubstTemplateTemplateParmPack, or a
4968 /// TemplateName::SubstTemplateTemplateParm (in which case the
4969 /// replacement must, recursively, be one of these).
4970 TemplateName Template;
4971
4972 TemplateSpecializationType(TemplateName T,
4973 ArrayRef<TemplateArgument> Args,
4974 QualType Canon,
4975 QualType Aliased);
4976
4977public:
4978 /// Determine whether any of the given template arguments are dependent.
4979 static bool anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
4980 bool &InstantiationDependent);
4981
4982 static bool anyDependentTemplateArguments(const TemplateArgumentListInfo &,
4983 bool &InstantiationDependent);
4984
4985 /// True if this template specialization type matches a current
4986 /// instantiation in the context in which it is found.
4987 bool isCurrentInstantiation() const {
4988 return isa<InjectedClassNameType>(getCanonicalTypeInternal());
4989 }
4990
4991 /// Determine if this template specialization type is for a type alias
4992 /// template that has been substituted.
4993 ///
4994 /// Nearly every template specialization type whose template is an alias
4995 /// template will be substituted. However, this is not the case when
4996 /// the specialization contains a pack expansion but the template alias
4997 /// does not have a corresponding parameter pack, e.g.,
4998 ///
4999 /// \code
5000 /// template<typename T, typename U, typename V> struct S;
5001 /// template<typename T, typename U> using A = S<T, int, U>;
5002 /// template<typename... Ts> struct X {
5003 /// typedef A<Ts...> type; // not a type alias
5004 /// };
5005 /// \endcode
5006 bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; }
5007
5008 /// Get the aliased type, if this is a specialization of a type alias
5009 /// template.
5010 QualType getAliasedType() const {
5011 assert(isTypeAlias() && "not a type alias template specialization")((isTypeAlias() && "not a type alias template specialization"
) ? static_cast<void> (0) : __assert_fail ("isTypeAlias() && \"not a type alias template specialization\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5011, __PRETTY_FUNCTION__))
;
5012 return *reinterpret_cast<const QualType*>(end());
5013 }
5014
5015 using iterator = const TemplateArgument *;
5016
5017 iterator begin() const { return getArgs(); }
5018 iterator end() const; // defined inline in TemplateBase.h
5019
5020 /// Retrieve the name of the template that we are specializing.
5021 TemplateName getTemplateName() const { return Template; }
5022
5023 /// Retrieve the template arguments.
5024 const TemplateArgument *getArgs() const {
5025 return reinterpret_cast<const TemplateArgument *>(this + 1);
5026 }
5027
5028 /// Retrieve the number of template arguments.
5029 unsigned getNumArgs() const {
5030 return TemplateSpecializationTypeBits.NumArgs;
5031 }
5032
5033 /// Retrieve a specific template argument as a type.
5034 /// \pre \c isArgType(Arg)
5035 const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
5036
5037 ArrayRef<TemplateArgument> template_arguments() const {
5038 return {getArgs(), getNumArgs()};
5039 }
5040
5041 bool isSugared() const {
5042 return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
5043 }
5044
5045 QualType desugar() const {
5046 return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
5047 }
5048
5049 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
5050 Profile(ID, Template, template_arguments(), Ctx);
5051 if (isTypeAlias())
5052 getAliasedType().Profile(ID);
5053 }
5054
5055 static void Profile(llvm::FoldingSetNodeID &ID, TemplateName T,
5056 ArrayRef<TemplateArgument> Args,
5057 const ASTContext &Context);
5058
5059 static bool classof(const Type *T) {
5060 return T->getTypeClass() == TemplateSpecialization;
5061 }
5062};
5063
5064/// Print a template argument list, including the '<' and '>'
5065/// enclosing the template arguments.
5066void printTemplateArgumentList(raw_ostream &OS,
5067 ArrayRef<TemplateArgument> Args,
5068 const PrintingPolicy &Policy);
5069
5070void printTemplateArgumentList(raw_ostream &OS,
5071 ArrayRef<TemplateArgumentLoc> Args,
5072 const PrintingPolicy &Policy);
5073
5074void printTemplateArgumentList(raw_ostream &OS,
5075 const TemplateArgumentListInfo &Args,
5076 const PrintingPolicy &Policy);
5077
5078/// The injected class name of a C++ class template or class
5079/// template partial specialization. Used to record that a type was
5080/// spelled with a bare identifier rather than as a template-id; the
5081/// equivalent for non-templated classes is just RecordType.
5082///
5083/// Injected class name types are always dependent. Template
5084/// instantiation turns these into RecordTypes.
5085///
5086/// Injected class name types are always canonical. This works
5087/// because it is impossible to compare an injected class name type
5088/// with the corresponding non-injected template type, for the same
5089/// reason that it is impossible to directly compare template
5090/// parameters from different dependent contexts: injected class name
5091/// types can only occur within the scope of a particular templated
5092/// declaration, and within that scope every template specialization
5093/// will canonicalize to the injected class name (when appropriate
5094/// according to the rules of the language).
5095class InjectedClassNameType : public Type {
5096 friend class ASTContext; // ASTContext creates these.
5097 friend class ASTNodeImporter;
5098 friend class ASTReader; // FIXME: ASTContext::getInjectedClassNameType is not
5099 // currently suitable for AST reading, too much
5100 // interdependencies.
5101 template <class T> friend class serialization::AbstractTypeReader;
5102
5103 CXXRecordDecl *Decl;
5104
5105 /// The template specialization which this type represents.
5106 /// For example, in
5107 /// template <class T> class A { ... };
5108 /// this is A<T>, whereas in
5109 /// template <class X, class Y> class A<B<X,Y> > { ... };
5110 /// this is A<B<X,Y> >.
5111 ///
5112 /// It is always unqualified, always a template specialization type,
5113 /// and always dependent.
5114 QualType InjectedType;
5115
5116 InjectedClassNameType(CXXRecordDecl *D, QualType TST)
5117 : Type(InjectedClassName, QualType(), /*Dependent=*/true,
5118 /*InstantiationDependent=*/true,
5119 /*VariablyModified=*/false,
5120 /*ContainsUnexpandedParameterPack=*/false),
5121 Decl(D), InjectedType(TST) {
5122 assert(isa<TemplateSpecializationType>(TST))((isa<TemplateSpecializationType>(TST)) ? static_cast<
void> (0) : __assert_fail ("isa<TemplateSpecializationType>(TST)"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5122, __PRETTY_FUNCTION__))
;
5123 assert(!TST.hasQualifiers())((!TST.hasQualifiers()) ? static_cast<void> (0) : __assert_fail
("!TST.hasQualifiers()", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5123, __PRETTY_FUNCTION__))
;
5124 assert(TST->isDependentType())((TST->isDependentType()) ? static_cast<void> (0) : __assert_fail
("TST->isDependentType()", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5124, __PRETTY_FUNCTION__))
;
5125 }
5126
5127public:
5128 QualType getInjectedSpecializationType() const { return InjectedType; }
5129
5130 const TemplateSpecializationType *getInjectedTST() const {
5131 return cast<TemplateSpecializationType>(InjectedType.getTypePtr());
5132 }
5133
5134 TemplateName getTemplateName() const {
5135 return getInjectedTST()->getTemplateName();
5136 }
5137
5138 CXXRecordDecl *getDecl() const;
5139
5140 bool isSugared() const { return false; }
5141 QualType desugar() const { return QualType(this, 0); }
5142
5143 static bool classof(const Type *T) {
5144 return T->getTypeClass() == InjectedClassName;
5145 }
5146};
5147
5148/// The kind of a tag type.
5149enum TagTypeKind {
5150 /// The "struct" keyword.
5151 TTK_Struct,
5152
5153 /// The "__interface" keyword.
5154 TTK_Interface,
5155
5156 /// The "union" keyword.
5157 TTK_Union,
5158
5159 /// The "class" keyword.
5160 TTK_Class,
5161
5162 /// The "enum" keyword.
5163 TTK_Enum
5164};
5165
5166/// The elaboration keyword that precedes a qualified type name or
5167/// introduces an elaborated-type-specifier.
5168enum ElaboratedTypeKeyword {
5169 /// The "struct" keyword introduces the elaborated-type-specifier.
5170 ETK_Struct,
5171
5172 /// The "__interface" keyword introduces the elaborated-type-specifier.
5173 ETK_Interface,
5174
5175 /// The "union" keyword introduces the elaborated-type-specifier.
5176 ETK_Union,
5177
5178 /// The "class" keyword introduces the elaborated-type-specifier.
5179 ETK_Class,
5180
5181 /// The "enum" keyword introduces the elaborated-type-specifier.
5182 ETK_Enum,
5183
5184 /// The "typename" keyword precedes the qualified type name, e.g.,
5185 /// \c typename T::type.
5186 ETK_Typename,
5187
5188 /// No keyword precedes the qualified type name.
5189 ETK_None
5190};
5191
5192/// A helper class for Type nodes having an ElaboratedTypeKeyword.
5193/// The keyword in stored in the free bits of the base class.
5194/// Also provides a few static helpers for converting and printing
5195/// elaborated type keyword and tag type kind enumerations.
5196class TypeWithKeyword : public Type {
5197protected:
5198 TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc,
5199 QualType Canonical, bool Dependent,
5200 bool InstantiationDependent, bool VariablyModified,
5201 bool ContainsUnexpandedParameterPack)
5202 : Type(tc, Canonical, Dependent, InstantiationDependent, VariablyModified,
5203 ContainsUnexpandedParameterPack) {
5204 TypeWithKeywordBits.Keyword = Keyword;
5205 }
5206
5207public:
5208 ElaboratedTypeKeyword getKeyword() const {
5209 return static_cast<ElaboratedTypeKeyword>(TypeWithKeywordBits.Keyword);
5210 }
5211
5212 /// Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
5213 static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec);
5214
5215 /// Converts a type specifier (DeclSpec::TST) into a tag type kind.
5216 /// It is an error to provide a type specifier which *isn't* a tag kind here.
5217 static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec);
5218
5219 /// Converts a TagTypeKind into an elaborated type keyword.
5220 static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag);
5221
5222 /// Converts an elaborated type keyword into a TagTypeKind.
5223 /// It is an error to provide an elaborated type keyword
5224 /// which *isn't* a tag kind here.
5225 static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword);
5226
5227 static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword);
5228
5229 static StringRef getKeywordName(ElaboratedTypeKeyword Keyword);
5230
5231 static StringRef getTagTypeKindName(TagTypeKind Kind) {
5232 return getKeywordName(getKeywordForTagTypeKind(Kind));
5233 }
5234
5235 class CannotCastToThisType {};
5236 static CannotCastToThisType classof(const Type *);
5237};
5238
5239/// Represents a type that was referred to using an elaborated type
5240/// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type,
5241/// or both.
5242///
5243/// This type is used to keep track of a type name as written in the
5244/// source code, including tag keywords and any nested-name-specifiers.
5245/// The type itself is always "sugar", used to express what was written
5246/// in the source code but containing no additional semantic information.
5247class ElaboratedType final
5248 : public TypeWithKeyword,
5249 public llvm::FoldingSetNode,
5250 private llvm::TrailingObjects<ElaboratedType, TagDecl *> {
5251 friend class ASTContext; // ASTContext creates these
5252 friend TrailingObjects;
5253
5254 /// The nested name specifier containing the qualifier.
5255 NestedNameSpecifier *NNS;
5256
5257 /// The type that this qualified name refers to.
5258 QualType NamedType;
5259
5260 /// The (re)declaration of this tag type owned by this occurrence is stored
5261 /// as a trailing object if there is one. Use getOwnedTagDecl to obtain
5262 /// it, or obtain a null pointer if there is none.
5263
5264 ElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
5265 QualType NamedType, QualType CanonType, TagDecl *OwnedTagDecl)
5266 : TypeWithKeyword(Keyword, Elaborated, CanonType,
5267 NamedType->isDependentType(),
5268 NamedType->isInstantiationDependentType(),
5269 NamedType->isVariablyModifiedType(),
5270 NamedType->containsUnexpandedParameterPack()),
5271 NNS(NNS), NamedType(NamedType) {
5272 ElaboratedTypeBits.HasOwnedTagDecl = false;
5273 if (OwnedTagDecl) {
5274 ElaboratedTypeBits.HasOwnedTagDecl = true;
5275 *getTrailingObjects<TagDecl *>() = OwnedTagDecl;
5276 }
5277 assert(!(Keyword == ETK_None && NNS == nullptr) &&((!(Keyword == ETK_None && NNS == nullptr) &&
"ElaboratedType cannot have elaborated type keyword " "and name qualifier both null."
) ? static_cast<void> (0) : __assert_fail ("!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5279, __PRETTY_FUNCTION__))
5278 "ElaboratedType cannot have elaborated type keyword "((!(Keyword == ETK_None && NNS == nullptr) &&
"ElaboratedType cannot have elaborated type keyword " "and name qualifier both null."
) ? static_cast<void> (0) : __assert_fail ("!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5279, __PRETTY_FUNCTION__))
5279 "and name qualifier both null.")((!(Keyword == ETK_None && NNS == nullptr) &&
"ElaboratedType cannot have elaborated type keyword " "and name qualifier both null."
) ? static_cast<void> (0) : __assert_fail ("!(Keyword == ETK_None && NNS == nullptr) && \"ElaboratedType cannot have elaborated type keyword \" \"and name qualifier both null.\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5279, __PRETTY_FUNCTION__))
;
5280 }
5281
5282public:
5283 /// Retrieve the qualification on this type.
5284 NestedNameSpecifier *getQualifier() const { return NNS; }
5285
5286 /// Retrieve the type named by the qualified-id.
5287 QualType getNamedType() const { return NamedType; }
5288
5289 /// Remove a single level of sugar.
5290 QualType desugar() const { return getNamedType(); }
5291
5292 /// Returns whether this type directly provides sugar.
5293 bool isSugared() const { return true; }
5294
5295 /// Return the (re)declaration of this type owned by this occurrence of this
5296 /// type, or nullptr if there is none.
5297 TagDecl *getOwnedTagDecl() const {
5298 return ElaboratedTypeBits.HasOwnedTagDecl ? *getTrailingObjects<TagDecl *>()
5299 : nullptr;
5300 }
5301
5302 void Profile(llvm::FoldingSetNodeID &ID) {
5303 Profile(ID, getKeyword(), NNS, NamedType, getOwnedTagDecl());
5304 }
5305
5306 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
5307 NestedNameSpecifier *NNS, QualType NamedType,
5308 TagDecl *OwnedTagDecl) {
5309 ID.AddInteger(Keyword);
5310 ID.AddPointer(NNS);
5311 NamedType.Profile(ID);
5312 ID.AddPointer(OwnedTagDecl);
5313 }
5314
5315 static bool classof(const Type *T) { return T->getTypeClass() == Elaborated; }
5316};
5317
5318/// Represents a qualified type name for which the type name is
5319/// dependent.
5320///
5321/// DependentNameType represents a class of dependent types that involve a
5322/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
5323/// name of a type. The DependentNameType may start with a "typename" (for a
5324/// typename-specifier), "class", "struct", "union", or "enum" (for a
5325/// dependent elaborated-type-specifier), or nothing (in contexts where we
5326/// know that we must be referring to a type, e.g., in a base class specifier).
5327/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
5328/// mode, this type is used with non-dependent names to delay name lookup until
5329/// instantiation.
5330class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
5331 friend class ASTContext; // ASTContext creates these
5332
5333 /// The nested name specifier containing the qualifier.
5334 NestedNameSpecifier *NNS;
5335
5336 /// The type that this typename specifier refers to.
5337 const IdentifierInfo *Name;
5338
5339 DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
5340 const IdentifierInfo *Name, QualType CanonType)
5341 : TypeWithKeyword(Keyword, DependentName, CanonType, /*Dependent=*/true,
5342 /*InstantiationDependent=*/true,
5343 /*VariablyModified=*/false,
5344 NNS->containsUnexpandedParameterPack()),
5345 NNS(NNS), Name(Name) {}
5346
5347public:
5348 /// Retrieve the qualification on this type.
5349 NestedNameSpecifier *getQualifier() const { return NNS; }
5350
5351 /// Retrieve the type named by the typename specifier as an identifier.
5352 ///
5353 /// This routine will return a non-NULL identifier pointer when the
5354 /// form of the original typename was terminated by an identifier,
5355 /// e.g., "typename T::type".
5356 const IdentifierInfo *getIdentifier() const {
5357 return Name;
5358 }
5359
5360 bool isSugared() const { return false; }
5361 QualType desugar() const { return QualType(this, 0); }
5362
5363 void Profile(llvm::FoldingSetNodeID &ID) {
5364 Profile(ID, getKeyword(), NNS, Name);
5365 }
5366
5367 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
5368 NestedNameSpecifier *NNS, const IdentifierInfo *Name) {
5369 ID.AddInteger(Keyword);
5370 ID.AddPointer(NNS);
5371 ID.AddPointer(Name);
5372 }
5373
5374 static bool classof(const Type *T) {
5375 return T->getTypeClass() == DependentName;
5376 }
5377};
5378
5379/// Represents a template specialization type whose template cannot be
5380/// resolved, e.g.
5381/// A<T>::template B<T>
5382class alignas(8) DependentTemplateSpecializationType
5383 : public TypeWithKeyword,
5384 public llvm::FoldingSetNode {
5385 friend class ASTContext; // ASTContext creates these
5386
5387 /// The nested name specifier containing the qualifier.
5388 NestedNameSpecifier *NNS;
5389
5390 /// The identifier of the template.
5391 const IdentifierInfo *Name;
5392
5393 DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
5394 NestedNameSpecifier *NNS,
5395 const IdentifierInfo *Name,
5396 ArrayRef<TemplateArgument> Args,
5397 QualType Canon);
5398
5399 const TemplateArgument *getArgBuffer() const {
5400 return reinterpret_cast<const TemplateArgument*>(this+1);
5401 }
5402
5403 TemplateArgument *getArgBuffer() {
5404 return reinterpret_cast<TemplateArgument*>(this+1);
5405 }
5406
5407public:
5408 NestedNameSpecifier *getQualifier() const { return NNS; }
5409 const IdentifierInfo *getIdentifier() const { return Name; }
5410
5411 /// Retrieve the template arguments.
5412 const TemplateArgument *getArgs() const {
5413 return getArgBuffer();
5414 }
5415
5416 /// Retrieve the number of template arguments.
5417 unsigned getNumArgs() const {
5418 return DependentTemplateSpecializationTypeBits.NumArgs;
5419 }
5420
5421 const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
5422
5423 ArrayRef<TemplateArgument> template_arguments() const {
5424 return {getArgs(), getNumArgs()};
5425 }
5426
5427 using iterator = const TemplateArgument *;
5428
5429 iterator begin() const { return getArgs(); }
5430 iterator end() const; // inline in TemplateBase.h
5431
5432 bool isSugared() const { return false; }
5433 QualType desugar() const { return QualType(this, 0); }
5434
5435 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
5436 Profile(ID, Context, getKeyword(), NNS, Name, {getArgs(), getNumArgs()});
5437 }
5438
5439 static void Profile(llvm::FoldingSetNodeID &ID,
5440 const ASTContext &Context,
5441 ElaboratedTypeKeyword Keyword,
5442 NestedNameSpecifier *Qualifier,
5443 const IdentifierInfo *Name,
5444 ArrayRef<TemplateArgument> Args);
5445
5446 static bool classof(const Type *T) {
5447 return T->getTypeClass() == DependentTemplateSpecialization;
5448 }
5449};
5450
5451/// Represents a pack expansion of types.
5452///
5453/// Pack expansions are part of C++11 variadic templates. A pack
5454/// expansion contains a pattern, which itself contains one or more
5455/// "unexpanded" parameter packs. When instantiated, a pack expansion
5456/// produces a series of types, each instantiated from the pattern of
5457/// the expansion, where the Ith instantiation of the pattern uses the
5458/// Ith arguments bound to each of the unexpanded parameter packs. The
5459/// pack expansion is considered to "expand" these unexpanded
5460/// parameter packs.
5461///
5462/// \code
5463/// template<typename ...Types> struct tuple;
5464///
5465/// template<typename ...Types>
5466/// struct tuple_of_references {
5467/// typedef tuple<Types&...> type;
5468/// };
5469/// \endcode
5470///
5471/// Here, the pack expansion \c Types&... is represented via a
5472/// PackExpansionType whose pattern is Types&.
5473class PackExpansionType : public Type, public llvm::FoldingSetNode {
5474 friend class ASTContext; // ASTContext creates these
5475
5476 /// The pattern of the pack expansion.
5477 QualType Pattern;
5478
5479 PackExpansionType(QualType Pattern, QualType Canon,
5480 Optional<unsigned> NumExpansions)
5481 : Type(PackExpansion, Canon, /*Dependent=*/Pattern->isDependentType(),
5482 /*InstantiationDependent=*/true,
5483 /*VariablyModified=*/Pattern->isVariablyModifiedType(),
5484 /*ContainsUnexpandedParameterPack=*/false),
5485 Pattern(Pattern) {
5486 PackExpansionTypeBits.NumExpansions =
5487 NumExpansions ? *NumExpansions + 1 : 0;
5488 }
5489
5490public:
5491 /// Retrieve the pattern of this pack expansion, which is the
5492 /// type that will be repeatedly instantiated when instantiating the
5493 /// pack expansion itself.
5494 QualType getPattern() const { return Pattern; }
5495
5496 /// Retrieve the number of expansions that this pack expansion will
5497 /// generate, if known.
5498 Optional<unsigned> getNumExpansions() const {
5499 if (PackExpansionTypeBits.NumExpansions)
5500 return PackExpansionTypeBits.NumExpansions - 1;
5501 return None;
5502 }
5503
5504 bool isSugared() const { return !Pattern->isDependentType(); }
5505 QualType desugar() const { return isSugared() ? Pattern : QualType(this, 0); }
5506
5507 void Profile(llvm::FoldingSetNodeID &ID) {
5508 Profile(ID, getPattern(), getNumExpansions());
5509 }
5510
5511 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern,
5512 Optional<unsigned> NumExpansions) {
5513 ID.AddPointer(Pattern.getAsOpaquePtr());
5514 ID.AddBoolean(NumExpansions.hasValue());
5515 if (NumExpansions)
5516 ID.AddInteger(*NumExpansions);
5517 }
5518
5519 static bool classof(const Type *T) {
5520 return T->getTypeClass() == PackExpansion;
5521 }
5522};
5523
5524/// This class wraps the list of protocol qualifiers. For types that can
5525/// take ObjC protocol qualifers, they can subclass this class.
5526template <class T>
5527class ObjCProtocolQualifiers {
5528protected:
5529 ObjCProtocolQualifiers() = default;
5530
5531 ObjCProtocolDecl * const *getProtocolStorage() const {
5532 return const_cast<ObjCProtocolQualifiers*>(this)->getProtocolStorage();
5533 }
5534
5535 ObjCProtocolDecl **getProtocolStorage() {
5536 return static_cast<T*>(this)->getProtocolStorageImpl();
5537 }
5538
5539 void setNumProtocols(unsigned N) {
5540 static_cast<T*>(this)->setNumProtocolsImpl(N);
5541 }
5542
5543 void initialize(ArrayRef<ObjCProtocolDecl *> protocols) {
5544 setNumProtocols(protocols.size());
5545 assert(getNumProtocols() == protocols.size() &&((getNumProtocols() == protocols.size() && "bitfield overflow in protocol count"
) ? static_cast<void> (0) : __assert_fail ("getNumProtocols() == protocols.size() && \"bitfield overflow in protocol count\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5546, __PRETTY_FUNCTION__))
5546 "bitfield overflow in protocol count")((getNumProtocols() == protocols.size() && "bitfield overflow in protocol count"
) ? static_cast<void> (0) : __assert_fail ("getNumProtocols() == protocols.size() && \"bitfield overflow in protocol count\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5546, __PRETTY_FUNCTION__))
;
5547 if (!protocols.empty())
5548 memcpy(getProtocolStorage(), protocols.data(),
5549 protocols.size() * sizeof(ObjCProtocolDecl*));
5550 }
5551
5552public:
5553 using qual_iterator = ObjCProtocolDecl * const *;
5554 using qual_range = llvm::iterator_range<qual_iterator>;
5555
5556 qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
5557 qual_iterator qual_begin() const { return getProtocolStorage(); }
5558 qual_iterator qual_end() const { return qual_begin() + getNumProtocols(); }
5559
5560 bool qual_empty() const { return getNumProtocols() == 0; }
5561
5562 /// Return the number of qualifying protocols in this type, or 0 if
5563 /// there are none.
5564 unsigned getNumProtocols() const {
5565 return static_cast<const T*>(this)->getNumProtocolsImpl();
5566 }
5567
5568 /// Fetch a protocol by index.
5569 ObjCProtocolDecl *getProtocol(unsigned I) const {
5570 assert(I < getNumProtocols() && "Out-of-range protocol access")((I < getNumProtocols() && "Out-of-range protocol access"
) ? static_cast<void> (0) : __assert_fail ("I < getNumProtocols() && \"Out-of-range protocol access\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5570, __PRETTY_FUNCTION__))
;
5571 return qual_begin()[I];
5572 }
5573
5574 /// Retrieve all of the protocol qualifiers.
5575 ArrayRef<ObjCProtocolDecl *> getProtocols() const {
5576 return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
5577 }
5578};
5579
5580/// Represents a type parameter type in Objective C. It can take
5581/// a list of protocols.
5582class ObjCTypeParamType : public Type,
5583 public ObjCProtocolQualifiers<ObjCTypeParamType>,
5584 public llvm::FoldingSetNode {
5585 friend class ASTContext;
5586 friend class ObjCProtocolQualifiers<ObjCTypeParamType>;
5587
5588 /// The number of protocols stored on this type.
5589 unsigned NumProtocols : 6;
5590
5591 ObjCTypeParamDecl *OTPDecl;
5592
5593 /// The protocols are stored after the ObjCTypeParamType node. In the
5594 /// canonical type, the list of protocols are sorted alphabetically
5595 /// and uniqued.
5596 ObjCProtocolDecl **getProtocolStorageImpl();
5597
5598 /// Return the number of qualifying protocols in this interface type,
5599 /// or 0 if there are none.
5600 unsigned getNumProtocolsImpl() const {
5601 return NumProtocols;
5602 }
5603
5604 void setNumProtocolsImpl(unsigned N) {
5605 NumProtocols = N;
5606 }
5607
5608 ObjCTypeParamType(const ObjCTypeParamDecl *D,
5609 QualType can,
5610 ArrayRef<ObjCProtocolDecl *> protocols);
5611
5612public:
5613 bool isSugared() const { return true; }
5614 QualType desugar() const { return getCanonicalTypeInternal(); }
5615
5616 static bool classof(const Type *T) {
5617 return T->getTypeClass() == ObjCTypeParam;
5618 }
5619
5620 void Profile(llvm::FoldingSetNodeID &ID);
5621 static void Profile(llvm::FoldingSetNodeID &ID,
5622 const ObjCTypeParamDecl *OTPDecl,
5623 ArrayRef<ObjCProtocolDecl *> protocols);
5624
5625 ObjCTypeParamDecl *getDecl() const { return OTPDecl; }
5626};
5627
5628/// Represents a class type in Objective C.
5629///
5630/// Every Objective C type is a combination of a base type, a set of
5631/// type arguments (optional, for parameterized classes) and a list of
5632/// protocols.
5633///
5634/// Given the following declarations:
5635/// \code
5636/// \@class C<T>;
5637/// \@protocol P;
5638/// \endcode
5639///
5640/// 'C' is an ObjCInterfaceType C. It is sugar for an ObjCObjectType
5641/// with base C and no protocols.
5642///
5643/// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P].
5644/// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no
5645/// protocol list.
5646/// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*',
5647/// and protocol list [P].
5648///
5649/// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose
5650/// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
5651/// and no protocols.
5652///
5653/// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
5654/// with base BuiltinType::ObjCIdType and protocol list [P]. Eventually
5655/// this should get its own sugar class to better represent the source.
5656class ObjCObjectType : public Type,
5657 public ObjCProtocolQualifiers<ObjCObjectType> {
5658 friend class ObjCProtocolQualifiers<ObjCObjectType>;
5659
5660 // ObjCObjectType.NumTypeArgs - the number of type arguments stored
5661 // after the ObjCObjectPointerType node.
5662 // ObjCObjectType.NumProtocols - the number of protocols stored
5663 // after the type arguments of ObjCObjectPointerType node.
5664 //
5665 // These protocols are those written directly on the type. If
5666 // protocol qualifiers ever become additive, the iterators will need
5667 // to get kindof complicated.
5668 //
5669 // In the canonical object type, these are sorted alphabetically
5670 // and uniqued.
5671
5672 /// Either a BuiltinType or an InterfaceType or sugar for either.
5673 QualType BaseType;
5674
5675 /// Cached superclass type.
5676 mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
5677 CachedSuperClassType;
5678
5679 QualType *getTypeArgStorage();
5680 const QualType *getTypeArgStorage() const {
5681 return const_cast<ObjCObjectType *>(this)->getTypeArgStorage();
5682 }
5683
5684 ObjCProtocolDecl **getProtocolStorageImpl();
5685 /// Return the number of qualifying protocols in this interface type,
5686 /// or 0 if there are none.
5687 unsigned getNumProtocolsImpl() const {
5688 return ObjCObjectTypeBits.NumProtocols;
5689 }
5690 void setNumProtocolsImpl(unsigned N) {
5691 ObjCObjectTypeBits.NumProtocols = N;
5692 }
5693
5694protected:
5695 enum Nonce_ObjCInterface { Nonce_ObjCInterface };
5696
5697 ObjCObjectType(QualType Canonical, QualType Base,
5698 ArrayRef<QualType> typeArgs,
5699 ArrayRef<ObjCProtocolDecl *> protocols,
5700 bool isKindOf);
5701
5702 ObjCObjectType(enum Nonce_ObjCInterface)
5703 : Type(ObjCInterface, QualType(), false, false, false, false),
5704 BaseType(QualType(this_(), 0)) {
5705 ObjCObjectTypeBits.NumProtocols = 0;
5706 ObjCObjectTypeBits.NumTypeArgs = 0;
5707 ObjCObjectTypeBits.IsKindOf = 0;
5708 }
5709
5710 void computeSuperClassTypeSlow() const;
5711
5712public:
5713 /// Gets the base type of this object type. This is always (possibly
5714 /// sugar for) one of:
5715 /// - the 'id' builtin type (as opposed to the 'id' type visible to the
5716 /// user, which is a typedef for an ObjCObjectPointerType)
5717 /// - the 'Class' builtin type (same caveat)
5718 /// - an ObjCObjectType (currently always an ObjCInterfaceType)
5719 QualType getBaseType() const { return BaseType; }
5720
5721 bool isObjCId() const {
5722 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
5723 }
5724
5725 bool isObjCClass() const {
5726 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
5727 }
5728
5729 bool isObjCUnqualifiedId() const { return qual_empty() && isObjCId(); }
5730 bool isObjCUnqualifiedClass() const { return qual_empty() && isObjCClass(); }
5731 bool isObjCUnqualifiedIdOrClass() const {
5732 if (!qual_empty()) return false;
5733 if (const BuiltinType *T = getBaseType()->getAs<BuiltinType>())
5734 return T->getKind() == BuiltinType::ObjCId ||
5735 T->getKind() == BuiltinType::ObjCClass;
5736 return false;
5737 }
5738 bool isObjCQualifiedId() const { return !qual_empty() && isObjCId(); }
5739 bool isObjCQualifiedClass() const { return !qual_empty() && isObjCClass(); }
5740
5741 /// Gets the interface declaration for this object type, if the base type
5742 /// really is an interface.
5743 ObjCInterfaceDecl *getInterface() const;
5744
5745 /// Determine whether this object type is "specialized", meaning
5746 /// that it has type arguments.
5747 bool isSpecialized() const;
5748
5749 /// Determine whether this object type was written with type arguments.
5750 bool isSpecializedAsWritten() const {
5751 return ObjCObjectTypeBits.NumTypeArgs > 0;
5752 }
5753
5754 /// Determine whether this object type is "unspecialized", meaning
5755 /// that it has no type arguments.
5756 bool isUnspecialized() const { return !isSpecialized(); }
5757
5758 /// Determine whether this object type is "unspecialized" as
5759 /// written, meaning that it has no type arguments.
5760 bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }
5761
5762 /// Retrieve the type arguments of this object type (semantically).
5763 ArrayRef<QualType> getTypeArgs() const;
5764
5765 /// Retrieve the type arguments of this object type as they were
5766 /// written.
5767 ArrayRef<QualType> getTypeArgsAsWritten() const {
5768 return llvm::makeArrayRef(getTypeArgStorage(),
5769 ObjCObjectTypeBits.NumTypeArgs);
5770 }
5771
5772 /// Whether this is a "__kindof" type as written.
5773 bool isKindOfTypeAsWritten() const { return ObjCObjectTypeBits.IsKindOf; }
5774
5775 /// Whether this ia a "__kindof" type (semantically).
5776 bool isKindOfType() const;
5777
5778 /// Retrieve the type of the superclass of this object type.
5779 ///
5780 /// This operation substitutes any type arguments into the
5781 /// superclass of the current class type, potentially producing a
5782 /// specialization of the superclass type. Produces a null type if
5783 /// there is no superclass.
5784 QualType getSuperClassType() const {
5785 if (!CachedSuperClassType.getInt())
5786 computeSuperClassTypeSlow();
5787
5788 assert(CachedSuperClassType.getInt() && "Superclass not set?")((CachedSuperClassType.getInt() && "Superclass not set?"
) ? static_cast<void> (0) : __assert_fail ("CachedSuperClassType.getInt() && \"Superclass not set?\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 5788, __PRETTY_FUNCTION__))
;
5789 return QualType(CachedSuperClassType.getPointer(), 0);
5790 }
5791
5792 /// Strip off the Objective-C "kindof" type and (with it) any
5793 /// protocol qualifiers.
5794 QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const;
5795
5796 bool isSugared() const { return false; }
5797 QualType desugar() const { return QualType(this, 0); }
5798
5799 static bool classof(const Type *T) {
5800 return T->getTypeClass() == ObjCObject ||
5801 T->getTypeClass() == ObjCInterface;
5802 }
5803};
5804
5805/// A class providing a concrete implementation
5806/// of ObjCObjectType, so as to not increase the footprint of
5807/// ObjCInterfaceType. Code outside of ASTContext and the core type
5808/// system should not reference this type.
5809class ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode {
5810 friend class ASTContext;
5811
5812 // If anyone adds fields here, ObjCObjectType::getProtocolStorage()
5813 // will need to be modified.
5814
5815 ObjCObjectTypeImpl(QualType Canonical, QualType Base,
5816 ArrayRef<QualType> typeArgs,
5817 ArrayRef<ObjCProtocolDecl *> protocols,
5818 bool isKindOf)
5819 : ObjCObjectType(Canonical, Base, typeArgs, protocols, isKindOf) {}
5820
5821public:
5822 void Profile(llvm::FoldingSetNodeID &ID);
5823 static void Profile(llvm::FoldingSetNodeID &ID,
5824 QualType Base,
5825 ArrayRef<QualType> typeArgs,
5826 ArrayRef<ObjCProtocolDecl *> protocols,
5827 bool isKindOf);
5828};
5829
5830inline QualType *ObjCObjectType::getTypeArgStorage() {
5831 return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1);
5832}
5833
5834inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
5835 return reinterpret_cast<ObjCProtocolDecl**>(
5836 getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
5837}
5838
5839inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
5840 return reinterpret_cast<ObjCProtocolDecl**>(
5841 static_cast<ObjCTypeParamType*>(this)+1);
5842}
5843
5844/// Interfaces are the core concept in Objective-C for object oriented design.
5845/// They basically correspond to C++ classes. There are two kinds of interface
5846/// types: normal interfaces like `NSString`, and qualified interfaces, which
5847/// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`.
5848///
5849/// ObjCInterfaceType guarantees the following properties when considered
5850/// as a subtype of its superclass, ObjCObjectType:
5851/// - There are no protocol qualifiers. To reinforce this, code which
5852/// tries to invoke the protocol methods via an ObjCInterfaceType will
5853/// fail to compile.
5854/// - It is its own base type. That is, if T is an ObjCInterfaceType*,
5855/// T->getBaseType() == QualType(T, 0).
5856class ObjCInterfaceType : public ObjCObjectType {
5857 friend class ASTContext; // ASTContext creates these.
5858 friend class ASTReader;
5859 friend class ObjCInterfaceDecl;
5860 template <class T> friend class serialization::AbstractTypeReader;
5861
5862 mutable ObjCInterfaceDecl *Decl;
5863
5864 ObjCInterfaceType(const ObjCInterfaceDecl *D)
5865 : ObjCObjectType(Nonce_ObjCInterface),
5866 Decl(const_cast<ObjCInterfaceDecl*>(D)) {}
5867
5868public:
5869 /// Get the declaration of this interface.
5870 ObjCInterfaceDecl *getDecl() const { return Decl; }
5871
5872 bool isSugared() const { return false; }
5873 QualType desugar() const { return QualType(this, 0); }
5874
5875 static bool classof(const Type *T) {
5876 return T->getTypeClass() == ObjCInterface;
5877 }
5878
5879 // Nonsense to "hide" certain members of ObjCObjectType within this
5880 // class. People asking for protocols on an ObjCInterfaceType are
5881 // not going to get what they want: ObjCInterfaceTypes are
5882 // guaranteed to have no protocols.
5883 enum {
5884 qual_iterator,
5885 qual_begin,
5886 qual_end,
5887 getNumProtocols,
5888 getProtocol
5889 };
5890};
5891
5892inline ObjCInterfaceDecl *ObjCObjectType::getInterface() const {
5893 QualType baseType = getBaseType();
5894 while (const auto *ObjT = baseType->getAs<ObjCObjectType>()) {
5895 if (const auto *T = dyn_cast<ObjCInterfaceType>(ObjT))
5896 return T->getDecl();
5897
5898 baseType = ObjT->getBaseType();
5899 }
5900
5901 return nullptr;
5902}
5903
5904/// Represents a pointer to an Objective C object.
5905///
5906/// These are constructed from pointer declarators when the pointee type is
5907/// an ObjCObjectType (or sugar for one). In addition, the 'id' and 'Class'
5908/// types are typedefs for these, and the protocol-qualified types 'id<P>'
5909/// and 'Class<P>' are translated into these.
5910///
5911/// Pointers to pointers to Objective C objects are still PointerTypes;
5912/// only the first level of pointer gets it own type implementation.
5913class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
5914 friend class ASTContext; // ASTContext creates these.
5915
5916 QualType PointeeType;
5917
5918 ObjCObjectPointerType(QualType Canonical, QualType Pointee)
5919 : Type(ObjCObjectPointer, Canonical,
5920 Pointee->isDependentType(),
5921 Pointee->isInstantiationDependentType(),
5922 Pointee->isVariablyModifiedType(),
5923 Pointee->containsUnexpandedParameterPack()),
5924 PointeeType(Pointee) {}
5925
5926public:
5927 /// Gets the type pointed to by this ObjC pointer.
5928 /// The result will always be an ObjCObjectType or sugar thereof.
5929 QualType getPointeeType() const { return PointeeType; }
5930
5931 /// Gets the type pointed to by this ObjC pointer. Always returns non-null.
5932 ///
5933 /// This method is equivalent to getPointeeType() except that
5934 /// it discards any typedefs (or other sugar) between this
5935 /// type and the "outermost" object type. So for:
5936 /// \code
5937 /// \@class A; \@protocol P; \@protocol Q;
5938 /// typedef A<P> AP;
5939 /// typedef A A1;
5940 /// typedef A1<P> A1P;
5941 /// typedef A1P<Q> A1PQ;
5942 /// \endcode
5943 /// For 'A*', getObjectType() will return 'A'.
5944 /// For 'A<P>*', getObjectType() will return 'A<P>'.
5945 /// For 'AP*', getObjectType() will return 'A<P>'.
5946 /// For 'A1*', getObjectType() will return 'A'.
5947 /// For 'A1<P>*', getObjectType() will return 'A1<P>'.
5948 /// For 'A1P*', getObjectType() will return 'A1<P>'.
5949 /// For 'A1PQ*', getObjectType() will return 'A1<Q>', because
5950 /// adding protocols to a protocol-qualified base discards the
5951 /// old qualifiers (for now). But if it didn't, getObjectType()
5952 /// would return 'A1P<Q>' (and we'd have to make iterating over
5953 /// qualifiers more complicated).
5954 const ObjCObjectType *getObjectType() const {
5955 return PointeeType->castAs<ObjCObjectType>();
5956 }
5957
5958 /// If this pointer points to an Objective C
5959 /// \@interface type, gets the type for that interface. Any protocol
5960 /// qualifiers on the interface are ignored.
5961 ///
5962 /// \return null if the base type for this pointer is 'id' or 'Class'
5963 const ObjCInterfaceType *getInterfaceType() const;
5964
5965 /// If this pointer points to an Objective \@interface
5966 /// type, gets the declaration for that interface.
5967 ///
5968 /// \return null if the base type for this pointer is 'id' or 'Class'
5969 ObjCInterfaceDecl *getInterfaceDecl() const {
5970 return getObjectType()->getInterface();
5971 }
5972
5973 /// True if this is equivalent to the 'id' type, i.e. if
5974 /// its object type is the primitive 'id' type with no protocols.
5975 bool isObjCIdType() const {
5976 return getObjectType()->isObjCUnqualifiedId();
5977 }
5978
5979 /// True if this is equivalent to the 'Class' type,
5980 /// i.e. if its object tive is the primitive 'Class' type with no protocols.
5981 bool isObjCClassType() const {
5982 return getObjectType()->isObjCUnqualifiedClass();
5983 }
5984
5985 /// True if this is equivalent to the 'id' or 'Class' type,
5986 bool isObjCIdOrClassType() const {
5987 return getObjectType()->isObjCUnqualifiedIdOrClass();
5988 }
5989
5990 /// True if this is equivalent to 'id<P>' for some non-empty set of
5991 /// protocols.
5992 bool isObjCQualifiedIdType() const {
5993 return getObjectType()->isObjCQualifiedId();
5994 }
5995
5996 /// True if this is equivalent to 'Class<P>' for some non-empty set of
5997 /// protocols.
5998 bool isObjCQualifiedClassType() const {
5999 return getObjectType()->isObjCQualifiedClass();
6000 }
6001
6002 /// Whether this is a "__kindof" type.
6003 bool isKindOfType() const { return getObjectType()->isKindOfType(); }
6004
6005 /// Whether this type is specialized, meaning that it has type arguments.
6006 bool isSpecialized() const { return getObjectType()->isSpecialized(); }
6007
6008 /// Whether this type is specialized, meaning that it has type arguments.
6009 bool isSpecializedAsWritten() const {
6010 return getObjectType()->isSpecializedAsWritten();
6011 }
6012
6013 /// Whether this type is unspecialized, meaning that is has no type arguments.
6014 bool isUnspecialized() const { return getObjectType()->isUnspecialized(); }
6015
6016 /// Determine whether this object type is "unspecialized" as
6017 /// written, meaning that it has no type arguments.
6018 bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }
6019
6020 /// Retrieve the type arguments for this type.
6021 ArrayRef<QualType> getTypeArgs() const {
6022 return getObjectType()->getTypeArgs();
6023 }
6024
6025 /// Retrieve the type arguments for this type.
6026 ArrayRef<QualType> getTypeArgsAsWritten() const {
6027 return getObjectType()->getTypeArgsAsWritten();
6028 }
6029
6030 /// An iterator over the qualifiers on the object type. Provided
6031 /// for convenience. This will always iterate over the full set of
6032 /// protocols on a type, not just those provided directly.
6033 using qual_iterator = ObjCObjectType::qual_iterator;
6034 using qual_range = llvm::iterator_range<qual_iterator>;
6035
6036 qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
6037
6038 qual_iterator qual_begin() const {
6039 return getObjectType()->qual_begin();
6040 }
6041
6042 qual_iterator qual_end() const {
6043 return getObjectType()->qual_end();
6044 }
6045
6046 bool qual_empty() const { return getObjectType()->qual_empty(); }
6047
6048 /// Return the number of qualifying protocols on the object type.
6049 unsigned getNumProtocols() const {
6050 return getObjectType()->getNumProtocols();
6051 }
6052
6053 /// Retrieve a qualifying protocol by index on the object type.
6054 ObjCProtocolDecl *getProtocol(unsigned I) const {
6055 return getObjectType()->getProtocol(I);
6056 }
6057
6058 bool isSugared() const { return false; }
6059 QualType desugar() const { return QualType(this, 0); }
6060
6061 /// Retrieve the type of the superclass of this object pointer type.
6062 ///
6063 /// This operation substitutes any type arguments into the
6064 /// superclass of the current class type, potentially producing a
6065 /// pointer to a specialization of the superclass type. Produces a
6066 /// null type if there is no superclass.
6067 QualType getSuperClassType() const;
6068
6069 /// Strip off the Objective-C "kindof" type and (with it) any
6070 /// protocol qualifiers.
6071 const ObjCObjectPointerType *stripObjCKindOfTypeAndQuals(
6072 const ASTContext &ctx) const;
6073
6074 void Profile(llvm::FoldingSetNodeID &ID) {
6075 Profile(ID, getPointeeType());
6076 }
6077
6078 static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
6079 ID.AddPointer(T.getAsOpaquePtr());
6080 }
6081
6082 static bool classof(const Type *T) {
6083 return T->getTypeClass() == ObjCObjectPointer;
6084 }
6085};
6086
6087class AtomicType : public Type, public llvm::FoldingSetNode {
6088 friend class ASTContext; // ASTContext creates these.
6089
6090 QualType ValueType;
6091
6092 AtomicType(QualType ValTy, QualType Canonical)
6093 : Type(Atomic, Canonical, ValTy->isDependentType(),
6094 ValTy->isInstantiationDependentType(),
6095 ValTy->isVariablyModifiedType(),
6096 ValTy->containsUnexpandedParameterPack()),
6097 ValueType(ValTy) {}
6098
6099public:
6100 /// Gets the type contained by this atomic type, i.e.
6101 /// the type returned by performing an atomic load of this atomic type.
6102 QualType getValueType() const { return ValueType; }
6103
6104 bool isSugared() const { return false; }
6105 QualType desugar() const { return QualType(this, 0); }
6106
6107 void Profile(llvm::FoldingSetNodeID &ID) {
6108 Profile(ID, getValueType());
6109 }
6110
6111 static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
6112 ID.AddPointer(T.getAsOpaquePtr());
6113 }
6114
6115 static bool classof(const Type *T) {
6116 return T->getTypeClass() == Atomic;
6117 }
6118};
6119
6120/// PipeType - OpenCL20.
6121class PipeType : public Type, public llvm::FoldingSetNode {
6122 friend class ASTContext; // ASTContext creates these.
6123
6124 QualType ElementType;
6125 bool isRead;
6126
6127 PipeType(QualType elemType, QualType CanonicalPtr, bool isRead)
6128 : Type(Pipe, CanonicalPtr, elemType->isDependentType(),
6129 elemType->isInstantiationDependentType(),
6130 elemType->isVariablyModifiedType(),
6131 elemType->containsUnexpandedParameterPack()),
6132 ElementType(elemType), isRead(isRead) {}
6133
6134public:
6135 QualType getElementType() const { return ElementType; }
6136
6137 bool isSugared() const { return false; }
6138
6139 QualType desugar() const { return QualType(this, 0); }
6140
6141 void Profile(llvm::FoldingSetNodeID &ID) {
6142 Profile(ID, getElementType(), isReadOnly());
6143 }
6144
6145 static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead) {
6146 ID.AddPointer(T.getAsOpaquePtr());
6147 ID.AddBoolean(isRead);
6148 }
6149
6150 static bool classof(const Type *T) {
6151 return T->getTypeClass() == Pipe;
6152 }
6153
6154 bool isReadOnly() const { return isRead; }
6155};
6156
6157/// A qualifier set is used to build a set of qualifiers.
6158class QualifierCollector : public Qualifiers {
6159public:
6160 QualifierCollector(Qualifiers Qs = Qualifiers()) : Qualifiers(Qs) {}
6161
6162 /// Collect any qualifiers on the given type and return an
6163 /// unqualified type. The qualifiers are assumed to be consistent
6164 /// with those already in the type.
6165 const Type *strip(QualType type) {
6166 addFastQualifiers(type.getLocalFastQualifiers());
6167 if (!type.hasLocalNonFastQualifiers())
6168 return type.getTypePtrUnsafe();
6169
6170 const ExtQuals *extQuals = type.getExtQualsUnsafe();
6171 addConsistentQualifiers(extQuals->getQualifiers());
6172 return extQuals->getBaseType();
6173 }
6174
6175 /// Apply the collected qualifiers to the given type.
6176 QualType apply(const ASTContext &Context, QualType QT) const;
6177
6178 /// Apply the collected qualifiers to the given type.
6179 QualType apply(const ASTContext &Context, const Type* T) const;
6180};
6181
6182/// A container of type source information.
6183///
6184/// A client can read the relevant info using TypeLoc wrappers, e.g:
6185/// @code
6186/// TypeLoc TL = TypeSourceInfo->getTypeLoc();
6187/// TL.getBeginLoc().print(OS, SrcMgr);
6188/// @endcode
6189class alignas(8) TypeSourceInfo {
6190 // Contains a memory block after the class, used for type source information,
6191 // allocated by ASTContext.
6192 friend class ASTContext;
6193
6194 QualType Ty;
6195
6196 TypeSourceInfo(QualType ty) : Ty(ty) {}
6197
6198public:
6199 /// Return the type wrapped by this type source info.
6200 QualType getType() const { return Ty; }
6201
6202 /// Return the TypeLoc wrapper for the type source info.
6203 TypeLoc getTypeLoc() const; // implemented in TypeLoc.h
6204
6205 /// Override the type stored in this TypeSourceInfo. Use with caution!
6206 void overrideType(QualType T) { Ty = T; }
6207};
6208
6209// Inline function definitions.
6210
6211inline SplitQualType SplitQualType::getSingleStepDesugaredType() const {
6212 SplitQualType desugar =
6213 Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
6214 desugar.Quals.addConsistentQualifiers(Quals);
6215 return desugar;
6216}
6217
6218inline const Type *QualType::getTypePtr() const {
6219 return getCommonPtr()->BaseType;
6220}
6221
6222inline const Type *QualType::getTypePtrOrNull() const {
6223 return (isNull() ? nullptr : getCommonPtr()->BaseType);
6224}
6225
6226inline SplitQualType QualType::split() const {
6227 if (!hasLocalNonFastQualifiers())
6228 return SplitQualType(getTypePtrUnsafe(),
6229 Qualifiers::fromFastMask(getLocalFastQualifiers()));
6230
6231 const ExtQuals *eq = getExtQualsUnsafe();
6232 Qualifiers qs = eq->getQualifiers();
6233 qs.addFastQualifiers(getLocalFastQualifiers());
6234 return SplitQualType(eq->getBaseType(), qs);
6235}
6236
6237inline Qualifiers QualType::getLocalQualifiers() const {
6238 Qualifiers Quals;
6239 if (hasLocalNonFastQualifiers())
6240 Quals = getExtQualsUnsafe()->getQualifiers();
6241 Quals.addFastQualifiers(getLocalFastQualifiers());
6242 return Quals;
6243}
6244
6245inline Qualifiers QualType::getQualifiers() const {
6246 Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
6247 quals.addFastQualifiers(getLocalFastQualifiers());
6248 return quals;
6249}
6250
6251inline unsigned QualType::getCVRQualifiers() const {
6252 unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
6253 cvr |= getLocalCVRQualifiers();
6254 return cvr;
6255}
6256
6257inline QualType QualType::getCanonicalType() const {
6258 QualType canon = getCommonPtr()->CanonicalType;
6259 return canon.withFastQualifiers(getLocalFastQualifiers());
6260}
6261
6262inline bool QualType::isCanonical() const {
6263 return getTypePtr()->isCanonicalUnqualified();
6264}
6265
6266inline bool QualType::isCanonicalAsParam() const {
6267 if (!isCanonical()) return false;
6268 if (hasLocalQualifiers()) return false;
6269
6270 const Type *T = getTypePtr();
6271 if (T->isVariablyModifiedType() && T->hasSizedVLAType())
6272 return false;
6273
6274 return !isa<FunctionType>(T) && !isa<ArrayType>(T);
6275}
6276
6277inline bool QualType::isConstQualified() const {
6278 return isLocalConstQualified() ||
6279 getCommonPtr()->CanonicalType.isLocalConstQualified();
6280}
6281
6282inline bool QualType::isRestrictQualified() const {
6283 return isLocalRestrictQualified() ||
6284 getCommonPtr()->CanonicalType.isLocalRestrictQualified();
6285}
6286
6287
6288inline bool QualType::isVolatileQualified() const {
6289 return isLocalVolatileQualified() ||
6290 getCommonPtr()->CanonicalType.isLocalVolatileQualified();
6291}
6292
6293inline bool QualType::hasQualifiers() const {
6294 return hasLocalQualifiers() ||
6295 getCommonPtr()->CanonicalType.hasLocalQualifiers();
6296}
6297
6298inline QualType QualType::getUnqualifiedType() const {
6299 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
6300 return QualType(getTypePtr(), 0);
6301
6302 return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
6303}
6304
6305inline SplitQualType QualType::getSplitUnqualifiedType() const {
6306 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
6307 return split();
6308
6309 return getSplitUnqualifiedTypeImpl(*this);
6310}
6311
6312inline void QualType::removeLocalConst() {
6313 removeLocalFastQualifiers(Qualifiers::Const);
6314}
6315
6316inline void QualType::removeLocalRestrict() {
6317 removeLocalFastQualifiers(Qualifiers::Restrict);
6318}
6319
6320inline void QualType::removeLocalVolatile() {
6321 removeLocalFastQualifiers(Qualifiers::Volatile);
6322}
6323
6324inline void QualType::removeLocalCVRQualifiers(unsigned Mask) {
6325 assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits")((!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(Mask & ~Qualifiers::CVRMask) && \"mask has non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 6325, __PRETTY_FUNCTION__))
;
6326 static_assert((int)Qualifiers::CVRMask == (int)Qualifiers::FastMask,
6327 "Fast bits differ from CVR bits!");
6328
6329 // Fast path: we don't need to touch the slow qualifiers.
6330 removeLocalFastQualifiers(Mask);
6331}
6332
6333/// Check if this type has any address space qualifier.
6334inline bool QualType::hasAddressSpace() const {
6335 return getQualifiers().hasAddressSpace();
6336}
6337
6338/// Return the address space of this type.
6339inline LangAS QualType::getAddressSpace() const {
6340 return getQualifiers().getAddressSpace();
6341}
6342
6343/// Return the gc attribute of this type.
6344inline Qualifiers::GC QualType::getObjCGCAttr() const {
6345 return getQualifiers().getObjCGCAttr();
6346}
6347
6348inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
6349 if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
6350 return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
6351 return false;
6352}
6353
6354inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion() const {
6355 if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
6356 return hasNonTrivialToPrimitiveDestructCUnion(RD);
6357 return false;
6358}
6359
6360inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion() const {
6361 if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
6362 return hasNonTrivialToPrimitiveCopyCUnion(RD);
6363 return false;
6364}
6365
6366inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) {
6367 if (const auto *PT = t.getAs<PointerType>()) {
6368 if (const auto *FT = PT->getPointeeType()->getAs<FunctionType>())
6369 return FT->getExtInfo();
6370 } else if (const auto *FT = t.getAs<FunctionType>())
6371 return FT->getExtInfo();
6372
6373 return FunctionType::ExtInfo();
6374}
6375
6376inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) {
6377 return getFunctionExtInfo(*t);
6378}
6379
6380/// Determine whether this type is more
6381/// qualified than the Other type. For example, "const volatile int"
6382/// is more qualified than "const int", "volatile int", and
6383/// "int". However, it is not more qualified than "const volatile
6384/// int".
6385inline bool QualType::isMoreQualifiedThan(QualType other) const {
6386 Qualifiers MyQuals = getQualifiers();
6387 Qualifiers OtherQuals = other.getQualifiers();
6388 return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals));
6389}
6390
6391/// Determine whether this type is at last
6392/// as qualified as the Other type. For example, "const volatile
6393/// int" is at least as qualified as "const int", "volatile int",
6394/// "int", and "const volatile int".
6395inline bool QualType::isAtLeastAsQualifiedAs(QualType other) const {
6396 Qualifiers OtherQuals = other.getQualifiers();
6397
6398 // Ignore __unaligned qualifier if this type is a void.
6399 if (getUnqualifiedType()->isVoidType())
6400 OtherQuals.removeUnaligned();
6401
6402 return getQualifiers().compatiblyIncludes(OtherQuals);
6403}
6404
6405/// If Type is a reference type (e.g., const
6406/// int&), returns the type that the reference refers to ("const
6407/// int"). Otherwise, returns the type itself. This routine is used
6408/// throughout Sema to implement C++ 5p6:
6409///
6410/// If an expression initially has the type "reference to T" (8.3.2,
6411/// 8.5.3), the type is adjusted to "T" prior to any further
6412/// analysis, the expression designates the object or function
6413/// denoted by the reference, and the expression is an lvalue.
6414inline QualType QualType::getNonReferenceType() const {
6415 if (const auto *RefType = (*this)->getAs<ReferenceType>())
6416 return RefType->getPointeeType();
6417 else
6418 return *this;
6419}
6420
6421inline bool QualType::isCForbiddenLValueType() const {
6422 return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
6423 getTypePtr()->isFunctionType());
6424}
6425
6426/// Tests whether the type is categorized as a fundamental type.
6427///
6428/// \returns True for types specified in C++0x [basic.fundamental].
6429inline bool Type::isFundamentalType() const {
6430 return isVoidType() ||
6431 isNullPtrType() ||
6432 // FIXME: It's really annoying that we don't have an
6433 // 'isArithmeticType()' which agrees with the standard definition.
6434 (isArithmeticType() && !isEnumeralType());
6435}
6436
6437/// Tests whether the type is categorized as a compound type.
6438///
6439/// \returns True for types specified in C++0x [basic.compound].
6440inline bool Type::isCompoundType() const {
6441 // C++0x [basic.compound]p1:
6442 // Compound types can be constructed in the following ways:
6443 // -- arrays of objects of a given type [...];
6444 return isArrayType() ||
6445 // -- functions, which have parameters of given types [...];
6446 isFunctionType() ||
6447 // -- pointers to void or objects or functions [...];
6448 isPointerType() ||
6449 // -- references to objects or functions of a given type. [...]
6450 isReferenceType() ||
6451 // -- classes containing a sequence of objects of various types, [...];
6452 isRecordType() ||
6453 // -- unions, which are classes capable of containing objects of different
6454 // types at different times;
6455 isUnionType() ||
6456 // -- enumerations, which comprise a set of named constant values. [...];
6457 isEnumeralType() ||
6458 // -- pointers to non-static class members, [...].
6459 isMemberPointerType();
6460}
6461
6462inline bool Type::isFunctionType() const {
6463 return isa<FunctionType>(CanonicalType);
6464}
6465
6466inline bool Type::isPointerType() const {
6467 return isa<PointerType>(CanonicalType);
6468}
6469
6470inline bool Type::isAnyPointerType() const {
6471 return isPointerType() || isObjCObjectPointerType();
6472}
6473
6474inline bool Type::isBlockPointerType() const {
6475 return isa<BlockPointerType>(CanonicalType);
6476}
6477
6478inline bool Type::isReferenceType() const {
6479 return isa<ReferenceType>(CanonicalType);
6480}
6481
6482inline bool Type::isLValueReferenceType() const {
6483 return isa<LValueReferenceType>(CanonicalType);
6484}
6485
6486inline bool Type::isRValueReferenceType() const {
6487 return isa<RValueReferenceType>(CanonicalType);
6488}
6489
6490inline bool Type::isObjectPointerType() const {
6491 // Note: an "object pointer type" is not the same thing as a pointer to an
6492 // object type; rather, it is a pointer to an object type or a pointer to cv
6493 // void.
6494 if (const auto *T = getAs<PointerType>())
6495 return !T->getPointeeType()->isFunctionType();
6496 else
6497 return false;
6498}
6499
6500inline bool Type::isFunctionPointerType() const {
6501 if (const auto *T = getAs<PointerType>())
6502 return T->getPointeeType()->isFunctionType();
6503 else
6504 return false;
6505}
6506
6507inline bool Type::isFunctionReferenceType() const {
6508 if (const auto *T = getAs<ReferenceType>())
6509 return T->getPointeeType()->isFunctionType();
6510 else
6511 return false;
6512}
6513
6514inline bool Type::isMemberPointerType() const {
6515 return isa<MemberPointerType>(CanonicalType);
6516}
6517
6518inline bool Type::isMemberFunctionPointerType() const {
6519 if (const auto *T = getAs<MemberPointerType>())
6520 return T->isMemberFunctionPointer();
6521 else
6522 return false;
6523}
6524
6525inline bool Type::isMemberDataPointerType() const {
6526 if (const auto *T = getAs<MemberPointerType>())
6527 return T->isMemberDataPointer();
6528 else
6529 return false;
6530}
6531
6532inline bool Type::isArrayType() const {
6533 return isa<ArrayType>(CanonicalType);
6534}
6535
6536inline bool Type::isConstantArrayType() const {
6537 return isa<ConstantArrayType>(CanonicalType);
6538}
6539
6540inline bool Type::isIncompleteArrayType() const {
6541 return isa<IncompleteArrayType>(CanonicalType);
6542}
6543
6544inline bool Type::isVariableArrayType() const {
6545 return isa<VariableArrayType>(CanonicalType);
6546}
6547
6548inline bool Type::isDependentSizedArrayType() const {
6549 return isa<DependentSizedArrayType>(CanonicalType);
6550}
6551
6552inline bool Type::isBuiltinType() const {
6553 return isa<BuiltinType>(CanonicalType);
6554}
6555
6556inline bool Type::isRecordType() const {
6557 return isa<RecordType>(CanonicalType);
6558}
6559
6560inline bool Type::isEnumeralType() const {
6561 return isa<EnumType>(CanonicalType);
6562}
6563
6564inline bool Type::isAnyComplexType() const {
6565 return isa<ComplexType>(CanonicalType);
6566}
6567
6568inline bool Type::isVectorType() const {
6569 return isa<VectorType>(CanonicalType);
6570}
6571
6572inline bool Type::isExtVectorType() const {
6573 return isa<ExtVectorType>(CanonicalType);
6574}
6575
6576inline bool Type::isDependentAddressSpaceType() const {
6577 return isa<DependentAddressSpaceType>(CanonicalType);
6578}
6579
6580inline bool Type::isObjCObjectPointerType() const {
6581 return isa<ObjCObjectPointerType>(CanonicalType);
21
Assuming field 'CanonicalType' is a 'ObjCObjectPointerType'
22
Returning the value 1, which participates in a condition later
6582}
6583
6584inline bool Type::isObjCObjectType() const {
6585 return isa<ObjCObjectType>(CanonicalType);
6586}
6587
6588inline bool Type::isObjCObjectOrInterfaceType() const {
6589 return isa<ObjCInterfaceType>(CanonicalType) ||
6590 isa<ObjCObjectType>(CanonicalType);
6591}
6592
6593inline bool Type::isAtomicType() const {
6594 return isa<AtomicType>(CanonicalType);
6595}
6596
6597inline bool Type::isUndeducedAutoType() const {
6598 return isa<AutoType>(CanonicalType);
6599}
6600
6601inline bool Type::isObjCQualifiedIdType() const {
6602 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6603 return OPT->isObjCQualifiedIdType();
6604 return false;
6605}
6606
6607inline bool Type::isObjCQualifiedClassType() const {
6608 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6609 return OPT->isObjCQualifiedClassType();
6610 return false;
6611}
6612
6613inline bool Type::isObjCIdType() const {
6614 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6615 return OPT->isObjCIdType();
6616 return false;
6617}
6618
6619inline bool Type::isObjCClassType() const {
6620 if (const auto *OPT = getAs<ObjCObjectPointerType>())
6621 return OPT->isObjCClassType();
6622 return false;
6623}
6624
6625inline bool Type::isObjCSelType() const {
6626 if (const auto *OPT = getAs<PointerType>())
6627 return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
6628 return false;
6629}
6630
6631inline bool Type::isObjCBuiltinType() const {
6632 return isObjCIdType() || isObjCClassType() || isObjCSelType();
6633}
6634
6635inline bool Type::isDecltypeType() const {
6636 return isa<DecltypeType>(this);
6637}
6638
6639#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6640 inline bool Type::is##Id##Type() const { \
6641 return isSpecificBuiltinType(BuiltinType::Id); \
6642 }
6643#include "clang/Basic/OpenCLImageTypes.def"
6644
6645inline bool Type::isSamplerT() const {
6646 return isSpecificBuiltinType(BuiltinType::OCLSampler);
6647}
6648
6649inline bool Type::isEventT() const {
6650 return isSpecificBuiltinType(BuiltinType::OCLEvent);
6651}
6652
6653inline bool Type::isClkEventT() const {
6654 return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
6655}
6656
6657inline bool Type::isQueueT() const {
6658 return isSpecificBuiltinType(BuiltinType::OCLQueue);
6659}
6660
6661inline bool Type::isReserveIDT() const {
6662 return isSpecificBuiltinType(BuiltinType::OCLReserveID);
6663}
6664
6665inline bool Type::isImageType() const {
6666#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
6667 return
6668#include "clang/Basic/OpenCLImageTypes.def"
6669 false; // end boolean or operation
6670}
6671
6672inline bool Type::isPipeType() const {
6673 return isa<PipeType>(CanonicalType);
6674}
6675
6676#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
6677 inline bool Type::is##Id##Type() const { \
6678 return isSpecificBuiltinType(BuiltinType::Id); \
6679 }
6680#include "clang/Basic/OpenCLExtensionTypes.def"
6681
6682inline bool Type::isOCLIntelSubgroupAVCType() const {
6683#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
6684 isOCLIntelSubgroupAVC##Id##Type() ||
6685 return
6686#include "clang/Basic/OpenCLExtensionTypes.def"
6687 false; // end of boolean or operation
6688}
6689
6690inline bool Type::isOCLExtOpaqueType() const {
6691#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
6692 return
6693#include "clang/Basic/OpenCLExtensionTypes.def"
6694 false; // end of boolean or operation
6695}
6696
6697inline bool Type::isOpenCLSpecificType() const {
6698 return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
6699 isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
6700}
6701
6702inline bool Type::isTemplateTypeParmType() const {
6703 return isa<TemplateTypeParmType>(CanonicalType);
6704}
6705
6706inline bool Type::isSpecificBuiltinType(unsigned K) const {
6707 if (const BuiltinType *BT = getAs<BuiltinType>())
6708 if (BT->getKind() == (BuiltinType::Kind) K)
6709 return true;
6710 return false;
6711}
6712
6713inline bool Type::isPlaceholderType() const {
6714 if (const auto *BT = dyn_cast<BuiltinType>(this))
6715 return BT->isPlaceholderType();
6716 return false;
6717}
6718
6719inline const BuiltinType *Type::getAsPlaceholderType() const {
6720 if (const auto *BT = dyn_cast<BuiltinType>(this))
6721 if (BT->isPlaceholderType())
6722 return BT;
6723 return nullptr;
6724}
6725
6726inline bool Type::isSpecificPlaceholderType(unsigned K) const {
6727 assert(BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K))((BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K)) ?
static_cast<void> (0) : __assert_fail ("BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K)"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 6727, __PRETTY_FUNCTION__))
;
6728 if (const auto *BT = dyn_cast<BuiltinType>(this))
6729 return (BT->getKind() == (BuiltinType::Kind) K);
6730 return false;
6731}
6732
6733inline bool Type::isNonOverloadPlaceholderType() const {
6734 if (const auto *BT = dyn_cast<BuiltinType>(this))
6735 return BT->isNonOverloadPlaceholderType();
6736 return false;
6737}
6738
6739inline bool Type::isVoidType() const {
6740 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
6741 return BT->getKind() == BuiltinType::Void;
6742 return false;
6743}
6744
6745inline bool Type::isHalfType() const {
6746 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
6747 return BT->getKind() == BuiltinType::Half;
6748 // FIXME: Should we allow complex __fp16? Probably not.
6749 return false;
6750}
6751
6752inline bool Type::isFloat16Type() const {
6753 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
6754 return BT->getKind() == BuiltinType::Float16;
6755 return false;
6756}
6757
6758inline bool Type::isFloat128Type() const {
6759 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
6760 return BT->getKind() == BuiltinType::Float128;
6761 return false;
6762}
6763
6764inline bool Type::isNullPtrType() const {
6765 if (const auto *BT = getAs<BuiltinType>())
6766 return BT->getKind() == BuiltinType::NullPtr;
6767 return false;
6768}
6769
6770bool IsEnumDeclComplete(EnumDecl *);
6771bool IsEnumDeclScoped(EnumDecl *);
6772
6773inline bool Type::isIntegerType() const {
6774 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
6775 return BT->getKind() >= BuiltinType::Bool &&
6776 BT->getKind() <= BuiltinType::Int128;
6777 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
6778 // Incomplete enum types are not treated as integer types.
6779 // FIXME: In C++, enum types are never integer types.
6780 return IsEnumDeclComplete(ET->getDecl()) &&
6781 !IsEnumDeclScoped(ET->getDecl());
6782 }
6783 return false;
6784}
6785
6786inline bool Type::isFixedPointType() const {
6787 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
6788 return BT->getKind() >= BuiltinType::ShortAccum &&
6789 BT->getKind() <= BuiltinType::SatULongFract;
6790 }
6791 return false;
6792}
6793
6794inline bool Type::isFixedPointOrIntegerType() const {
6795 return isFixedPointType() || isIntegerType();
6796}
6797
6798inline bool Type::isSaturatedFixedPointType() const {
6799 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
6800 return BT->getKind() >= BuiltinType::SatShortAccum &&
6801 BT->getKind() <= BuiltinType::SatULongFract;
6802 }
6803 return false;
6804}
6805
6806inline bool Type::isUnsaturatedFixedPointType() const {
6807 return isFixedPointType() && !isSaturatedFixedPointType();
6808}
6809
6810inline bool Type::isSignedFixedPointType() const {
6811 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
6812 return ((BT->getKind() >= BuiltinType::ShortAccum &&
6813 BT->getKind() <= BuiltinType::LongAccum) ||
6814 (BT->getKind() >= BuiltinType::ShortFract &&
6815 BT->getKind() <= BuiltinType::LongFract) ||
6816 (BT->getKind() >= BuiltinType::SatShortAccum &&
6817 BT->getKind() <= BuiltinType::SatLongAccum) ||
6818 (BT->getKind() >= BuiltinType::SatShortFract &&
6819 BT->getKind() <= BuiltinType::SatLongFract));
6820 }
6821 return false;
6822}
6823
6824inline bool Type::isUnsignedFixedPointType() const {
6825 return isFixedPointType() && !isSignedFixedPointType();
6826}
6827
6828inline bool Type::isScalarType() const {
6829 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
6830 return BT->getKind() > BuiltinType::Void &&
6831 BT->getKind() <= BuiltinType::NullPtr;
6832 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
6833 // Enums are scalar types, but only if they are defined. Incomplete enums
6834 // are not treated as scalar types.
6835 return IsEnumDeclComplete(ET->getDecl());
6836 return isa<PointerType>(CanonicalType) ||
6837 isa<BlockPointerType>(CanonicalType) ||
6838 isa<MemberPointerType>(CanonicalType) ||
6839 isa<ComplexType>(CanonicalType) ||
6840 isa<ObjCObjectPointerType>(CanonicalType);
6841}
6842
6843inline bool Type::isIntegralOrEnumerationType() const {
6844 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
6845 return BT->getKind() >= BuiltinType::Bool &&
6846 BT->getKind() <= BuiltinType::Int128;
6847
6848 // Check for a complete enum type; incomplete enum types are not properly an
6849 // enumeration type in the sense required here.
6850 if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
6851 return IsEnumDeclComplete(ET->getDecl());
6852
6853 return false;
6854}
6855
6856inline bool Type::isBooleanType() const {
6857 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
6858 return BT->getKind() == BuiltinType::Bool;
6859 return false;
6860}
6861
6862inline bool Type::isUndeducedType() const {
6863 auto *DT = getContainedDeducedType();
6864 return DT && !DT->isDeduced();
6865}
6866
6867/// Determines whether this is a type for which one can define
6868/// an overloaded operator.
6869inline bool Type::isOverloadableType() const {
6870 return isDependentType() || isRecordType() || isEnumeralType();
6871}
6872
6873/// Determines whether this type can decay to a pointer type.
6874inline bool Type::canDecayToPointerType() const {
6875 return isFunctionType() || isArrayType();
6876}
6877
6878inline bool Type::hasPointerRepresentation() const {
6879 return (isPointerType() || isReferenceType() || isBlockPointerType() ||
6880 isObjCObjectPointerType() || isNullPtrType());
6881}
6882
6883inline bool Type::hasObjCPointerRepresentation() const {
6884 return isObjCObjectPointerType();
6885}
6886
6887inline const Type *Type::getBaseElementTypeUnsafe() const {
6888 const Type *type = this;
6889 while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
6890 type = arrayType->getElementType().getTypePtr();
6891 return type;
6892}
6893
6894inline const Type *Type::getPointeeOrArrayElementType() const {
6895 const Type *type = this;
6896 if (type->isAnyPointerType())
6897 return type->getPointeeType().getTypePtr();
6898 else if (type->isArrayType())
6899 return type->getBaseElementTypeUnsafe();
6900 return type;
6901}
6902/// Insertion operator for diagnostics. This allows sending address spaces into
6903/// a diagnostic with <<.
6904inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
6905 LangAS AS) {
6906 DB.AddTaggedVal(static_cast<std::underlying_type_t<LangAS>>(AS),
6907 DiagnosticsEngine::ArgumentKind::ak_addrspace);
6908 return DB;
6909}
6910
6911/// Insertion operator for partial diagnostics. This allows sending adress
6912/// spaces into a diagnostic with <<.
6913inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
6914 LangAS AS) {
6915 PD.AddTaggedVal(static_cast<std::underlying_type_t<LangAS>>(AS),
6916 DiagnosticsEngine::ArgumentKind::ak_addrspace);
6917 return PD;
6918}
6919
6920/// Insertion operator for diagnostics. This allows sending Qualifiers into a
6921/// diagnostic with <<.
6922inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
6923 Qualifiers Q) {
6924 DB.AddTaggedVal(Q.getAsOpaqueValue(),
6925 DiagnosticsEngine::ArgumentKind::ak_qual);
6926 return DB;
6927}
6928
6929/// Insertion operator for partial diagnostics. This allows sending Qualifiers
6930/// into a diagnostic with <<.
6931inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
6932 Qualifiers Q) {
6933 PD.AddTaggedVal(Q.getAsOpaqueValue(),
6934 DiagnosticsEngine::ArgumentKind::ak_qual);
6935 return PD;
6936}
6937
6938/// Insertion operator for diagnostics. This allows sending QualType's into a
6939/// diagnostic with <<.
6940inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
6941 QualType T) {
6942 DB.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
6943 DiagnosticsEngine::ak_qualtype);
6944 return DB;
6945}
6946
6947/// Insertion operator for partial diagnostics. This allows sending QualType's
6948/// into a diagnostic with <<.
6949inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
6950 QualType T) {
6951 PD.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
6952 DiagnosticsEngine::ak_qualtype);
6953 return PD;
6954}
6955
6956// Helper class template that is used by Type::getAs to ensure that one does
6957// not try to look through a qualified type to get to an array type.
6958template <typename T>
6959using TypeIsArrayType =
6960 std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
6961 std::is_base_of<ArrayType, T>::value>;
6962
6963// Member-template getAs<specific type>'.
6964template <typename T> const T *Type::getAs() const {
6965 static_assert(!TypeIsArrayType<T>::value,
6966 "ArrayType cannot be used with getAs!");
6967
6968 // If this is directly a T type, return it.
6969 if (const auto *Ty = dyn_cast<T>(this))
6970 return Ty;
6971
6972 // If the canonical form of this type isn't the right kind, reject it.
6973 if (!isa<T>(CanonicalType))
6974 return nullptr;
6975
6976 // If this is a typedef for the type, strip the typedef off without
6977 // losing all typedef information.
6978 return cast<T>(getUnqualifiedDesugaredType());
6979}
6980
6981template <typename T> const T *Type::getAsAdjusted() const {
6982 static_assert(!TypeIsArrayType<T>::value, "ArrayType cannot be used with getAsAdjusted!");
6983
6984 // If this is directly a T type, return it.
6985 if (const auto *Ty = dyn_cast<T>(this))
6986 return Ty;
6987
6988 // If the canonical form of this type isn't the right kind, reject it.
6989 if (!isa<T>(CanonicalType))
6990 return nullptr;
6991
6992 // Strip off type adjustments that do not modify the underlying nature of the
6993 // type.
6994 const Type *Ty = this;
6995 while (Ty) {
6996 if (const auto *A = dyn_cast<AttributedType>(Ty))
6997 Ty = A->getModifiedType().getTypePtr();
6998 else if (const auto *E = dyn_cast<ElaboratedType>(Ty))
6999 Ty = E->desugar().getTypePtr();
7000 else if (const auto *P = dyn_cast<ParenType>(Ty))
7001 Ty = P->desugar().getTypePtr();
7002 else if (const auto *A = dyn_cast<AdjustedType>(Ty))
7003 Ty = A->desugar().getTypePtr();
7004 else if (const auto *M = dyn_cast<MacroQualifiedType>(Ty))
7005 Ty = M->desugar().getTypePtr();
7006 else
7007 break;
7008 }
7009
7010 // Just because the canonical type is correct does not mean we can use cast<>,
7011 // since we may not have stripped off all the sugar down to the base type.
7012 return dyn_cast<T>(Ty);
7013}
7014
7015inline const ArrayType *Type::getAsArrayTypeUnsafe() const {
7016 // If this is directly an array type, return it.
7017 if (const auto *arr = dyn_cast<ArrayType>(this))
7018 return arr;
7019
7020 // If the canonical form of this type isn't the right kind, reject it.
7021 if (!isa<ArrayType>(CanonicalType))
7022 return nullptr;
7023
7024 // If this is a typedef for the type, strip the typedef off without
7025 // losing all typedef information.
7026 return cast<ArrayType>(getUnqualifiedDesugaredType());
7027}
7028
7029template <typename T> const T *Type::castAs() const {
7030 static_assert(!TypeIsArrayType<T>::value,
7031 "ArrayType cannot be used with castAs!");
7032
7033 if (const auto *ty = dyn_cast<T>(this)) return ty;
7034 assert(isa<T>(CanonicalType))((isa<T>(CanonicalType)) ? static_cast<void> (0) :
__assert_fail ("isa<T>(CanonicalType)", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 7034, __PRETTY_FUNCTION__))
;
7035 return cast<T>(getUnqualifiedDesugaredType());
7036}
7037
7038inline const ArrayType *Type::castAsArrayTypeUnsafe() const {
7039 assert(isa<ArrayType>(CanonicalType))((isa<ArrayType>(CanonicalType)) ? static_cast<void>
(0) : __assert_fail ("isa<ArrayType>(CanonicalType)", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 7039, __PRETTY_FUNCTION__))
;
7040 if (const auto *arr = dyn_cast<ArrayType>(this)) return arr;
7041 return cast<ArrayType>(getUnqualifiedDesugaredType());
7042}
7043
7044DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr,
7045 QualType CanonicalPtr)
7046 : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
7047#ifndef NDEBUG
7048 QualType Adjusted = getAdjustedType();
7049 (void)AttributedType::stripOuterNullability(Adjusted);
7050 assert(isa<PointerType>(Adjusted))((isa<PointerType>(Adjusted)) ? static_cast<void>
(0) : __assert_fail ("isa<PointerType>(Adjusted)", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 7050, __PRETTY_FUNCTION__))
;
7051#endif
7052}
7053
7054QualType DecayedType::getPointeeType() const {
7055 QualType Decayed = getDecayedType();
7056 (void)AttributedType::stripOuterNullability(Decayed);
7057 return cast<PointerType>(Decayed)->getPointeeType();
7058}
7059
7060// Get the decimal string representation of a fixed point type, represented
7061// as a scaled integer.
7062// TODO: At some point, we should change the arguments to instead just accept an
7063// APFixedPoint instead of APSInt and scale.
7064void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
7065 unsigned Scale);
7066
7067} // namespace clang
7068
7069#endif // LLVM_CLANG_AST_TYPE_H

/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/llvm/include/llvm/ADT/PointerUnion.h

1//===- llvm/ADT/PointerUnion.h - Discriminated Union of 2 Ptrs --*- 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 PointerUnion class, which is a discriminated union of
10// pointer types.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_ADT_POINTERUNION_H
15#define LLVM_ADT_POINTERUNION_H
16
17#include "llvm/ADT/DenseMapInfo.h"
18#include "llvm/ADT/PointerIntPair.h"
19#include "llvm/Support/PointerLikeTypeTraits.h"
20#include <cassert>
21#include <cstddef>
22#include <cstdint>
23
24namespace llvm {
25
26template <typename T> struct PointerUnionTypeSelectorReturn {
27 using Return = T;
28};
29
30/// Get a type based on whether two types are the same or not.
31///
32/// For:
33///
34/// \code
35/// using Ret = typename PointerUnionTypeSelector<T1, T2, EQ, NE>::Return;
36/// \endcode
37///
38/// Ret will be EQ type if T1 is same as T2 or NE type otherwise.
39template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
40struct PointerUnionTypeSelector {
41 using Return = typename PointerUnionTypeSelectorReturn<RET_NE>::Return;
42};
43
44template <typename T, typename RET_EQ, typename RET_NE>
45struct PointerUnionTypeSelector<T, T, RET_EQ, RET_NE> {
46 using Return = typename PointerUnionTypeSelectorReturn<RET_EQ>::Return;
47};
48
49template <typename T1, typename T2, typename RET_EQ, typename RET_NE>
50struct PointerUnionTypeSelectorReturn<
51 PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>> {
52 using Return =
53 typename PointerUnionTypeSelector<T1, T2, RET_EQ, RET_NE>::Return;
54};
55
56namespace pointer_union_detail {
57 /// Determine the number of bits required to store integers with values < n.
58 /// This is ceil(log2(n)).
59 constexpr int bitsRequired(unsigned n) {
60 return n > 1 ? 1 + bitsRequired((n + 1) / 2) : 0;
61 }
62
63 template <typename... Ts> constexpr int lowBitsAvailable() {
64 return std::min<int>({PointerLikeTypeTraits<Ts>::NumLowBitsAvailable...});
65 }
66
67 /// Find the index of a type in a list of types. TypeIndex<T, Us...>::Index
68 /// is the index of T in Us, or sizeof...(Us) if T does not appear in the
69 /// list.
70 template <typename T, typename ...Us> struct TypeIndex;
71 template <typename T, typename ...Us> struct TypeIndex<T, T, Us...> {
72 static constexpr int Index = 0;
73 };
74 template <typename T, typename U, typename... Us>
75 struct TypeIndex<T, U, Us...> {
76 static constexpr int Index = 1 + TypeIndex<T, Us...>::Index;
77 };
78 template <typename T> struct TypeIndex<T> {
79 static constexpr int Index = 0;
80 };
81
82 /// Find the first type in a list of types.
83 template <typename T, typename...> struct GetFirstType {
84 using type = T;
85 };
86
87 /// Provide PointerLikeTypeTraits for void* that is used by PointerUnion
88 /// for the template arguments.
89 template <typename ...PTs> class PointerUnionUIntTraits {
90 public:
91 static inline void *getAsVoidPointer(void *P) { return P; }
92 static inline void *getFromVoidPointer(void *P) { return P; }
93 static constexpr int NumLowBitsAvailable = lowBitsAvailable<PTs...>();
94 };
95
96 /// Implement assignment in terms of construction.
97 template <typename Derived, typename T> struct AssignableFrom {
98 Derived &operator=(T t) {
99 return static_cast<Derived &>(*this) = Derived(t);
100 }
101 };
102
103 template <typename Derived, typename ValTy, int I, typename ...Types>
104 class PointerUnionMembers;
105
106 template <typename Derived, typename ValTy, int I>
107 class PointerUnionMembers<Derived, ValTy, I> {
108 protected:
109 ValTy Val;
110 PointerUnionMembers() = default;
111 PointerUnionMembers(ValTy Val) : Val(Val) {}
112
113 friend struct PointerLikeTypeTraits<Derived>;
114 };
115
116 template <typename Derived, typename ValTy, int I, typename Type,
117 typename ...Types>
118 class PointerUnionMembers<Derived, ValTy, I, Type, Types...>
119 : public PointerUnionMembers<Derived, ValTy, I + 1, Types...> {
120 using Base = PointerUnionMembers<Derived, ValTy, I + 1, Types...>;
121 public:
122 using Base::Base;
123 PointerUnionMembers() = default;
124 PointerUnionMembers(Type V)
125 : Base(ValTy(const_cast<void *>(
126 PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
127 I)) {}
128
129 using Base::operator=;
130 Derived &operator=(Type V) {
131 this->Val = ValTy(
132 const_cast<void *>(PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
133 I);
134 return static_cast<Derived &>(*this);
135 };
136 };
137}
138
139/// A discriminated union of two or more pointer types, with the discriminator
140/// in the low bit of the pointer.
141///
142/// This implementation is extremely efficient in space due to leveraging the
143/// low bits of the pointer, while exposing a natural and type-safe API.
144///
145/// Common use patterns would be something like this:
146/// PointerUnion<int*, float*> P;
147/// P = (int*)0;
148/// printf("%d %d", P.is<int*>(), P.is<float*>()); // prints "1 0"
149/// X = P.get<int*>(); // ok.
150/// Y = P.get<float*>(); // runtime assertion failure.
151/// Z = P.get<double*>(); // compile time failure.
152/// P = (float*)0;
153/// Y = P.get<float*>(); // ok.
154/// X = P.get<int*>(); // runtime assertion failure.
155template <typename... PTs>
156class PointerUnion
157 : public pointer_union_detail::PointerUnionMembers<
158 PointerUnion<PTs...>,
159 PointerIntPair<
160 void *, pointer_union_detail::bitsRequired(sizeof...(PTs)), int,
161 pointer_union_detail::PointerUnionUIntTraits<PTs...>>,
162 0, PTs...> {
163 // The first type is special because we want to directly cast a pointer to a
164 // default-initialized union to a pointer to the first type. But we don't
165 // want PointerUnion to be a 'template <typename First, typename ...Rest>'
166 // because it's much more convenient to have a name for the whole pack. So
167 // split off the first type here.
168 using First = typename pointer_union_detail::GetFirstType<PTs...>::type;
169 using Base = typename PointerUnion::PointerUnionMembers;
170
171public:
172 PointerUnion() = default;
173
174 PointerUnion(std::nullptr_t) : PointerUnion() {}
175 using Base::Base;
176
177 /// Test if the pointer held in the union is null, regardless of
178 /// which type it is.
179 bool isNull() const { return !this->Val.getPointer(); }
15
Assuming the condition is false
16
Returning zero, which participates in a condition later
180
181 explicit operator bool() const { return !isNull(); }
182
183 /// Test if the Union currently holds the type matching T.
184 template <typename T> int is() const {
185 constexpr int Index = pointer_union_detail::TypeIndex<T, PTs...>::Index;
186 static_assert(Index < sizeof...(PTs),
187 "PointerUnion::is<T> given type not in the union");
188 return this->Val.getInt() == Index;
189 }
190
191 /// Returns the value of the specified pointer type.
192 ///
193 /// If the specified pointer type is incorrect, assert.
194 template <typename T> T get() const {
195 assert(is<T>() && "Invalid accessor called")((is<T>() && "Invalid accessor called") ? static_cast
<void> (0) : __assert_fail ("is<T>() && \"Invalid accessor called\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/llvm/include/llvm/ADT/PointerUnion.h"
, 195, __PRETTY_FUNCTION__))
;
196 return PointerLikeTypeTraits<T>::getFromVoidPointer(this->Val.getPointer());
197 }
198
199 /// Returns the current pointer if it is of the specified pointer type,
200 /// otherwises returns null.
201 template <typename T> T dyn_cast() const {
202 if (is<T>())
203 return get<T>();
204 return T();
205 }
206
207 /// If the union is set to the first pointer type get an address pointing to
208 /// it.
209 First const *getAddrOfPtr1() const {
210 return const_cast<PointerUnion *>(this)->getAddrOfPtr1();
211 }
212
213 /// If the union is set to the first pointer type get an address pointing to
214 /// it.
215 First *getAddrOfPtr1() {
216 assert(is<First>() && "Val is not the first pointer")((is<First>() && "Val is not the first pointer"
) ? static_cast<void> (0) : __assert_fail ("is<First>() && \"Val is not the first pointer\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/llvm/include/llvm/ADT/PointerUnion.h"
, 216, __PRETTY_FUNCTION__))
;
217 assert(((PointerLikeTypeTraits<First>::getAsVoidPointer(get<
First>()) == this->Val.getPointer() && "Can't get the address because PointerLikeTypeTraits changes the ptr"
) ? static_cast<void> (0) : __assert_fail ("PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) == this->Val.getPointer() && \"Can't get the address because PointerLikeTypeTraits changes the ptr\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/llvm/include/llvm/ADT/PointerUnion.h"
, 220, __PRETTY_FUNCTION__))
218 PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) ==((PointerLikeTypeTraits<First>::getAsVoidPointer(get<
First>()) == this->Val.getPointer() && "Can't get the address because PointerLikeTypeTraits changes the ptr"
) ? static_cast<void> (0) : __assert_fail ("PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) == this->Val.getPointer() && \"Can't get the address because PointerLikeTypeTraits changes the ptr\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/llvm/include/llvm/ADT/PointerUnion.h"
, 220, __PRETTY_FUNCTION__))
219 this->Val.getPointer() &&((PointerLikeTypeTraits<First>::getAsVoidPointer(get<
First>()) == this->Val.getPointer() && "Can't get the address because PointerLikeTypeTraits changes the ptr"
) ? static_cast<void> (0) : __assert_fail ("PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) == this->Val.getPointer() && \"Can't get the address because PointerLikeTypeTraits changes the ptr\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/llvm/include/llvm/ADT/PointerUnion.h"
, 220, __PRETTY_FUNCTION__))
220 "Can't get the address because PointerLikeTypeTraits changes the ptr")((PointerLikeTypeTraits<First>::getAsVoidPointer(get<
First>()) == this->Val.getPointer() && "Can't get the address because PointerLikeTypeTraits changes the ptr"
) ? static_cast<void> (0) : __assert_fail ("PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) == this->Val.getPointer() && \"Can't get the address because PointerLikeTypeTraits changes the ptr\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/llvm/include/llvm/ADT/PointerUnion.h"
, 220, __PRETTY_FUNCTION__))
;
221 return const_cast<First *>(
222 reinterpret_cast<const First *>(this->Val.getAddrOfPointer()));
223 }
224
225 /// Assignment from nullptr which just clears the union.
226 const PointerUnion &operator=(std::nullptr_t) {
227 this->Val.initWithPointer(nullptr);
228 return *this;
229 }
230
231 /// Assignment from elements of the union.
232 using Base::operator=;
233
234 void *getOpaqueValue() const { return this->Val.getOpaqueValue(); }
235 static inline PointerUnion getFromOpaqueValue(void *VP) {
236 PointerUnion V;
237 V.Val = decltype(V.Val)::getFromOpaqueValue(VP);
238 return V;
239 }
240};
241
242template <typename ...PTs>
243bool operator==(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
244 return lhs.getOpaqueValue() == rhs.getOpaqueValue();
245}
246
247template <typename ...PTs>
248bool operator!=(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
249 return lhs.getOpaqueValue() != rhs.getOpaqueValue();
250}
251
252template <typename ...PTs>
253bool operator<(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
254 return lhs.getOpaqueValue() < rhs.getOpaqueValue();
255}
256
257// Teach SmallPtrSet that PointerUnion is "basically a pointer", that has
258// # low bits available = min(PT1bits,PT2bits)-1.
259template <typename ...PTs>
260struct PointerLikeTypeTraits<PointerUnion<PTs...>> {
261 static inline void *getAsVoidPointer(const PointerUnion<PTs...> &P) {
262 return P.getOpaqueValue();
263 }
264
265 static inline PointerUnion<PTs...> getFromVoidPointer(void *P) {
266 return PointerUnion<PTs...>::getFromOpaqueValue(P);
267 }
268
269 // The number of bits available are the min of the pointer types minus the
270 // bits needed for the discriminator.
271 static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<decltype(
272 PointerUnion<PTs...>::Val)>::NumLowBitsAvailable;
273};
274
275/// A pointer union of three pointer types. See documentation for PointerUnion
276/// for usage.
277template <typename PT1, typename PT2, typename PT3>
278using PointerUnion3 = PointerUnion<PT1, PT2, PT3>;
279
280/// A pointer union of four pointer types. See documentation for PointerUnion
281/// for usage.
282template <typename PT1, typename PT2, typename PT3, typename PT4>
283using PointerUnion4 = PointerUnion<PT1, PT2, PT3, PT4>;
284
285// Teach DenseMap how to use PointerUnions as keys.
286template <typename ...PTs> struct DenseMapInfo<PointerUnion<PTs...>> {
287 using Union = PointerUnion<PTs...>;
288 using FirstInfo =
289 DenseMapInfo<typename pointer_union_detail::GetFirstType<PTs...>::type>;
290
291 static inline Union getEmptyKey() { return Union(FirstInfo::getEmptyKey()); }
292
293 static inline Union getTombstoneKey() {
294 return Union(FirstInfo::getTombstoneKey());
295 }
296
297 static unsigned getHashValue(const Union &UnionVal) {
298 intptr_t key = (intptr_t)UnionVal.getOpaqueValue();
299 return DenseMapInfo<intptr_t>::getHashValue(key);
300 }
301
302 static bool isEqual(const Union &LHS, const Union &RHS) {
303 return LHS == RHS;
304 }
305};
306
307} // end namespace llvm
308
309#endif // LLVM_ADT_POINTERUNION_H