Bug Summary

File:src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaCodeComplete.cpp
Warning:line 8702, column 9
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -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 -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include/clang/Sema -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../include -I /usr/src/gnu/usr.bin/clang/libclangSema/obj -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaCodeComplete.cpp

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/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/ASTConcept.h"
13#include "clang/AST/Decl.h"
14#include "clang/AST/DeclBase.h"
15#include "clang/AST/DeclCXX.h"
16#include "clang/AST/DeclObjC.h"
17#include "clang/AST/DeclTemplate.h"
18#include "clang/AST/Expr.h"
19#include "clang/AST/ExprCXX.h"
20#include "clang/AST/ExprConcepts.h"
21#include "clang/AST/ExprObjC.h"
22#include "clang/AST/NestedNameSpecifier.h"
23#include "clang/AST/QualTypeNames.h"
24#include "clang/AST/RecursiveASTVisitor.h"
25#include "clang/AST/Type.h"
26#include "clang/Basic/CharInfo.h"
27#include "clang/Basic/OperatorKinds.h"
28#include "clang/Basic/Specifiers.h"
29#include "clang/Lex/HeaderSearch.h"
30#include "clang/Lex/MacroInfo.h"
31#include "clang/Lex/Preprocessor.h"
32#include "clang/Sema/CodeCompleteConsumer.h"
33#include "clang/Sema/DeclSpec.h"
34#include "clang/Sema/Designator.h"
35#include "clang/Sema/Lookup.h"
36#include "clang/Sema/Overload.h"
37#include "clang/Sema/Scope.h"
38#include "clang/Sema/ScopeInfo.h"
39#include "clang/Sema/Sema.h"
40#include "clang/Sema/SemaInternal.h"
41#include "llvm/ADT/ArrayRef.h"
42#include "llvm/ADT/DenseSet.h"
43#include "llvm/ADT/SmallBitVector.h"
44#include "llvm/ADT/SmallPtrSet.h"
45#include "llvm/ADT/SmallString.h"
46#include "llvm/ADT/StringExtras.h"
47#include "llvm/ADT/StringSwitch.h"
48#include "llvm/ADT/Twine.h"
49#include "llvm/ADT/iterator_range.h"
50#include "llvm/Support/Casting.h"
51#include "llvm/Support/Path.h"
52#include "llvm/Support/raw_ostream.h"
53#include <list>
54#include <map>
55#include <string>
56#include <vector>
57
58using namespace clang;
59using namespace sema;
60
61namespace {
62/// A container of code-completion results.
63class ResultBuilder {
64public:
65 /// The type of a name-lookup filter, which can be provided to the
66 /// name-lookup routines to specify which declarations should be included in
67 /// the result set (when it returns true) and which declarations should be
68 /// filtered out (returns false).
69 typedef bool (ResultBuilder::*LookupFilter)(const NamedDecl *) const;
70
71 typedef CodeCompletionResult Result;
72
73private:
74 /// The actual results we have found.
75 std::vector<Result> Results;
76
77 /// A record of all of the declarations we have found and placed
78 /// into the result set, used to ensure that no declaration ever gets into
79 /// the result set twice.
80 llvm::SmallPtrSet<const Decl *, 16> AllDeclsFound;
81
82 typedef std::pair<const NamedDecl *, unsigned> DeclIndexPair;
83
84 /// An entry in the shadow map, which is optimized to store
85 /// a single (declaration, index) mapping (the common case) but
86 /// can also store a list of (declaration, index) mappings.
87 class ShadowMapEntry {
88 typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector;
89
90 /// Contains either the solitary NamedDecl * or a vector
91 /// of (declaration, index) pairs.
92 llvm::PointerUnion<const NamedDecl *, DeclIndexPairVector *> DeclOrVector;
93
94 /// When the entry contains a single declaration, this is
95 /// the index associated with that entry.
96 unsigned SingleDeclIndex;
97
98 public:
99 ShadowMapEntry() : DeclOrVector(), SingleDeclIndex(0) {}
100 ShadowMapEntry(const ShadowMapEntry &) = delete;
101 ShadowMapEntry(ShadowMapEntry &&Move) { *this = std::move(Move); }
102 ShadowMapEntry &operator=(const ShadowMapEntry &) = delete;
103 ShadowMapEntry &operator=(ShadowMapEntry &&Move) {
104 SingleDeclIndex = Move.SingleDeclIndex;
105 DeclOrVector = Move.DeclOrVector;
106 Move.DeclOrVector = nullptr;
107 return *this;
108 }
109
110 void Add(const NamedDecl *ND, unsigned Index) {
111 if (DeclOrVector.isNull()) {
112 // 0 - > 1 elements: just set the single element information.
113 DeclOrVector = ND;
114 SingleDeclIndex = Index;
115 return;
116 }
117
118 if (const NamedDecl *PrevND =
119 DeclOrVector.dyn_cast<const NamedDecl *>()) {
120 // 1 -> 2 elements: create the vector of results and push in the
121 // existing declaration.
122 DeclIndexPairVector *Vec = new DeclIndexPairVector;
123 Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex));
124 DeclOrVector = Vec;
125 }
126
127 // Add the new element to the end of the vector.
128 DeclOrVector.get<DeclIndexPairVector *>()->push_back(
129 DeclIndexPair(ND, Index));
130 }
131
132 ~ShadowMapEntry() {
133 if (DeclIndexPairVector *Vec =
134 DeclOrVector.dyn_cast<DeclIndexPairVector *>()) {
135 delete Vec;
136 DeclOrVector = ((NamedDecl *)nullptr);
137 }
138 }
139
140 // Iteration.
141 class iterator;
142 iterator begin() const;
143 iterator end() const;
144 };
145
146 /// A mapping from declaration names to the declarations that have
147 /// this name within a particular scope and their index within the list of
148 /// results.
149 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
150
151 /// The semantic analysis object for which results are being
152 /// produced.
153 Sema &SemaRef;
154
155 /// The allocator used to allocate new code-completion strings.
156 CodeCompletionAllocator &Allocator;
157
158 CodeCompletionTUInfo &CCTUInfo;
159
160 /// If non-NULL, a filter function used to remove any code-completion
161 /// results that are not desirable.
162 LookupFilter Filter;
163
164 /// Whether we should allow declarations as
165 /// nested-name-specifiers that would otherwise be filtered out.
166 bool AllowNestedNameSpecifiers;
167
168 /// If set, the type that we would prefer our resulting value
169 /// declarations to have.
170 ///
171 /// Closely matching the preferred type gives a boost to a result's
172 /// priority.
173 CanQualType PreferredType;
174
175 /// A list of shadow maps, which is used to model name hiding at
176 /// different levels of, e.g., the inheritance hierarchy.
177 std::list<ShadowMap> ShadowMaps;
178
179 /// Overloaded C++ member functions found by SemaLookup.
180 /// Used to determine when one overload is dominated by another.
181 llvm::DenseMap<std::pair<DeclContext *, /*Name*/uintptr_t>, ShadowMapEntry>
182 OverloadMap;
183
184 /// If we're potentially referring to a C++ member function, the set
185 /// of qualifiers applied to the object type.
186 Qualifiers ObjectTypeQualifiers;
187 /// The kind of the object expression, for rvalue/lvalue overloads.
188 ExprValueKind ObjectKind;
189
190 /// Whether the \p ObjectTypeQualifiers field is active.
191 bool HasObjectTypeQualifiers;
192
193 /// The selector that we prefer.
194 Selector PreferredSelector;
195
196 /// The completion context in which we are gathering results.
197 CodeCompletionContext CompletionContext;
198
199 /// If we are in an instance method definition, the \@implementation
200 /// object.
201 ObjCImplementationDecl *ObjCImplementation;
202
203 void AdjustResultPriorityForDecl(Result &R);
204
205 void MaybeAddConstructorResults(Result R);
206
207public:
208 explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator,
209 CodeCompletionTUInfo &CCTUInfo,
210 const CodeCompletionContext &CompletionContext,
211 LookupFilter Filter = nullptr)
212 : SemaRef(SemaRef), Allocator(Allocator), CCTUInfo(CCTUInfo),
213 Filter(Filter), AllowNestedNameSpecifiers(false),
214 HasObjectTypeQualifiers(false), CompletionContext(CompletionContext),
215 ObjCImplementation(nullptr) {
216 // If this is an Objective-C instance method definition, dig out the
217 // corresponding implementation.
218 switch (CompletionContext.getKind()) {
219 case CodeCompletionContext::CCC_Expression:
220 case CodeCompletionContext::CCC_ObjCMessageReceiver:
221 case CodeCompletionContext::CCC_ParenthesizedExpression:
222 case CodeCompletionContext::CCC_Statement:
223 case CodeCompletionContext::CCC_Recovery:
224 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl())
225 if (Method->isInstanceMethod())
226 if (ObjCInterfaceDecl *Interface = Method->getClassInterface())
227 ObjCImplementation = Interface->getImplementation();
228 break;
229
230 default:
231 break;
232 }
233 }
234
235 /// Determine the priority for a reference to the given declaration.
236 unsigned getBasePriority(const NamedDecl *D);
237
238 /// Whether we should include code patterns in the completion
239 /// results.
240 bool includeCodePatterns() const {
241 return SemaRef.CodeCompleter &&
242 SemaRef.CodeCompleter->includeCodePatterns();
243 }
244
245 /// Set the filter used for code-completion results.
246 void setFilter(LookupFilter Filter) { this->Filter = Filter; }
247
248 Result *data() { return Results.empty() ? nullptr : &Results.front(); }
249 unsigned size() const { return Results.size(); }
250 bool empty() const { return Results.empty(); }
251
252 /// Specify the preferred type.
253 void setPreferredType(QualType T) {
254 PreferredType = SemaRef.Context.getCanonicalType(T);
255 }
256
257 /// Set the cv-qualifiers on the object type, for us in filtering
258 /// calls to member functions.
259 ///
260 /// When there are qualifiers in this set, they will be used to filter
261 /// out member functions that aren't available (because there will be a
262 /// cv-qualifier mismatch) or prefer functions with an exact qualifier
263 /// match.
264 void setObjectTypeQualifiers(Qualifiers Quals, ExprValueKind Kind) {
265 ObjectTypeQualifiers = Quals;
266 ObjectKind = Kind;
267 HasObjectTypeQualifiers = true;
268 }
269
270 /// Set the preferred selector.
271 ///
272 /// When an Objective-C method declaration result is added, and that
273 /// method's selector matches this preferred selector, we give that method
274 /// a slight priority boost.
275 void setPreferredSelector(Selector Sel) { PreferredSelector = Sel; }
276
277 /// Retrieve the code-completion context for which results are
278 /// being collected.
279 const CodeCompletionContext &getCompletionContext() const {
280 return CompletionContext;
281 }
282
283 /// Specify whether nested-name-specifiers are allowed.
284 void allowNestedNameSpecifiers(bool Allow = true) {
285 AllowNestedNameSpecifiers = Allow;
286 }
287
288 /// Return the semantic analysis object for which we are collecting
289 /// code completion results.
290 Sema &getSema() const { return SemaRef; }
291
292 /// Retrieve the allocator used to allocate code completion strings.
293 CodeCompletionAllocator &getAllocator() const { return Allocator; }
294
295 CodeCompletionTUInfo &getCodeCompletionTUInfo() const { return CCTUInfo; }
296
297 /// Determine whether the given declaration is at all interesting
298 /// as a code-completion result.
299 ///
300 /// \param ND the declaration that we are inspecting.
301 ///
302 /// \param AsNestedNameSpecifier will be set true if this declaration is
303 /// only interesting when it is a nested-name-specifier.
304 bool isInterestingDecl(const NamedDecl *ND,
305 bool &AsNestedNameSpecifier) const;
306
307 /// Check whether the result is hidden by the Hiding declaration.
308 ///
309 /// \returns true if the result is hidden and cannot be found, false if
310 /// the hidden result could still be found. When false, \p R may be
311 /// modified to describe how the result can be found (e.g., via extra
312 /// qualification).
313 bool CheckHiddenResult(Result &R, DeclContext *CurContext,
314 const NamedDecl *Hiding);
315
316 /// Add a new result to this result set (if it isn't already in one
317 /// of the shadow maps), or replace an existing result (for, e.g., a
318 /// redeclaration).
319 ///
320 /// \param R the result to add (if it is unique).
321 ///
322 /// \param CurContext the context in which this result will be named.
323 void MaybeAddResult(Result R, DeclContext *CurContext = nullptr);
324
325 /// Add a new result to this result set, where we already know
326 /// the hiding declaration (if any).
327 ///
328 /// \param R the result to add (if it is unique).
329 ///
330 /// \param CurContext the context in which this result will be named.
331 ///
332 /// \param Hiding the declaration that hides the result.
333 ///
334 /// \param InBaseClass whether the result was found in a base
335 /// class of the searched context.
336 void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding,
337 bool InBaseClass);
338
339 /// Add a new non-declaration result to this result set.
340 void AddResult(Result R);
341
342 /// Enter into a new scope.
343 void EnterNewScope();
344
345 /// Exit from the current scope.
346 void ExitScope();
347
348 /// Ignore this declaration, if it is seen again.
349 void Ignore(const Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); }
350
351 /// Add a visited context.
352 void addVisitedContext(DeclContext *Ctx) {
353 CompletionContext.addVisitedContext(Ctx);
354 }
355
356 /// \name Name lookup predicates
357 ///
358 /// These predicates can be passed to the name lookup functions to filter the
359 /// results of name lookup. All of the predicates have the same type, so that
360 ///
361 //@{
362 bool IsOrdinaryName(const NamedDecl *ND) const;
363 bool IsOrdinaryNonTypeName(const NamedDecl *ND) const;
364 bool IsIntegralConstantValue(const NamedDecl *ND) const;
365 bool IsOrdinaryNonValueName(const NamedDecl *ND) const;
366 bool IsNestedNameSpecifier(const NamedDecl *ND) const;
367 bool IsEnum(const NamedDecl *ND) const;
368 bool IsClassOrStruct(const NamedDecl *ND) const;
369 bool IsUnion(const NamedDecl *ND) const;
370 bool IsNamespace(const NamedDecl *ND) const;
371 bool IsNamespaceOrAlias(const NamedDecl *ND) const;
372 bool IsType(const NamedDecl *ND) const;
373 bool IsMember(const NamedDecl *ND) const;
374 bool IsObjCIvar(const NamedDecl *ND) const;
375 bool IsObjCMessageReceiver(const NamedDecl *ND) const;
376 bool IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const;
377 bool IsObjCCollection(const NamedDecl *ND) const;
378 bool IsImpossibleToSatisfy(const NamedDecl *ND) const;
379 //@}
380};
381} // namespace
382
383void PreferredTypeBuilder::enterReturn(Sema &S, SourceLocation Tok) {
384 if (!Enabled)
385 return;
386 if (isa<BlockDecl>(S.CurContext)) {
387 if (sema::BlockScopeInfo *BSI = S.getCurBlock()) {
388 ComputeType = nullptr;
389 Type = BSI->ReturnType;
390 ExpectedLoc = Tok;
391 }
392 } else if (const auto *Function = dyn_cast<FunctionDecl>(S.CurContext)) {
393 ComputeType = nullptr;
394 Type = Function->getReturnType();
395 ExpectedLoc = Tok;
396 } else if (const auto *Method = dyn_cast<ObjCMethodDecl>(S.CurContext)) {
397 ComputeType = nullptr;
398 Type = Method->getReturnType();
399 ExpectedLoc = Tok;
400 }
401}
402
403void PreferredTypeBuilder::enterVariableInit(SourceLocation Tok, Decl *D) {
404 if (!Enabled)
405 return;
406 auto *VD = llvm::dyn_cast_or_null<ValueDecl>(D);
407 ComputeType = nullptr;
408 Type = VD ? VD->getType() : QualType();
409 ExpectedLoc = Tok;
410}
411
412static QualType getDesignatedType(QualType BaseType, const Designation &Desig);
413
414void PreferredTypeBuilder::enterDesignatedInitializer(SourceLocation Tok,
415 QualType BaseType,
416 const Designation &D) {
417 if (!Enabled)
418 return;
419 ComputeType = nullptr;
420 Type = getDesignatedType(BaseType, D);
421 ExpectedLoc = Tok;
422}
423
424void PreferredTypeBuilder::enterFunctionArgument(
425 SourceLocation Tok, llvm::function_ref<QualType()> ComputeType) {
426 if (!Enabled)
427 return;
428 this->ComputeType = ComputeType;
429 Type = QualType();
430 ExpectedLoc = Tok;
431}
432
433void PreferredTypeBuilder::enterParenExpr(SourceLocation Tok,
434 SourceLocation LParLoc) {
435 if (!Enabled)
436 return;
437 // expected type for parenthesized expression does not change.
438 if (ExpectedLoc == LParLoc)
439 ExpectedLoc = Tok;
440}
441
442static QualType getPreferredTypeOfBinaryRHS(Sema &S, Expr *LHS,
443 tok::TokenKind Op) {
444 if (!LHS)
445 return QualType();
446
447 QualType LHSType = LHS->getType();
448 if (LHSType->isPointerType()) {
449 if (Op == tok::plus || Op == tok::plusequal || Op == tok::minusequal)
450 return S.getASTContext().getPointerDiffType();
451 // Pointer difference is more common than subtracting an int from a pointer.
452 if (Op == tok::minus)
453 return LHSType;
454 }
455
456 switch (Op) {
457 // No way to infer the type of RHS from LHS.
458 case tok::comma:
459 return QualType();
460 // Prefer the type of the left operand for all of these.
461 // Arithmetic operations.
462 case tok::plus:
463 case tok::plusequal:
464 case tok::minus:
465 case tok::minusequal:
466 case tok::percent:
467 case tok::percentequal:
468 case tok::slash:
469 case tok::slashequal:
470 case tok::star:
471 case tok::starequal:
472 // Assignment.
473 case tok::equal:
474 // Comparison operators.
475 case tok::equalequal:
476 case tok::exclaimequal:
477 case tok::less:
478 case tok::lessequal:
479 case tok::greater:
480 case tok::greaterequal:
481 case tok::spaceship:
482 return LHS->getType();
483 // Binary shifts are often overloaded, so don't try to guess those.
484 case tok::greatergreater:
485 case tok::greatergreaterequal:
486 case tok::lessless:
487 case tok::lesslessequal:
488 if (LHSType->isIntegralOrEnumerationType())
489 return S.getASTContext().IntTy;
490 return QualType();
491 // Logical operators, assume we want bool.
492 case tok::ampamp:
493 case tok::pipepipe:
494 case tok::caretcaret:
495 return S.getASTContext().BoolTy;
496 // Operators often used for bit manipulation are typically used with the type
497 // of the left argument.
498 case tok::pipe:
499 case tok::pipeequal:
500 case tok::caret:
501 case tok::caretequal:
502 case tok::amp:
503 case tok::ampequal:
504 if (LHSType->isIntegralOrEnumerationType())
505 return LHSType;
506 return QualType();
507 // RHS should be a pointer to a member of the 'LHS' type, but we can't give
508 // any particular type here.
509 case tok::periodstar:
510 case tok::arrowstar:
511 return QualType();
512 default:
513 // FIXME(ibiryukov): handle the missing op, re-add the assertion.
514 // assert(false && "unhandled binary op");
515 return QualType();
516 }
517}
518
519/// Get preferred type for an argument of an unary expression. \p ContextType is
520/// preferred type of the whole unary expression.
521static QualType getPreferredTypeOfUnaryArg(Sema &S, QualType ContextType,
522 tok::TokenKind Op) {
523 switch (Op) {
524 case tok::exclaim:
525 return S.getASTContext().BoolTy;
526 case tok::amp:
527 if (!ContextType.isNull() && ContextType->isPointerType())
528 return ContextType->getPointeeType();
529 return QualType();
530 case tok::star:
531 if (ContextType.isNull())
532 return QualType();
533 return S.getASTContext().getPointerType(ContextType.getNonReferenceType());
534 case tok::plus:
535 case tok::minus:
536 case tok::tilde:
537 case tok::minusminus:
538 case tok::plusplus:
539 if (ContextType.isNull())
540 return S.getASTContext().IntTy;
541 // leave as is, these operators typically return the same type.
542 return ContextType;
543 case tok::kw___real:
544 case tok::kw___imag:
545 return QualType();
546 default:
547 assert(false && "unhandled unary op")((void)0);
548 return QualType();
549 }
550}
551
552void PreferredTypeBuilder::enterBinary(Sema &S, SourceLocation Tok, Expr *LHS,
553 tok::TokenKind Op) {
554 if (!Enabled)
555 return;
556 ComputeType = nullptr;
557 Type = getPreferredTypeOfBinaryRHS(S, LHS, Op);
558 ExpectedLoc = Tok;
559}
560
561void PreferredTypeBuilder::enterMemAccess(Sema &S, SourceLocation Tok,
562 Expr *Base) {
563 if (!Enabled || !Base)
564 return;
565 // Do we have expected type for Base?
566 if (ExpectedLoc != Base->getBeginLoc())
567 return;
568 // Keep the expected type, only update the location.
569 ExpectedLoc = Tok;
570 return;
571}
572
573void PreferredTypeBuilder::enterUnary(Sema &S, SourceLocation Tok,
574 tok::TokenKind OpKind,
575 SourceLocation OpLoc) {
576 if (!Enabled)
577 return;
578 ComputeType = nullptr;
579 Type = getPreferredTypeOfUnaryArg(S, this->get(OpLoc), OpKind);
580 ExpectedLoc = Tok;
581}
582
583void PreferredTypeBuilder::enterSubscript(Sema &S, SourceLocation Tok,
584 Expr *LHS) {
585 if (!Enabled)
586 return;
587 ComputeType = nullptr;
588 Type = S.getASTContext().IntTy;
589 ExpectedLoc = Tok;
590}
591
592void PreferredTypeBuilder::enterTypeCast(SourceLocation Tok,
593 QualType CastType) {
594 if (!Enabled)
595 return;
596 ComputeType = nullptr;
597 Type = !CastType.isNull() ? CastType.getCanonicalType() : QualType();
598 ExpectedLoc = Tok;
599}
600
601void PreferredTypeBuilder::enterCondition(Sema &S, SourceLocation Tok) {
602 if (!Enabled)
603 return;
604 ComputeType = nullptr;
605 Type = S.getASTContext().BoolTy;
606 ExpectedLoc = Tok;
607}
608
609class ResultBuilder::ShadowMapEntry::iterator {
610 llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator;
611 unsigned SingleDeclIndex;
612
613public:
614 typedef DeclIndexPair value_type;
615 typedef value_type reference;
616 typedef std::ptrdiff_t difference_type;
617 typedef std::input_iterator_tag iterator_category;
618
619 class pointer {
620 DeclIndexPair Value;
621
622 public:
623 pointer(const DeclIndexPair &Value) : Value(Value) {}
624
625 const DeclIndexPair *operator->() const { return &Value; }
626 };
627
628 iterator() : DeclOrIterator((NamedDecl *)nullptr), SingleDeclIndex(0) {}
629
630 iterator(const NamedDecl *SingleDecl, unsigned Index)
631 : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) {}
632
633 iterator(const DeclIndexPair *Iterator)
634 : DeclOrIterator(Iterator), SingleDeclIndex(0) {}
635
636 iterator &operator++() {
637 if (DeclOrIterator.is<const NamedDecl *>()) {
638 DeclOrIterator = (NamedDecl *)nullptr;
639 SingleDeclIndex = 0;
640 return *this;
641 }
642
643 const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair *>();
644 ++I;
645 DeclOrIterator = I;
646 return *this;
647 }
648
649 /*iterator operator++(int) {
650 iterator tmp(*this);
651 ++(*this);
652 return tmp;
653 }*/
654
655 reference operator*() const {
656 if (const NamedDecl *ND = DeclOrIterator.dyn_cast<const NamedDecl *>())
657 return reference(ND, SingleDeclIndex);
658
659 return *DeclOrIterator.get<const DeclIndexPair *>();
660 }
661
662 pointer operator->() const { return pointer(**this); }
663
664 friend bool operator==(const iterator &X, const iterator &Y) {
665 return X.DeclOrIterator.getOpaqueValue() ==
666 Y.DeclOrIterator.getOpaqueValue() &&
667 X.SingleDeclIndex == Y.SingleDeclIndex;
668 }
669
670 friend bool operator!=(const iterator &X, const iterator &Y) {
671 return !(X == Y);
672 }
673};
674
675ResultBuilder::ShadowMapEntry::iterator
676ResultBuilder::ShadowMapEntry::begin() const {
677 if (DeclOrVector.isNull())
678 return iterator();
679
680 if (const NamedDecl *ND = DeclOrVector.dyn_cast<const NamedDecl *>())
681 return iterator(ND, SingleDeclIndex);
682
683 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin());
684}
685
686ResultBuilder::ShadowMapEntry::iterator
687ResultBuilder::ShadowMapEntry::end() const {
688 if (DeclOrVector.is<const NamedDecl *>() || DeclOrVector.isNull())
689 return iterator();
690
691 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end());
692}
693
694/// Compute the qualification required to get from the current context
695/// (\p CurContext) to the target context (\p TargetContext).
696///
697/// \param Context the AST context in which the qualification will be used.
698///
699/// \param CurContext the context where an entity is being named, which is
700/// typically based on the current scope.
701///
702/// \param TargetContext the context in which the named entity actually
703/// resides.
704///
705/// \returns a nested name specifier that refers into the target context, or
706/// NULL if no qualification is needed.
707static NestedNameSpecifier *
708getRequiredQualification(ASTContext &Context, const DeclContext *CurContext,
709 const DeclContext *TargetContext) {
710 SmallVector<const DeclContext *, 4> TargetParents;
711
712 for (const DeclContext *CommonAncestor = TargetContext;
713 CommonAncestor && !CommonAncestor->Encloses(CurContext);
714 CommonAncestor = CommonAncestor->getLookupParent()) {
715 if (CommonAncestor->isTransparentContext() ||
716 CommonAncestor->isFunctionOrMethod())
717 continue;
718
719 TargetParents.push_back(CommonAncestor);
720 }
721
722 NestedNameSpecifier *Result = nullptr;
723 while (!TargetParents.empty()) {
724 const DeclContext *Parent = TargetParents.pop_back_val();
725
726 if (const auto *Namespace = dyn_cast<NamespaceDecl>(Parent)) {
727 if (!Namespace->getIdentifier())
728 continue;
729
730 Result = NestedNameSpecifier::Create(Context, Result, Namespace);
731 } else if (const auto *TD = dyn_cast<TagDecl>(Parent))
732 Result = NestedNameSpecifier::Create(
733 Context, Result, false, Context.getTypeDeclType(TD).getTypePtr());
734 }
735 return Result;
736}
737
738// Some declarations have reserved names that we don't want to ever show.
739// Filter out names reserved for the implementation if they come from a
740// system header.
741static bool shouldIgnoreDueToReservedName(const NamedDecl *ND, Sema &SemaRef) {
742 ReservedIdentifierStatus Status = ND->isReserved(SemaRef.getLangOpts());
743 // Ignore reserved names for compiler provided decls.
744 if ((Status != ReservedIdentifierStatus::NotReserved) &&
745 (Status != ReservedIdentifierStatus::StartsWithUnderscoreAtGlobalScope) &&
746 ND->getLocation().isInvalid())
747 return true;
748
749 // For system headers ignore only double-underscore names.
750 // This allows for system headers providing private symbols with a single
751 // underscore.
752 if (Status == ReservedIdentifierStatus::StartsWithDoubleUnderscore &&
753 SemaRef.SourceMgr.isInSystemHeader(
754 SemaRef.SourceMgr.getSpellingLoc(ND->getLocation())))
755 return true;
756
757 return false;
758}
759
760bool ResultBuilder::isInterestingDecl(const NamedDecl *ND,
761 bool &AsNestedNameSpecifier) const {
762 AsNestedNameSpecifier = false;
763
764 auto *Named = ND;
765 ND = ND->getUnderlyingDecl();
766
767 // Skip unnamed entities.
768 if (!ND->getDeclName())
769 return false;
770
771 // Friend declarations and declarations introduced due to friends are never
772 // added as results.
773 if (ND->getFriendObjectKind() == Decl::FOK_Undeclared)
774 return false;
775
776 // Class template (partial) specializations are never added as results.
777 if (isa<ClassTemplateSpecializationDecl>(ND) ||
778 isa<ClassTemplatePartialSpecializationDecl>(ND))
779 return false;
780
781 // Using declarations themselves are never added as results.
782 if (isa<UsingDecl>(ND))
783 return false;
784
785 if (shouldIgnoreDueToReservedName(ND, SemaRef))
786 return false;
787
788 if (Filter == &ResultBuilder::IsNestedNameSpecifier ||
789 (isa<NamespaceDecl>(ND) && Filter != &ResultBuilder::IsNamespace &&
790 Filter != &ResultBuilder::IsNamespaceOrAlias && Filter != nullptr))
791 AsNestedNameSpecifier = true;
792
793 // Filter out any unwanted results.
794 if (Filter && !(this->*Filter)(Named)) {
795 // Check whether it is interesting as a nested-name-specifier.
796 if (AllowNestedNameSpecifiers && SemaRef.getLangOpts().CPlusPlus &&
797 IsNestedNameSpecifier(ND) &&
798 (Filter != &ResultBuilder::IsMember ||
799 (isa<CXXRecordDecl>(ND) &&
800 cast<CXXRecordDecl>(ND)->isInjectedClassName()))) {
801 AsNestedNameSpecifier = true;
802 return true;
803 }
804
805 return false;
806 }
807 // ... then it must be interesting!
808 return true;
809}
810
811bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext,
812 const NamedDecl *Hiding) {
813 // In C, there is no way to refer to a hidden name.
814 // FIXME: This isn't true; we can find a tag name hidden by an ordinary
815 // name if we introduce the tag type.
816 if (!SemaRef.getLangOpts().CPlusPlus)
817 return true;
818
819 const DeclContext *HiddenCtx =
820 R.Declaration->getDeclContext()->getRedeclContext();
821
822 // There is no way to qualify a name declared in a function or method.
823 if (HiddenCtx->isFunctionOrMethod())
824 return true;
825
826 if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext())
827 return true;
828
829 // We can refer to the result with the appropriate qualification. Do it.
830 R.Hidden = true;
831 R.QualifierIsInformative = false;
832
833 if (!R.Qualifier)
834 R.Qualifier = getRequiredQualification(SemaRef.Context, CurContext,
835 R.Declaration->getDeclContext());
836 return false;
837}
838
839/// A simplified classification of types used to determine whether two
840/// types are "similar enough" when adjusting priorities.
841SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) {
842 switch (T->getTypeClass()) {
843 case Type::Builtin:
844 switch (cast<BuiltinType>(T)->getKind()) {
845 case BuiltinType::Void:
846 return STC_Void;
847
848 case BuiltinType::NullPtr:
849 return STC_Pointer;
850
851 case BuiltinType::Overload:
852 case BuiltinType::Dependent:
853 return STC_Other;
854
855 case BuiltinType::ObjCId:
856 case BuiltinType::ObjCClass:
857 case BuiltinType::ObjCSel:
858 return STC_ObjectiveC;
859
860 default:
861 return STC_Arithmetic;
862 }
863
864 case Type::Complex:
865 return STC_Arithmetic;
866
867 case Type::Pointer:
868 return STC_Pointer;
869
870 case Type::BlockPointer:
871 return STC_Block;
872
873 case Type::LValueReference:
874 case Type::RValueReference:
875 return getSimplifiedTypeClass(T->getAs<ReferenceType>()->getPointeeType());
876
877 case Type::ConstantArray:
878 case Type::IncompleteArray:
879 case Type::VariableArray:
880 case Type::DependentSizedArray:
881 return STC_Array;
882
883 case Type::DependentSizedExtVector:
884 case Type::Vector:
885 case Type::ExtVector:
886 return STC_Arithmetic;
887
888 case Type::FunctionProto:
889 case Type::FunctionNoProto:
890 return STC_Function;
891
892 case Type::Record:
893 return STC_Record;
894
895 case Type::Enum:
896 return STC_Arithmetic;
897
898 case Type::ObjCObject:
899 case Type::ObjCInterface:
900 case Type::ObjCObjectPointer:
901 return STC_ObjectiveC;
902
903 default:
904 return STC_Other;
905 }
906}
907
908/// Get the type that a given expression will have if this declaration
909/// is used as an expression in its "typical" code-completion form.
910QualType clang::getDeclUsageType(ASTContext &C, const NamedDecl *ND) {
911 ND = ND->getUnderlyingDecl();
912
913 if (const auto *Type = dyn_cast<TypeDecl>(ND))
914 return C.getTypeDeclType(Type);
915 if (const auto *Iface = dyn_cast<ObjCInterfaceDecl>(ND))
916 return C.getObjCInterfaceType(Iface);
917
918 QualType T;
919 if (const FunctionDecl *Function = ND->getAsFunction())
920 T = Function->getCallResultType();
921 else if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND))
922 T = Method->getSendResultType();
923 else if (const auto *Enumerator = dyn_cast<EnumConstantDecl>(ND))
924 T = C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext()));
925 else if (const auto *Property = dyn_cast<ObjCPropertyDecl>(ND))
926 T = Property->getType();
927 else if (const auto *Value = dyn_cast<ValueDecl>(ND))
928 T = Value->getType();
929
930 if (T.isNull())
931 return QualType();
932
933 // Dig through references, function pointers, and block pointers to
934 // get down to the likely type of an expression when the entity is
935 // used.
936 do {
937 if (const auto *Ref = T->getAs<ReferenceType>()) {
938 T = Ref->getPointeeType();
939 continue;
940 }
941
942 if (const auto *Pointer = T->getAs<PointerType>()) {
943 if (Pointer->getPointeeType()->isFunctionType()) {
944 T = Pointer->getPointeeType();
945 continue;
946 }
947
948 break;
949 }
950
951 if (const auto *Block = T->getAs<BlockPointerType>()) {
952 T = Block->getPointeeType();
953 continue;
954 }
955
956 if (const auto *Function = T->getAs<FunctionType>()) {
957 T = Function->getReturnType();
958 continue;
959 }
960
961 break;
962 } while (true);
963
964 return T;
965}
966
967unsigned ResultBuilder::getBasePriority(const NamedDecl *ND) {
968 if (!ND)
969 return CCP_Unlikely;
970
971 // Context-based decisions.
972 const DeclContext *LexicalDC = ND->getLexicalDeclContext();
973 if (LexicalDC->isFunctionOrMethod()) {
974 // _cmd is relatively rare
975 if (const auto *ImplicitParam = dyn_cast<ImplicitParamDecl>(ND))
976 if (ImplicitParam->getIdentifier() &&
977 ImplicitParam->getIdentifier()->isStr("_cmd"))
978 return CCP_ObjC_cmd;
979
980 return CCP_LocalDeclaration;
981 }
982
983 const DeclContext *DC = ND->getDeclContext()->getRedeclContext();
984 if (DC->isRecord() || isa<ObjCContainerDecl>(DC)) {
985 // Explicit destructor calls are very rare.
986 if (isa<CXXDestructorDecl>(ND))
987 return CCP_Unlikely;
988 // Explicit operator and conversion function calls are also very rare.
989 auto DeclNameKind = ND->getDeclName().getNameKind();
990 if (DeclNameKind == DeclarationName::CXXOperatorName ||
991 DeclNameKind == DeclarationName::CXXLiteralOperatorName ||
992 DeclNameKind == DeclarationName::CXXConversionFunctionName)
993 return CCP_Unlikely;
994 return CCP_MemberDeclaration;
995 }
996
997 // Content-based decisions.
998 if (isa<EnumConstantDecl>(ND))
999 return CCP_Constant;
1000
1001 // Use CCP_Type for type declarations unless we're in a statement, Objective-C
1002 // message receiver, or parenthesized expression context. There, it's as
1003 // likely that the user will want to write a type as other declarations.
1004 if ((isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) &&
1005 !(CompletionContext.getKind() == CodeCompletionContext::CCC_Statement ||
1006 CompletionContext.getKind() ==
1007 CodeCompletionContext::CCC_ObjCMessageReceiver ||
1008 CompletionContext.getKind() ==
1009 CodeCompletionContext::CCC_ParenthesizedExpression))
1010 return CCP_Type;
1011
1012 return CCP_Declaration;
1013}
1014
1015void ResultBuilder::AdjustResultPriorityForDecl(Result &R) {
1016 // If this is an Objective-C method declaration whose selector matches our
1017 // preferred selector, give it a priority boost.
1018 if (!PreferredSelector.isNull())
1019 if (const auto *Method = dyn_cast<ObjCMethodDecl>(R.Declaration))
1020 if (PreferredSelector == Method->getSelector())
1021 R.Priority += CCD_SelectorMatch;
1022
1023 // If we have a preferred type, adjust the priority for results with exactly-
1024 // matching or nearly-matching types.
1025 if (!PreferredType.isNull()) {
1026 QualType T = getDeclUsageType(SemaRef.Context, R.Declaration);
1027 if (!T.isNull()) {
1028 CanQualType TC = SemaRef.Context.getCanonicalType(T);
1029 // Check for exactly-matching types (modulo qualifiers).
1030 if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC))
1031 R.Priority /= CCF_ExactTypeMatch;
1032 // Check for nearly-matching types, based on classification of each.
1033 else if ((getSimplifiedTypeClass(PreferredType) ==
1034 getSimplifiedTypeClass(TC)) &&
1035 !(PreferredType->isEnumeralType() && TC->isEnumeralType()))
1036 R.Priority /= CCF_SimilarTypeMatch;
1037 }
1038 }
1039}
1040
1041static DeclContext::lookup_result getConstructors(ASTContext &Context,
1042 const CXXRecordDecl *Record) {
1043 QualType RecordTy = Context.getTypeDeclType(Record);
1044 DeclarationName ConstructorName =
1045 Context.DeclarationNames.getCXXConstructorName(
1046 Context.getCanonicalType(RecordTy));
1047 return Record->lookup(ConstructorName);
1048}
1049
1050void ResultBuilder::MaybeAddConstructorResults(Result R) {
1051 if (!SemaRef.getLangOpts().CPlusPlus || !R.Declaration ||
1052 !CompletionContext.wantConstructorResults())
1053 return;
1054
1055 const NamedDecl *D = R.Declaration;
1056 const CXXRecordDecl *Record = nullptr;
1057 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D))
1058 Record = ClassTemplate->getTemplatedDecl();
1059 else if ((Record = dyn_cast<CXXRecordDecl>(D))) {
1060 // Skip specializations and partial specializations.
1061 if (isa<ClassTemplateSpecializationDecl>(Record))
1062 return;
1063 } else {
1064 // There are no constructors here.
1065 return;
1066 }
1067
1068 Record = Record->getDefinition();
1069 if (!Record)
1070 return;
1071
1072 for (NamedDecl *Ctor : getConstructors(SemaRef.Context, Record)) {
1073 R.Declaration = Ctor;
1074 R.CursorKind = getCursorKindForDecl(R.Declaration);
1075 Results.push_back(R);
1076 }
1077}
1078
1079static bool isConstructor(const Decl *ND) {
1080 if (const auto *Tmpl = dyn_cast<FunctionTemplateDecl>(ND))
1081 ND = Tmpl->getTemplatedDecl();
1082 return isa<CXXConstructorDecl>(ND);
1083}
1084
1085void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) {
1086 assert(!ShadowMaps.empty() && "Must enter into a results scope")((void)0);
1087
1088 if (R.Kind != Result::RK_Declaration) {
1089 // For non-declaration results, just add the result.
1090 Results.push_back(R);
1091 return;
1092 }
1093
1094 // Look through using declarations.
1095 if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
1096 CodeCompletionResult Result(Using->getTargetDecl(),
1097 getBasePriority(Using->getTargetDecl()),
1098 R.Qualifier);
1099 Result.ShadowDecl = Using;
1100 MaybeAddResult(Result, CurContext);
1101 return;
1102 }
1103
1104 const Decl *CanonDecl = R.Declaration->getCanonicalDecl();
1105 unsigned IDNS = CanonDecl->getIdentifierNamespace();
1106
1107 bool AsNestedNameSpecifier = false;
1108 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
1109 return;
1110
1111 // C++ constructors are never found by name lookup.
1112 if (isConstructor(R.Declaration))
1113 return;
1114
1115 ShadowMap &SMap = ShadowMaps.back();
1116 ShadowMapEntry::iterator I, IEnd;
1117 ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName());
1118 if (NamePos != SMap.end()) {
1119 I = NamePos->second.begin();
1120 IEnd = NamePos->second.end();
1121 }
1122
1123 for (; I != IEnd; ++I) {
1124 const NamedDecl *ND = I->first;
1125 unsigned Index = I->second;
1126 if (ND->getCanonicalDecl() == CanonDecl) {
1127 // This is a redeclaration. Always pick the newer declaration.
1128 Results[Index].Declaration = R.Declaration;
1129
1130 // We're done.
1131 return;
1132 }
1133 }
1134
1135 // This is a new declaration in this scope. However, check whether this
1136 // declaration name is hidden by a similarly-named declaration in an outer
1137 // scope.
1138 std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end();
1139 --SMEnd;
1140 for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) {
1141 ShadowMapEntry::iterator I, IEnd;
1142 ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName());
1143 if (NamePos != SM->end()) {
1144 I = NamePos->second.begin();
1145 IEnd = NamePos->second.end();
1146 }
1147 for (; I != IEnd; ++I) {
1148 // A tag declaration does not hide a non-tag declaration.
1149 if (I->first->hasTagIdentifierNamespace() &&
1150 (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary |
1151 Decl::IDNS_LocalExtern | Decl::IDNS_ObjCProtocol)))
1152 continue;
1153
1154 // Protocols are in distinct namespaces from everything else.
1155 if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol) ||
1156 (IDNS & Decl::IDNS_ObjCProtocol)) &&
1157 I->first->getIdentifierNamespace() != IDNS)
1158 continue;
1159
1160 // The newly-added result is hidden by an entry in the shadow map.
1161 if (CheckHiddenResult(R, CurContext, I->first))
1162 return;
1163
1164 break;
1165 }
1166 }
1167
1168 // Make sure that any given declaration only shows up in the result set once.
1169 if (!AllDeclsFound.insert(CanonDecl).second)
1170 return;
1171
1172 // If the filter is for nested-name-specifiers, then this result starts a
1173 // nested-name-specifier.
1174 if (AsNestedNameSpecifier) {
1175 R.StartsNestedNameSpecifier = true;
1176 R.Priority = CCP_NestedNameSpecifier;
1177 } else
1178 AdjustResultPriorityForDecl(R);
1179
1180 // If this result is supposed to have an informative qualifier, add one.
1181 if (R.QualifierIsInformative && !R.Qualifier &&
1182 !R.StartsNestedNameSpecifier) {
1183 const DeclContext *Ctx = R.Declaration->getDeclContext();
1184 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
1185 R.Qualifier =
1186 NestedNameSpecifier::Create(SemaRef.Context, nullptr, Namespace);
1187 else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
1188 R.Qualifier = NestedNameSpecifier::Create(
1189 SemaRef.Context, nullptr, false,
1190 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
1191 else
1192 R.QualifierIsInformative = false;
1193 }
1194
1195 // Insert this result into the set of results and into the current shadow
1196 // map.
1197 SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
1198 Results.push_back(R);
1199
1200 if (!AsNestedNameSpecifier)
1201 MaybeAddConstructorResults(R);
1202}
1203
1204static void setInBaseClass(ResultBuilder::Result &R) {
1205 R.Priority += CCD_InBaseClass;
1206 R.InBaseClass = true;
1207}
1208
1209enum class OverloadCompare { BothViable, Dominates, Dominated };
1210// Will Candidate ever be called on the object, when overloaded with Incumbent?
1211// Returns Dominates if Candidate is always called, Dominated if Incumbent is
1212// always called, BothViable if either may be called dependending on arguments.
1213// Precondition: must actually be overloads!
1214static OverloadCompare compareOverloads(const CXXMethodDecl &Candidate,
1215 const CXXMethodDecl &Incumbent,
1216 const Qualifiers &ObjectQuals,
1217 ExprValueKind ObjectKind) {
1218 // Base/derived shadowing is handled elsewhere.
1219 if (Candidate.getDeclContext() != Incumbent.getDeclContext())
1220 return OverloadCompare::BothViable;
1221 if (Candidate.isVariadic() != Incumbent.isVariadic() ||
1222 Candidate.getNumParams() != Incumbent.getNumParams() ||
1223 Candidate.getMinRequiredArguments() !=
1224 Incumbent.getMinRequiredArguments())
1225 return OverloadCompare::BothViable;
1226 for (unsigned I = 0, E = Candidate.getNumParams(); I != E; ++I)
1227 if (Candidate.parameters()[I]->getType().getCanonicalType() !=
1228 Incumbent.parameters()[I]->getType().getCanonicalType())
1229 return OverloadCompare::BothViable;
1230 if (!llvm::empty(Candidate.specific_attrs<EnableIfAttr>()) ||
1231 !llvm::empty(Incumbent.specific_attrs<EnableIfAttr>()))
1232 return OverloadCompare::BothViable;
1233 // At this point, we know calls can't pick one or the other based on
1234 // arguments, so one of the two must win. (Or both fail, handled elsewhere).
1235 RefQualifierKind CandidateRef = Candidate.getRefQualifier();
1236 RefQualifierKind IncumbentRef = Incumbent.getRefQualifier();
1237 if (CandidateRef != IncumbentRef) {
1238 // If the object kind is LValue/RValue, there's one acceptable ref-qualifier
1239 // and it can't be mixed with ref-unqualified overloads (in valid code).
1240
1241 // For xvalue objects, we prefer the rvalue overload even if we have to
1242 // add qualifiers (which is rare, because const&& is rare).
1243 if (ObjectKind == clang::VK_XValue)
1244 return CandidateRef == RQ_RValue ? OverloadCompare::Dominates
1245 : OverloadCompare::Dominated;
1246 }
1247 // Now the ref qualifiers are the same (or we're in some invalid state).
1248 // So make some decision based on the qualifiers.
1249 Qualifiers CandidateQual = Candidate.getMethodQualifiers();
1250 Qualifiers IncumbentQual = Incumbent.getMethodQualifiers();
1251 bool CandidateSuperset = CandidateQual.compatiblyIncludes(IncumbentQual);
1252 bool IncumbentSuperset = IncumbentQual.compatiblyIncludes(CandidateQual);
1253 if (CandidateSuperset == IncumbentSuperset)
1254 return OverloadCompare::BothViable;
1255 return IncumbentSuperset ? OverloadCompare::Dominates
1256 : OverloadCompare::Dominated;
1257}
1258
1259void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
1260 NamedDecl *Hiding, bool InBaseClass = false) {
1261 if (R.Kind != Result::RK_Declaration) {
1262 // For non-declaration results, just add the result.
1263 Results.push_back(R);
1264 return;
1265 }
1266
1267 // Look through using declarations.
1268 if (const auto *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
1269 CodeCompletionResult Result(Using->getTargetDecl(),
1270 getBasePriority(Using->getTargetDecl()),
1271 R.Qualifier);
1272 Result.ShadowDecl = Using;
1273 AddResult(Result, CurContext, Hiding);
1274 return;
1275 }
1276
1277 bool AsNestedNameSpecifier = false;
1278 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
1279 return;
1280
1281 // C++ constructors are never found by name lookup.
1282 if (isConstructor(R.Declaration))
1283 return;
1284
1285 if (Hiding && CheckHiddenResult(R, CurContext, Hiding))
1286 return;
1287
1288 // Make sure that any given declaration only shows up in the result set once.
1289 if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()).second)
1290 return;
1291
1292 // If the filter is for nested-name-specifiers, then this result starts a
1293 // nested-name-specifier.
1294 if (AsNestedNameSpecifier) {
1295 R.StartsNestedNameSpecifier = true;
1296 R.Priority = CCP_NestedNameSpecifier;
1297 } else if (Filter == &ResultBuilder::IsMember && !R.Qualifier &&
1298 InBaseClass &&
1299 isa<CXXRecordDecl>(
1300 R.Declaration->getDeclContext()->getRedeclContext()))
1301 R.QualifierIsInformative = true;
1302
1303 // If this result is supposed to have an informative qualifier, add one.
1304 if (R.QualifierIsInformative && !R.Qualifier &&
1305 !R.StartsNestedNameSpecifier) {
1306 const DeclContext *Ctx = R.Declaration->getDeclContext();
1307 if (const auto *Namespace = dyn_cast<NamespaceDecl>(Ctx))
1308 R.Qualifier =
1309 NestedNameSpecifier::Create(SemaRef.Context, nullptr, Namespace);
1310 else if (const auto *Tag = dyn_cast<TagDecl>(Ctx))
1311 R.Qualifier = NestedNameSpecifier::Create(
1312 SemaRef.Context, nullptr, false,
1313 SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
1314 else
1315 R.QualifierIsInformative = false;
1316 }
1317
1318 // Adjust the priority if this result comes from a base class.
1319 if (InBaseClass)
1320 setInBaseClass(R);
1321
1322 AdjustResultPriorityForDecl(R);
1323
1324 if (HasObjectTypeQualifiers)
1325 if (const auto *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
1326 if (Method->isInstance()) {
1327 Qualifiers MethodQuals = Method->getMethodQualifiers();
1328 if (ObjectTypeQualifiers == MethodQuals)
1329 R.Priority += CCD_ObjectQualifierMatch;
1330 else if (ObjectTypeQualifiers - MethodQuals) {
1331 // The method cannot be invoked, because doing so would drop
1332 // qualifiers.
1333 return;
1334 }
1335 // Detect cases where a ref-qualified method cannot be invoked.
1336 switch (Method->getRefQualifier()) {
1337 case RQ_LValue:
1338 if (ObjectKind != VK_LValue && !MethodQuals.hasConst())
1339 return;
1340 break;
1341 case RQ_RValue:
1342 if (ObjectKind == VK_LValue)
1343 return;
1344 break;
1345 case RQ_None:
1346 break;
1347 }
1348
1349 /// Check whether this dominates another overloaded method, which should
1350 /// be suppressed (or vice versa).
1351 /// Motivating case is const_iterator begin() const vs iterator begin().
1352 auto &OverloadSet = OverloadMap[std::make_pair(
1353 CurContext, Method->getDeclName().getAsOpaqueInteger())];
1354 for (const DeclIndexPair Entry : OverloadSet) {
1355 Result &Incumbent = Results[Entry.second];
1356 switch (compareOverloads(*Method,
1357 *cast<CXXMethodDecl>(Incumbent.Declaration),
1358 ObjectTypeQualifiers, ObjectKind)) {
1359 case OverloadCompare::Dominates:
1360 // Replace the dominated overload with this one.
1361 // FIXME: if the overload dominates multiple incumbents then we
1362 // should remove all. But two overloads is by far the common case.
1363 Incumbent = std::move(R);
1364 return;
1365 case OverloadCompare::Dominated:
1366 // This overload can't be called, drop it.
1367 return;
1368 case OverloadCompare::BothViable:
1369 break;
1370 }
1371 }
1372 OverloadSet.Add(Method, Results.size());
1373 }
1374
1375 // Insert this result into the set of results.
1376 Results.push_back(R);
1377
1378 if (!AsNestedNameSpecifier)
1379 MaybeAddConstructorResults(R);
1380}
1381
1382void ResultBuilder::AddResult(Result R) {
1383 assert(R.Kind != Result::RK_Declaration &&((void)0)
1384 "Declaration results need more context")((void)0);
1385 Results.push_back(R);
1386}
1387
1388/// Enter into a new scope.
1389void ResultBuilder::EnterNewScope() { ShadowMaps.emplace_back(); }
1390
1391/// Exit from the current scope.
1392void ResultBuilder::ExitScope() {
1393 ShadowMaps.pop_back();
1394}
1395
1396/// Determines whether this given declaration will be found by
1397/// ordinary name lookup.
1398bool ResultBuilder::IsOrdinaryName(const NamedDecl *ND) const {
1399 ND = ND->getUnderlyingDecl();
1400
1401 // If name lookup finds a local extern declaration, then we are in a
1402 // context where it behaves like an ordinary name.
1403 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1404 if (SemaRef.getLangOpts().CPlusPlus)
1405 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
1406 else if (SemaRef.getLangOpts().ObjC) {
1407 if (isa<ObjCIvarDecl>(ND))
1408 return true;
1409 }
1410
1411 return ND->getIdentifierNamespace() & IDNS;
1412}
1413
1414/// Determines whether this given declaration will be found by
1415/// ordinary name lookup but is not a type name.
1416bool ResultBuilder::IsOrdinaryNonTypeName(const NamedDecl *ND) const {
1417 ND = ND->getUnderlyingDecl();
1418 if (isa<TypeDecl>(ND))
1419 return false;
1420 // Objective-C interfaces names are not filtered by this method because they
1421 // can be used in a class property expression. We can still filter out
1422 // @class declarations though.
1423 if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND)) {
1424 if (!ID->getDefinition())
1425 return false;
1426 }
1427
1428 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1429 if (SemaRef.getLangOpts().CPlusPlus)
1430 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
1431 else if (SemaRef.getLangOpts().ObjC) {
1432 if (isa<ObjCIvarDecl>(ND))
1433 return true;
1434 }
1435
1436 return ND->getIdentifierNamespace() & IDNS;
1437}
1438
1439bool ResultBuilder::IsIntegralConstantValue(const NamedDecl *ND) const {
1440 if (!IsOrdinaryNonTypeName(ND))
1441 return 0;
1442
1443 if (const auto *VD = dyn_cast<ValueDecl>(ND->getUnderlyingDecl()))
1444 if (VD->getType()->isIntegralOrEnumerationType())
1445 return true;
1446
1447 return false;
1448}
1449
1450/// Determines whether this given declaration will be found by
1451/// ordinary name lookup.
1452bool ResultBuilder::IsOrdinaryNonValueName(const NamedDecl *ND) const {
1453 ND = ND->getUnderlyingDecl();
1454
1455 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1456 if (SemaRef.getLangOpts().CPlusPlus)
1457 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace;
1458
1459 return (ND->getIdentifierNamespace() & IDNS) && !isa<ValueDecl>(ND) &&
1460 !isa<FunctionTemplateDecl>(ND) && !isa<ObjCPropertyDecl>(ND);
1461}
1462
1463/// Determines whether the given declaration is suitable as the
1464/// start of a C++ nested-name-specifier, e.g., a class or namespace.
1465bool ResultBuilder::IsNestedNameSpecifier(const NamedDecl *ND) const {
1466 // Allow us to find class templates, too.
1467 if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1468 ND = ClassTemplate->getTemplatedDecl();
1469
1470 return SemaRef.isAcceptableNestedNameSpecifier(ND);
1471}
1472
1473/// Determines whether the given declaration is an enumeration.
1474bool ResultBuilder::IsEnum(const NamedDecl *ND) const {
1475 return isa<EnumDecl>(ND);
1476}
1477
1478/// Determines whether the given declaration is a class or struct.
1479bool ResultBuilder::IsClassOrStruct(const NamedDecl *ND) const {
1480 // Allow us to find class templates, too.
1481 if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1482 ND = ClassTemplate->getTemplatedDecl();
1483
1484 // For purposes of this check, interfaces match too.
1485 if (const auto *RD = dyn_cast<RecordDecl>(ND))
1486 return RD->getTagKind() == TTK_Class || RD->getTagKind() == TTK_Struct ||
1487 RD->getTagKind() == TTK_Interface;
1488
1489 return false;
1490}
1491
1492/// Determines whether the given declaration is a union.
1493bool ResultBuilder::IsUnion(const NamedDecl *ND) const {
1494 // Allow us to find class templates, too.
1495 if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1496 ND = ClassTemplate->getTemplatedDecl();
1497
1498 if (const auto *RD = dyn_cast<RecordDecl>(ND))
1499 return RD->getTagKind() == TTK_Union;
1500
1501 return false;
1502}
1503
1504/// Determines whether the given declaration is a namespace.
1505bool ResultBuilder::IsNamespace(const NamedDecl *ND) const {
1506 return isa<NamespaceDecl>(ND);
1507}
1508
1509/// Determines whether the given declaration is a namespace or
1510/// namespace alias.
1511bool ResultBuilder::IsNamespaceOrAlias(const NamedDecl *ND) const {
1512 return isa<NamespaceDecl>(ND->getUnderlyingDecl());
1513}
1514
1515/// Determines whether the given declaration is a type.
1516bool ResultBuilder::IsType(const NamedDecl *ND) const {
1517 ND = ND->getUnderlyingDecl();
1518 return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
1519}
1520
1521/// Determines which members of a class should be visible via
1522/// "." or "->". Only value declarations, nested name specifiers, and
1523/// using declarations thereof should show up.
1524bool ResultBuilder::IsMember(const NamedDecl *ND) const {
1525 ND = ND->getUnderlyingDecl();
1526 return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||
1527 isa<ObjCPropertyDecl>(ND);
1528}
1529
1530static bool isObjCReceiverType(ASTContext &C, QualType T) {
1531 T = C.getCanonicalType(T);
1532 switch (T->getTypeClass()) {
1533 case Type::ObjCObject:
1534 case Type::ObjCInterface:
1535 case Type::ObjCObjectPointer:
1536 return true;
1537
1538 case Type::Builtin:
1539 switch (cast<BuiltinType>(T)->getKind()) {
1540 case BuiltinType::ObjCId:
1541 case BuiltinType::ObjCClass:
1542 case BuiltinType::ObjCSel:
1543 return true;
1544
1545 default:
1546 break;
1547 }
1548 return false;
1549
1550 default:
1551 break;
1552 }
1553
1554 if (!C.getLangOpts().CPlusPlus)
1555 return false;
1556
1557 // FIXME: We could perform more analysis here to determine whether a
1558 // particular class type has any conversions to Objective-C types. For now,
1559 // just accept all class types.
1560 return T->isDependentType() || T->isRecordType();
1561}
1562
1563bool ResultBuilder::IsObjCMessageReceiver(const NamedDecl *ND) const {
1564 QualType T = getDeclUsageType(SemaRef.Context, ND);
1565 if (T.isNull())
1566 return false;
1567
1568 T = SemaRef.Context.getBaseElementType(T);
1569 return isObjCReceiverType(SemaRef.Context, T);
1570}
1571
1572bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture(
1573 const NamedDecl *ND) const {
1574 if (IsObjCMessageReceiver(ND))
1575 return true;
1576
1577 const auto *Var = dyn_cast<VarDecl>(ND);
1578 if (!Var)
1579 return false;
1580
1581 return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>();
1582}
1583
1584bool ResultBuilder::IsObjCCollection(const NamedDecl *ND) const {
1585 if ((SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) ||
1586 (!SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND)))
1587 return false;
1588
1589 QualType T = getDeclUsageType(SemaRef.Context, ND);
1590 if (T.isNull())
1591 return false;
1592
1593 T = SemaRef.Context.getBaseElementType(T);
1594 return T->isObjCObjectType() || T->isObjCObjectPointerType() ||
1595 T->isObjCIdType() ||
1596 (SemaRef.getLangOpts().CPlusPlus && T->isRecordType());
1597}
1598
1599bool ResultBuilder::IsImpossibleToSatisfy(const NamedDecl *ND) const {
1600 return false;
1601}
1602
1603/// Determines whether the given declaration is an Objective-C
1604/// instance variable.
1605bool ResultBuilder::IsObjCIvar(const NamedDecl *ND) const {
1606 return isa<ObjCIvarDecl>(ND);
1607}
1608
1609namespace {
1610
1611/// Visible declaration consumer that adds a code-completion result
1612/// for each visible declaration.
1613class CodeCompletionDeclConsumer : public VisibleDeclConsumer {
1614 ResultBuilder &Results;
1615 DeclContext *InitialLookupCtx;
1616 // NamingClass and BaseType are used for access-checking. See
1617 // Sema::IsSimplyAccessible for details.
1618 CXXRecordDecl *NamingClass;
1619 QualType BaseType;
1620 std::vector<FixItHint> FixIts;
1621
1622public:
1623 CodeCompletionDeclConsumer(
1624 ResultBuilder &Results, DeclContext *InitialLookupCtx,
1625 QualType BaseType = QualType(),
1626 std::vector<FixItHint> FixIts = std::vector<FixItHint>())
1627 : Results(Results), InitialLookupCtx(InitialLookupCtx),
1628 FixIts(std::move(FixIts)) {
1629 NamingClass = llvm::dyn_cast<CXXRecordDecl>(InitialLookupCtx);
1630 // If BaseType was not provided explicitly, emulate implicit 'this->'.
1631 if (BaseType.isNull()) {
1632 auto ThisType = Results.getSema().getCurrentThisType();
1633 if (!ThisType.isNull()) {
1634 assert(ThisType->isPointerType())((void)0);
1635 BaseType = ThisType->getPointeeType();
1636 if (!NamingClass)
1637 NamingClass = BaseType->getAsCXXRecordDecl();
1638 }
1639 }
1640 this->BaseType = BaseType;
1641 }
1642
1643 void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
1644 bool InBaseClass) override {
1645 ResultBuilder::Result Result(ND, Results.getBasePriority(ND), nullptr,
1646 false, IsAccessible(ND, Ctx), FixIts);
1647 Results.AddResult(Result, InitialLookupCtx, Hiding, InBaseClass);
1648 }
1649
1650 void EnteredContext(DeclContext *Ctx) override {
1651 Results.addVisitedContext(Ctx);
1652 }
1653
1654private:
1655 bool IsAccessible(NamedDecl *ND, DeclContext *Ctx) {
1656 // Naming class to use for access check. In most cases it was provided
1657 // explicitly (e.g. member access (lhs.foo) or qualified lookup (X::)),
1658 // for unqualified lookup we fallback to the \p Ctx in which we found the
1659 // member.
1660 auto *NamingClass = this->NamingClass;
1661 QualType BaseType = this->BaseType;
1662 if (auto *Cls = llvm::dyn_cast_or_null<CXXRecordDecl>(Ctx)) {
1663 if (!NamingClass)
1664 NamingClass = Cls;
1665 // When we emulate implicit 'this->' in an unqualified lookup, we might
1666 // end up with an invalid naming class. In that case, we avoid emulating
1667 // 'this->' qualifier to satisfy preconditions of the access checking.
1668 if (NamingClass->getCanonicalDecl() != Cls->getCanonicalDecl() &&
1669 !NamingClass->isDerivedFrom(Cls)) {
1670 NamingClass = Cls;
1671 BaseType = QualType();
1672 }
1673 } else {
1674 // The decl was found outside the C++ class, so only ObjC access checks
1675 // apply. Those do not rely on NamingClass and BaseType, so we clear them
1676 // out.
1677 NamingClass = nullptr;
1678 BaseType = QualType();
1679 }
1680 return Results.getSema().IsSimplyAccessible(ND, NamingClass, BaseType);
1681 }
1682};
1683} // namespace
1684
1685/// Add type specifiers for the current language as keyword results.
1686static void AddTypeSpecifierResults(const LangOptions &LangOpts,
1687 ResultBuilder &Results) {
1688 typedef CodeCompletionResult Result;
1689 Results.AddResult(Result("short", CCP_Type));
1690 Results.AddResult(Result("long", CCP_Type));
1691 Results.AddResult(Result("signed", CCP_Type));
1692 Results.AddResult(Result("unsigned", CCP_Type));
1693 Results.AddResult(Result("void", CCP_Type));
1694 Results.AddResult(Result("char", CCP_Type));
1695 Results.AddResult(Result("int", CCP_Type));
1696 Results.AddResult(Result("float", CCP_Type));
1697 Results.AddResult(Result("double", CCP_Type));
1698 Results.AddResult(Result("enum", CCP_Type));
1699 Results.AddResult(Result("struct", CCP_Type));
1700 Results.AddResult(Result("union", CCP_Type));
1701 Results.AddResult(Result("const", CCP_Type));
1702 Results.AddResult(Result("volatile", CCP_Type));
1703
1704 if (LangOpts.C99) {
1705 // C99-specific
1706 Results.AddResult(Result("_Complex", CCP_Type));
1707 Results.AddResult(Result("_Imaginary", CCP_Type));
1708 Results.AddResult(Result("_Bool", CCP_Type));
1709 Results.AddResult(Result("restrict", CCP_Type));
1710 }
1711
1712 CodeCompletionBuilder Builder(Results.getAllocator(),
1713 Results.getCodeCompletionTUInfo());
1714 if (LangOpts.CPlusPlus) {
1715 // C++-specific
1716 Results.AddResult(
1717 Result("bool", CCP_Type + (LangOpts.ObjC ? CCD_bool_in_ObjC : 0)));
1718 Results.AddResult(Result("class", CCP_Type));
1719 Results.AddResult(Result("wchar_t", CCP_Type));
1720
1721 // typename name
1722 Builder.AddTypedTextChunk("typename");
1723 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1724 Builder.AddPlaceholderChunk("name");
1725 Results.AddResult(Result(Builder.TakeString()));
1726
1727 if (LangOpts.CPlusPlus11) {
1728 Results.AddResult(Result("auto", CCP_Type));
1729 Results.AddResult(Result("char16_t", CCP_Type));
1730 Results.AddResult(Result("char32_t", CCP_Type));
1731
1732 Builder.AddTypedTextChunk("decltype");
1733 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1734 Builder.AddPlaceholderChunk("expression");
1735 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1736 Results.AddResult(Result(Builder.TakeString()));
1737 }
1738 } else
1739 Results.AddResult(Result("__auto_type", CCP_Type));
1740
1741 // GNU keywords
1742 if (LangOpts.GNUKeywords) {
1743 // FIXME: Enable when we actually support decimal floating point.
1744 // Results.AddResult(Result("_Decimal32"));
1745 // Results.AddResult(Result("_Decimal64"));
1746 // Results.AddResult(Result("_Decimal128"));
1747
1748 Builder.AddTypedTextChunk("typeof");
1749 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1750 Builder.AddPlaceholderChunk("expression");
1751 Results.AddResult(Result(Builder.TakeString()));
1752
1753 Builder.AddTypedTextChunk("typeof");
1754 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1755 Builder.AddPlaceholderChunk("type");
1756 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1757 Results.AddResult(Result(Builder.TakeString()));
1758 }
1759
1760 // Nullability
1761 Results.AddResult(Result("_Nonnull", CCP_Type));
1762 Results.AddResult(Result("_Null_unspecified", CCP_Type));
1763 Results.AddResult(Result("_Nullable", CCP_Type));
1764}
1765
1766static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC,
1767 const LangOptions &LangOpts,
1768 ResultBuilder &Results) {
1769 typedef CodeCompletionResult Result;
1770 // Note: we don't suggest either "auto" or "register", because both
1771 // are pointless as storage specifiers. Elsewhere, we suggest "auto"
1772 // in C++0x as a type specifier.
1773 Results.AddResult(Result("extern"));
1774 Results.AddResult(Result("static"));
1775
1776 if (LangOpts.CPlusPlus11) {
1777 CodeCompletionAllocator &Allocator = Results.getAllocator();
1778 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1779
1780 // alignas
1781 Builder.AddTypedTextChunk("alignas");
1782 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1783 Builder.AddPlaceholderChunk("expression");
1784 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1785 Results.AddResult(Result(Builder.TakeString()));
1786
1787 Results.AddResult(Result("constexpr"));
1788 Results.AddResult(Result("thread_local"));
1789 }
1790}
1791
1792static void AddFunctionSpecifiers(Sema::ParserCompletionContext CCC,
1793 const LangOptions &LangOpts,
1794 ResultBuilder &Results) {
1795 typedef CodeCompletionResult Result;
1796 switch (CCC) {
1797 case Sema::PCC_Class:
1798 case Sema::PCC_MemberTemplate:
1799 if (LangOpts.CPlusPlus) {
1800 Results.AddResult(Result("explicit"));
1801 Results.AddResult(Result("friend"));
1802 Results.AddResult(Result("mutable"));
1803 Results.AddResult(Result("virtual"));
1804 }
1805 LLVM_FALLTHROUGH[[gnu::fallthrough]];
1806
1807 case Sema::PCC_ObjCInterface:
1808 case Sema::PCC_ObjCImplementation:
1809 case Sema::PCC_Namespace:
1810 case Sema::PCC_Template:
1811 if (LangOpts.CPlusPlus || LangOpts.C99)
1812 Results.AddResult(Result("inline"));
1813 break;
1814
1815 case Sema::PCC_ObjCInstanceVariableList:
1816 case Sema::PCC_Expression:
1817 case Sema::PCC_Statement:
1818 case Sema::PCC_ForInit:
1819 case Sema::PCC_Condition:
1820 case Sema::PCC_RecoveryInFunction:
1821 case Sema::PCC_Type:
1822 case Sema::PCC_ParenthesizedExpression:
1823 case Sema::PCC_LocalDeclarationSpecifiers:
1824 break;
1825 }
1826}
1827
1828static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt);
1829static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt);
1830static void AddObjCVisibilityResults(const LangOptions &LangOpts,
1831 ResultBuilder &Results, bool NeedAt);
1832static void AddObjCImplementationResults(const LangOptions &LangOpts,
1833 ResultBuilder &Results, bool NeedAt);
1834static void AddObjCInterfaceResults(const LangOptions &LangOpts,
1835 ResultBuilder &Results, bool NeedAt);
1836static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt);
1837
1838static void AddTypedefResult(ResultBuilder &Results) {
1839 CodeCompletionBuilder Builder(Results.getAllocator(),
1840 Results.getCodeCompletionTUInfo());
1841 Builder.AddTypedTextChunk("typedef");
1842 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1843 Builder.AddPlaceholderChunk("type");
1844 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1845 Builder.AddPlaceholderChunk("name");
1846 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1847 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1848}
1849
1850// using name = type
1851static void AddUsingAliasResult(CodeCompletionBuilder &Builder,
1852 ResultBuilder &Results) {
1853 Builder.AddTypedTextChunk("using");
1854 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1855 Builder.AddPlaceholderChunk("name");
1856 Builder.AddChunk(CodeCompletionString::CK_Equal);
1857 Builder.AddPlaceholderChunk("type");
1858 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1859 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1860}
1861
1862static bool WantTypesInContext(Sema::ParserCompletionContext CCC,
1863 const LangOptions &LangOpts) {
1864 switch (CCC) {
1865 case Sema::PCC_Namespace:
1866 case Sema::PCC_Class:
1867 case Sema::PCC_ObjCInstanceVariableList:
1868 case Sema::PCC_Template:
1869 case Sema::PCC_MemberTemplate:
1870 case Sema::PCC_Statement:
1871 case Sema::PCC_RecoveryInFunction:
1872 case Sema::PCC_Type:
1873 case Sema::PCC_ParenthesizedExpression:
1874 case Sema::PCC_LocalDeclarationSpecifiers:
1875 return true;
1876
1877 case Sema::PCC_Expression:
1878 case Sema::PCC_Condition:
1879 return LangOpts.CPlusPlus;
1880
1881 case Sema::PCC_ObjCInterface:
1882 case Sema::PCC_ObjCImplementation:
1883 return false;
1884
1885 case Sema::PCC_ForInit:
1886 return LangOpts.CPlusPlus || LangOpts.ObjC || LangOpts.C99;
1887 }
1888
1889 llvm_unreachable("Invalid ParserCompletionContext!")__builtin_unreachable();
1890}
1891
1892static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context,
1893 const Preprocessor &PP) {
1894 PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
1895 Policy.AnonymousTagLocations = false;
1896 Policy.SuppressStrongLifetime = true;
1897 Policy.SuppressUnwrittenScope = true;
1898 Policy.SuppressScope = true;
1899 return Policy;
1900}
1901
1902/// Retrieve a printing policy suitable for code completion.
1903static PrintingPolicy getCompletionPrintingPolicy(Sema &S) {
1904 return getCompletionPrintingPolicy(S.Context, S.PP);
1905}
1906
1907/// Retrieve the string representation of the given type as a string
1908/// that has the appropriate lifetime for code completion.
1909///
1910/// This routine provides a fast path where we provide constant strings for
1911/// common type names.
1912static const char *GetCompletionTypeString(QualType T, ASTContext &Context,
1913 const PrintingPolicy &Policy,
1914 CodeCompletionAllocator &Allocator) {
1915 if (!T.getLocalQualifiers()) {
1916 // Built-in type names are constant strings.
1917 if (const BuiltinType *BT = dyn_cast<BuiltinType>(T))
1918 return BT->getNameAsCString(Policy);
1919
1920 // Anonymous tag types are constant strings.
1921 if (const TagType *TagT = dyn_cast<TagType>(T))
1922 if (TagDecl *Tag = TagT->getDecl())
1923 if (!Tag->hasNameForLinkage()) {
1924 switch (Tag->getTagKind()) {
1925 case TTK_Struct:
1926 return "struct <anonymous>";
1927 case TTK_Interface:
1928 return "__interface <anonymous>";
1929 case TTK_Class:
1930 return "class <anonymous>";
1931 case TTK_Union:
1932 return "union <anonymous>";
1933 case TTK_Enum:
1934 return "enum <anonymous>";
1935 }
1936 }
1937 }
1938
1939 // Slow path: format the type as a string.
1940 std::string Result;
1941 T.getAsStringInternal(Result, Policy);
1942 return Allocator.CopyString(Result);
1943}
1944
1945/// Add a completion for "this", if we're in a member function.
1946static void addThisCompletion(Sema &S, ResultBuilder &Results) {
1947 QualType ThisTy = S.getCurrentThisType();
1948 if (ThisTy.isNull())
1949 return;
1950
1951 CodeCompletionAllocator &Allocator = Results.getAllocator();
1952 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1953 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
1954 Builder.AddResultTypeChunk(
1955 GetCompletionTypeString(ThisTy, S.Context, Policy, Allocator));
1956 Builder.AddTypedTextChunk("this");
1957 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1958}
1959
1960static void AddStaticAssertResult(CodeCompletionBuilder &Builder,
1961 ResultBuilder &Results,
1962 const LangOptions &LangOpts) {
1963 if (!LangOpts.CPlusPlus11)
1964 return;
1965
1966 Builder.AddTypedTextChunk("static_assert");
1967 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1968 Builder.AddPlaceholderChunk("expression");
1969 Builder.AddChunk(CodeCompletionString::CK_Comma);
1970 Builder.AddPlaceholderChunk("message");
1971 Builder.AddChunk(CodeCompletionString::CK_RightParen);
1972 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1973 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1974}
1975
1976static void AddOverrideResults(ResultBuilder &Results,
1977 const CodeCompletionContext &CCContext,
1978 CodeCompletionBuilder &Builder) {
1979 Sema &S = Results.getSema();
1980 const auto *CR = llvm::dyn_cast<CXXRecordDecl>(S.CurContext);
1981 // If not inside a class/struct/union return empty.
1982 if (!CR)
1983 return;
1984 // First store overrides within current class.
1985 // These are stored by name to make querying fast in the later step.
1986 llvm::StringMap<std::vector<FunctionDecl *>> Overrides;
1987 for (auto *Method : CR->methods()) {
1988 if (!Method->isVirtual() || !Method->getIdentifier())
1989 continue;
1990 Overrides[Method->getName()].push_back(Method);
1991 }
1992
1993 for (const auto &Base : CR->bases()) {
1994 const auto *BR = Base.getType().getTypePtr()->getAsCXXRecordDecl();
1995 if (!BR)
1996 continue;
1997 for (auto *Method : BR->methods()) {
1998 if (!Method->isVirtual() || !Method->getIdentifier())
1999 continue;
2000 const auto it = Overrides.find(Method->getName());
2001 bool IsOverriden = false;
2002 if (it != Overrides.end()) {
2003 for (auto *MD : it->second) {
2004 // If the method in current body is not an overload of this virtual
2005 // function, then it overrides this one.
2006 if (!S.IsOverload(MD, Method, false)) {
2007 IsOverriden = true;
2008 break;
2009 }
2010 }
2011 }
2012 if (!IsOverriden) {
2013 // Generates a new CodeCompletionResult by taking this function and
2014 // converting it into an override declaration with only one chunk in the
2015 // final CodeCompletionString as a TypedTextChunk.
2016 std::string OverrideSignature;
2017 llvm::raw_string_ostream OS(OverrideSignature);
2018 CodeCompletionResult CCR(Method, 0);
2019 PrintingPolicy Policy =
2020 getCompletionPrintingPolicy(S.getASTContext(), S.getPreprocessor());
2021 auto *CCS = CCR.createCodeCompletionStringForOverride(
2022 S.getPreprocessor(), S.getASTContext(), Builder,
2023 /*IncludeBriefComments=*/false, CCContext, Policy);
2024 Results.AddResult(CodeCompletionResult(CCS, Method, CCP_CodePattern));
2025 }
2026 }
2027 }
2028}
2029
2030/// Add language constructs that show up for "ordinary" names.
2031static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC, Scope *S,
2032 Sema &SemaRef, ResultBuilder &Results) {
2033 CodeCompletionAllocator &Allocator = Results.getAllocator();
2034 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
2035
2036 typedef CodeCompletionResult Result;
2037 switch (CCC) {
2038 case Sema::PCC_Namespace:
2039 if (SemaRef.getLangOpts().CPlusPlus) {
2040 if (Results.includeCodePatterns()) {
2041 // namespace <identifier> { declarations }
2042 Builder.AddTypedTextChunk("namespace");
2043 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2044 Builder.AddPlaceholderChunk("identifier");
2045 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2046 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2047 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2048 Builder.AddPlaceholderChunk("declarations");
2049 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2050 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2051 Results.AddResult(Result(Builder.TakeString()));
2052 }
2053
2054 // namespace identifier = identifier ;
2055 Builder.AddTypedTextChunk("namespace");
2056 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2057 Builder.AddPlaceholderChunk("name");
2058 Builder.AddChunk(CodeCompletionString::CK_Equal);
2059 Builder.AddPlaceholderChunk("namespace");
2060 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2061 Results.AddResult(Result(Builder.TakeString()));
2062
2063 // Using directives
2064 Builder.AddTypedTextChunk("using namespace");
2065 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2066 Builder.AddPlaceholderChunk("identifier");
2067 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2068 Results.AddResult(Result(Builder.TakeString()));
2069
2070 // asm(string-literal)
2071 Builder.AddTypedTextChunk("asm");
2072 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2073 Builder.AddPlaceholderChunk("string-literal");
2074 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2075 Results.AddResult(Result(Builder.TakeString()));
2076
2077 if (Results.includeCodePatterns()) {
2078 // Explicit template instantiation
2079 Builder.AddTypedTextChunk("template");
2080 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2081 Builder.AddPlaceholderChunk("declaration");
2082 Results.AddResult(Result(Builder.TakeString()));
2083 } else {
2084 Results.AddResult(Result("template", CodeCompletionResult::RK_Keyword));
2085 }
2086 }
2087
2088 if (SemaRef.getLangOpts().ObjC)
2089 AddObjCTopLevelResults(Results, true);
2090
2091 AddTypedefResult(Results);
2092 LLVM_FALLTHROUGH[[gnu::fallthrough]];
2093
2094 case Sema::PCC_Class:
2095 if (SemaRef.getLangOpts().CPlusPlus) {
2096 // Using declaration
2097 Builder.AddTypedTextChunk("using");
2098 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2099 Builder.AddPlaceholderChunk("qualifier");
2100 Builder.AddTextChunk("::");
2101 Builder.AddPlaceholderChunk("name");
2102 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2103 Results.AddResult(Result(Builder.TakeString()));
2104
2105 if (SemaRef.getLangOpts().CPlusPlus11)
2106 AddUsingAliasResult(Builder, Results);
2107
2108 // using typename qualifier::name (only in a dependent context)
2109 if (SemaRef.CurContext->isDependentContext()) {
2110 Builder.AddTypedTextChunk("using typename");
2111 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2112 Builder.AddPlaceholderChunk("qualifier");
2113 Builder.AddTextChunk("::");
2114 Builder.AddPlaceholderChunk("name");
2115 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2116 Results.AddResult(Result(Builder.TakeString()));
2117 }
2118
2119 AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts());
2120
2121 if (CCC == Sema::PCC_Class) {
2122 AddTypedefResult(Results);
2123
2124 bool IsNotInheritanceScope =
2125 !(S->getFlags() & Scope::ClassInheritanceScope);
2126 // public:
2127 Builder.AddTypedTextChunk("public");
2128 if (IsNotInheritanceScope && Results.includeCodePatterns())
2129 Builder.AddChunk(CodeCompletionString::CK_Colon);
2130 Results.AddResult(Result(Builder.TakeString()));
2131
2132 // protected:
2133 Builder.AddTypedTextChunk("protected");
2134 if (IsNotInheritanceScope && Results.includeCodePatterns())
2135 Builder.AddChunk(CodeCompletionString::CK_Colon);
2136 Results.AddResult(Result(Builder.TakeString()));
2137
2138 // private:
2139 Builder.AddTypedTextChunk("private");
2140 if (IsNotInheritanceScope && Results.includeCodePatterns())
2141 Builder.AddChunk(CodeCompletionString::CK_Colon);
2142 Results.AddResult(Result(Builder.TakeString()));
2143
2144 // FIXME: This adds override results only if we are at the first word of
2145 // the declaration/definition. Also call this from other sides to have
2146 // more use-cases.
2147 AddOverrideResults(Results, CodeCompletionContext::CCC_ClassStructUnion,
2148 Builder);
2149 }
2150 }
2151 LLVM_FALLTHROUGH[[gnu::fallthrough]];
2152
2153 case Sema::PCC_Template:
2154 case Sema::PCC_MemberTemplate:
2155 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
2156 // template < parameters >
2157 Builder.AddTypedTextChunk("template");
2158 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
2159 Builder.AddPlaceholderChunk("parameters");
2160 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
2161 Results.AddResult(Result(Builder.TakeString()));
2162 } else {
2163 Results.AddResult(Result("template", CodeCompletionResult::RK_Keyword));
2164 }
2165
2166 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2167 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2168 break;
2169
2170 case Sema::PCC_ObjCInterface:
2171 AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true);
2172 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2173 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2174 break;
2175
2176 case Sema::PCC_ObjCImplementation:
2177 AddObjCImplementationResults(SemaRef.getLangOpts(), Results, true);
2178 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2179 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2180 break;
2181
2182 case Sema::PCC_ObjCInstanceVariableList:
2183 AddObjCVisibilityResults(SemaRef.getLangOpts(), Results, true);
2184 break;
2185
2186 case Sema::PCC_RecoveryInFunction:
2187 case Sema::PCC_Statement: {
2188 if (SemaRef.getLangOpts().CPlusPlus11)
2189 AddUsingAliasResult(Builder, Results);
2190
2191 AddTypedefResult(Results);
2192
2193 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() &&
2194 SemaRef.getLangOpts().CXXExceptions) {
2195 Builder.AddTypedTextChunk("try");
2196 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2197 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2198 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2199 Builder.AddPlaceholderChunk("statements");
2200 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2201 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2202 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2203 Builder.AddTextChunk("catch");
2204 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2205 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2206 Builder.AddPlaceholderChunk("declaration");
2207 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2208 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2209 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2210 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2211 Builder.AddPlaceholderChunk("statements");
2212 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2213 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2214 Results.AddResult(Result(Builder.TakeString()));
2215 }
2216 if (SemaRef.getLangOpts().ObjC)
2217 AddObjCStatementResults(Results, true);
2218
2219 if (Results.includeCodePatterns()) {
2220 // if (condition) { statements }
2221 Builder.AddTypedTextChunk("if");
2222 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2223 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2224 if (SemaRef.getLangOpts().CPlusPlus)
2225 Builder.AddPlaceholderChunk("condition");
2226 else
2227 Builder.AddPlaceholderChunk("expression");
2228 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2229 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2230 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2231 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2232 Builder.AddPlaceholderChunk("statements");
2233 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2234 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2235 Results.AddResult(Result(Builder.TakeString()));
2236
2237 // switch (condition) { }
2238 Builder.AddTypedTextChunk("switch");
2239 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2240 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2241 if (SemaRef.getLangOpts().CPlusPlus)
2242 Builder.AddPlaceholderChunk("condition");
2243 else
2244 Builder.AddPlaceholderChunk("expression");
2245 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2246 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2247 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2248 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2249 Builder.AddPlaceholderChunk("cases");
2250 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2251 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2252 Results.AddResult(Result(Builder.TakeString()));
2253 }
2254
2255 // Switch-specific statements.
2256 if (SemaRef.getCurFunction() &&
2257 !SemaRef.getCurFunction()->SwitchStack.empty()) {
2258 // case expression:
2259 Builder.AddTypedTextChunk("case");
2260 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2261 Builder.AddPlaceholderChunk("expression");
2262 Builder.AddChunk(CodeCompletionString::CK_Colon);
2263 Results.AddResult(Result(Builder.TakeString()));
2264
2265 // default:
2266 Builder.AddTypedTextChunk("default");
2267 Builder.AddChunk(CodeCompletionString::CK_Colon);
2268 Results.AddResult(Result(Builder.TakeString()));
2269 }
2270
2271 if (Results.includeCodePatterns()) {
2272 /// while (condition) { statements }
2273 Builder.AddTypedTextChunk("while");
2274 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2275 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2276 if (SemaRef.getLangOpts().CPlusPlus)
2277 Builder.AddPlaceholderChunk("condition");
2278 else
2279 Builder.AddPlaceholderChunk("expression");
2280 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2281 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2282 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2283 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2284 Builder.AddPlaceholderChunk("statements");
2285 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2286 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2287 Results.AddResult(Result(Builder.TakeString()));
2288
2289 // do { statements } while ( expression );
2290 Builder.AddTypedTextChunk("do");
2291 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2292 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2293 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2294 Builder.AddPlaceholderChunk("statements");
2295 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2296 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2297 Builder.AddTextChunk("while");
2298 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2299 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2300 Builder.AddPlaceholderChunk("expression");
2301 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2302 Results.AddResult(Result(Builder.TakeString()));
2303
2304 // for ( for-init-statement ; condition ; expression ) { statements }
2305 Builder.AddTypedTextChunk("for");
2306 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2307 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2308 if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99)
2309 Builder.AddPlaceholderChunk("init-statement");
2310 else
2311 Builder.AddPlaceholderChunk("init-expression");
2312 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2313 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2314 Builder.AddPlaceholderChunk("condition");
2315 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2316 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2317 Builder.AddPlaceholderChunk("inc-expression");
2318 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2319 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2320 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2321 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2322 Builder.AddPlaceholderChunk("statements");
2323 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2324 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2325 Results.AddResult(Result(Builder.TakeString()));
2326
2327 if (SemaRef.getLangOpts().CPlusPlus11 || SemaRef.getLangOpts().ObjC) {
2328 // for ( range_declaration (:|in) range_expression ) { statements }
2329 Builder.AddTypedTextChunk("for");
2330 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2331 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2332 Builder.AddPlaceholderChunk("range-declaration");
2333 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2334 if (SemaRef.getLangOpts().ObjC)
2335 Builder.AddTextChunk("in");
2336 else
2337 Builder.AddChunk(CodeCompletionString::CK_Colon);
2338 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2339 Builder.AddPlaceholderChunk("range-expression");
2340 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2341 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2342 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
2343 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2344 Builder.AddPlaceholderChunk("statements");
2345 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
2346 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
2347 Results.AddResult(Result(Builder.TakeString()));
2348 }
2349 }
2350
2351 if (S->getContinueParent()) {
2352 // continue ;
2353 Builder.AddTypedTextChunk("continue");
2354 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2355 Results.AddResult(Result(Builder.TakeString()));
2356 }
2357
2358 if (S->getBreakParent()) {
2359 // break ;
2360 Builder.AddTypedTextChunk("break");
2361 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2362 Results.AddResult(Result(Builder.TakeString()));
2363 }
2364
2365 // "return expression ;" or "return ;", depending on the return type.
2366 QualType ReturnType;
2367 if (const auto *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext))
2368 ReturnType = Function->getReturnType();
2369 else if (const auto *Method = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext))
2370 ReturnType = Method->getReturnType();
2371 else if (SemaRef.getCurBlock() &&
2372 !SemaRef.getCurBlock()->ReturnType.isNull())
2373 ReturnType = SemaRef.getCurBlock()->ReturnType;;
2374 if (ReturnType.isNull() || ReturnType->isVoidType()) {
2375 Builder.AddTypedTextChunk("return");
2376 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2377 Results.AddResult(Result(Builder.TakeString()));
2378 } else {
2379 assert(!ReturnType.isNull())((void)0);
2380 // "return expression ;"
2381 Builder.AddTypedTextChunk("return");
2382 Builder.AddChunk(clang::CodeCompletionString::CK_HorizontalSpace);
2383 Builder.AddPlaceholderChunk("expression");
2384 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2385 Results.AddResult(Result(Builder.TakeString()));
2386 // When boolean, also add 'return true;' and 'return false;'.
2387 if (ReturnType->isBooleanType()) {
2388 Builder.AddTypedTextChunk("return true");
2389 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2390 Results.AddResult(Result(Builder.TakeString()));
2391
2392 Builder.AddTypedTextChunk("return false");
2393 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2394 Results.AddResult(Result(Builder.TakeString()));
2395 }
2396 // For pointers, suggest 'return nullptr' in C++.
2397 if (SemaRef.getLangOpts().CPlusPlus11 &&
2398 (ReturnType->isPointerType() || ReturnType->isMemberPointerType())) {
2399 Builder.AddTypedTextChunk("return nullptr");
2400 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2401 Results.AddResult(Result(Builder.TakeString()));
2402 }
2403 }
2404
2405 // goto identifier ;
2406 Builder.AddTypedTextChunk("goto");
2407 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2408 Builder.AddPlaceholderChunk("label");
2409 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2410 Results.AddResult(Result(Builder.TakeString()));
2411
2412 // Using directives
2413 Builder.AddTypedTextChunk("using namespace");
2414 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2415 Builder.AddPlaceholderChunk("identifier");
2416 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
2417 Results.AddResult(Result(Builder.TakeString()));
2418
2419 AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts());
2420 }
2421 LLVM_FALLTHROUGH[[gnu::fallthrough]];
2422
2423 // Fall through (for statement expressions).
2424 case Sema::PCC_ForInit:
2425 case Sema::PCC_Condition:
2426 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
2427 // Fall through: conditions and statements can have expressions.
2428 LLVM_FALLTHROUGH[[gnu::fallthrough]];
2429
2430 case Sema::PCC_ParenthesizedExpression:
2431 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
2432 CCC == Sema::PCC_ParenthesizedExpression) {
2433 // (__bridge <type>)<expression>
2434 Builder.AddTypedTextChunk("__bridge");
2435 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2436 Builder.AddPlaceholderChunk("type");
2437 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2438 Builder.AddPlaceholderChunk("expression");
2439 Results.AddResult(Result(Builder.TakeString()));
2440
2441 // (__bridge_transfer <Objective-C type>)<expression>
2442 Builder.AddTypedTextChunk("__bridge_transfer");
2443 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2444 Builder.AddPlaceholderChunk("Objective-C type");
2445 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2446 Builder.AddPlaceholderChunk("expression");
2447 Results.AddResult(Result(Builder.TakeString()));
2448
2449 // (__bridge_retained <CF type>)<expression>
2450 Builder.AddTypedTextChunk("__bridge_retained");
2451 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2452 Builder.AddPlaceholderChunk("CF type");
2453 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2454 Builder.AddPlaceholderChunk("expression");
2455 Results.AddResult(Result(Builder.TakeString()));
2456 }
2457 // Fall through
2458 LLVM_FALLTHROUGH[[gnu::fallthrough]];
2459
2460 case Sema::PCC_Expression: {
2461 if (SemaRef.getLangOpts().CPlusPlus) {
2462 // 'this', if we're in a non-static member function.
2463 addThisCompletion(SemaRef, Results);
2464
2465 // true
2466 Builder.AddResultTypeChunk("bool");
2467 Builder.AddTypedTextChunk("true");
2468 Results.AddResult(Result(Builder.TakeString()));
2469
2470 // false
2471 Builder.AddResultTypeChunk("bool");
2472 Builder.AddTypedTextChunk("false");
2473 Results.AddResult(Result(Builder.TakeString()));
2474
2475 if (SemaRef.getLangOpts().RTTI) {
2476 // dynamic_cast < type-id > ( expression )
2477 Builder.AddTypedTextChunk("dynamic_cast");
2478 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
2479 Builder.AddPlaceholderChunk("type");
2480 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
2481 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2482 Builder.AddPlaceholderChunk("expression");
2483 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2484 Results.AddResult(Result(Builder.TakeString()));
2485 }
2486
2487 // static_cast < type-id > ( expression )
2488 Builder.AddTypedTextChunk("static_cast");
2489 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
2490 Builder.AddPlaceholderChunk("type");
2491 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
2492 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2493 Builder.AddPlaceholderChunk("expression");
2494 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2495 Results.AddResult(Result(Builder.TakeString()));
2496
2497 // reinterpret_cast < type-id > ( expression )
2498 Builder.AddTypedTextChunk("reinterpret_cast");
2499 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
2500 Builder.AddPlaceholderChunk("type");
2501 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
2502 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2503 Builder.AddPlaceholderChunk("expression");
2504 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2505 Results.AddResult(Result(Builder.TakeString()));
2506
2507 // const_cast < type-id > ( expression )
2508 Builder.AddTypedTextChunk("const_cast");
2509 Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
2510 Builder.AddPlaceholderChunk("type");
2511 Builder.AddChunk(CodeCompletionString::CK_RightAngle);
2512 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2513 Builder.AddPlaceholderChunk("expression");
2514 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2515 Results.AddResult(Result(Builder.TakeString()));
2516
2517 if (SemaRef.getLangOpts().RTTI) {
2518 // typeid ( expression-or-type )
2519 Builder.AddResultTypeChunk("std::type_info");
2520 Builder.AddTypedTextChunk("typeid");
2521 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2522 Builder.AddPlaceholderChunk("expression-or-type");
2523 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2524 Results.AddResult(Result(Builder.TakeString()));
2525 }
2526
2527 // new T ( ... )
2528 Builder.AddTypedTextChunk("new");
2529 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2530 Builder.AddPlaceholderChunk("type");
2531 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2532 Builder.AddPlaceholderChunk("expressions");
2533 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2534 Results.AddResult(Result(Builder.TakeString()));
2535
2536 // new T [ ] ( ... )
2537 Builder.AddTypedTextChunk("new");
2538 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2539 Builder.AddPlaceholderChunk("type");
2540 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
2541 Builder.AddPlaceholderChunk("size");
2542 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
2543 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2544 Builder.AddPlaceholderChunk("expressions");
2545 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2546 Results.AddResult(Result(Builder.TakeString()));
2547
2548 // delete expression
2549 Builder.AddResultTypeChunk("void");
2550 Builder.AddTypedTextChunk("delete");
2551 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2552 Builder.AddPlaceholderChunk("expression");
2553 Results.AddResult(Result(Builder.TakeString()));
2554
2555 // delete [] expression
2556 Builder.AddResultTypeChunk("void");
2557 Builder.AddTypedTextChunk("delete");
2558 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2559 Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
2560 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
2561 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2562 Builder.AddPlaceholderChunk("expression");
2563 Results.AddResult(Result(Builder.TakeString()));
2564
2565 if (SemaRef.getLangOpts().CXXExceptions) {
2566 // throw expression
2567 Builder.AddResultTypeChunk("void");
2568 Builder.AddTypedTextChunk("throw");
2569 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2570 Builder.AddPlaceholderChunk("expression");
2571 Results.AddResult(Result(Builder.TakeString()));
2572 }
2573
2574 // FIXME: Rethrow?
2575
2576 if (SemaRef.getLangOpts().CPlusPlus11) {
2577 // nullptr
2578 Builder.AddResultTypeChunk("std::nullptr_t");
2579 Builder.AddTypedTextChunk("nullptr");
2580 Results.AddResult(Result(Builder.TakeString()));
2581
2582 // alignof
2583 Builder.AddResultTypeChunk("size_t");
2584 Builder.AddTypedTextChunk("alignof");
2585 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2586 Builder.AddPlaceholderChunk("type");
2587 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2588 Results.AddResult(Result(Builder.TakeString()));
2589
2590 // noexcept
2591 Builder.AddResultTypeChunk("bool");
2592 Builder.AddTypedTextChunk("noexcept");
2593 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2594 Builder.AddPlaceholderChunk("expression");
2595 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2596 Results.AddResult(Result(Builder.TakeString()));
2597
2598 // sizeof... expression
2599 Builder.AddResultTypeChunk("size_t");
2600 Builder.AddTypedTextChunk("sizeof...");
2601 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2602 Builder.AddPlaceholderChunk("parameter-pack");
2603 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2604 Results.AddResult(Result(Builder.TakeString()));
2605 }
2606 }
2607
2608 if (SemaRef.getLangOpts().ObjC) {
2609 // Add "super", if we're in an Objective-C class with a superclass.
2610 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
2611 // The interface can be NULL.
2612 if (ObjCInterfaceDecl *ID = Method->getClassInterface())
2613 if (ID->getSuperClass()) {
2614 std::string SuperType;
2615 SuperType = ID->getSuperClass()->getNameAsString();
2616 if (Method->isInstanceMethod())
2617 SuperType += " *";
2618
2619 Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
2620 Builder.AddTypedTextChunk("super");
2621 Results.AddResult(Result(Builder.TakeString()));
2622 }
2623 }
2624
2625 AddObjCExpressionResults(Results, true);
2626 }
2627
2628 if (SemaRef.getLangOpts().C11) {
2629 // _Alignof
2630 Builder.AddResultTypeChunk("size_t");
2631 if (SemaRef.PP.isMacroDefined("alignof"))
2632 Builder.AddTypedTextChunk("alignof");
2633 else
2634 Builder.AddTypedTextChunk("_Alignof");
2635 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2636 Builder.AddPlaceholderChunk("type");
2637 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2638 Results.AddResult(Result(Builder.TakeString()));
2639 }
2640
2641 // sizeof expression
2642 Builder.AddResultTypeChunk("size_t");
2643 Builder.AddTypedTextChunk("sizeof");
2644 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2645 Builder.AddPlaceholderChunk("expression-or-type");
2646 Builder.AddChunk(CodeCompletionString::CK_RightParen);
2647 Results.AddResult(Result(Builder.TakeString()));
2648 break;
2649 }
2650
2651 case Sema::PCC_Type:
2652 case Sema::PCC_LocalDeclarationSpecifiers:
2653 break;
2654 }
2655
2656 if (WantTypesInContext(CCC, SemaRef.getLangOpts()))
2657 AddTypeSpecifierResults(SemaRef.getLangOpts(), Results);
2658
2659 if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type)
2660 Results.AddResult(Result("operator"));
2661}
2662
2663/// If the given declaration has an associated type, add it as a result
2664/// type chunk.
2665static void AddResultTypeChunk(ASTContext &Context,
2666 const PrintingPolicy &Policy,
2667 const NamedDecl *ND, QualType BaseType,
2668 CodeCompletionBuilder &Result) {
2669 if (!ND)
2670 return;
2671
2672 // Skip constructors and conversion functions, which have their return types
2673 // built into their names.
2674 if (isConstructor(ND) || isa<CXXConversionDecl>(ND))
2675 return;
2676
2677 // Determine the type of the declaration (if it has a type).
2678 QualType T;
2679 if (const FunctionDecl *Function = ND->getAsFunction())
2680 T = Function->getReturnType();
2681 else if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2682 if (!BaseType.isNull())
2683 T = Method->getSendResultType(BaseType);
2684 else
2685 T = Method->getReturnType();
2686 } else if (const auto *Enumerator = dyn_cast<EnumConstantDecl>(ND)) {
2687 T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2688 T = clang::TypeName::getFullyQualifiedType(T, Context);
2689 } else if (isa<UnresolvedUsingValueDecl>(ND)) {
2690 /* Do nothing: ignore unresolved using declarations*/
2691 } else if (const auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
2692 if (!BaseType.isNull())
2693 T = Ivar->getUsageType(BaseType);
2694 else
2695 T = Ivar->getType();
2696 } else if (const auto *Value = dyn_cast<ValueDecl>(ND)) {
2697 T = Value->getType();
2698 } else if (const auto *Property = dyn_cast<ObjCPropertyDecl>(ND)) {
2699 if (!BaseType.isNull())
2700 T = Property->getUsageType(BaseType);
2701 else
2702 T = Property->getType();
2703 }
2704
2705 if (T.isNull() || Context.hasSameType(T, Context.DependentTy))
2706 return;
2707
2708 Result.AddResultTypeChunk(
2709 GetCompletionTypeString(T, Context, Policy, Result.getAllocator()));
2710}
2711
2712static void MaybeAddSentinel(Preprocessor &PP,
2713 const NamedDecl *FunctionOrMethod,
2714 CodeCompletionBuilder &Result) {
2715 if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>())
2716 if (Sentinel->getSentinel() == 0) {
2717 if (PP.getLangOpts().ObjC && PP.isMacroDefined("nil"))
2718 Result.AddTextChunk(", nil");
2719 else if (PP.isMacroDefined("NULL"))
2720 Result.AddTextChunk(", NULL");
2721 else
2722 Result.AddTextChunk(", (void*)0");
2723 }
2724}
2725
2726static std::string formatObjCParamQualifiers(unsigned ObjCQuals,
2727 QualType &Type) {
2728 std::string Result;
2729 if (ObjCQuals & Decl::OBJC_TQ_In)
2730 Result += "in ";
2731 else if (ObjCQuals & Decl::OBJC_TQ_Inout)
2732 Result += "inout ";
2733 else if (ObjCQuals & Decl::OBJC_TQ_Out)
2734 Result += "out ";
2735 if (ObjCQuals & Decl::OBJC_TQ_Bycopy)
2736 Result += "bycopy ";
2737 else if (ObjCQuals & Decl::OBJC_TQ_Byref)
2738 Result += "byref ";
2739 if (ObjCQuals & Decl::OBJC_TQ_Oneway)
2740 Result += "oneway ";
2741 if (ObjCQuals & Decl::OBJC_TQ_CSNullability) {
2742 if (auto nullability = AttributedType::stripOuterNullability(Type)) {
2743 switch (*nullability) {
2744 case NullabilityKind::NonNull:
2745 Result += "nonnull ";
2746 break;
2747
2748 case NullabilityKind::Nullable:
2749 Result += "nullable ";
2750 break;
2751
2752 case NullabilityKind::Unspecified:
2753 Result += "null_unspecified ";
2754 break;
2755
2756 case NullabilityKind::NullableResult:
2757 llvm_unreachable("Not supported as a context-sensitive keyword!")__builtin_unreachable();
2758 break;
2759 }
2760 }
2761 }
2762 return Result;
2763}
2764
2765/// Tries to find the most appropriate type location for an Objective-C
2766/// block placeholder.
2767///
2768/// This function ignores things like typedefs and qualifiers in order to
2769/// present the most relevant and accurate block placeholders in code completion
2770/// results.
2771static void findTypeLocationForBlockDecl(const TypeSourceInfo *TSInfo,
2772 FunctionTypeLoc &Block,
2773 FunctionProtoTypeLoc &BlockProto,
2774 bool SuppressBlock = false) {
2775 if (!TSInfo)
2776 return;
2777 TypeLoc TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
2778 while (true) {
2779 // Look through typedefs.
2780 if (!SuppressBlock) {
2781 if (TypedefTypeLoc TypedefTL = TL.getAs<TypedefTypeLoc>()) {
2782 if (TypeSourceInfo *InnerTSInfo =
2783 TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) {
2784 TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc();
2785 continue;
2786 }
2787 }
2788
2789 // Look through qualified types
2790 if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) {
2791 TL = QualifiedTL.getUnqualifiedLoc();
2792 continue;
2793 }
2794
2795 if (AttributedTypeLoc AttrTL = TL.getAs<AttributedTypeLoc>()) {
2796 TL = AttrTL.getModifiedLoc();
2797 continue;
2798 }
2799 }
2800
2801 // Try to get the function prototype behind the block pointer type,
2802 // then we're done.
2803 if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) {
2804 TL = BlockPtr.getPointeeLoc().IgnoreParens();
2805 Block = TL.getAs<FunctionTypeLoc>();
2806 BlockProto = TL.getAs<FunctionProtoTypeLoc>();
2807 }
2808 break;
2809 }
2810}
2811
2812static std::string
2813formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
2814 FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2815 bool SuppressBlockName = false,
2816 bool SuppressBlock = false,
2817 Optional<ArrayRef<QualType>> ObjCSubsts = None);
2818
2819static std::string
2820FormatFunctionParameter(const PrintingPolicy &Policy, const ParmVarDecl *Param,
2821 bool SuppressName = false, bool SuppressBlock = false,
2822 Optional<ArrayRef<QualType>> ObjCSubsts = None) {
2823 // Params are unavailable in FunctionTypeLoc if the FunctionType is invalid.
2824 // It would be better to pass in the param Type, which is usually avaliable.
2825 // But this case is rare, so just pretend we fell back to int as elsewhere.
2826 if (!Param)
2827 return "int";
2828 bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
2829 if (Param->getType()->isDependentType() ||
2830 !Param->getType()->isBlockPointerType()) {
2831 // The argument for a dependent or non-block parameter is a placeholder
2832 // containing that parameter's type.
2833 std::string Result;
2834
2835 if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
2836 Result = std::string(Param->getIdentifier()->getName());
2837
2838 QualType Type = Param->getType();
2839 if (ObjCSubsts)
2840 Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts,
2841 ObjCSubstitutionContext::Parameter);
2842 if (ObjCMethodParam) {
2843 Result =
2844 "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(), Type);
2845 Result += Type.getAsString(Policy) + ")";
2846 if (Param->getIdentifier() && !SuppressName)
2847 Result += Param->getIdentifier()->getName();
2848 } else {
2849 Type.getAsStringInternal(Result, Policy);
2850 }
2851 return Result;
2852 }
2853
2854 // The argument for a block pointer parameter is a block literal with
2855 // the appropriate type.
2856 FunctionTypeLoc Block;
2857 FunctionProtoTypeLoc BlockProto;
2858 findTypeLocationForBlockDecl(Param->getTypeSourceInfo(), Block, BlockProto,
2859 SuppressBlock);
2860 // Try to retrieve the block type information from the property if this is a
2861 // parameter in a setter.
2862 if (!Block && ObjCMethodParam &&
2863 cast<ObjCMethodDecl>(Param->getDeclContext())->isPropertyAccessor()) {
2864 if (const auto *PD = cast<ObjCMethodDecl>(Param->getDeclContext())
2865 ->findPropertyDecl(/*CheckOverrides=*/false))
2866 findTypeLocationForBlockDecl(PD->getTypeSourceInfo(), Block, BlockProto,
2867 SuppressBlock);
2868 }
2869
2870 if (!Block) {
2871 // We were unable to find a FunctionProtoTypeLoc with parameter names
2872 // for the block; just use the parameter type as a placeholder.
2873 std::string Result;
2874 if (!ObjCMethodParam && Param->getIdentifier())
2875 Result = std::string(Param->getIdentifier()->getName());
2876
2877 QualType Type = Param->getType().getUnqualifiedType();
2878
2879 if (ObjCMethodParam) {
2880 Result = Type.getAsString(Policy);
2881 std::string Quals =
2882 formatObjCParamQualifiers(Param->getObjCDeclQualifier(), Type);
2883 if (!Quals.empty())
2884 Result = "(" + Quals + " " + Result + ")";
2885 if (Result.back() != ')')
2886 Result += " ";
2887 if (Param->getIdentifier())
2888 Result += Param->getIdentifier()->getName();
2889 } else {
2890 Type.getAsStringInternal(Result, Policy);
2891 }
2892
2893 return Result;
2894 }
2895
2896 // We have the function prototype behind the block pointer type, as it was
2897 // written in the source.
2898 return formatBlockPlaceholder(Policy, Param, Block, BlockProto,
2899 /*SuppressBlockName=*/false, SuppressBlock,
2900 ObjCSubsts);
2901}
2902
2903/// Returns a placeholder string that corresponds to an Objective-C block
2904/// declaration.
2905///
2906/// \param BlockDecl A declaration with an Objective-C block type.
2907///
2908/// \param Block The most relevant type location for that block type.
2909///
2910/// \param SuppressBlockName Determines whether or not the name of the block
2911/// declaration is included in the resulting string.
2912static std::string
2913formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
2914 FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2915 bool SuppressBlockName, bool SuppressBlock,
2916 Optional<ArrayRef<QualType>> ObjCSubsts) {
2917 std::string Result;
2918 QualType ResultType = Block.getTypePtr()->getReturnType();
2919 if (ObjCSubsts)
2920 ResultType =
2921 ResultType.substObjCTypeArgs(BlockDecl->getASTContext(), *ObjCSubsts,
2922 ObjCSubstitutionContext::Result);
2923 if (!ResultType->isVoidType() || SuppressBlock)
2924 ResultType.getAsStringInternal(Result, Policy);
2925
2926 // Format the parameter list.
2927 std::string Params;
2928 if (!BlockProto || Block.getNumParams() == 0) {
2929 if (BlockProto && BlockProto.getTypePtr()->isVariadic())
2930 Params = "(...)";
2931 else
2932 Params = "(void)";
2933 } else {
2934 Params += "(";
2935 for (unsigned I = 0, N = Block.getNumParams(); I != N; ++I) {
2936 if (I)
2937 Params += ", ";
2938 Params += FormatFunctionParameter(Policy, Block.getParam(I),
2939 /*SuppressName=*/false,
2940 /*SuppressBlock=*/true, ObjCSubsts);
2941
2942 if (I == N - 1 && BlockProto.getTypePtr()->isVariadic())
2943 Params += ", ...";
2944 }
2945 Params += ")";
2946 }
2947
2948 if (SuppressBlock) {
2949 // Format as a parameter.
2950 Result = Result + " (^";
2951 if (!SuppressBlockName && BlockDecl->getIdentifier())
2952 Result += BlockDecl->getIdentifier()->getName();
2953 Result += ")";
2954 Result += Params;
2955 } else {
2956 // Format as a block literal argument.
2957 Result = '^' + Result;
2958 Result += Params;
2959
2960 if (!SuppressBlockName && BlockDecl->getIdentifier())
2961 Result += BlockDecl->getIdentifier()->getName();
2962 }
2963
2964 return Result;
2965}
2966
2967static std::string GetDefaultValueString(const ParmVarDecl *Param,
2968 const SourceManager &SM,
2969 const LangOptions &LangOpts) {
2970 const SourceRange SrcRange = Param->getDefaultArgRange();
2971 CharSourceRange CharSrcRange = CharSourceRange::getTokenRange(SrcRange);
2972 bool Invalid = CharSrcRange.isInvalid();
2973 if (Invalid)
2974 return "";
2975 StringRef srcText =
2976 Lexer::getSourceText(CharSrcRange, SM, LangOpts, &Invalid);
2977 if (Invalid)
2978 return "";
2979
2980 if (srcText.empty() || srcText == "=") {
2981 // Lexer can't determine the value.
2982 // This happens if the code is incorrect (for example class is forward
2983 // declared).
2984 return "";
2985 }
2986 std::string DefValue(srcText.str());
2987 // FIXME: remove this check if the Lexer::getSourceText value is fixed and
2988 // this value always has (or always does not have) '=' in front of it
2989 if (DefValue.at(0) != '=') {
2990 // If we don't have '=' in front of value.
2991 // Lexer returns built-in types values without '=' and user-defined types
2992 // values with it.
2993 return " = " + DefValue;
2994 }
2995 return " " + DefValue;
2996}
2997
2998/// Add function parameter chunks to the given code completion string.
2999static void AddFunctionParameterChunks(Preprocessor &PP,
3000 const PrintingPolicy &Policy,
3001 const FunctionDecl *Function,
3002 CodeCompletionBuilder &Result,
3003 unsigned Start = 0,
3004 bool InOptional = false) {
3005 bool FirstParameter = true;
3006
3007 for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
3008 const ParmVarDecl *Param = Function->getParamDecl(P);
3009
3010 if (Param->hasDefaultArg() && !InOptional) {
3011 // When we see an optional default argument, put that argument and
3012 // the remaining default arguments into a new, optional string.
3013 CodeCompletionBuilder Opt(Result.getAllocator(),
3014 Result.getCodeCompletionTUInfo());
3015 if (!FirstParameter)
3016 Opt.AddChunk(CodeCompletionString::CK_Comma);
3017 AddFunctionParameterChunks(PP, Policy, Function, Opt, P, true);
3018 Result.AddOptionalChunk(Opt.TakeString());
3019 break;
3020 }
3021
3022 if (FirstParameter)
3023 FirstParameter = false;
3024 else
3025 Result.AddChunk(CodeCompletionString::CK_Comma);
3026
3027 InOptional = false;
3028
3029 // Format the placeholder string.
3030 std::string PlaceholderStr = FormatFunctionParameter(Policy, Param);
3031 if (Param->hasDefaultArg())
3032 PlaceholderStr +=
3033 GetDefaultValueString(Param, PP.getSourceManager(), PP.getLangOpts());
3034
3035 if (Function->isVariadic() && P == N - 1)
3036 PlaceholderStr += ", ...";
3037
3038 // Add the placeholder string.
3039 Result.AddPlaceholderChunk(
3040 Result.getAllocator().CopyString(PlaceholderStr));
3041 }
3042
3043 if (const auto *Proto = Function->getType()->getAs<FunctionProtoType>())
3044 if (Proto->isVariadic()) {
3045 if (Proto->getNumParams() == 0)
3046 Result.AddPlaceholderChunk("...");
3047
3048 MaybeAddSentinel(PP, Function, Result);
3049 }
3050}
3051
3052/// Add template parameter chunks to the given code completion string.
3053static void AddTemplateParameterChunks(
3054 ASTContext &Context, const PrintingPolicy &Policy,
3055 const TemplateDecl *Template, CodeCompletionBuilder &Result,
3056 unsigned MaxParameters = 0, unsigned Start = 0, bool InDefaultArg = false) {
3057 bool FirstParameter = true;
3058
3059 // Prefer to take the template parameter names from the first declaration of
3060 // the template.
3061 Template = cast<TemplateDecl>(Template->getCanonicalDecl());
3062
3063 TemplateParameterList *Params = Template->getTemplateParameters();
3064 TemplateParameterList::iterator PEnd = Params->end();
3065 if (MaxParameters)
3066 PEnd = Params->begin() + MaxParameters;
3067 for (TemplateParameterList::iterator P = Params->begin() + Start; P != PEnd;
3068 ++P) {
3069 bool HasDefaultArg = false;
3070 std::string PlaceholderStr;
3071 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
3072 if (TTP->wasDeclaredWithTypename())
3073 PlaceholderStr = "typename";
3074 else if (const auto *TC = TTP->getTypeConstraint()) {
3075 llvm::raw_string_ostream OS(PlaceholderStr);
3076 TC->print(OS, Policy);
3077 OS.flush();
3078 } else
3079 PlaceholderStr = "class";
3080
3081 if (TTP->getIdentifier()) {
3082 PlaceholderStr += ' ';
3083 PlaceholderStr += TTP->getIdentifier()->getName();
3084 }
3085
3086 HasDefaultArg = TTP->hasDefaultArgument();
3087 } else if (NonTypeTemplateParmDecl *NTTP =
3088 dyn_cast<NonTypeTemplateParmDecl>(*P)) {
3089 if (NTTP->getIdentifier())
3090 PlaceholderStr = std::string(NTTP->getIdentifier()->getName());
3091 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
3092 HasDefaultArg = NTTP->hasDefaultArgument();
3093 } else {
3094 assert(isa<TemplateTemplateParmDecl>(*P))((void)0);
3095 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
3096
3097 // Since putting the template argument list into the placeholder would
3098 // be very, very long, we just use an abbreviation.
3099 PlaceholderStr = "template<...> class";
3100 if (TTP->getIdentifier()) {
3101 PlaceholderStr += ' ';
3102 PlaceholderStr += TTP->getIdentifier()->getName();
3103 }
3104
3105 HasDefaultArg = TTP->hasDefaultArgument();
3106 }
3107
3108 if (HasDefaultArg && !InDefaultArg) {
3109 // When we see an optional default argument, put that argument and
3110 // the remaining default arguments into a new, optional string.
3111 CodeCompletionBuilder Opt(Result.getAllocator(),
3112 Result.getCodeCompletionTUInfo());
3113 if (!FirstParameter)
3114 Opt.AddChunk(CodeCompletionString::CK_Comma);
3115 AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
3116 P - Params->begin(), true);
3117 Result.AddOptionalChunk(Opt.TakeString());
3118 break;
3119 }
3120
3121 InDefaultArg = false;
3122
3123 if (FirstParameter)
3124 FirstParameter = false;
3125 else
3126 Result.AddChunk(CodeCompletionString::CK_Comma);
3127
3128 // Add the placeholder string.
3129 Result.AddPlaceholderChunk(
3130 Result.getAllocator().CopyString(PlaceholderStr));
3131 }
3132}
3133
3134/// Add a qualifier to the given code-completion string, if the
3135/// provided nested-name-specifier is non-NULL.
3136static void AddQualifierToCompletionString(CodeCompletionBuilder &Result,
3137 NestedNameSpecifier *Qualifier,
3138 bool QualifierIsInformative,
3139 ASTContext &Context,
3140 const PrintingPolicy &Policy) {
3141 if (!Qualifier)
3142 return;
3143
3144 std::string PrintedNNS;
3145 {
3146 llvm::raw_string_ostream OS(PrintedNNS);
3147 Qualifier->print(OS, Policy);
3148 }
3149 if (QualifierIsInformative)
3150 Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
3151 else
3152 Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
3153}
3154
3155static void
3156AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result,
3157 const FunctionDecl *Function) {
3158 const auto *Proto = Function->getType()->getAs<FunctionProtoType>();
3159 if (!Proto || !Proto->getMethodQuals())
3160 return;
3161
3162 // FIXME: Add ref-qualifier!
3163
3164 // Handle single qualifiers without copying
3165 if (Proto->getMethodQuals().hasOnlyConst()) {
3166 Result.AddInformativeChunk(" const");
3167 return;
3168 }
3169
3170 if (Proto->getMethodQuals().hasOnlyVolatile()) {
3171 Result.AddInformativeChunk(" volatile");
3172 return;
3173 }
3174
3175 if (Proto->getMethodQuals().hasOnlyRestrict()) {
3176 Result.AddInformativeChunk(" restrict");
3177 return;
3178 }
3179
3180 // Handle multiple qualifiers.
3181 std::string QualsStr;
3182 if (Proto->isConst())
3183 QualsStr += " const";
3184 if (Proto->isVolatile())
3185 QualsStr += " volatile";
3186 if (Proto->isRestrict())
3187 QualsStr += " restrict";
3188 Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
3189}
3190
3191/// Add the name of the given declaration
3192static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
3193 const NamedDecl *ND,
3194 CodeCompletionBuilder &Result) {
3195 DeclarationName Name = ND->getDeclName();
3196 if (!Name)
3197 return;
3198
3199 switch (Name.getNameKind()) {
3200 case DeclarationName::CXXOperatorName: {
3201 const char *OperatorName = nullptr;
3202 switch (Name.getCXXOverloadedOperator()) {
3203 case OO_None:
3204 case OO_Conditional:
3205 case NUM_OVERLOADED_OPERATORS:
3206 OperatorName = "operator";
3207 break;
3208
3209#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
3210 case OO_##Name: \
3211 OperatorName = "operator" Spelling; \
3212 break;
3213#define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemberOnly)
3214#include "clang/Basic/OperatorKinds.def"
3215
3216 case OO_New:
3217 OperatorName = "operator new";
3218 break;
3219 case OO_Delete:
3220 OperatorName = "operator delete";
3221 break;
3222 case OO_Array_New:
3223 OperatorName = "operator new[]";
3224 break;
3225 case OO_Array_Delete:
3226 OperatorName = "operator delete[]";
3227 break;
3228 case OO_Call:
3229 OperatorName = "operator()";
3230 break;
3231 case OO_Subscript:
3232 OperatorName = "operator[]";
3233 break;
3234 }
3235 Result.AddTypedTextChunk(OperatorName);
3236 break;
3237 }
3238
3239 case DeclarationName::Identifier:
3240 case DeclarationName::CXXConversionFunctionName:
3241 case DeclarationName::CXXDestructorName:
3242 case DeclarationName::CXXLiteralOperatorName:
3243 Result.AddTypedTextChunk(
3244 Result.getAllocator().CopyString(ND->getNameAsString()));
3245 break;
3246
3247 case DeclarationName::CXXDeductionGuideName:
3248 case DeclarationName::CXXUsingDirective:
3249 case DeclarationName::ObjCZeroArgSelector:
3250 case DeclarationName::ObjCOneArgSelector:
3251 case DeclarationName::ObjCMultiArgSelector:
3252 break;
3253
3254 case DeclarationName::CXXConstructorName: {
3255 CXXRecordDecl *Record = nullptr;
3256 QualType Ty = Name.getCXXNameType();
3257 if (const auto *RecordTy = Ty->getAs<RecordType>())
3258 Record = cast<CXXRecordDecl>(RecordTy->getDecl());
3259 else if (const auto *InjectedTy = Ty->getAs<InjectedClassNameType>())
3260 Record = InjectedTy->getDecl();
3261 else {
3262 Result.AddTypedTextChunk(
3263 Result.getAllocator().CopyString(ND->getNameAsString()));
3264 break;
3265 }
3266
3267 Result.AddTypedTextChunk(
3268 Result.getAllocator().CopyString(Record->getNameAsString()));
3269 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
3270 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
3271 AddTemplateParameterChunks(Context, Policy, Template, Result);
3272 Result.AddChunk(CodeCompletionString::CK_RightAngle);
3273 }
3274 break;
3275 }
3276 }
3277}
3278
3279CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(
3280 Sema &S, const CodeCompletionContext &CCContext,
3281 CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo,
3282 bool IncludeBriefComments) {
3283 return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator,
3284 CCTUInfo, IncludeBriefComments);
3285}
3286
3287CodeCompletionString *CodeCompletionResult::CreateCodeCompletionStringForMacro(
3288 Preprocessor &PP, CodeCompletionAllocator &Allocator,
3289 CodeCompletionTUInfo &CCTUInfo) {
3290 assert(Kind == RK_Macro)((void)0);
3291 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
3292 const MacroInfo *MI = PP.getMacroInfo(Macro);
3293 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Macro->getName()));
3294
3295 if (!MI || !MI->isFunctionLike())
3296 return Result.TakeString();
3297
3298 // Format a function-like macro with placeholders for the arguments.
3299 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3300 MacroInfo::param_iterator A = MI->param_begin(), AEnd = MI->param_end();
3301
3302 // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
3303 if (MI->isC99Varargs()) {
3304 --AEnd;
3305
3306 if (A == AEnd) {
3307 Result.AddPlaceholderChunk("...");
3308 }
3309 }
3310
3311 for (MacroInfo::param_iterator A = MI->param_begin(); A != AEnd; ++A) {
3312 if (A != MI->param_begin())
3313 Result.AddChunk(CodeCompletionString::CK_Comma);
3314
3315 if (MI->isVariadic() && (A + 1) == AEnd) {
3316 SmallString<32> Arg = (*A)->getName();
3317 if (MI->isC99Varargs())
3318 Arg += ", ...";
3319 else
3320 Arg += "...";
3321 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
3322 break;
3323 }
3324
3325 // Non-variadic macros are simple.
3326 Result.AddPlaceholderChunk(
3327 Result.getAllocator().CopyString((*A)->getName()));
3328 }
3329 Result.AddChunk(CodeCompletionString::CK_RightParen);
3330 return Result.TakeString();
3331}
3332
3333/// If possible, create a new code completion string for the given
3334/// result.
3335///
3336/// \returns Either a new, heap-allocated code completion string describing
3337/// how to use this result, or NULL to indicate that the string or name of the
3338/// result is all that is needed.
3339CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(
3340 ASTContext &Ctx, Preprocessor &PP, const CodeCompletionContext &CCContext,
3341 CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo,
3342 bool IncludeBriefComments) {
3343 if (Kind == RK_Macro)
3344 return CreateCodeCompletionStringForMacro(PP, Allocator, CCTUInfo);
3345
3346 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
3347
3348 PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
3349 if (Kind == RK_Pattern) {
3350 Pattern->Priority = Priority;
3351 Pattern->Availability = Availability;
3352
3353 if (Declaration) {
3354 Result.addParentContext(Declaration->getDeclContext());
3355 Pattern->ParentName = Result.getParentName();
3356 if (const RawComment *RC =
3357 getPatternCompletionComment(Ctx, Declaration)) {
3358 Result.addBriefComment(RC->getBriefText(Ctx));
3359 Pattern->BriefComment = Result.getBriefComment();
3360 }
3361 }
3362
3363 return Pattern;
3364 }
3365
3366 if (Kind == RK_Keyword) {
3367 Result.AddTypedTextChunk(Keyword);
3368 return Result.TakeString();
3369 }
3370 assert(Kind == RK_Declaration && "Missed a result kind?")((void)0);
3371 return createCodeCompletionStringForDecl(
3372 PP, Ctx, Result, IncludeBriefComments, CCContext, Policy);
3373}
3374
3375static void printOverrideString(const CodeCompletionString &CCS,
3376 std::string &BeforeName,
3377 std::string &NameAndSignature) {
3378 bool SeenTypedChunk = false;
3379 for (auto &Chunk : CCS) {
3380 if (Chunk.Kind == CodeCompletionString::CK_Optional) {
3381 assert(SeenTypedChunk && "optional parameter before name")((void)0);
3382 // Note that we put all chunks inside into NameAndSignature.
3383 printOverrideString(*Chunk.Optional, NameAndSignature, NameAndSignature);
3384 continue;
3385 }
3386 SeenTypedChunk |= Chunk.Kind == CodeCompletionString::CK_TypedText;
3387 if (SeenTypedChunk)
3388 NameAndSignature += Chunk.Text;
3389 else
3390 BeforeName += Chunk.Text;
3391 }
3392}
3393
3394CodeCompletionString *
3395CodeCompletionResult::createCodeCompletionStringForOverride(
3396 Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result,
3397 bool IncludeBriefComments, const CodeCompletionContext &CCContext,
3398 PrintingPolicy &Policy) {
3399 auto *CCS = createCodeCompletionStringForDecl(PP, Ctx, Result,
3400 /*IncludeBriefComments=*/false,
3401 CCContext, Policy);
3402 std::string BeforeName;
3403 std::string NameAndSignature;
3404 // For overrides all chunks go into the result, none are informative.
3405 printOverrideString(*CCS, BeforeName, NameAndSignature);
3406 NameAndSignature += " override";
3407
3408 Result.AddTextChunk(Result.getAllocator().CopyString(BeforeName));
3409 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3410 Result.AddTypedTextChunk(Result.getAllocator().CopyString(NameAndSignature));
3411 return Result.TakeString();
3412}
3413
3414// FIXME: Right now this works well with lambdas. Add support for other functor
3415// types like std::function.
3416static const NamedDecl *extractFunctorCallOperator(const NamedDecl *ND) {
3417 const auto *VD = dyn_cast<VarDecl>(ND);
3418 if (!VD)
3419 return nullptr;
3420 const auto *RecordDecl = VD->getType()->getAsCXXRecordDecl();
3421 if (!RecordDecl || !RecordDecl->isLambda())
3422 return nullptr;
3423 return RecordDecl->getLambdaCallOperator();
3424}
3425
3426CodeCompletionString *CodeCompletionResult::createCodeCompletionStringForDecl(
3427 Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result,
3428 bool IncludeBriefComments, const CodeCompletionContext &CCContext,
3429 PrintingPolicy &Policy) {
3430 const NamedDecl *ND = Declaration;
3431 Result.addParentContext(ND->getDeclContext());
3432
3433 if (IncludeBriefComments) {
3434 // Add documentation comment, if it exists.
3435 if (const RawComment *RC = getCompletionComment(Ctx, Declaration)) {
3436 Result.addBriefComment(RC->getBriefText(Ctx));
3437 }
3438 }
3439
3440 if (StartsNestedNameSpecifier) {
3441 Result.AddTypedTextChunk(
3442 Result.getAllocator().CopyString(ND->getNameAsString()));
3443 Result.AddTextChunk("::");
3444 return Result.TakeString();
3445 }
3446
3447 for (const auto *I : ND->specific_attrs<AnnotateAttr>())
3448 Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation()));
3449
3450 auto AddFunctionTypeAndResult = [&](const FunctionDecl *Function) {
3451 AddResultTypeChunk(Ctx, Policy, Function, CCContext.getBaseType(), Result);
3452 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3453 Ctx, Policy);
3454 AddTypedNameChunk(Ctx, Policy, ND, Result);
3455 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3456 AddFunctionParameterChunks(PP, Policy, Function, Result);
3457 Result.AddChunk(CodeCompletionString::CK_RightParen);
3458 AddFunctionTypeQualsToCompletionString(Result, Function);
3459 };
3460
3461 if (const auto *Function = dyn_cast<FunctionDecl>(ND)) {
3462 AddFunctionTypeAndResult(Function);
3463 return Result.TakeString();
3464 }
3465
3466 if (const auto *CallOperator =
3467 dyn_cast_or_null<FunctionDecl>(extractFunctorCallOperator(ND))) {
3468 AddFunctionTypeAndResult(CallOperator);
3469 return Result.TakeString();
3470 }
3471
3472 AddResultTypeChunk(Ctx, Policy, ND, CCContext.getBaseType(), Result);
3473
3474 if (const FunctionTemplateDecl *FunTmpl =
3475 dyn_cast<FunctionTemplateDecl>(ND)) {
3476 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3477 Ctx, Policy);
3478 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
3479 AddTypedNameChunk(Ctx, Policy, Function, Result);
3480
3481 // Figure out which template parameters are deduced (or have default
3482 // arguments).
3483 llvm::SmallBitVector Deduced;
3484 Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
3485 unsigned LastDeducibleArgument;
3486 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
3487 --LastDeducibleArgument) {
3488 if (!Deduced[LastDeducibleArgument - 1]) {
3489 // C++0x: Figure out if the template argument has a default. If so,
3490 // the user doesn't need to type this argument.
3491 // FIXME: We need to abstract template parameters better!
3492 bool HasDefaultArg = false;
3493 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
3494 LastDeducibleArgument - 1);
3495 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
3496 HasDefaultArg = TTP->hasDefaultArgument();
3497 else if (NonTypeTemplateParmDecl *NTTP =
3498 dyn_cast<NonTypeTemplateParmDecl>(Param))
3499 HasDefaultArg = NTTP->hasDefaultArgument();
3500 else {
3501 assert(isa<TemplateTemplateParmDecl>(Param))((void)0);
3502 HasDefaultArg =
3503 cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
3504 }
3505
3506 if (!HasDefaultArg)
3507 break;
3508 }
3509 }
3510
3511 if (LastDeducibleArgument) {
3512 // Some of the function template arguments cannot be deduced from a
3513 // function call, so we introduce an explicit template argument list
3514 // containing all of the arguments up to the first deducible argument.
3515 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
3516 AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
3517 LastDeducibleArgument);
3518 Result.AddChunk(CodeCompletionString::CK_RightAngle);
3519 }
3520
3521 // Add the function parameters
3522 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3523 AddFunctionParameterChunks(PP, Policy, Function, Result);
3524 Result.AddChunk(CodeCompletionString::CK_RightParen);
3525 AddFunctionTypeQualsToCompletionString(Result, Function);
3526 return Result.TakeString();
3527 }
3528
3529 if (const auto *Template = dyn_cast<TemplateDecl>(ND)) {
3530 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3531 Ctx, Policy);
3532 Result.AddTypedTextChunk(
3533 Result.getAllocator().CopyString(Template->getNameAsString()));
3534 Result.AddChunk(CodeCompletionString::CK_LeftAngle);
3535 AddTemplateParameterChunks(Ctx, Policy, Template, Result);
3536 Result.AddChunk(CodeCompletionString::CK_RightAngle);
3537 return Result.TakeString();
3538 }
3539
3540 if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) {
3541 Selector Sel = Method->getSelector();
3542 if (Sel.isUnarySelector()) {
3543 Result.AddTypedTextChunk(
3544 Result.getAllocator().CopyString(Sel.getNameForSlot(0)));
3545 return Result.TakeString();
3546 }
3547
3548 std::string SelName = Sel.getNameForSlot(0).str();
3549 SelName += ':';
3550 if (StartParameter == 0)
3551 Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
3552 else {
3553 Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
3554
3555 // If there is only one parameter, and we're past it, add an empty
3556 // typed-text chunk since there is nothing to type.
3557 if (Method->param_size() == 1)
3558 Result.AddTypedTextChunk("");
3559 }
3560 unsigned Idx = 0;
3561 // The extra Idx < Sel.getNumArgs() check is needed due to legacy C-style
3562 // method parameters.
3563 for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(),
3564 PEnd = Method->param_end();
3565 P != PEnd && Idx < Sel.getNumArgs(); (void)++P, ++Idx) {
3566 if (Idx > 0) {
3567 std::string Keyword;
3568 if (Idx > StartParameter)
3569 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace);
3570 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
3571 Keyword += II->getName();
3572 Keyword += ":";
3573 if (Idx < StartParameter || AllParametersAreInformative)
3574 Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
3575 else
3576 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
3577 }
3578
3579 // If we're before the starting parameter, skip the placeholder.
3580 if (Idx < StartParameter)
3581 continue;
3582
3583 std::string Arg;
3584 QualType ParamType = (*P)->getType();
3585 Optional<ArrayRef<QualType>> ObjCSubsts;
3586 if (!CCContext.getBaseType().isNull())
3587 ObjCSubsts = CCContext.getBaseType()->getObjCSubstitutions(Method);
3588
3589 if (ParamType->isBlockPointerType() && !DeclaringEntity)
3590 Arg = FormatFunctionParameter(Policy, *P, true,
3591 /*SuppressBlock=*/false, ObjCSubsts);
3592 else {
3593 if (ObjCSubsts)
3594 ParamType = ParamType.substObjCTypeArgs(
3595 Ctx, *ObjCSubsts, ObjCSubstitutionContext::Parameter);
3596 Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(),
3597 ParamType);
3598 Arg += ParamType.getAsString(Policy) + ")";
3599 if (IdentifierInfo *II = (*P)->getIdentifier())
3600 if (DeclaringEntity || AllParametersAreInformative)
3601 Arg += II->getName();
3602 }
3603
3604 if (Method->isVariadic() && (P + 1) == PEnd)
3605 Arg += ", ...";
3606
3607 if (DeclaringEntity)
3608 Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
3609 else if (AllParametersAreInformative)
3610 Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
3611 else
3612 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
3613 }
3614
3615 if (Method->isVariadic()) {
3616 if (Method->param_size() == 0) {
3617 if (DeclaringEntity)
3618 Result.AddTextChunk(", ...");
3619 else if (AllParametersAreInformative)
3620 Result.AddInformativeChunk(", ...");
3621 else
3622 Result.AddPlaceholderChunk(", ...");
3623 }
3624
3625 MaybeAddSentinel(PP, Method, Result);
3626 }
3627
3628 return Result.TakeString();
3629 }
3630
3631 if (Qualifier)
3632 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3633 Ctx, Policy);
3634
3635 Result.AddTypedTextChunk(
3636 Result.getAllocator().CopyString(ND->getNameAsString()));
3637 return Result.TakeString();
3638}
3639
3640const RawComment *clang::getCompletionComment(const ASTContext &Ctx,
3641 const NamedDecl *ND) {
3642 if (!ND)
3643 return nullptr;
3644 if (auto *RC = Ctx.getRawCommentForAnyRedecl(ND))
3645 return RC;
3646
3647 // Try to find comment from a property for ObjC methods.
3648 const auto *M = dyn_cast<ObjCMethodDecl>(ND);
3649 if (!M)
3650 return nullptr;
3651 const ObjCPropertyDecl *PDecl = M->findPropertyDecl();
3652 if (!PDecl)
3653 return nullptr;
3654
3655 return Ctx.getRawCommentForAnyRedecl(PDecl);
3656}
3657
3658const RawComment *clang::getPatternCompletionComment(const ASTContext &Ctx,
3659 const NamedDecl *ND) {
3660 const auto *M = dyn_cast_or_null<ObjCMethodDecl>(ND);
3661 if (!M || !M->isPropertyAccessor())
3662 return nullptr;
3663
3664 // Provide code completion comment for self.GetterName where
3665 // GetterName is the getter method for a property with name
3666 // different from the property name (declared via a property
3667 // getter attribute.
3668 const ObjCPropertyDecl *PDecl = M->findPropertyDecl();
3669 if (!PDecl)
3670 return nullptr;
3671 if (PDecl->getGetterName() == M->getSelector() &&
3672 PDecl->getIdentifier() != M->getIdentifier()) {
3673 if (auto *RC = Ctx.getRawCommentForAnyRedecl(M))
3674 return RC;
3675 if (auto *RC = Ctx.getRawCommentForAnyRedecl(PDecl))
3676 return RC;
3677 }
3678 return nullptr;
3679}
3680
3681const RawComment *clang::getParameterComment(
3682 const ASTContext &Ctx,
3683 const CodeCompleteConsumer::OverloadCandidate &Result, unsigned ArgIndex) {
3684 auto FDecl = Result.getFunction();
3685 if (!FDecl)
3686 return nullptr;
3687 if (ArgIndex < FDecl->getNumParams())
3688 return Ctx.getRawCommentForAnyRedecl(FDecl->getParamDecl(ArgIndex));
3689 return nullptr;
3690}
3691
3692/// Add function overload parameter chunks to the given code completion
3693/// string.
3694static void AddOverloadParameterChunks(ASTContext &Context,
3695 const PrintingPolicy &Policy,
3696 const FunctionDecl *Function,
3697 const FunctionProtoType *Prototype,
3698 CodeCompletionBuilder &Result,
3699 unsigned CurrentArg, unsigned Start = 0,
3700 bool InOptional = false) {
3701 bool FirstParameter = true;
3702 unsigned NumParams =
3703 Function ? Function->getNumParams() : Prototype->getNumParams();
3704
3705 for (unsigned P = Start; P != NumParams; ++P) {
3706 if (Function && Function->getParamDecl(P)->hasDefaultArg() && !InOptional) {
3707 // When we see an optional default argument, put that argument and
3708 // the remaining default arguments into a new, optional string.
3709 CodeCompletionBuilder Opt(Result.getAllocator(),
3710 Result.getCodeCompletionTUInfo());
3711 if (!FirstParameter)
3712 Opt.AddChunk(CodeCompletionString::CK_Comma);
3713 // Optional sections are nested.
3714 AddOverloadParameterChunks(Context, Policy, Function, Prototype, Opt,
3715 CurrentArg, P, /*InOptional=*/true);
3716 Result.AddOptionalChunk(Opt.TakeString());
3717 return;
3718 }
3719
3720 if (FirstParameter)
3721 FirstParameter = false;
3722 else
3723 Result.AddChunk(CodeCompletionString::CK_Comma);
3724
3725 InOptional = false;
3726
3727 // Format the placeholder string.
3728 std::string Placeholder;
3729 if (Function) {
3730 const ParmVarDecl *Param = Function->getParamDecl(P);
3731 Placeholder = FormatFunctionParameter(Policy, Param);
3732 if (Param->hasDefaultArg())
3733 Placeholder += GetDefaultValueString(Param, Context.getSourceManager(),
3734 Context.getLangOpts());
3735 } else {
3736 Placeholder = Prototype->getParamType(P).getAsString(Policy);
3737 }
3738
3739 if (P == CurrentArg)
3740 Result.AddCurrentParameterChunk(
3741 Result.getAllocator().CopyString(Placeholder));
3742 else
3743 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Placeholder));
3744 }
3745
3746 if (Prototype && Prototype->isVariadic()) {
3747 CodeCompletionBuilder Opt(Result.getAllocator(),
3748 Result.getCodeCompletionTUInfo());
3749 if (!FirstParameter)
3750 Opt.AddChunk(CodeCompletionString::CK_Comma);
3751
3752 if (CurrentArg < NumParams)
3753 Opt.AddPlaceholderChunk("...");
3754 else
3755 Opt.AddCurrentParameterChunk("...");
3756
3757 Result.AddOptionalChunk(Opt.TakeString());
3758 }
3759}
3760
3761CodeCompletionString *
3762CodeCompleteConsumer::OverloadCandidate::CreateSignatureString(
3763 unsigned CurrentArg, Sema &S, CodeCompletionAllocator &Allocator,
3764 CodeCompletionTUInfo &CCTUInfo, bool IncludeBriefComments) const {
3765 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
3766 // Show signatures of constructors as they are declared:
3767 // vector(int n) rather than vector<string>(int n)
3768 // This is less noisy without being less clear, and avoids tricky cases.
3769 Policy.SuppressTemplateArgsInCXXConstructors = true;
3770
3771 // FIXME: Set priority, availability appropriately.
3772 CodeCompletionBuilder Result(Allocator, CCTUInfo, 1,
3773 CXAvailability_Available);
3774 FunctionDecl *FDecl = getFunction();
3775 const FunctionProtoType *Proto =
3776 dyn_cast<FunctionProtoType>(getFunctionType());
3777 if (!FDecl && !Proto) {
3778 // Function without a prototype. Just give the return type and a
3779 // highlighted ellipsis.
3780 const FunctionType *FT = getFunctionType();
3781 Result.AddResultTypeChunk(Result.getAllocator().CopyString(
3782 FT->getReturnType().getAsString(Policy)));
3783 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3784 Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "...");
3785 Result.AddChunk(CodeCompletionString::CK_RightParen);
3786 return Result.TakeString();
3787 }
3788
3789 if (FDecl) {
3790 if (IncludeBriefComments) {
3791 if (auto RC = getParameterComment(S.getASTContext(), *this, CurrentArg))
3792 Result.addBriefComment(RC->getBriefText(S.getASTContext()));
3793 }
3794 AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result);
3795
3796 std::string Name;
3797 llvm::raw_string_ostream OS(Name);
3798 FDecl->getDeclName().print(OS, Policy);
3799 Result.AddTextChunk(Result.getAllocator().CopyString(OS.str()));
3800 } else {
3801 Result.AddResultTypeChunk(Result.getAllocator().CopyString(
3802 Proto->getReturnType().getAsString(Policy)));
3803 }
3804
3805 Result.AddChunk(CodeCompletionString::CK_LeftParen);
3806 AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
3807 CurrentArg);
3808 Result.AddChunk(CodeCompletionString::CK_RightParen);
3809
3810 return Result.TakeString();
3811}
3812
3813unsigned clang::getMacroUsagePriority(StringRef MacroName,
3814 const LangOptions &LangOpts,
3815 bool PreferredTypeIsPointer) {
3816 unsigned Priority = CCP_Macro;
3817
3818 // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
3819 if (MacroName.equals("nil") || MacroName.equals("NULL") ||
3820 MacroName.equals("Nil")) {
3821 Priority = CCP_Constant;
3822 if (PreferredTypeIsPointer)
3823 Priority = Priority / CCF_SimilarTypeMatch;
3824 }
3825 // Treat "YES", "NO", "true", and "false" as constants.
3826 else if (MacroName.equals("YES") || MacroName.equals("NO") ||
3827 MacroName.equals("true") || MacroName.equals("false"))
3828 Priority = CCP_Constant;
3829 // Treat "bool" as a type.
3830 else if (MacroName.equals("bool"))
3831 Priority = CCP_Type + (LangOpts.ObjC ? CCD_bool_in_ObjC : 0);
3832
3833 return Priority;
3834}
3835
3836CXCursorKind clang::getCursorKindForDecl(const Decl *D) {
3837 if (!D)
3838 return CXCursor_UnexposedDecl;
3839
3840 switch (D->getKind()) {
3841 case Decl::Enum:
3842 return CXCursor_EnumDecl;
3843 case Decl::EnumConstant:
3844 return CXCursor_EnumConstantDecl;
3845 case Decl::Field:
3846 return CXCursor_FieldDecl;
3847 case Decl::Function:
3848 return CXCursor_FunctionDecl;
3849 case Decl::ObjCCategory:
3850 return CXCursor_ObjCCategoryDecl;
3851 case Decl::ObjCCategoryImpl:
3852 return CXCursor_ObjCCategoryImplDecl;
3853 case Decl::ObjCImplementation:
3854 return CXCursor_ObjCImplementationDecl;
3855
3856 case Decl::ObjCInterface:
3857 return CXCursor_ObjCInterfaceDecl;
3858 case Decl::ObjCIvar:
3859 return CXCursor_ObjCIvarDecl;
3860 case Decl::ObjCMethod:
3861 return cast<ObjCMethodDecl>(D)->isInstanceMethod()
3862 ? CXCursor_ObjCInstanceMethodDecl
3863 : CXCursor_ObjCClassMethodDecl;
3864 case Decl::CXXMethod:
3865 return CXCursor_CXXMethod;
3866 case Decl::CXXConstructor:
3867 return CXCursor_Constructor;
3868 case Decl::CXXDestructor:
3869 return CXCursor_Destructor;
3870 case Decl::CXXConversion:
3871 return CXCursor_ConversionFunction;
3872 case Decl::ObjCProperty:
3873 return CXCursor_ObjCPropertyDecl;
3874 case Decl::ObjCProtocol:
3875 return CXCursor_ObjCProtocolDecl;
3876 case Decl::ParmVar:
3877 return CXCursor_ParmDecl;
3878 case Decl::Typedef:
3879 return CXCursor_TypedefDecl;
3880 case Decl::TypeAlias:
3881 return CXCursor_TypeAliasDecl;
3882 case Decl::TypeAliasTemplate:
3883 return CXCursor_TypeAliasTemplateDecl;
3884 case Decl::Var:
3885 return CXCursor_VarDecl;
3886 case Decl::Namespace:
3887 return CXCursor_Namespace;
3888 case Decl::NamespaceAlias:
3889 return CXCursor_NamespaceAlias;
3890 case Decl::TemplateTypeParm:
3891 return CXCursor_TemplateTypeParameter;
3892 case Decl::NonTypeTemplateParm:
3893 return CXCursor_NonTypeTemplateParameter;
3894 case Decl::TemplateTemplateParm:
3895 return CXCursor_TemplateTemplateParameter;
3896 case Decl::FunctionTemplate:
3897 return CXCursor_FunctionTemplate;
3898 case Decl::ClassTemplate:
3899 return CXCursor_ClassTemplate;
3900 case Decl::AccessSpec:
3901 return CXCursor_CXXAccessSpecifier;
3902 case Decl::ClassTemplatePartialSpecialization:
3903 return CXCursor_ClassTemplatePartialSpecialization;
3904 case Decl::UsingDirective:
3905 return CXCursor_UsingDirective;
3906 case Decl::StaticAssert:
3907 return CXCursor_StaticAssert;
3908 case Decl::Friend:
3909 return CXCursor_FriendDecl;
3910 case Decl::TranslationUnit:
3911 return CXCursor_TranslationUnit;
3912
3913 case Decl::Using:
3914 case Decl::UnresolvedUsingValue:
3915 case Decl::UnresolvedUsingTypename:
3916 return CXCursor_UsingDeclaration;
3917
3918 case Decl::UsingEnum:
3919 return CXCursor_EnumDecl;
3920
3921 case Decl::ObjCPropertyImpl:
3922 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
3923 case ObjCPropertyImplDecl::Dynamic:
3924 return CXCursor_ObjCDynamicDecl;
3925
3926 case ObjCPropertyImplDecl::Synthesize:
3927 return CXCursor_ObjCSynthesizeDecl;
3928 }
3929 llvm_unreachable("Unexpected Kind!")__builtin_unreachable();
3930
3931 case Decl::Import:
3932 return CXCursor_ModuleImportDecl;
3933
3934 case Decl::ObjCTypeParam:
3935 return CXCursor_TemplateTypeParameter;
3936
3937 default:
3938 if (const auto *TD = dyn_cast<TagDecl>(D)) {
3939 switch (TD->getTagKind()) {
3940 case TTK_Interface: // fall through
3941 case TTK_Struct:
3942 return CXCursor_StructDecl;
3943 case TTK_Class:
3944 return CXCursor_ClassDecl;
3945 case TTK_Union:
3946 return CXCursor_UnionDecl;
3947 case TTK_Enum:
3948 return CXCursor_EnumDecl;
3949 }
3950 }
3951 }
3952
3953 return CXCursor_UnexposedDecl;
3954}
3955
3956static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
3957 bool LoadExternal, bool IncludeUndefined,
3958 bool TargetTypeIsPointer = false) {
3959 typedef CodeCompletionResult Result;
3960
3961 Results.EnterNewScope();
3962
3963 for (Preprocessor::macro_iterator M = PP.macro_begin(LoadExternal),
3964 MEnd = PP.macro_end(LoadExternal);
3965 M != MEnd; ++M) {
3966 auto MD = PP.getMacroDefinition(M->first);
3967 if (IncludeUndefined || MD) {
3968 MacroInfo *MI = MD.getMacroInfo();
3969 if (MI && MI->isUsedForHeaderGuard())
3970 continue;
3971
3972 Results.AddResult(
3973 Result(M->first, MI,
3974 getMacroUsagePriority(M->first->getName(), PP.getLangOpts(),
3975 TargetTypeIsPointer)));
3976 }
3977 }
3978
3979 Results.ExitScope();
3980}
3981
3982static void AddPrettyFunctionResults(const LangOptions &LangOpts,
3983 ResultBuilder &Results) {
3984 typedef CodeCompletionResult Result;
3985
3986 Results.EnterNewScope();
3987
3988 Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
3989 Results.AddResult(Result("__FUNCTION__", CCP_Constant));
3990 if (LangOpts.C99 || LangOpts.CPlusPlus11)
3991 Results.AddResult(Result("__func__", CCP_Constant));
3992 Results.ExitScope();
3993}
3994
3995static void HandleCodeCompleteResults(Sema *S,
3996 CodeCompleteConsumer *CodeCompleter,
3997 CodeCompletionContext Context,
3998 CodeCompletionResult *Results,
3999 unsigned NumResults) {
4000 if (CodeCompleter)
4001 CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
4002}
4003
4004static CodeCompletionContext
4005mapCodeCompletionContext(Sema &S, Sema::ParserCompletionContext PCC) {
4006 switch (PCC) {
4007 case Sema::PCC_Namespace:
4008 return CodeCompletionContext::CCC_TopLevel;
4009
4010 case Sema::PCC_Class:
4011 return CodeCompletionContext::CCC_ClassStructUnion;
4012
4013 case Sema::PCC_ObjCInterface:
4014 return CodeCompletionContext::CCC_ObjCInterface;
4015
4016 case Sema::PCC_ObjCImplementation:
4017 return CodeCompletionContext::CCC_ObjCImplementation;
4018
4019 case Sema::PCC_ObjCInstanceVariableList:
4020 return CodeCompletionContext::CCC_ObjCIvarList;
4021
4022 case Sema::PCC_Template:
4023 case Sema::PCC_MemberTemplate:
4024 if (S.CurContext->isFileContext())
4025 return CodeCompletionContext::CCC_TopLevel;
4026 if (S.CurContext->isRecord())
4027 return CodeCompletionContext::CCC_ClassStructUnion;
4028 return CodeCompletionContext::CCC_Other;
4029
4030 case Sema::PCC_RecoveryInFunction:
4031 return CodeCompletionContext::CCC_Recovery;
4032
4033 case Sema::PCC_ForInit:
4034 if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
4035 S.getLangOpts().ObjC)
4036 return CodeCompletionContext::CCC_ParenthesizedExpression;
4037 else
4038 return CodeCompletionContext::CCC_Expression;
4039
4040 case Sema::PCC_Expression:
4041 return CodeCompletionContext::CCC_Expression;
4042 case Sema::PCC_Condition:
4043 return CodeCompletionContext(CodeCompletionContext::CCC_Expression,
4044 S.getASTContext().BoolTy);
4045
4046 case Sema::PCC_Statement:
4047 return CodeCompletionContext::CCC_Statement;
4048
4049 case Sema::PCC_Type:
4050 return CodeCompletionContext::CCC_Type;
4051
4052 case Sema::PCC_ParenthesizedExpression:
4053 return CodeCompletionContext::CCC_ParenthesizedExpression;
4054
4055 case Sema::PCC_LocalDeclarationSpecifiers:
4056 return CodeCompletionContext::CCC_Type;
4057 }
4058
4059 llvm_unreachable("Invalid ParserCompletionContext!")__builtin_unreachable();
4060}
4061
4062/// If we're in a C++ virtual member function, add completion results
4063/// that invoke the functions we override, since it's common to invoke the
4064/// overridden function as well as adding new functionality.
4065///
4066/// \param S The semantic analysis object for which we are generating results.
4067///
4068/// \param InContext This context in which the nested-name-specifier preceding
4069/// the code-completion point
4070static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
4071 ResultBuilder &Results) {
4072 // Look through blocks.
4073 DeclContext *CurContext = S.CurContext;
4074 while (isa<BlockDecl>(CurContext))
4075 CurContext = CurContext->getParent();
4076
4077 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
4078 if (!Method || !Method->isVirtual())
4079 return;
4080
4081 // We need to have names for all of the parameters, if we're going to
4082 // generate a forwarding call.
4083 for (auto P : Method->parameters())
4084 if (!P->getDeclName())
4085 return;
4086
4087 PrintingPolicy Policy = getCompletionPrintingPolicy(S);
4088 for (const CXXMethodDecl *Overridden : Method->overridden_methods()) {
4089 CodeCompletionBuilder Builder(Results.getAllocator(),
4090 Results.getCodeCompletionTUInfo());
4091 if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
4092 continue;
4093
4094 // If we need a nested-name-specifier, add one now.
4095 if (!InContext) {
4096 NestedNameSpecifier *NNS = getRequiredQualification(
4097 S.Context, CurContext, Overridden->getDeclContext());
4098 if (NNS) {
4099 std::string Str;
4100 llvm::raw_string_ostream OS(Str);
4101 NNS->print(OS, Policy);
4102 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
4103 }
4104 } else if (!InContext->Equals(Overridden->getDeclContext()))
4105 continue;
4106
4107 Builder.AddTypedTextChunk(
4108 Results.getAllocator().CopyString(Overridden->getNameAsString()));
4109 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4110 bool FirstParam = true;
4111 for (auto P : Method->parameters()) {
4112 if (FirstParam)
4113 FirstParam = false;
4114 else
4115 Builder.AddChunk(CodeCompletionString::CK_Comma);
4116
4117 Builder.AddPlaceholderChunk(
4118 Results.getAllocator().CopyString(P->getIdentifier()->getName()));
4119 }
4120 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4121 Results.AddResult(CodeCompletionResult(
4122 Builder.TakeString(), CCP_SuperCompletion, CXCursor_CXXMethod,
4123 CXAvailability_Available, Overridden));
4124 Results.Ignore(Overridden);
4125 }
4126}
4127
4128void Sema::CodeCompleteModuleImport(SourceLocation ImportLoc,
4129 ModuleIdPath Path) {
4130 typedef CodeCompletionResult Result;
4131 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4132 CodeCompleter->getCodeCompletionTUInfo(),
4133 CodeCompletionContext::CCC_Other);
4134 Results.EnterNewScope();
4135
4136 CodeCompletionAllocator &Allocator = Results.getAllocator();
4137 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
4138 typedef CodeCompletionResult Result;
4139 if (Path.empty()) {
4140 // Enumerate all top-level modules.
4141 SmallVector<Module *, 8> Modules;
4142 PP.getHeaderSearchInfo().collectAllModules(Modules);
4143 for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
4144 Builder.AddTypedTextChunk(
4145 Builder.getAllocator().CopyString(Modules[I]->Name));
4146 Results.AddResult(Result(
4147 Builder.TakeString(), CCP_Declaration, CXCursor_ModuleImportDecl,
4148 Modules[I]->isAvailable() ? CXAvailability_Available
4149 : CXAvailability_NotAvailable));
4150 }
4151 } else if (getLangOpts().Modules) {
4152 // Load the named module.
4153 Module *Mod =
4154 PP.getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible,
4155 /*IsInclusionDirective=*/false);
4156 // Enumerate submodules.
4157 if (Mod) {
4158 for (Module::submodule_iterator Sub = Mod->submodule_begin(),
4159 SubEnd = Mod->submodule_end();
4160 Sub != SubEnd; ++Sub) {
4161
4162 Builder.AddTypedTextChunk(
4163 Builder.getAllocator().CopyString((*Sub)->Name));
4164 Results.AddResult(Result(
4165 Builder.TakeString(), CCP_Declaration, CXCursor_ModuleImportDecl,
4166 (*Sub)->isAvailable() ? CXAvailability_Available
4167 : CXAvailability_NotAvailable));
4168 }
4169 }
4170 }
4171 Results.ExitScope();
4172 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4173 Results.data(), Results.size());
4174}
4175
4176void Sema::CodeCompleteOrdinaryName(Scope *S,
4177 ParserCompletionContext CompletionContext) {
4178 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4179 CodeCompleter->getCodeCompletionTUInfo(),
4180 mapCodeCompletionContext(*this, CompletionContext));
4181 Results.EnterNewScope();
4182
4183 // Determine how to filter results, e.g., so that the names of
4184 // values (functions, enumerators, function templates, etc.) are
4185 // only allowed where we can have an expression.
4186 switch (CompletionContext) {
4187 case PCC_Namespace:
4188 case PCC_Class:
4189 case PCC_ObjCInterface:
4190 case PCC_ObjCImplementation:
4191 case PCC_ObjCInstanceVariableList:
4192 case PCC_Template:
4193 case PCC_MemberTemplate:
4194 case PCC_Type:
4195 case PCC_LocalDeclarationSpecifiers:
4196 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
4197 break;
4198
4199 case PCC_Statement:
4200 case PCC_ParenthesizedExpression:
4201 case PCC_Expression:
4202 case PCC_ForInit:
4203 case PCC_Condition:
4204 if (WantTypesInContext(CompletionContext, getLangOpts()))
4205 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4206 else
4207 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
4208
4209 if (getLangOpts().CPlusPlus)
4210 MaybeAddOverrideCalls(*this, /*InContext=*/nullptr, Results);
4211 break;
4212
4213 case PCC_RecoveryInFunction:
4214 // Unfiltered
4215 break;
4216 }
4217
4218 // If we are in a C++ non-static member function, check the qualifiers on
4219 // the member function to filter/prioritize the results list.
4220 auto ThisType = getCurrentThisType();
4221 if (!ThisType.isNull())
4222 Results.setObjectTypeQualifiers(ThisType->getPointeeType().getQualifiers(),
4223 VK_LValue);
4224
4225 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4226 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4227 CodeCompleter->includeGlobals(),
4228 CodeCompleter->loadExternal());
4229
4230 AddOrdinaryNameResults(CompletionContext, S, *this, Results);
4231 Results.ExitScope();
4232
4233 switch (CompletionContext) {
4234 case PCC_ParenthesizedExpression:
4235 case PCC_Expression:
4236 case PCC_Statement:
4237 case PCC_RecoveryInFunction:
4238 if (S->getFnParent())
4239 AddPrettyFunctionResults(getLangOpts(), Results);
4240 break;
4241
4242 case PCC_Namespace:
4243 case PCC_Class:
4244 case PCC_ObjCInterface:
4245 case PCC_ObjCImplementation:
4246 case PCC_ObjCInstanceVariableList:
4247 case PCC_Template:
4248 case PCC_MemberTemplate:
4249 case PCC_ForInit:
4250 case PCC_Condition:
4251 case PCC_Type:
4252 case PCC_LocalDeclarationSpecifiers:
4253 break;
4254 }
4255
4256 if (CodeCompleter->includeMacros())
4257 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
4258
4259 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4260 Results.data(), Results.size());
4261}
4262
4263static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
4264 ParsedType Receiver,
4265 ArrayRef<IdentifierInfo *> SelIdents,
4266 bool AtArgumentExpression, bool IsSuper,
4267 ResultBuilder &Results);
4268
4269void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
4270 bool AllowNonIdentifiers,
4271 bool AllowNestedNameSpecifiers) {
4272 typedef CodeCompletionResult Result;
4273 ResultBuilder Results(
4274 *this, CodeCompleter->getAllocator(),
4275 CodeCompleter->getCodeCompletionTUInfo(),
4276 AllowNestedNameSpecifiers
4277 // FIXME: Try to separate codepath leading here to deduce whether we
4278 // need an existing symbol or a new one.
4279 ? CodeCompletionContext::CCC_SymbolOrNewName
4280 : CodeCompletionContext::CCC_NewName);
4281 Results.EnterNewScope();
4282
4283 // Type qualifiers can come after names.
4284 Results.AddResult(Result("const"));
4285 Results.AddResult(Result("volatile"));
4286 if (getLangOpts().C99)
4287 Results.AddResult(Result("restrict"));
4288
4289 if (getLangOpts().CPlusPlus) {
4290 if (getLangOpts().CPlusPlus11 &&
4291 (DS.getTypeSpecType() == DeclSpec::TST_class ||
4292 DS.getTypeSpecType() == DeclSpec::TST_struct))
4293 Results.AddResult("final");
4294
4295 if (AllowNonIdentifiers) {
4296 Results.AddResult(Result("operator"));
4297 }
4298
4299 // Add nested-name-specifiers.
4300 if (AllowNestedNameSpecifiers) {
4301 Results.allowNestedNameSpecifiers();
4302 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
4303 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4304 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
4305 CodeCompleter->includeGlobals(),
4306 CodeCompleter->loadExternal());
4307 Results.setFilter(nullptr);
4308 }
4309 }
4310 Results.ExitScope();
4311
4312 // If we're in a context where we might have an expression (rather than a
4313 // declaration), and what we've seen so far is an Objective-C type that could
4314 // be a receiver of a class message, this may be a class message send with
4315 // the initial opening bracket '[' missing. Add appropriate completions.
4316 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
4317 DS.getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier &&
4318 DS.getTypeSpecType() == DeclSpec::TST_typename &&
4319 DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified &&
4320 DS.getTypeSpecSign() == TypeSpecifierSign::Unspecified &&
4321 !DS.isTypeAltiVecVector() && S &&
4322 (S->getFlags() & Scope::DeclScope) != 0 &&
4323 (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope |
4324 Scope::FunctionPrototypeScope | Scope::AtCatchScope)) ==
4325 0) {
4326 ParsedType T = DS.getRepAsType();
4327 if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
4328 AddClassMessageCompletions(*this, S, T, None, false, false, Results);
4329 }
4330
4331 // Note that we intentionally suppress macro results here, since we do not
4332 // encourage using macros to produce the names of entities.
4333
4334 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4335 Results.data(), Results.size());
4336}
4337
4338struct Sema::CodeCompleteExpressionData {
4339 CodeCompleteExpressionData(QualType PreferredType = QualType(),
4340 bool IsParenthesized = false)
4341 : PreferredType(PreferredType), IntegralConstantExpression(false),
4342 ObjCCollection(false), IsParenthesized(IsParenthesized) {}
4343
4344 QualType PreferredType;
4345 bool IntegralConstantExpression;
4346 bool ObjCCollection;
4347 bool IsParenthesized;
4348 SmallVector<Decl *, 4> IgnoreDecls;
4349};
4350
4351namespace {
4352/// Information that allows to avoid completing redundant enumerators.
4353struct CoveredEnumerators {
4354 llvm::SmallPtrSet<EnumConstantDecl *, 8> Seen;
4355 NestedNameSpecifier *SuggestedQualifier = nullptr;
4356};
4357} // namespace
4358
4359static void AddEnumerators(ResultBuilder &Results, ASTContext &Context,
4360 EnumDecl *Enum, DeclContext *CurContext,
4361 const CoveredEnumerators &Enumerators) {
4362 NestedNameSpecifier *Qualifier = Enumerators.SuggestedQualifier;
4363 if (Context.getLangOpts().CPlusPlus && !Qualifier && Enumerators.Seen.empty()) {
4364 // If there are no prior enumerators in C++, check whether we have to
4365 // qualify the names of the enumerators that we suggest, because they
4366 // may not be visible in this scope.
4367 Qualifier = getRequiredQualification(Context, CurContext, Enum);
4368 }
4369
4370 Results.EnterNewScope();
4371 for (auto *E : Enum->enumerators()) {
4372 if (Enumerators.Seen.count(E))
4373 continue;
4374
4375 CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);
4376 Results.AddResult(R, CurContext, nullptr, false);
4377 }
4378 Results.ExitScope();
4379}
4380
4381/// Try to find a corresponding FunctionProtoType for function-like types (e.g.
4382/// function pointers, std::function, etc).
4383static const FunctionProtoType *TryDeconstructFunctionLike(QualType T) {
4384 assert(!T.isNull())((void)0);
4385 // Try to extract first template argument from std::function<> and similar.
4386 // Note we only handle the sugared types, they closely match what users wrote.
4387 // We explicitly choose to not handle ClassTemplateSpecializationDecl.
4388 if (auto *Specialization = T->getAs<TemplateSpecializationType>()) {
4389 if (Specialization->getNumArgs() != 1)
4390 return nullptr;
4391 const TemplateArgument &Argument = Specialization->getArg(0);
4392 if (Argument.getKind() != TemplateArgument::Type)
4393 return nullptr;
4394 return Argument.getAsType()->getAs<FunctionProtoType>();
4395 }
4396 // Handle other cases.
4397 if (T->isPointerType())
4398 T = T->getPointeeType();
4399 return T->getAs<FunctionProtoType>();
4400}
4401
4402/// Adds a pattern completion for a lambda expression with the specified
4403/// parameter types and placeholders for parameter names.
4404static void AddLambdaCompletion(ResultBuilder &Results,
4405 llvm::ArrayRef<QualType> Parameters,
4406 const LangOptions &LangOpts) {
4407 if (!Results.includeCodePatterns())
4408 return;
4409 CodeCompletionBuilder Completion(Results.getAllocator(),
4410 Results.getCodeCompletionTUInfo());
4411 // [](<parameters>) {}
4412 Completion.AddChunk(CodeCompletionString::CK_LeftBracket);
4413 Completion.AddPlaceholderChunk("=");
4414 Completion.AddChunk(CodeCompletionString::CK_RightBracket);
4415 if (!Parameters.empty()) {
4416 Completion.AddChunk(CodeCompletionString::CK_LeftParen);
4417 bool First = true;
4418 for (auto Parameter : Parameters) {
4419 if (!First)
4420 Completion.AddChunk(CodeCompletionString::ChunkKind::CK_Comma);
4421 else
4422 First = false;
4423
4424 constexpr llvm::StringLiteral NamePlaceholder = "!#!NAME_GOES_HERE!#!";
4425 std::string Type = std::string(NamePlaceholder);
4426 Parameter.getAsStringInternal(Type, PrintingPolicy(LangOpts));
4427 llvm::StringRef Prefix, Suffix;
4428 std::tie(Prefix, Suffix) = llvm::StringRef(Type).split(NamePlaceholder);
4429 Prefix = Prefix.rtrim();
4430 Suffix = Suffix.ltrim();
4431
4432 Completion.AddTextChunk(Completion.getAllocator().CopyString(Prefix));
4433 Completion.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4434 Completion.AddPlaceholderChunk("parameter");
4435 Completion.AddTextChunk(Completion.getAllocator().CopyString(Suffix));
4436 };
4437 Completion.AddChunk(CodeCompletionString::CK_RightParen);
4438 }
4439 Completion.AddChunk(clang::CodeCompletionString::CK_HorizontalSpace);
4440 Completion.AddChunk(CodeCompletionString::CK_LeftBrace);
4441 Completion.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4442 Completion.AddPlaceholderChunk("body");
4443 Completion.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4444 Completion.AddChunk(CodeCompletionString::CK_RightBrace);
4445
4446 Results.AddResult(Completion.TakeString());
4447}
4448
4449/// Perform code-completion in an expression context when we know what
4450/// type we're looking for.
4451void Sema::CodeCompleteExpression(Scope *S,
4452 const CodeCompleteExpressionData &Data) {
4453 ResultBuilder Results(
4454 *this, CodeCompleter->getAllocator(),
4455 CodeCompleter->getCodeCompletionTUInfo(),
4456 CodeCompletionContext(
4457 Data.IsParenthesized
4458 ? CodeCompletionContext::CCC_ParenthesizedExpression
4459 : CodeCompletionContext::CCC_Expression,
4460 Data.PreferredType));
4461 auto PCC =
4462 Data.IsParenthesized ? PCC_ParenthesizedExpression : PCC_Expression;
4463 if (Data.ObjCCollection)
4464 Results.setFilter(&ResultBuilder::IsObjCCollection);
4465 else if (Data.IntegralConstantExpression)
4466 Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
4467 else if (WantTypesInContext(PCC, getLangOpts()))
4468 Results.setFilter(&ResultBuilder::IsOrdinaryName);
4469 else
4470 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
4471
4472 if (!Data.PreferredType.isNull())
4473 Results.setPreferredType(Data.PreferredType.getNonReferenceType());
4474
4475 // Ignore any declarations that we were told that we don't care about.
4476 for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
4477 Results.Ignore(Data.IgnoreDecls[I]);
4478
4479 CodeCompletionDeclConsumer Consumer(Results, CurContext);
4480 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4481 CodeCompleter->includeGlobals(),
4482 CodeCompleter->loadExternal());
4483
4484 Results.EnterNewScope();
4485 AddOrdinaryNameResults(PCC, S, *this, Results);
4486 Results.ExitScope();
4487
4488 bool PreferredTypeIsPointer = false;
4489 if (!Data.PreferredType.isNull()) {
4490 PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType() ||
4491 Data.PreferredType->isMemberPointerType() ||
4492 Data.PreferredType->isBlockPointerType();
4493 if (Data.PreferredType->isEnumeralType()) {
4494 EnumDecl *Enum = Data.PreferredType->castAs<EnumType>()->getDecl();
4495 if (auto *Def = Enum->getDefinition())
4496 Enum = Def;
4497 // FIXME: collect covered enumerators in cases like:
4498 // if (x == my_enum::one) { ... } else if (x == ^) {}
4499 AddEnumerators(Results, Context, Enum, CurContext, CoveredEnumerators());
4500 }
4501 }
4502
4503 if (S->getFnParent() && !Data.ObjCCollection &&
4504 !Data.IntegralConstantExpression)
4505 AddPrettyFunctionResults(getLangOpts(), Results);
4506
4507 if (CodeCompleter->includeMacros())
4508 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false,
4509 PreferredTypeIsPointer);
4510
4511 // Complete a lambda expression when preferred type is a function.
4512 if (!Data.PreferredType.isNull() && getLangOpts().CPlusPlus11) {
4513 if (const FunctionProtoType *F =
4514 TryDeconstructFunctionLike(Data.PreferredType))
4515 AddLambdaCompletion(Results, F->getParamTypes(), getLangOpts());
4516 }
4517
4518 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4519 Results.data(), Results.size());
4520}
4521
4522void Sema::CodeCompleteExpression(Scope *S, QualType PreferredType,
4523 bool IsParenthesized) {
4524 return CodeCompleteExpression(
4525 S, CodeCompleteExpressionData(PreferredType, IsParenthesized));
4526}
4527
4528void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E,
4529 QualType PreferredType) {
4530 if (E.isInvalid())
4531 CodeCompleteExpression(S, PreferredType);
4532 else if (getLangOpts().ObjC)
4533 CodeCompleteObjCInstanceMessage(S, E.get(), None, false);
4534}
4535
4536/// The set of properties that have already been added, referenced by
4537/// property name.
4538typedef llvm::SmallPtrSet<IdentifierInfo *, 16> AddedPropertiesSet;
4539
4540/// Retrieve the container definition, if any?
4541static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) {
4542 if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
4543 if (Interface->hasDefinition())
4544 return Interface->getDefinition();
4545
4546 return Interface;
4547 }
4548
4549 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
4550 if (Protocol->hasDefinition())
4551 return Protocol->getDefinition();
4552
4553 return Protocol;
4554 }
4555 return Container;
4556}
4557
4558/// Adds a block invocation code completion result for the given block
4559/// declaration \p BD.
4560static void AddObjCBlockCall(ASTContext &Context, const PrintingPolicy &Policy,
4561 CodeCompletionBuilder &Builder,
4562 const NamedDecl *BD,
4563 const FunctionTypeLoc &BlockLoc,
4564 const FunctionProtoTypeLoc &BlockProtoLoc) {
4565 Builder.AddResultTypeChunk(
4566 GetCompletionTypeString(BlockLoc.getReturnLoc().getType(), Context,
4567 Policy, Builder.getAllocator()));
4568
4569 AddTypedNameChunk(Context, Policy, BD, Builder);
4570 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4571
4572 if (BlockProtoLoc && BlockProtoLoc.getTypePtr()->isVariadic()) {
4573 Builder.AddPlaceholderChunk("...");
4574 } else {
4575 for (unsigned I = 0, N = BlockLoc.getNumParams(); I != N; ++I) {
4576 if (I)
4577 Builder.AddChunk(CodeCompletionString::CK_Comma);
4578
4579 // Format the placeholder string.
4580 std::string PlaceholderStr =
4581 FormatFunctionParameter(Policy, BlockLoc.getParam(I));
4582
4583 if (I == N - 1 && BlockProtoLoc &&
4584 BlockProtoLoc.getTypePtr()->isVariadic())
4585 PlaceholderStr += ", ...";
4586
4587 // Add the placeholder string.
4588 Builder.AddPlaceholderChunk(
4589 Builder.getAllocator().CopyString(PlaceholderStr));
4590 }
4591 }
4592
4593 Builder.AddChunk(CodeCompletionString::CK_RightParen);
4594}
4595
4596static void
4597AddObjCProperties(const CodeCompletionContext &CCContext,
4598 ObjCContainerDecl *Container, bool AllowCategories,
4599 bool AllowNullaryMethods, DeclContext *CurContext,
4600 AddedPropertiesSet &AddedProperties, ResultBuilder &Results,
4601 bool IsBaseExprStatement = false,
4602 bool IsClassProperty = false, bool InOriginalClass = true) {
4603 typedef CodeCompletionResult Result;
4604
4605 // Retrieve the definition.
4606 Container = getContainerDef(Container);
4607
4608 // Add properties in this container.
4609 const auto AddProperty = [&](const ObjCPropertyDecl *P) {
4610 if (!AddedProperties.insert(P->getIdentifier()).second)
4611 return;
4612
4613 // FIXME: Provide block invocation completion for non-statement
4614 // expressions.
4615 if (!P->getType().getTypePtr()->isBlockPointerType() ||
4616 !IsBaseExprStatement) {
4617 Result R = Result(P, Results.getBasePriority(P), nullptr);
4618 if (!InOriginalClass)
4619 setInBaseClass(R);
4620 Results.MaybeAddResult(R, CurContext);
4621 return;
4622 }
4623
4624 // Block setter and invocation completion is provided only when we are able
4625 // to find the FunctionProtoTypeLoc with parameter names for the block.
4626 FunctionTypeLoc BlockLoc;
4627 FunctionProtoTypeLoc BlockProtoLoc;
4628 findTypeLocationForBlockDecl(P->getTypeSourceInfo(), BlockLoc,
4629 BlockProtoLoc);
4630 if (!BlockLoc) {
4631 Result R = Result(P, Results.getBasePriority(P), nullptr);
4632 if (!InOriginalClass)
4633 setInBaseClass(R);
4634 Results.MaybeAddResult(R, CurContext);
4635 return;
4636 }
4637
4638 // The default completion result for block properties should be the block
4639 // invocation completion when the base expression is a statement.
4640 CodeCompletionBuilder Builder(Results.getAllocator(),
4641 Results.getCodeCompletionTUInfo());
4642 AddObjCBlockCall(Container->getASTContext(),
4643 getCompletionPrintingPolicy(Results.getSema()), Builder, P,
4644 BlockLoc, BlockProtoLoc);
4645 Result R = Result(Builder.TakeString(), P, Results.getBasePriority(P));
4646 if (!InOriginalClass)
4647 setInBaseClass(R);
4648 Results.MaybeAddResult(R, CurContext);
4649
4650 // Provide additional block setter completion iff the base expression is a
4651 // statement and the block property is mutable.
4652 if (!P->isReadOnly()) {
4653 CodeCompletionBuilder Builder(Results.getAllocator(),
4654 Results.getCodeCompletionTUInfo());
4655 AddResultTypeChunk(Container->getASTContext(),
4656 getCompletionPrintingPolicy(Results.getSema()), P,
4657 CCContext.getBaseType(), Builder);
4658 Builder.AddTypedTextChunk(
4659 Results.getAllocator().CopyString(P->getName()));
4660 Builder.AddChunk(CodeCompletionString::CK_Equal);
4661
4662 std::string PlaceholderStr = formatBlockPlaceholder(
4663 getCompletionPrintingPolicy(Results.getSema()), P, BlockLoc,
4664 BlockProtoLoc, /*SuppressBlockName=*/true);
4665 // Add the placeholder string.
4666 Builder.AddPlaceholderChunk(
4667 Builder.getAllocator().CopyString(PlaceholderStr));
4668
4669 // When completing blocks properties that return void the default
4670 // property completion result should show up before the setter,
4671 // otherwise the setter completion should show up before the default
4672 // property completion, as we normally want to use the result of the
4673 // call.
4674 Result R =
4675 Result(Builder.TakeString(), P,
4676 Results.getBasePriority(P) +
4677 (BlockLoc.getTypePtr()->getReturnType()->isVoidType()
4678 ? CCD_BlockPropertySetter
4679 : -CCD_BlockPropertySetter));
4680 if (!InOriginalClass)
4681 setInBaseClass(R);
4682 Results.MaybeAddResult(R, CurContext);
4683 }
4684 };
4685
4686 if (IsClassProperty) {
4687 for (const auto *P : Container->class_properties())
4688 AddProperty(P);
4689 } else {
4690 for (const auto *P : Container->instance_properties())
4691 AddProperty(P);
4692 }
4693
4694 // Add nullary methods or implicit class properties
4695 if (AllowNullaryMethods) {
4696 ASTContext &Context = Container->getASTContext();
4697 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
4698 // Adds a method result
4699 const auto AddMethod = [&](const ObjCMethodDecl *M) {
4700 IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0);
4701 if (!Name)
4702 return;
4703 if (!AddedProperties.insert(Name).second)
4704 return;
4705 CodeCompletionBuilder Builder(Results.getAllocator(),
4706 Results.getCodeCompletionTUInfo());
4707 AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(), Builder);
4708 Builder.AddTypedTextChunk(
4709 Results.getAllocator().CopyString(Name->getName()));
4710 Result R = Result(Builder.TakeString(), M,
4711 CCP_MemberDeclaration + CCD_MethodAsProperty);
4712 if (!InOriginalClass)
4713 setInBaseClass(R);
4714 Results.MaybeAddResult(R, CurContext);
4715 };
4716
4717 if (IsClassProperty) {
4718 for (const auto *M : Container->methods()) {
4719 // Gather the class method that can be used as implicit property
4720 // getters. Methods with arguments or methods that return void aren't
4721 // added to the results as they can't be used as a getter.
4722 if (!M->getSelector().isUnarySelector() ||
4723 M->getReturnType()->isVoidType() || M->isInstanceMethod())
4724 continue;
4725 AddMethod(M);
4726 }
4727 } else {
4728 for (auto *M : Container->methods()) {
4729 if (M->getSelector().isUnarySelector())
4730 AddMethod(M);
4731 }
4732 }
4733 }
4734
4735 // Add properties in referenced protocols.
4736 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
4737 for (auto *P : Protocol->protocols())
4738 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
4739 CurContext, AddedProperties, Results,
4740 IsBaseExprStatement, IsClassProperty,
4741 /*InOriginalClass*/ false);
4742 } else if (ObjCInterfaceDecl *IFace =
4743 dyn_cast<ObjCInterfaceDecl>(Container)) {
4744 if (AllowCategories) {
4745 // Look through categories.
4746 for (auto *Cat : IFace->known_categories())
4747 AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods,
4748 CurContext, AddedProperties, Results,
4749 IsBaseExprStatement, IsClassProperty,
4750 InOriginalClass);
4751 }
4752
4753 // Look through protocols.
4754 for (auto *I : IFace->all_referenced_protocols())
4755 AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods,
4756 CurContext, AddedProperties, Results,
4757 IsBaseExprStatement, IsClassProperty,
4758 /*InOriginalClass*/ false);
4759
4760 // Look in the superclass.
4761 if (IFace->getSuperClass())
4762 AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories,
4763 AllowNullaryMethods, CurContext, AddedProperties,
4764 Results, IsBaseExprStatement, IsClassProperty,
4765 /*InOriginalClass*/ false);
4766 } else if (const auto *Category =
4767 dyn_cast<ObjCCategoryDecl>(Container)) {
4768 // Look through protocols.
4769 for (auto *P : Category->protocols())
4770 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
4771 CurContext, AddedProperties, Results,
4772 IsBaseExprStatement, IsClassProperty,
4773 /*InOriginalClass*/ false);
4774 }
4775}
4776
4777static void AddRecordMembersCompletionResults(
4778 Sema &SemaRef, ResultBuilder &Results, Scope *S, QualType BaseType,
4779 ExprValueKind BaseKind, RecordDecl *RD, Optional<FixItHint> AccessOpFixIt) {
4780 // Indicate that we are performing a member access, and the cv-qualifiers
4781 // for the base object type.
4782 Results.setObjectTypeQualifiers(BaseType.getQualifiers(), BaseKind);
4783
4784 // Access to a C/C++ class, struct, or union.
4785 Results.allowNestedNameSpecifiers();
4786 std::vector<FixItHint> FixIts;
4787 if (AccessOpFixIt)
4788 FixIts.emplace_back(AccessOpFixIt.getValue());
4789 CodeCompletionDeclConsumer Consumer(Results, RD, BaseType, std::move(FixIts));
4790 SemaRef.LookupVisibleDecls(RD, Sema::LookupMemberName, Consumer,
4791 SemaRef.CodeCompleter->includeGlobals(),
4792 /*IncludeDependentBases=*/true,
4793 SemaRef.CodeCompleter->loadExternal());
4794
4795 if (SemaRef.getLangOpts().CPlusPlus) {
4796 if (!Results.empty()) {
4797 // The "template" keyword can follow "->" or "." in the grammar.
4798 // However, we only want to suggest the template keyword if something
4799 // is dependent.
4800 bool IsDependent = BaseType->isDependentType();
4801 if (!IsDependent) {
4802 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
4803 if (DeclContext *Ctx = DepScope->getEntity()) {
4804 IsDependent = Ctx->isDependentContext();
4805 break;
4806 }
4807 }
4808
4809 if (IsDependent)
4810 Results.AddResult(CodeCompletionResult("template"));
4811 }
4812 }
4813}
4814
4815// Returns the RecordDecl inside the BaseType, falling back to primary template
4816// in case of specializations. Since we might not have a decl for the
4817// instantiation/specialization yet, e.g. dependent code.
4818static RecordDecl *getAsRecordDecl(const QualType BaseType) {
4819 if (auto *RD = BaseType->getAsRecordDecl()) {
4820 if (const auto *CTSD =
4821 llvm::dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
4822 // Template might not be instantiated yet, fall back to primary template
4823 // in such cases.
4824 if (CTSD->getTemplateSpecializationKind() == TSK_Undeclared)
4825 RD = CTSD->getSpecializedTemplate()->getTemplatedDecl();
4826 }
4827 return RD;
4828 }
4829
4830 if (const auto *TST = BaseType->getAs<TemplateSpecializationType>()) {
4831 if (const auto *TD = dyn_cast_or_null<ClassTemplateDecl>(
4832 TST->getTemplateName().getAsTemplateDecl())) {
4833 return TD->getTemplatedDecl();
4834 }
4835 }
4836
4837 return nullptr;
4838}
4839
4840namespace {
4841// Collects completion-relevant information about a concept-constrainted type T.
4842// In particular, examines the constraint expressions to find members of T.
4843//
4844// The design is very simple: we walk down each constraint looking for
4845// expressions of the form T.foo().
4846// If we're extra lucky, the return type is specified.
4847// We don't do any clever handling of && or || in constraint expressions, we
4848// take members from both branches.
4849//
4850// For example, given:
4851// template <class T> concept X = requires (T t, string& s) { t.print(s); };
4852// template <X U> void foo(U u) { u.^ }
4853// We want to suggest the inferred member function 'print(string)'.
4854// We see that u has type U, so X<U> holds.
4855// X<U> requires t.print(s) to be valid, where t has type U (substituted for T).
4856// By looking at the CallExpr we find the signature of print().
4857//
4858// While we tend to know in advance which kind of members (access via . -> ::)
4859// we want, it's simpler just to gather them all and post-filter.
4860//
4861// FIXME: some of this machinery could be used for non-concept type-parms too,
4862// enabling completion for type parameters based on other uses of that param.
4863//
4864// FIXME: there are other cases where a type can be constrained by a concept,
4865// e.g. inside `if constexpr(ConceptSpecializationExpr) { ... }`
4866class ConceptInfo {
4867public:
4868 // Describes a likely member of a type, inferred by concept constraints.
4869 // Offered as a code completion for T. T-> and T:: contexts.
4870 struct Member {
4871 // Always non-null: we only handle members with ordinary identifier names.
4872 const IdentifierInfo *Name = nullptr;
4873 // Set for functions we've seen called.
4874 // We don't have the declared parameter types, only the actual types of
4875 // arguments we've seen. These are still valuable, as it's hard to render
4876 // a useful function completion with neither parameter types nor names!
4877 llvm::Optional<SmallVector<QualType, 1>> ArgTypes;
4878 // Whether this is accessed as T.member, T->member, or T::member.
4879 enum AccessOperator {
4880 Colons,
4881 Arrow,
4882 Dot,
4883 } Operator = Dot;
4884 // What's known about the type of a variable or return type of a function.
4885 const TypeConstraint *ResultType = nullptr;
4886 // FIXME: also track:
4887 // - kind of entity (function/variable/type), to expose structured results
4888 // - template args kinds/types, as a proxy for template params
4889
4890 // For now we simply return these results as "pattern" strings.
4891 CodeCompletionString *render(Sema &S, CodeCompletionAllocator &Alloc,
4892 CodeCompletionTUInfo &Info) const {
4893 CodeCompletionBuilder B(Alloc, Info);
4894 // Result type
4895 if (ResultType) {
4896 std::string AsString;
4897 {
4898 llvm::raw_string_ostream OS(AsString);
4899 QualType ExactType = deduceType(*ResultType);
4900 if (!ExactType.isNull())
4901 ExactType.print(OS, getCompletionPrintingPolicy(S));
4902 else
4903 ResultType->print(OS, getCompletionPrintingPolicy(S));
4904 }
4905 B.AddResultTypeChunk(Alloc.CopyString(AsString));
4906 }
4907 // Member name
4908 B.AddTypedTextChunk(Alloc.CopyString(Name->getName()));
4909 // Function argument list
4910 if (ArgTypes) {
4911 B.AddChunk(clang::CodeCompletionString::CK_LeftParen);
4912 bool First = true;
4913 for (QualType Arg : *ArgTypes) {
4914 if (First)
4915 First = false;
4916 else {
4917 B.AddChunk(clang::CodeCompletionString::CK_Comma);
4918 B.AddChunk(clang::CodeCompletionString::CK_HorizontalSpace);
4919 }
4920 B.AddPlaceholderChunk(Alloc.CopyString(
4921 Arg.getAsString(getCompletionPrintingPolicy(S))));
4922 }
4923 B.AddChunk(clang::CodeCompletionString::CK_RightParen);
4924 }
4925 return B.TakeString();
4926 }
4927 };
4928
4929 // BaseType is the type parameter T to infer members from.
4930 // T must be accessible within S, as we use it to find the template entity
4931 // that T is attached to in order to gather the relevant constraints.
4932 ConceptInfo(const TemplateTypeParmType &BaseType, Scope *S) {
4933 auto *TemplatedEntity = getTemplatedEntity(BaseType.getDecl(), S);
4934 for (const Expr *E : constraintsForTemplatedEntity(TemplatedEntity))
4935 believe(E, &BaseType);
4936 }
4937
4938 std::vector<Member> members() {
4939 std::vector<Member> Results;
4940 for (const auto &E : this->Results)
4941 Results.push_back(E.second);
4942 llvm::sort(Results, [](const Member &L, const Member &R) {
4943 return L.Name->getName() < R.Name->getName();
4944 });
4945 return Results;
4946 }
4947
4948private:
4949 // Infer members of T, given that the expression E (dependent on T) is true.
4950 void believe(const Expr *E, const TemplateTypeParmType *T) {
4951 if (!E || !T)
4952 return;
4953 if (auto *CSE = dyn_cast<ConceptSpecializationExpr>(E)) {
4954 // If the concept is
4955 // template <class A, class B> concept CD = f<A, B>();
4956 // And the concept specialization is
4957 // CD<int, T>
4958 // Then we're substituting T for B, so we want to make f<A, B>() true
4959 // by adding members to B - i.e. believe(f<A, B>(), B);
4960 //
4961 // For simplicity:
4962 // - we don't attempt to substitute int for A
4963 // - when T is used in other ways (like CD<T*>) we ignore it
4964 ConceptDecl *CD = CSE->getNamedConcept();
4965 TemplateParameterList *Params = CD->getTemplateParameters();
4966 unsigned Index = 0;
4967 for (const auto &Arg : CSE->getTemplateArguments()) {
4968 if (Index >= Params->size())
4969 break; // Won't happen in valid code.
4970 if (isApprox(Arg, T)) {
4971 auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Params->getParam(Index));
4972 if (!TTPD)
4973 continue;
4974 // T was used as an argument, and bound to the parameter TT.
4975 auto *TT = cast<TemplateTypeParmType>(TTPD->getTypeForDecl());
4976 // So now we know the constraint as a function of TT is true.
4977 believe(CD->getConstraintExpr(), TT);
4978 // (concepts themselves have no associated constraints to require)
4979 }
4980
4981 ++Index;
4982 }
4983 } else if (auto *BO = dyn_cast<BinaryOperator>(E)) {
4984 // For A && B, we can infer members from both branches.
4985 // For A || B, the union is still more useful than the intersection.
4986 if (BO->getOpcode() == BO_LAnd || BO->getOpcode() == BO_LOr) {
4987 believe(BO->getLHS(), T);
4988 believe(BO->getRHS(), T);
4989 }
4990 } else if (auto *RE = dyn_cast<RequiresExpr>(E)) {
4991 // A requires(){...} lets us infer members from each requirement.
4992 for (const concepts::Requirement *Req : RE->getRequirements()) {
4993 if (!Req->isDependent())
4994 continue; // Can't tell us anything about T.
4995 // Now Req cannot a substitution-error: those aren't dependent.
4996
4997 if (auto *TR = dyn_cast<concepts::TypeRequirement>(Req)) {
4998 // Do a full traversal so we get `foo` from `typename T::foo::bar`.
4999 QualType AssertedType = TR->getType()->getType();
5000 ValidVisitor(this, T).TraverseType(AssertedType);
5001 } else if (auto *ER = dyn_cast<concepts::ExprRequirement>(Req)) {
5002 ValidVisitor Visitor(this, T);
5003 // If we have a type constraint on the value of the expression,
5004 // AND the whole outer expression describes a member, then we'll
5005 // be able to use the constraint to provide the return type.
5006 if (ER->getReturnTypeRequirement().isTypeConstraint()) {
5007 Visitor.OuterType =
5008 ER->getReturnTypeRequirement().getTypeConstraint();
5009 Visitor.OuterExpr = ER->getExpr();
5010 }
5011 Visitor.TraverseStmt(ER->getExpr());
5012 } else if (auto *NR = dyn_cast<concepts::NestedRequirement>(Req)) {
5013 believe(NR->getConstraintExpr(), T);
5014 }
5015 }
5016 }
5017 }
5018
5019 // This visitor infers members of T based on traversing expressions/types
5020 // that involve T. It is invoked with code known to be valid for T.
5021 class ValidVisitor : public RecursiveASTVisitor<ValidVisitor> {
5022 ConceptInfo *Outer;
5023 const TemplateTypeParmType *T;
5024
5025 CallExpr *Caller = nullptr;
5026 Expr *Callee = nullptr;
5027
5028 public:
5029 // If set, OuterExpr is constrained by OuterType.
5030 Expr *OuterExpr = nullptr;
5031 const TypeConstraint *OuterType = nullptr;
5032
5033 ValidVisitor(ConceptInfo *Outer, const TemplateTypeParmType *T)
5034 : Outer(Outer), T(T) {
5035 assert(T)((void)0);
5036 }
5037
5038 // In T.foo or T->foo, `foo` is a member function/variable.
5039 bool VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) {
5040 const Type *Base = E->getBaseType().getTypePtr();
5041 bool IsArrow = E->isArrow();
5042 if (Base->isPointerType() && IsArrow) {
5043 IsArrow = false;
5044 Base = Base->getPointeeType().getTypePtr();
5045 }
5046 if (isApprox(Base, T))
5047 addValue(E, E->getMember(), IsArrow ? Member::Arrow : Member::Dot);
5048 return true;
5049 }
5050
5051 // In T::foo, `foo` is a static member function/variable.
5052 bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
5053 if (E->getQualifier() && isApprox(E->getQualifier()->getAsType(), T))
5054 addValue(E, E->getDeclName(), Member::Colons);
5055 return true;
5056 }
5057
5058 // In T::typename foo, `foo` is a type.
5059 bool VisitDependentNameType(DependentNameType *DNT) {
5060 const auto *Q = DNT->getQualifier();
5061 if (Q && isApprox(Q->getAsType(), T))
5062 addType(DNT->getIdentifier());
5063 return true;
5064 }
5065
5066 // In T::foo::bar, `foo` must be a type.
5067 // VisitNNS() doesn't exist, and TraverseNNS isn't always called :-(
5068 bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSL) {
5069 if (NNSL) {
5070 NestedNameSpecifier *NNS = NNSL.getNestedNameSpecifier();
5071 const auto *Q = NNS->getPrefix();
5072 if (Q && isApprox(Q->getAsType(), T))
5073 addType(NNS->getAsIdentifier());
5074 }
5075 // FIXME: also handle T::foo<X>::bar
5076 return RecursiveASTVisitor::TraverseNestedNameSpecifierLoc(NNSL);
5077 }
5078
5079 // FIXME also handle T::foo<X>
5080
5081 // Track the innermost caller/callee relationship so we can tell if a
5082 // nested expr is being called as a function.
5083 bool VisitCallExpr(CallExpr *CE) {
5084 Caller = CE;
5085 Callee = CE->getCallee();
5086 return true;
5087 }
5088
5089 private:
5090 void addResult(Member &&M) {
5091 auto R = Outer->Results.try_emplace(M.Name);
5092 Member &O = R.first->second;
5093 // Overwrite existing if the new member has more info.
5094 // The preference of . vs :: vs -> is fairly arbitrary.
5095 if (/*Inserted*/ R.second ||
5096 std::make_tuple(M.ArgTypes.hasValue(), M.ResultType != nullptr,
5097 M.Operator) > std::make_tuple(O.ArgTypes.hasValue(),
5098 O.ResultType != nullptr,
5099 O.Operator))
5100 O = std::move(M);
5101 }
5102
5103 void addType(const IdentifierInfo *Name) {
5104 if (!Name)
5105 return;
5106 Member M;
5107 M.Name = Name;
5108 M.Operator = Member::Colons;
5109 addResult(std::move(M));
5110 }
5111
5112 void addValue(Expr *E, DeclarationName Name,
5113 Member::AccessOperator Operator) {
5114 if (!Name.isIdentifier())
5115 return;
5116 Member Result;
5117 Result.Name = Name.getAsIdentifierInfo();
5118 Result.Operator = Operator;
5119 // If this is the callee of an immediately-enclosing CallExpr, then
5120 // treat it as a method, otherwise it's a variable.
5121 if (Caller != nullptr && Callee == E) {
5122 Result.ArgTypes.emplace();
5123 for (const auto *Arg : Caller->arguments())
5124 Result.ArgTypes->push_back(Arg->getType());
5125 if (Caller == OuterExpr) {
5126 Result.ResultType = OuterType;
5127 }
5128 } else {
5129 if (E == OuterExpr)
5130 Result.ResultType = OuterType;
5131 }
5132 addResult(std::move(Result));
5133 }
5134 };
5135
5136 static bool isApprox(const TemplateArgument &Arg, const Type *T) {
5137 return Arg.getKind() == TemplateArgument::Type &&
5138 isApprox(Arg.getAsType().getTypePtr(), T);
5139 }
5140
5141 static bool isApprox(const Type *T1, const Type *T2) {
5142 return T1 && T2 &&
5143 T1->getCanonicalTypeUnqualified() ==
5144 T2->getCanonicalTypeUnqualified();
5145 }
5146
5147 // Returns the DeclContext immediately enclosed by the template parameter
5148 // scope. For primary templates, this is the templated (e.g.) CXXRecordDecl.
5149 // For specializations, this is e.g. ClassTemplatePartialSpecializationDecl.
5150 static DeclContext *getTemplatedEntity(const TemplateTypeParmDecl *D,
5151 Scope *S) {
5152 if (D == nullptr)
5153 return nullptr;
5154 Scope *Inner = nullptr;
5155 while (S) {
5156 if (S->isTemplateParamScope() && S->isDeclScope(D))
5157 return Inner ? Inner->getEntity() : nullptr;
5158 Inner = S;
5159 S = S->getParent();
5160 }
5161 return nullptr;
5162 }
5163
5164 // Gets all the type constraint expressions that might apply to the type
5165 // variables associated with DC (as returned by getTemplatedEntity()).
5166 static SmallVector<const Expr *, 1>
5167 constraintsForTemplatedEntity(DeclContext *DC) {
5168 SmallVector<const Expr *, 1> Result;
5169 if (DC == nullptr)
5170 return Result;
5171 // Primary templates can have constraints.
5172 if (const auto *TD = cast<Decl>(DC)->getDescribedTemplate())
5173 TD->getAssociatedConstraints(Result);
5174 // Partial specializations may have constraints.
5175 if (const auto *CTPSD =
5176 dyn_cast<ClassTemplatePartialSpecializationDecl>(DC))
5177 CTPSD->getAssociatedConstraints(Result);
5178 if (const auto *VTPSD = dyn_cast<VarTemplatePartialSpecializationDecl>(DC))
5179 VTPSD->getAssociatedConstraints(Result);
5180 return Result;
5181 }
5182
5183 // Attempt to find the unique type satisfying a constraint.
5184 // This lets us show e.g. `int` instead of `std::same_as<int>`.
5185 static QualType deduceType(const TypeConstraint &T) {
5186 // Assume a same_as<T> return type constraint is std::same_as or equivalent.
5187 // In this case the return type is T.
5188 DeclarationName DN = T.getNamedConcept()->getDeclName();
5189 if (DN.isIdentifier() && DN.getAsIdentifierInfo()->isStr("same_as"))
5190 if (const auto *Args = T.getTemplateArgsAsWritten())
5191 if (Args->getNumTemplateArgs() == 1) {
5192 const auto &Arg = Args->arguments().front().getArgument();
5193 if (Arg.getKind() == TemplateArgument::Type)
5194 return Arg.getAsType();
5195 }
5196 return {};
5197 }
5198
5199 llvm::DenseMap<const IdentifierInfo *, Member> Results;
5200};
5201
5202// Returns a type for E that yields acceptable member completions.
5203// In particular, when E->getType() is DependentTy, try to guess a likely type.
5204// We accept some lossiness (like dropping parameters).
5205// We only try to handle common expressions on the LHS of MemberExpr.
5206QualType getApproximateType(const Expr *E) {
5207 QualType Unresolved = E->getType();
5208 if (Unresolved.isNull() ||
5209 !Unresolved->isSpecificBuiltinType(BuiltinType::Dependent))
5210 return Unresolved;
5211 E = E->IgnoreParens();
5212 // A call: approximate-resolve callee to a function type, get its return type
5213 if (const CallExpr *CE = llvm::dyn_cast<CallExpr>(E)) {
5214 QualType Callee = getApproximateType(CE->getCallee());
5215 if (Callee.isNull() ||
5216 Callee->isSpecificPlaceholderType(BuiltinType::BoundMember))
5217 Callee = Expr::findBoundMemberType(CE->getCallee());
5218 if (Callee.isNull())
5219 return Unresolved;
5220
5221 if (const auto *FnTypePtr = Callee->getAs<PointerType>()) {
5222 Callee = FnTypePtr->getPointeeType();
5223 } else if (const auto *BPT = Callee->getAs<BlockPointerType>()) {
5224 Callee = BPT->getPointeeType();
5225 }
5226 if (const FunctionType *FnType = Callee->getAs<FunctionType>())
5227 return FnType->getReturnType().getNonReferenceType();
5228
5229 // Unresolved call: try to guess the return type.
5230 if (const auto *OE = llvm::dyn_cast<OverloadExpr>(CE->getCallee())) {
5231 // If all candidates have the same approximate return type, use it.
5232 // Discard references and const to allow more to be "the same".
5233 // (In particular, if there's one candidate + ADL, resolve it).
5234 const Type *Common = nullptr;
5235 for (const auto *D : OE->decls()) {
5236 QualType ReturnType;
5237 if (const auto *FD = llvm::dyn_cast<FunctionDecl>(D))
5238 ReturnType = FD->getReturnType();
5239 else if (const auto *FTD = llvm::dyn_cast<FunctionTemplateDecl>(D))
5240 ReturnType = FTD->getTemplatedDecl()->getReturnType();
5241 if (ReturnType.isNull())
5242 continue;
5243 const Type *Candidate =
5244 ReturnType.getNonReferenceType().getCanonicalType().getTypePtr();
5245 if (Common && Common != Candidate)
5246 return Unresolved; // Multiple candidates.
5247 Common = Candidate;
5248 }
5249 if (Common != nullptr)
5250 return QualType(Common, 0);
5251 }
5252 }
5253 // A dependent member: approximate-resolve the base, then lookup.
5254 if (const auto *CDSME = llvm::dyn_cast<CXXDependentScopeMemberExpr>(E)) {
5255 QualType Base = CDSME->isImplicitAccess()
5256 ? CDSME->getBaseType()
5257 : getApproximateType(CDSME->getBase());
5258 if (CDSME->isArrow() && !Base.isNull())
5259 Base = Base->getPointeeType(); // could handle unique_ptr etc here?
5260 RecordDecl *RD = Base.isNull() ? nullptr : getAsRecordDecl(Base);
5261 if (RD && RD->isCompleteDefinition()) {
5262 for (const auto *Member : RD->lookup(CDSME->getMember()))
5263 if (const ValueDecl *VD = llvm::dyn_cast<ValueDecl>(Member))
5264 return VD->getType().getNonReferenceType();
5265 }
5266 }
5267 return Unresolved;
5268}
5269
5270// If \p Base is ParenListExpr, assume a chain of comma operators and pick the
5271// last expr. We expect other ParenListExprs to be resolved to e.g. constructor
5272// calls before here. (So the ParenListExpr should be nonempty, but check just
5273// in case)
5274Expr *unwrapParenList(Expr *Base) {
5275 if (auto *PLE = llvm::dyn_cast_or_null<ParenListExpr>(Base)) {
5276 if (PLE->getNumExprs() == 0)
5277 return nullptr;
5278 Base = PLE->getExpr(PLE->getNumExprs() - 1);
5279 }
5280 return Base;
5281}
5282
5283} // namespace
5284
5285void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base,
5286 Expr *OtherOpBase,
5287 SourceLocation OpLoc, bool IsArrow,
5288 bool IsBaseExprStatement,
5289 QualType PreferredType) {
5290 Base = unwrapParenList(Base);
5291 OtherOpBase = unwrapParenList(OtherOpBase);
5292 if (!Base || !CodeCompleter)
5293 return;
5294
5295 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
5296 if (ConvertedBase.isInvalid())
5297 return;
5298 QualType ConvertedBaseType = getApproximateType(ConvertedBase.get());
5299
5300 enum CodeCompletionContext::Kind contextKind;
5301
5302 if (IsArrow) {
5303 if (const auto *Ptr = ConvertedBaseType->getAs<PointerType>())
5304 ConvertedBaseType = Ptr->getPointeeType();
5305 }
5306
5307 if (IsArrow) {
5308 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess;
5309 } else {
5310 if (ConvertedBaseType->isObjCObjectPointerType() ||
5311 ConvertedBaseType->isObjCObjectOrInterfaceType()) {
5312 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess;
5313 } else {
5314 contextKind = CodeCompletionContext::CCC_DotMemberAccess;
5315 }
5316 }
5317
5318 CodeCompletionContext CCContext(contextKind, ConvertedBaseType);
5319 CCContext.setPreferredType(PreferredType);
5320 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5321 CodeCompleter->getCodeCompletionTUInfo(), CCContext,
5322 &ResultBuilder::IsMember);
5323
5324 auto DoCompletion = [&](Expr *Base, bool IsArrow,
5325 Optional<FixItHint> AccessOpFixIt) -> bool {
5326 if (!Base)
5327 return false;
5328
5329 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
5330 if (ConvertedBase.isInvalid())
5331 return false;
5332 Base = ConvertedBase.get();
5333
5334 QualType BaseType = getApproximateType(Base);
5335 if (BaseType.isNull())
5336 return false;
5337 ExprValueKind BaseKind = Base->getValueKind();
5338
5339 if (IsArrow) {
5340 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
5341 BaseType = Ptr->getPointeeType();
5342 BaseKind = VK_LValue;
5343 } else if (BaseType->isObjCObjectPointerType() ||
5344 BaseType->isTemplateTypeParmType()) {
5345 // Both cases (dot/arrow) handled below.
5346 } else {
5347 return false;
5348 }
5349 }
5350
5351 if (RecordDecl *RD = getAsRecordDecl(BaseType)) {
5352 AddRecordMembersCompletionResults(*this, Results, S, BaseType, BaseKind,
5353 RD, std::move(AccessOpFixIt));
5354 } else if (const auto *TTPT =
5355 dyn_cast<TemplateTypeParmType>(BaseType.getTypePtr())) {
5356 auto Operator =
5357 IsArrow ? ConceptInfo::Member::Arrow : ConceptInfo::Member::Dot;
5358 for (const auto &R : ConceptInfo(*TTPT, S).members()) {
5359 if (R.Operator != Operator)
5360 continue;
5361 CodeCompletionResult Result(
5362 R.render(*this, CodeCompleter->getAllocator(),
5363 CodeCompleter->getCodeCompletionTUInfo()));
5364 if (AccessOpFixIt)
5365 Result.FixIts.push_back(*AccessOpFixIt);
5366 Results.AddResult(std::move(Result));
5367 }
5368 } else if (!IsArrow && BaseType->isObjCObjectPointerType()) {
5369 // Objective-C property reference. Bail if we're performing fix-it code
5370 // completion since Objective-C properties are normally backed by ivars,
5371 // most Objective-C fix-its here would have little value.
5372 if (AccessOpFixIt.hasValue()) {
5373 return false;
5374 }
5375 AddedPropertiesSet AddedProperties;
5376
5377 if (const ObjCObjectPointerType *ObjCPtr =
5378 BaseType->getAsObjCInterfacePointerType()) {
5379 // Add property results based on our interface.
5380 assert(ObjCPtr && "Non-NULL pointer guaranteed above!")((void)0);
5381 AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true,
5382 /*AllowNullaryMethods=*/true, CurContext,
5383 AddedProperties, Results, IsBaseExprStatement);
5384 }
5385
5386 // Add properties from the protocols in a qualified interface.
5387 for (auto *I : BaseType->castAs<ObjCObjectPointerType>()->quals())
5388 AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true,
5389 CurContext, AddedProperties, Results,
5390 IsBaseExprStatement, /*IsClassProperty*/ false,
5391 /*InOriginalClass*/ false);
5392 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
5393 (!IsArrow && BaseType->isObjCObjectType())) {
5394 // Objective-C instance variable access. Bail if we're performing fix-it
5395 // code completion since Objective-C properties are normally backed by
5396 // ivars, most Objective-C fix-its here would have little value.
5397 if (AccessOpFixIt.hasValue()) {
5398 return false;
5399 }
5400 ObjCInterfaceDecl *Class = nullptr;
5401 if (const ObjCObjectPointerType *ObjCPtr =
5402 BaseType->getAs<ObjCObjectPointerType>())
5403 Class = ObjCPtr->getInterfaceDecl();
5404 else
5405 Class = BaseType->castAs<ObjCObjectType>()->getInterface();
5406
5407 // Add all ivars from this class and its superclasses.
5408 if (Class) {
5409 CodeCompletionDeclConsumer Consumer(Results, Class, BaseType);
5410 Results.setFilter(&ResultBuilder::IsObjCIvar);
5411 LookupVisibleDecls(
5412 Class, LookupMemberName, Consumer, CodeCompleter->includeGlobals(),
5413 /*IncludeDependentBases=*/false, CodeCompleter->loadExternal());
5414 }
5415 }
5416
5417 // FIXME: How do we cope with isa?
5418 return true;
5419 };
5420
5421 Results.EnterNewScope();
5422
5423 bool CompletionSucceded = DoCompletion(Base, IsArrow, None);
5424 if (CodeCompleter->includeFixIts()) {
5425 const CharSourceRange OpRange =
5426 CharSourceRange::getTokenRange(OpLoc, OpLoc);
5427 CompletionSucceded |= DoCompletion(
5428 OtherOpBase, !IsArrow,
5429 FixItHint::CreateReplacement(OpRange, IsArrow ? "." : "->"));
5430 }
5431
5432 Results.ExitScope();
5433
5434 if (!CompletionSucceded)
5435 return;
5436
5437 // Hand off the results found for code completion.
5438 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5439 Results.data(), Results.size());
5440}
5441
5442void Sema::CodeCompleteObjCClassPropertyRefExpr(Scope *S,
5443 IdentifierInfo &ClassName,
5444 SourceLocation ClassNameLoc,
5445 bool IsBaseExprStatement) {
5446 IdentifierInfo *ClassNamePtr = &ClassName;
5447 ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(ClassNamePtr, ClassNameLoc);
5448 if (!IFace)
5449 return;
5450 CodeCompletionContext CCContext(
5451 CodeCompletionContext::CCC_ObjCPropertyAccess);
5452 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5453 CodeCompleter->getCodeCompletionTUInfo(), CCContext,
5454 &ResultBuilder::IsMember);
5455 Results.EnterNewScope();
5456 AddedPropertiesSet AddedProperties;
5457 AddObjCProperties(CCContext, IFace, true,
5458 /*AllowNullaryMethods=*/true, CurContext, AddedProperties,
5459 Results, IsBaseExprStatement,
5460 /*IsClassProperty=*/true);
5461 Results.ExitScope();
5462 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5463 Results.data(), Results.size());
5464}
5465
5466void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
5467 if (!CodeCompleter)
5468 return;
5469
5470 ResultBuilder::LookupFilter Filter = nullptr;
5471 enum CodeCompletionContext::Kind ContextKind =
5472 CodeCompletionContext::CCC_Other;
5473 switch ((DeclSpec::TST)TagSpec) {
5474 case DeclSpec::TST_enum:
5475 Filter = &ResultBuilder::IsEnum;
5476 ContextKind = CodeCompletionContext::CCC_EnumTag;
5477 break;
5478
5479 case DeclSpec::TST_union:
5480 Filter = &ResultBuilder::IsUnion;
5481 ContextKind = CodeCompletionContext::CCC_UnionTag;
5482 break;
5483
5484 case DeclSpec::TST_struct:
5485 case DeclSpec::TST_class:
5486 case DeclSpec::TST_interface:
5487 Filter = &ResultBuilder::IsClassOrStruct;
5488 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag;
5489 break;
5490
5491 default:
5492 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag")__builtin_unreachable();
5493 }
5494
5495 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5496 CodeCompleter->getCodeCompletionTUInfo(), ContextKind);
5497 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5498
5499 // First pass: look for tags.
5500 Results.setFilter(Filter);
5501 LookupVisibleDecls(S, LookupTagName, Consumer,
5502 CodeCompleter->includeGlobals(),
5503 CodeCompleter->loadExternal());
5504
5505 if (CodeCompleter->includeGlobals()) {
5506 // Second pass: look for nested name specifiers.
5507 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
5508 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
5509 CodeCompleter->includeGlobals(),
5510 CodeCompleter->loadExternal());
5511 }
5512
5513 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5514 Results.data(), Results.size());
5515}
5516
5517static void AddTypeQualifierResults(DeclSpec &DS, ResultBuilder &Results,
5518 const LangOptions &LangOpts) {
5519 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
5520 Results.AddResult("const");
5521 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile))
5522 Results.AddResult("volatile");
5523 if (LangOpts.C99 && !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
5524 Results.AddResult("restrict");
5525 if (LangOpts.C11 && !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic))
5526 Results.AddResult("_Atomic");
5527 if (LangOpts.MSVCCompat && !(DS.getTypeQualifiers() & DeclSpec::TQ_unaligned))
5528 Results.AddResult("__unaligned");
5529}
5530
5531void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) {
5532 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5533 CodeCompleter->getCodeCompletionTUInfo(),
5534 CodeCompletionContext::CCC_TypeQualifiers);
5535 Results.EnterNewScope();
5536 AddTypeQualifierResults(DS, Results, LangOpts);
5537 Results.ExitScope();
5538 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5539 Results.data(), Results.size());
5540}
5541
5542void Sema::CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
5543 const VirtSpecifiers *VS) {
5544 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5545 CodeCompleter->getCodeCompletionTUInfo(),
5546 CodeCompletionContext::CCC_TypeQualifiers);
5547 Results.EnterNewScope();
5548 AddTypeQualifierResults(DS, Results, LangOpts);
5549 if (LangOpts.CPlusPlus11) {
5550 Results.AddResult("noexcept");
5551 if (D.getContext() == DeclaratorContext::Member && !D.isCtorOrDtor() &&
5552 !D.isStaticMember()) {
5553 if (!VS || !VS->isFinalSpecified())
5554 Results.AddResult("final");
5555 if (!VS || !VS->isOverrideSpecified())
5556 Results.AddResult("override");
5557 }
5558 }
5559 Results.ExitScope();
5560 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5561 Results.data(), Results.size());
5562}
5563
5564void Sema::CodeCompleteBracketDeclarator(Scope *S) {
5565 CodeCompleteExpression(S, QualType(getASTContext().getSizeType()));
5566}
5567
5568void Sema::CodeCompleteCase(Scope *S) {
5569 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
5570 return;
5571
5572 SwitchStmt *Switch = getCurFunction()->SwitchStack.back().getPointer();
5573 // Condition expression might be invalid, do not continue in this case.
5574 if (!Switch->getCond())
5575 return;
5576 QualType type = Switch->getCond()->IgnoreImplicit()->getType();
5577 if (!type->isEnumeralType()) {
5578 CodeCompleteExpressionData Data(type);
5579 Data.IntegralConstantExpression = true;
5580 CodeCompleteExpression(S, Data);
5581 return;
5582 }
5583
5584 // Code-complete the cases of a switch statement over an enumeration type
5585 // by providing the list of
5586 EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
5587 if (EnumDecl *Def = Enum->getDefinition())
5588 Enum = Def;
5589
5590 // Determine which enumerators we have already seen in the switch statement.
5591 // FIXME: Ideally, we would also be able to look *past* the code-completion
5592 // token, in case we are code-completing in the middle of the switch and not
5593 // at the end. However, we aren't able to do so at the moment.
5594 CoveredEnumerators Enumerators;
5595 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
5596 SC = SC->getNextSwitchCase()) {
5597 CaseStmt *Case = dyn_cast<CaseStmt>(SC);
5598 if (!Case)
5599 continue;
5600
5601 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
5602 if (auto *DRE = dyn_cast<DeclRefExpr>(CaseVal))
5603 if (auto *Enumerator =
5604 dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
5605 // We look into the AST of the case statement to determine which
5606 // enumerator was named. Alternatively, we could compute the value of
5607 // the integral constant expression, then compare it against the
5608 // values of each enumerator. However, value-based approach would not
5609 // work as well with C++ templates where enumerators declared within a
5610 // template are type- and value-dependent.
5611 Enumerators.Seen.insert(Enumerator);
5612
5613 // If this is a qualified-id, keep track of the nested-name-specifier
5614 // so that we can reproduce it as part of code completion, e.g.,
5615 //
5616 // switch (TagD.getKind()) {
5617 // case TagDecl::TK_enum:
5618 // break;
5619 // case XXX
5620 //
5621 // At the XXX, our completions are TagDecl::TK_union,
5622 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
5623 // TK_struct, and TK_class.
5624 Enumerators.SuggestedQualifier = DRE->getQualifier();
5625 }
5626 }
5627
5628 // Add any enumerators that have not yet been mentioned.
5629 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5630 CodeCompleter->getCodeCompletionTUInfo(),
5631 CodeCompletionContext::CCC_Expression);
5632 AddEnumerators(Results, Context, Enum, CurContext, Enumerators);
5633
5634 if (CodeCompleter->includeMacros()) {
5635 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
5636 }
5637 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5638 Results.data(), Results.size());
5639}
5640
5641static bool anyNullArguments(ArrayRef<Expr *> Args) {
5642 if (Args.size() && !Args.data())
5643 return true;
5644
5645 for (unsigned I = 0; I != Args.size(); ++I)
5646 if (!Args[I])
5647 return true;
5648
5649 return false;
5650}
5651
5652typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate;
5653
5654static void mergeCandidatesWithResults(
5655 Sema &SemaRef, SmallVectorImpl<ResultCandidate> &Results,
5656 OverloadCandidateSet &CandidateSet, SourceLocation Loc, size_t ArgSize) {
5657 // Sort the overload candidate set by placing the best overloads first.
5658 llvm::stable_sort(CandidateSet, [&](const OverloadCandidate &X,
5659 const OverloadCandidate &Y) {
5660 return isBetterOverloadCandidate(SemaRef, X, Y, Loc,
5661 CandidateSet.getKind());
5662 });
5663
5664 // Add the remaining viable overload candidates as code-completion results.
5665 for (OverloadCandidate &Candidate : CandidateSet) {
5666 if (Candidate.Function) {
5667 if (Candidate.Function->isDeleted())
5668 continue;
5669 if (!Candidate.Function->isVariadic() &&
5670 Candidate.Function->getNumParams() <= ArgSize &&
5671 // Having zero args is annoying, normally we don't surface a function
5672 // with 2 params, if you already have 2 params, because you are
5673 // inserting the 3rd now. But with zero, it helps the user to figure
5674 // out there are no overloads that take any arguments. Hence we are
5675 // keeping the overload.
5676 ArgSize > 0)
5677 continue;
5678 }
5679 if (Candidate.Viable)
5680 Results.push_back(ResultCandidate(Candidate.Function));
5681 }
5682}
5683
5684/// Get the type of the Nth parameter from a given set of overload
5685/// candidates.
5686static QualType getParamType(Sema &SemaRef,
5687 ArrayRef<ResultCandidate> Candidates, unsigned N) {
5688
5689 // Given the overloads 'Candidates' for a function call matching all arguments
5690 // up to N, return the type of the Nth parameter if it is the same for all
5691 // overload candidates.
5692 QualType ParamType;
5693 for (auto &Candidate : Candidates) {
5694 if (const auto *FType = Candidate.getFunctionType())
5695 if (const auto *Proto = dyn_cast<FunctionProtoType>(FType))
5696 if (N < Proto->getNumParams()) {
5697 if (ParamType.isNull())
5698 ParamType = Proto->getParamType(N);
5699 else if (!SemaRef.Context.hasSameUnqualifiedType(
5700 ParamType.getNonReferenceType(),
5701 Proto->getParamType(N).getNonReferenceType()))
5702 // Otherwise return a default-constructed QualType.
5703 return QualType();
5704 }
5705 }
5706
5707 return ParamType;
5708}
5709
5710static QualType
5711ProduceSignatureHelp(Sema &SemaRef, Scope *S,
5712 MutableArrayRef<ResultCandidate> Candidates,
5713 unsigned CurrentArg, SourceLocation OpenParLoc) {
5714 if (Candidates.empty())
5715 return QualType();
5716 if (SemaRef.getPreprocessor().isCodeCompletionReached())
5717 SemaRef.CodeCompleter->ProcessOverloadCandidates(
5718 SemaRef, CurrentArg, Candidates.data(), Candidates.size(), OpenParLoc);
5719 return getParamType(SemaRef, Candidates, CurrentArg);
5720}
5721
5722QualType Sema::ProduceCallSignatureHelp(Scope *S, Expr *Fn,
5723 ArrayRef<Expr *> Args,
5724 SourceLocation OpenParLoc) {
5725 Fn = unwrapParenList(Fn);
5726 if (!CodeCompleter || !Fn)
5727 return QualType();
5728
5729 // FIXME: Provide support for variadic template functions.
5730 // Ignore type-dependent call expressions entirely.
5731 if (Fn->isTypeDependent() || anyNullArguments(Args))
5732 return QualType();
5733 // In presence of dependent args we surface all possible signatures using the
5734 // non-dependent args in the prefix. Afterwards we do a post filtering to make
5735 // sure provided candidates satisfy parameter count restrictions.
5736 auto ArgsWithoutDependentTypes =
5737 Args.take_while([](Expr *Arg) { return !Arg->isTypeDependent(); });
5738
5739 SmallVector<ResultCandidate, 8> Results;
5740
5741 Expr *NakedFn = Fn->IgnoreParenCasts();
5742 // Build an overload candidate set based on the functions we find.
5743 SourceLocation Loc = Fn->getExprLoc();
5744 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
5745
5746 if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn)) {
5747 AddOverloadedCallCandidates(ULE, ArgsWithoutDependentTypes, CandidateSet,
5748 /*PartialOverloading=*/true);
5749 } else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
5750 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
5751 if (UME->hasExplicitTemplateArgs()) {
5752 UME->copyTemplateArgumentsInto(TemplateArgsBuffer);
5753 TemplateArgs = &TemplateArgsBuffer;
5754 }
5755
5756 // Add the base as first argument (use a nullptr if the base is implicit).
5757 SmallVector<Expr *, 12> ArgExprs(
5758 1, UME->isImplicitAccess() ? nullptr : UME->getBase());
5759 ArgExprs.append(ArgsWithoutDependentTypes.begin(),
5760 ArgsWithoutDependentTypes.end());
5761 UnresolvedSet<8> Decls;
5762 Decls.append(UME->decls_begin(), UME->decls_end());
5763 const bool FirstArgumentIsBase = !UME->isImplicitAccess() && UME->getBase();
5764 AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs,
5765 /*SuppressUserConversions=*/false,
5766 /*PartialOverloading=*/true, FirstArgumentIsBase);
5767 } else {
5768 FunctionDecl *FD = nullptr;
5769 if (auto *MCE = dyn_cast<MemberExpr>(NakedFn))
5770 FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl());
5771 else if (auto *DRE = dyn_cast<DeclRefExpr>(NakedFn))
5772 FD = dyn_cast<FunctionDecl>(DRE->getDecl());
5773 if (FD) { // We check whether it's a resolved function declaration.
5774 if (!getLangOpts().CPlusPlus ||
5775 !FD->getType()->getAs<FunctionProtoType>())
5776 Results.push_back(ResultCandidate(FD));
5777 else
5778 AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()),
5779 ArgsWithoutDependentTypes, CandidateSet,
5780 /*SuppressUserConversions=*/false,
5781 /*PartialOverloading=*/true);
5782
5783 } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) {
5784 // If expression's type is CXXRecordDecl, it may overload the function
5785 // call operator, so we check if it does and add them as candidates.
5786 // A complete type is needed to lookup for member function call operators.
5787 if (isCompleteType(Loc, NakedFn->getType())) {
5788 DeclarationName OpName =
5789 Context.DeclarationNames.getCXXOperatorName(OO_Call);
5790 LookupResult R(*this, OpName, Loc, LookupOrdinaryName);
5791 LookupQualifiedName(R, DC);
5792 R.suppressDiagnostics();
5793 SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
5794 ArgExprs.append(ArgsWithoutDependentTypes.begin(),
5795 ArgsWithoutDependentTypes.end());
5796 AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet,
5797 /*ExplicitArgs=*/nullptr,
5798 /*SuppressUserConversions=*/false,
5799 /*PartialOverloading=*/true);
5800 }
5801 } else {
5802 // Lastly we check whether expression's type is function pointer or
5803 // function.
5804 QualType T = NakedFn->getType();
5805 if (!T->getPointeeType().isNull())
5806 T = T->getPointeeType();
5807
5808 if (auto FP = T->getAs<FunctionProtoType>()) {
5809 if (!TooManyArguments(FP->getNumParams(),
5810 ArgsWithoutDependentTypes.size(),
5811 /*PartialOverloading=*/true) ||
5812 FP->isVariadic())
5813 Results.push_back(ResultCandidate(FP));
5814 } else if (auto FT = T->getAs<FunctionType>())
5815 // No prototype and declaration, it may be a K & R style function.
5816 Results.push_back(ResultCandidate(FT));
5817 }
5818 }
5819 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc, Args.size());
5820 QualType ParamType =
5821 ProduceSignatureHelp(*this, S, Results, Args.size(), OpenParLoc);
5822 return !CandidateSet.empty() ? ParamType : QualType();
5823}
5824
5825QualType Sema::ProduceConstructorSignatureHelp(Scope *S, QualType Type,
5826 SourceLocation Loc,
5827 ArrayRef<Expr *> Args,
5828 SourceLocation OpenParLoc) {
5829 if (!CodeCompleter)
5830 return QualType();
5831
5832 // A complete type is needed to lookup for constructors.
5833 CXXRecordDecl *RD =
5834 isCompleteType(Loc, Type) ? Type->getAsCXXRecordDecl() : nullptr;
5835 if (!RD)
5836 return Type;
5837
5838 // FIXME: Provide support for member initializers.
5839 // FIXME: Provide support for variadic template constructors.
5840
5841 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
5842
5843 for (NamedDecl *C : LookupConstructors(RD)) {
5844 if (auto *FD = dyn_cast<FunctionDecl>(C)) {
5845 AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()), Args,
5846 CandidateSet,
5847 /*SuppressUserConversions=*/false,
5848 /*PartialOverloading=*/true,
5849 /*AllowExplicit*/ true);
5850 } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(C)) {
5851 AddTemplateOverloadCandidate(
5852 FTD, DeclAccessPair::make(FTD, C->getAccess()),
5853 /*ExplicitTemplateArgs=*/nullptr, Args, CandidateSet,
5854 /*SuppressUserConversions=*/false,
5855 /*PartialOverloading=*/true);
5856 }
5857 }
5858
5859 SmallVector<ResultCandidate, 8> Results;
5860 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc, Args.size());
5861 return ProduceSignatureHelp(*this, S, Results, Args.size(), OpenParLoc);
5862}
5863
5864QualType Sema::ProduceCtorInitMemberSignatureHelp(
5865 Scope *S, Decl *ConstructorDecl, CXXScopeSpec SS, ParsedType TemplateTypeTy,
5866 ArrayRef<Expr *> ArgExprs, IdentifierInfo *II, SourceLocation OpenParLoc) {
5867 if (!CodeCompleter)
5868 return QualType();
5869
5870 CXXConstructorDecl *Constructor =
5871 dyn_cast<CXXConstructorDecl>(ConstructorDecl);
5872 if (!Constructor)
5873 return QualType();
5874 // FIXME: Add support for Base class constructors as well.
5875 if (ValueDecl *MemberDecl = tryLookupCtorInitMemberDecl(
5876 Constructor->getParent(), SS, TemplateTypeTy, II))
5877 return ProduceConstructorSignatureHelp(getCurScope(), MemberDecl->getType(),
5878 MemberDecl->getLocation(), ArgExprs,
5879 OpenParLoc);
5880 return QualType();
5881}
5882
5883static QualType getDesignatedType(QualType BaseType, const Designation &Desig) {
5884 for (unsigned I = 0; I < Desig.getNumDesignators(); ++I) {
5885 if (BaseType.isNull())
5886 break;
5887 QualType NextType;
5888 const auto &D = Desig.getDesignator(I);
5889 if (D.isArrayDesignator() || D.isArrayRangeDesignator()) {
5890 if (BaseType->isArrayType())
5891 NextType = BaseType->getAsArrayTypeUnsafe()->getElementType();
5892 } else {
5893 assert(D.isFieldDesignator())((void)0);
5894 auto *RD = getAsRecordDecl(BaseType);
5895 if (RD && RD->isCompleteDefinition()) {
5896 for (const auto *Member : RD->lookup(D.getField()))
5897 if (const FieldDecl *FD = llvm::dyn_cast<FieldDecl>(Member)) {
5898 NextType = FD->getType();
5899 break;
5900 }
5901 }
5902 }
5903 BaseType = NextType;
5904 }
5905 return BaseType;
5906}
5907
5908void Sema::CodeCompleteDesignator(QualType BaseType,
5909 llvm::ArrayRef<Expr *> InitExprs,
5910 const Designation &D) {
5911 BaseType = getDesignatedType(BaseType, D);
5912 if (BaseType.isNull())
5913 return;
5914 const auto *RD = getAsRecordDecl(BaseType);
5915 if (!RD || RD->fields().empty())
5916 return;
5917
5918 CodeCompletionContext CCC(CodeCompletionContext::CCC_DotMemberAccess,
5919 BaseType);
5920 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5921 CodeCompleter->getCodeCompletionTUInfo(), CCC);
5922
5923 Results.EnterNewScope();
5924 for (const auto *FD : RD->fields()) {
5925 // FIXME: Make use of previous designators to mark any fields before those
5926 // inaccessible, and also compute the next initializer priority.
5927 ResultBuilder::Result Result(FD, Results.getBasePriority(FD));
5928 Results.AddResult(Result, CurContext, /*Hiding=*/nullptr);
5929 }
5930 Results.ExitScope();
5931 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5932 Results.data(), Results.size());
5933}
5934
5935void Sema::CodeCompleteInitializer(Scope *S, Decl *D) {
5936 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
5937 if (!VD) {
5938 CodeCompleteOrdinaryName(S, PCC_Expression);
5939 return;
5940 }
5941
5942 CodeCompleteExpressionData Data;
5943 Data.PreferredType = VD->getType();
5944 // Ignore VD to avoid completing the variable itself, e.g. in 'int foo = ^'.
5945 Data.IgnoreDecls.push_back(VD);
5946
5947 CodeCompleteExpression(S, Data);
5948}
5949
5950void Sema::CodeCompleteAfterIf(Scope *S, bool IsBracedThen) {
5951 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5952 CodeCompleter->getCodeCompletionTUInfo(),
5953 mapCodeCompletionContext(*this, PCC_Statement));
5954 Results.setFilter(&ResultBuilder::IsOrdinaryName);
5955 Results.EnterNewScope();
5956
5957 CodeCompletionDeclConsumer Consumer(Results, CurContext);
5958 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5959 CodeCompleter->includeGlobals(),
5960 CodeCompleter->loadExternal());
5961
5962 AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
5963
5964 // "else" block
5965 CodeCompletionBuilder Builder(Results.getAllocator(),
5966 Results.getCodeCompletionTUInfo());
5967
5968 auto AddElseBodyPattern = [&] {
5969 if (IsBracedThen) {
5970 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5971 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5972 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
5973 Builder.AddPlaceholderChunk("statements");
5974 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
5975 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5976 } else {
5977 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
5978 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5979 Builder.AddPlaceholderChunk("statement");
5980 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
5981 }
5982 };
5983 Builder.AddTypedTextChunk("else");
5984 if (Results.includeCodePatterns())
5985 AddElseBodyPattern();
5986 Results.AddResult(Builder.TakeString());
5987
5988 // "else if" block
5989 Builder.AddTypedTextChunk("else if");
5990 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5991 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5992 if (getLangOpts().CPlusPlus)
5993 Builder.AddPlaceholderChunk("condition");
5994 else
5995 Builder.AddPlaceholderChunk("expression");
5996 Builder.AddChunk(CodeCompletionString::CK_RightParen);
5997 if (Results.includeCodePatterns()) {
5998 AddElseBodyPattern();
5999 }
6000 Results.AddResult(Builder.TakeString());
6001
6002 Results.ExitScope();
6003
6004 if (S->getFnParent())
6005 AddPrettyFunctionResults(getLangOpts(), Results);
6006
6007 if (CodeCompleter->includeMacros())
6008 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
6009
6010 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6011 Results.data(), Results.size());
6012}
6013
6014void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
6015 bool EnteringContext,
6016 bool IsUsingDeclaration, QualType BaseType,
6017 QualType PreferredType) {
6018 if (SS.isEmpty() || !CodeCompleter)
6019 return;
6020
6021 CodeCompletionContext CC(CodeCompletionContext::CCC_Symbol, PreferredType);
6022 CC.setIsUsingDeclaration(IsUsingDeclaration);
6023 CC.setCXXScopeSpecifier(SS);
6024
6025 // We want to keep the scope specifier even if it's invalid (e.g. the scope
6026 // "a::b::" is not corresponding to any context/namespace in the AST), since
6027 // it can be useful for global code completion which have information about
6028 // contexts/symbols that are not in the AST.
6029 if (SS.isInvalid()) {
6030 // As SS is invalid, we try to collect accessible contexts from the current
6031 // scope with a dummy lookup so that the completion consumer can try to
6032 // guess what the specified scope is.
6033 ResultBuilder DummyResults(*this, CodeCompleter->getAllocator(),
6034 CodeCompleter->getCodeCompletionTUInfo(), CC);
6035 if (!PreferredType.isNull())
6036 DummyResults.setPreferredType(PreferredType);
6037 if (S->getEntity()) {
6038 CodeCompletionDeclConsumer Consumer(DummyResults, S->getEntity(),
6039 BaseType);
6040 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
6041 /*IncludeGlobalScope=*/false,
6042 /*LoadExternal=*/false);
6043 }
6044 HandleCodeCompleteResults(this, CodeCompleter,
6045 DummyResults.getCompletionContext(), nullptr, 0);
6046 return;
6047 }
6048 // Always pretend to enter a context to ensure that a dependent type
6049 // resolves to a dependent record.
6050 DeclContext *Ctx = computeDeclContext(SS, /*EnteringContext=*/true);
6051
6052 // Try to instantiate any non-dependent declaration contexts before
6053 // we look in them. Bail out if we fail.
6054 NestedNameSpecifier *NNS = SS.getScopeRep();
6055 if (NNS != nullptr && SS.isValid() && !NNS->isDependent()) {
6056 if (Ctx == nullptr || RequireCompleteDeclContext(SS, Ctx))
6057 return;
6058 }
6059
6060 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6061 CodeCompleter->getCodeCompletionTUInfo(), CC);
6062 if (!PreferredType.isNull())
6063 Results.setPreferredType(PreferredType);
6064 Results.EnterNewScope();
6065
6066 // The "template" keyword can follow "::" in the grammar, but only
6067 // put it into the grammar if the nested-name-specifier is dependent.
6068 // FIXME: results is always empty, this appears to be dead.
6069 if (!Results.empty() && NNS->isDependent())
6070 Results.AddResult("template");
6071
6072 // If the scope is a concept-constrained type parameter, infer nested
6073 // members based on the constraints.
6074 if (const auto *TTPT =
6075 dyn_cast_or_null<TemplateTypeParmType>(NNS->getAsType())) {
6076 for (const auto &R : ConceptInfo(*TTPT, S).members()) {
6077 if (R.Operator != ConceptInfo::Member::Colons)
6078 continue;
6079 Results.AddResult(CodeCompletionResult(
6080 R.render(*this, CodeCompleter->getAllocator(),
6081 CodeCompleter->getCodeCompletionTUInfo())));
6082 }
6083 }
6084
6085 // Add calls to overridden virtual functions, if there are any.
6086 //
6087 // FIXME: This isn't wonderful, because we don't know whether we're actually
6088 // in a context that permits expressions. This is a general issue with
6089 // qualified-id completions.
6090 if (Ctx && !EnteringContext)
6091 MaybeAddOverrideCalls(*this, Ctx, Results);
6092 Results.ExitScope();
6093
6094 if (Ctx &&
6095 (CodeCompleter->includeNamespaceLevelDecls() || !Ctx->isFileContext())) {
6096 CodeCompletionDeclConsumer Consumer(Results, Ctx, BaseType);
6097 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer,
6098 /*IncludeGlobalScope=*/true,
6099 /*IncludeDependentBases=*/true,
6100 CodeCompleter->loadExternal());
6101 }
6102
6103 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6104 Results.data(), Results.size());
6105}
6106
6107void Sema::CodeCompleteUsing(Scope *S) {
6108 if (!CodeCompleter)
6109 return;
6110
6111 // This can be both a using alias or using declaration, in the former we
6112 // expect a new name and a symbol in the latter case.
6113 CodeCompletionContext Context(CodeCompletionContext::CCC_SymbolOrNewName);
6114 Context.setIsUsingDeclaration(true);
6115
6116 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6117 CodeCompleter->getCodeCompletionTUInfo(), Context,
6118 &ResultBuilder::IsNestedNameSpecifier);
6119 Results.EnterNewScope();
6120
6121 // If we aren't in class scope, we could see the "namespace" keyword.
6122 if (!S->isClassScope())
6123 Results.AddResult(CodeCompletionResult("namespace"));
6124
6125 // After "using", we can see anything that would start a
6126 // nested-name-specifier.
6127 CodeCompletionDeclConsumer Consumer(Results, CurContext);
6128 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
6129 CodeCompleter->includeGlobals(),
6130 CodeCompleter->loadExternal());
6131 Results.ExitScope();
6132
6133 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6134 Results.data(), Results.size());
6135}
6136
6137void Sema::CodeCompleteUsingDirective(Scope *S) {
6138 if (!CodeCompleter)
6139 return;
6140
6141 // After "using namespace", we expect to see a namespace name or namespace
6142 // alias.
6143 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6144 CodeCompleter->getCodeCompletionTUInfo(),
6145 CodeCompletionContext::CCC_Namespace,
6146 &ResultBuilder::IsNamespaceOrAlias);
6147 Results.EnterNewScope();
6148 CodeCompletionDeclConsumer Consumer(Results, CurContext);
6149 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
6150 CodeCompleter->includeGlobals(),
6151 CodeCompleter->loadExternal());
6152 Results.ExitScope();
6153 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6154 Results.data(), Results.size());
6155}
6156
6157void Sema::CodeCompleteNamespaceDecl(Scope *S) {
6158 if (!CodeCompleter)
6159 return;
6160
6161 DeclContext *Ctx = S->getEntity();
6162 if (!S->getParent())
6163 Ctx = Context.getTranslationUnitDecl();
6164
6165 bool SuppressedGlobalResults =
6166 Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
6167
6168 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6169 CodeCompleter->getCodeCompletionTUInfo(),
6170 SuppressedGlobalResults
6171 ? CodeCompletionContext::CCC_Namespace
6172 : CodeCompletionContext::CCC_Other,
6173 &ResultBuilder::IsNamespace);
6174
6175 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
6176 // We only want to see those namespaces that have already been defined
6177 // within this scope, because its likely that the user is creating an
6178 // extended namespace declaration. Keep track of the most recent
6179 // definition of each namespace.
6180 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
6181 for (DeclContext::specific_decl_iterator<NamespaceDecl>
6182 NS(Ctx->decls_begin()),
6183 NSEnd(Ctx->decls_end());
6184 NS != NSEnd; ++NS)
6185 OrigToLatest[NS->getOriginalNamespace()] = *NS;
6186
6187 // Add the most recent definition (or extended definition) of each
6188 // namespace to the list of results.
6189 Results.EnterNewScope();
6190 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
6191 NS = OrigToLatest.begin(),
6192 NSEnd = OrigToLatest.end();
6193 NS != NSEnd; ++NS)
6194 Results.AddResult(
6195 CodeCompletionResult(NS->second, Results.getBasePriority(NS->second),
6196 nullptr),
6197 CurContext, nullptr, false);
6198 Results.ExitScope();
6199 }
6200
6201 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6202 Results.data(), Results.size());
6203}
6204
6205void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) {
6206 if (!CodeCompleter)
6207 return;
6208
6209 // After "namespace", we expect to see a namespace or alias.
6210 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6211 CodeCompleter->getCodeCompletionTUInfo(),
6212 CodeCompletionContext::CCC_Namespace,
6213 &ResultBuilder::IsNamespaceOrAlias);
6214 CodeCompletionDeclConsumer Consumer(Results, CurContext);
6215 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
6216 CodeCompleter->includeGlobals(),
6217 CodeCompleter->loadExternal());
6218 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6219 Results.data(), Results.size());
6220}
6221
6222void Sema::CodeCompleteOperatorName(Scope *S) {
6223 if (!CodeCompleter)
6224 return;
6225
6226 typedef CodeCompletionResult Result;
6227 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6228 CodeCompleter->getCodeCompletionTUInfo(),
6229 CodeCompletionContext::CCC_Type,
6230 &ResultBuilder::IsType);
6231 Results.EnterNewScope();
6232
6233 // Add the names of overloadable operators. Note that OO_Conditional is not
6234 // actually overloadable.
6235#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
6236 if (OO_##Name != OO_Conditional) \
6237 Results.AddResult(Result(Spelling));
6238#include "clang/Basic/OperatorKinds.def"
6239
6240 // Add any type names visible from the current scope
6241 Results.allowNestedNameSpecifiers();
6242 CodeCompletionDeclConsumer Consumer(Results, CurContext);
6243 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
6244 CodeCompleter->includeGlobals(),
6245 CodeCompleter->loadExternal());
6246
6247 // Add any type specifiers
6248 AddTypeSpecifierResults(getLangOpts(), Results);
6249 Results.ExitScope();
6250
6251 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6252 Results.data(), Results.size());
6253}
6254
6255void Sema::CodeCompleteConstructorInitializer(
6256 Decl *ConstructorD, ArrayRef<CXXCtorInitializer *> Initializers) {
6257 if (!ConstructorD)
6258 return;
6259
6260 AdjustDeclIfTemplate(ConstructorD);
6261
6262 auto *Constructor = dyn_cast<CXXConstructorDecl>(ConstructorD);
6263 if (!Constructor)
6264 return;
6265
6266 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6267 CodeCompleter->getCodeCompletionTUInfo(),
6268 CodeCompletionContext::CCC_Symbol);
6269 Results.EnterNewScope();
6270
6271 // Fill in any already-initialized fields or base classes.
6272 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
6273 llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
6274 for (unsigned I = 0, E = Initializers.size(); I != E; ++I) {
6275 if (Initializers[I]->isBaseInitializer())
6276 InitializedBases.insert(Context.getCanonicalType(
6277 QualType(Initializers[I]->getBaseClass(), 0)));
6278 else
6279 InitializedFields.insert(
6280 cast<FieldDecl>(Initializers[I]->getAnyMember()));
6281 }
6282
6283 // Add completions for base classes.
6284 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
6285 bool SawLastInitializer = Initializers.empty();
6286 CXXRecordDecl *ClassDecl = Constructor->getParent();
6287
6288 auto GenerateCCS = [&](const NamedDecl *ND, const char *Name) {
6289 CodeCompletionBuilder Builder(Results.getAllocator(),
6290 Results.getCodeCompletionTUInfo());
6291 Builder.AddTypedTextChunk(Name);
6292 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6293 if (const auto *Function = dyn_cast<FunctionDecl>(ND))
6294 AddFunctionParameterChunks(PP, Policy, Function, Builder);
6295 else if (const auto *FunTemplDecl = dyn_cast<FunctionTemplateDecl>(ND))
6296 AddFunctionParameterChunks(PP, Policy, FunTemplDecl->getTemplatedDecl(),
6297 Builder);
6298 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6299 return Builder.TakeString();
6300 };
6301 auto AddDefaultCtorInit = [&](const char *Name, const char *Type,
6302 const NamedDecl *ND) {
6303 CodeCompletionBuilder Builder(Results.getAllocator(),
6304 Results.getCodeCompletionTUInfo());
6305 Builder.AddTypedTextChunk(Name);
6306 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6307 Builder.AddPlaceholderChunk(Type);
6308 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6309 if (ND) {
6310 auto CCR = CodeCompletionResult(
6311 Builder.TakeString(), ND,
6312 SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration);
6313 if (isa<FieldDecl>(ND))
6314 CCR.CursorKind = CXCursor_MemberRef;
6315 return Results.AddResult(CCR);
6316 }
6317 return Results.AddResult(CodeCompletionResult(
6318 Builder.TakeString(),
6319 SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration));
6320 };
6321 auto AddCtorsWithName = [&](const CXXRecordDecl *RD, unsigned int Priority,
6322 const char *Name, const FieldDecl *FD) {
6323 if (!RD)
6324 return AddDefaultCtorInit(Name,
6325 FD ? Results.getAllocator().CopyString(
6326 FD->getType().getAsString(Policy))
6327 : Name,
6328 FD);
6329 auto Ctors = getConstructors(Context, RD);
6330 if (Ctors.begin() == Ctors.end())
6331 return AddDefaultCtorInit(Name, Name, RD);
6332 for (const NamedDecl *Ctor : Ctors) {
6333 auto CCR = CodeCompletionResult(GenerateCCS(Ctor, Name), RD, Priority);
6334 CCR.CursorKind = getCursorKindForDecl(Ctor);
6335 Results.AddResult(CCR);
6336 }
6337 };
6338 auto AddBase = [&](const CXXBaseSpecifier &Base) {
6339 const char *BaseName =
6340 Results.getAllocator().CopyString(Base.getType().getAsString(Policy));
6341 const auto *RD = Base.getType()->getAsCXXRecordDecl();
6342 AddCtorsWithName(
6343 RD, SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration,
6344 BaseName, nullptr);
6345 };
6346 auto AddField = [&](const FieldDecl *FD) {
6347 const char *FieldName =
6348 Results.getAllocator().CopyString(FD->getIdentifier()->getName());
6349 const CXXRecordDecl *RD = FD->getType()->getAsCXXRecordDecl();
6350 AddCtorsWithName(
6351 RD, SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration,
6352 FieldName, FD);
6353 };
6354
6355 for (const auto &Base : ClassDecl->bases()) {
6356 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
6357 .second) {
6358 SawLastInitializer =
6359 !Initializers.empty() && Initializers.back()->isBaseInitializer() &&
6360 Context.hasSameUnqualifiedType(
6361 Base.getType(), QualType(Initializers.back()->getBaseClass(), 0));
6362 continue;
6363 }
6364
6365 AddBase(Base);
6366 SawLastInitializer = false;
6367 }
6368
6369 // Add completions for virtual base classes.
6370 for (const auto &Base : ClassDecl->vbases()) {
6371 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
6372 .second) {
6373 SawLastInitializer =
6374 !Initializers.empty() && Initializers.back()->isBaseInitializer() &&
6375 Context.hasSameUnqualifiedType(
6376 Base.getType(), QualType(Initializers.back()->getBaseClass(), 0));
6377 continue;
6378 }
6379
6380 AddBase(Base);
6381 SawLastInitializer = false;
6382 }
6383
6384 // Add completions for members.
6385 for (auto *Field : ClassDecl->fields()) {
6386 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))
6387 .second) {
6388 SawLastInitializer = !Initializers.empty() &&
6389 Initializers.back()->isAnyMemberInitializer() &&
6390 Initializers.back()->getAnyMember() == Field;
6391 continue;
6392 }
6393
6394 if (!Field->getDeclName())
6395 continue;
6396
6397 AddField(Field);
6398 SawLastInitializer = false;
6399 }
6400 Results.ExitScope();
6401
6402 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6403 Results.data(), Results.size());
6404}
6405
6406/// Determine whether this scope denotes a namespace.
6407static bool isNamespaceScope(Scope *S) {
6408 DeclContext *DC = S->getEntity();
6409 if (!DC)
6410 return false;
6411
6412 return DC->isFileContext();
6413}
6414
6415void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
6416 bool AfterAmpersand) {
6417 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6418 CodeCompleter->getCodeCompletionTUInfo(),
6419 CodeCompletionContext::CCC_Other);
6420 Results.EnterNewScope();
6421
6422 // Note what has already been captured.
6423 llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
6424 bool IncludedThis = false;
6425 for (const auto &C : Intro.Captures) {
6426 if (C.Kind == LCK_This) {
6427 IncludedThis = true;
6428 continue;
6429 }
6430
6431 Known.insert(C.Id);
6432 }
6433
6434 // Look for other capturable variables.
6435 for (; S && !isNamespaceScope(S); S = S->getParent()) {
6436 for (const auto *D : S->decls()) {
6437 const auto *Var = dyn_cast<VarDecl>(D);
6438 if (!Var || !Var->hasLocalStorage() || Var->hasAttr<BlocksAttr>())
6439 continue;
6440
6441 if (Known.insert(Var->getIdentifier()).second)
6442 Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration),
6443 CurContext, nullptr, false);
6444 }
6445 }
6446
6447 // Add 'this', if it would be valid.
6448 if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
6449 addThisCompletion(*this, Results);
6450
6451 Results.ExitScope();
6452
6453 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6454 Results.data(), Results.size());
6455}
6456
6457void Sema::CodeCompleteAfterFunctionEquals(Declarator &D) {
6458 if (!LangOpts.CPlusPlus11)
6459 return;
6460 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6461 CodeCompleter->getCodeCompletionTUInfo(),
6462 CodeCompletionContext::CCC_Other);
6463 auto ShouldAddDefault = [&D, this]() {
6464 if (!D.isFunctionDeclarator())
6465 return false;
6466 auto &Id = D.getName();
6467 if (Id.getKind() == UnqualifiedIdKind::IK_DestructorName)
6468 return true;
6469 // FIXME(liuhui): Ideally, we should check the constructor parameter list to
6470 // verify that it is the default, copy or move constructor?
6471 if (Id.getKind() == UnqualifiedIdKind::IK_ConstructorName &&
6472 D.getFunctionTypeInfo().NumParams <= 1)
6473 return true;
6474 if (Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId) {
6475 auto Op = Id.OperatorFunctionId.Operator;
6476 // FIXME(liuhui): Ideally, we should check the function parameter list to
6477 // verify that it is the copy or move assignment?
6478 if (Op == OverloadedOperatorKind::OO_Equal)
6479 return true;
6480 if (LangOpts.CPlusPlus20 &&
6481 (Op == OverloadedOperatorKind::OO_EqualEqual ||
6482 Op == OverloadedOperatorKind::OO_ExclaimEqual ||
6483 Op == OverloadedOperatorKind::OO_Less ||
6484 Op == OverloadedOperatorKind::OO_LessEqual ||
6485 Op == OverloadedOperatorKind::OO_Greater ||
6486 Op == OverloadedOperatorKind::OO_GreaterEqual ||
6487 Op == OverloadedOperatorKind::OO_Spaceship))
6488 return true;
6489 }
6490 return false;
6491 };
6492
6493 Results.EnterNewScope();
6494 if (ShouldAddDefault())
6495 Results.AddResult("default");
6496 // FIXME(liuhui): Ideally, we should only provide `delete` completion for the
6497 // first function declaration.
6498 Results.AddResult("delete");
6499 Results.ExitScope();
6500 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6501 Results.data(), Results.size());
6502}
6503
6504/// Macro that optionally prepends an "@" to the string literal passed in via
6505/// Keyword, depending on whether NeedAt is true or false.
6506#define OBJC_AT_KEYWORD_NAME(NeedAt, Keyword)((NeedAt) ? "@" Keyword : Keyword) ((NeedAt) ? "@" Keyword : Keyword)
6507
6508static void AddObjCImplementationResults(const LangOptions &LangOpts,
6509 ResultBuilder &Results, bool NeedAt) {
6510 typedef CodeCompletionResult Result;
6511 // Since we have an implementation, we can end it.
6512 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "end")((NeedAt) ? "@" "end" : "end")));
6513
6514 CodeCompletionBuilder Builder(Results.getAllocator(),
6515 Results.getCodeCompletionTUInfo());
6516 if (LangOpts.ObjC) {
6517 // @dynamic
6518 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "dynamic")((NeedAt) ? "@" "dynamic" : "dynamic"));
6519 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6520 Builder.AddPlaceholderChunk("property");
6521 Results.AddResult(Result(Builder.TakeString()));
6522
6523 // @synthesize
6524 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "synthesize")((NeedAt) ? "@" "synthesize" : "synthesize"));
6525 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6526 Builder.AddPlaceholderChunk("property");
6527 Results.AddResult(Result(Builder.TakeString()));
6528 }
6529}
6530
6531static void AddObjCInterfaceResults(const LangOptions &LangOpts,
6532 ResultBuilder &Results, bool NeedAt) {
6533 typedef CodeCompletionResult Result;
6534
6535 // Since we have an interface or protocol, we can end it.
6536 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "end")((NeedAt) ? "@" "end" : "end")));
6537
6538 if (LangOpts.ObjC) {
6539 // @property
6540 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "property")((NeedAt) ? "@" "property" : "property")));
6541
6542 // @required
6543 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "required")((NeedAt) ? "@" "required" : "required")));
6544
6545 // @optional
6546 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "optional")((NeedAt) ? "@" "optional" : "optional")));
6547 }
6548}
6549
6550static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
6551 typedef CodeCompletionResult Result;
6552 CodeCompletionBuilder Builder(Results.getAllocator(),
6553 Results.getCodeCompletionTUInfo());
6554
6555 // @class name ;
6556 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "class")((NeedAt) ? "@" "class" : "class"));
6557 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6558 Builder.AddPlaceholderChunk("name");
6559 Results.AddResult(Result(Builder.TakeString()));
6560
6561 if (Results.includeCodePatterns()) {
6562 // @interface name
6563 // FIXME: Could introduce the whole pattern, including superclasses and
6564 // such.
6565 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "interface")((NeedAt) ? "@" "interface" : "interface"));
6566 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6567 Builder.AddPlaceholderChunk("class");
6568 Results.AddResult(Result(Builder.TakeString()));
6569
6570 // @protocol name
6571 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "protocol")((NeedAt) ? "@" "protocol" : "protocol"));
6572 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6573 Builder.AddPlaceholderChunk("protocol");
6574 Results.AddResult(Result(Builder.TakeString()));
6575
6576 // @implementation name
6577 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "implementation")((NeedAt) ? "@" "implementation" : "implementation"));
6578 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6579 Builder.AddPlaceholderChunk("class");
6580 Results.AddResult(Result(Builder.TakeString()));
6581 }
6582
6583 // @compatibility_alias name
6584 Builder.AddTypedTextChunk(
6585 OBJC_AT_KEYWORD_NAME(NeedAt, "compatibility_alias")((NeedAt) ? "@" "compatibility_alias" : "compatibility_alias"
)
);
6586 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6587 Builder.AddPlaceholderChunk("alias");
6588 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6589 Builder.AddPlaceholderChunk("class");
6590 Results.AddResult(Result(Builder.TakeString()));
6591
6592 if (Results.getSema().getLangOpts().Modules) {
6593 // @import name
6594 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import")((NeedAt) ? "@" "import" : "import"));
6595 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6596 Builder.AddPlaceholderChunk("module");
6597 Results.AddResult(Result(Builder.TakeString()));
6598 }
6599}
6600
6601void Sema::CodeCompleteObjCAtDirective(Scope *S) {
6602 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6603 CodeCompleter->getCodeCompletionTUInfo(),
6604 CodeCompletionContext::CCC_Other);
6605 Results.EnterNewScope();
6606 if (isa<ObjCImplDecl>(CurContext))
6607 AddObjCImplementationResults(getLangOpts(), Results, false);
6608 else if (CurContext->isObjCContainer())
6609 AddObjCInterfaceResults(getLangOpts(), Results, false);
6610 else
6611 AddObjCTopLevelResults(Results, false);
6612 Results.ExitScope();
6613 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6614 Results.data(), Results.size());
6615}
6616
6617static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
6618 typedef CodeCompletionResult Result;
6619 CodeCompletionBuilder Builder(Results.getAllocator(),
6620 Results.getCodeCompletionTUInfo());
6621
6622 // @encode ( type-name )
6623 const char *EncodeType = "char[]";
6624 if (Results.getSema().getLangOpts().CPlusPlus ||
6625 Results.getSema().getLangOpts().ConstStrings)
6626 EncodeType = "const char[]";
6627 Builder.AddResultTypeChunk(EncodeType);
6628 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "encode")((NeedAt) ? "@" "encode" : "encode"));
6629 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6630 Builder.AddPlaceholderChunk("type-name");
6631 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6632 Results.AddResult(Result(Builder.TakeString()));
6633
6634 // @protocol ( protocol-name )
6635 Builder.AddResultTypeChunk("Protocol *");
6636 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "protocol")((NeedAt) ? "@" "protocol" : "protocol"));
6637 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6638 Builder.AddPlaceholderChunk("protocol-name");
6639 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6640 Results.AddResult(Result(Builder.TakeString()));
6641
6642 // @selector ( selector )
6643 Builder.AddResultTypeChunk("SEL");
6644 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "selector")((NeedAt) ? "@" "selector" : "selector"));
6645 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6646 Builder.AddPlaceholderChunk("selector");
6647 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6648 Results.AddResult(Result(Builder.TakeString()));
6649
6650 // @"string"
6651 Builder.AddResultTypeChunk("NSString *");
6652 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "\"")((NeedAt) ? "@" "\"" : "\""));
6653 Builder.AddPlaceholderChunk("string");
6654 Builder.AddTextChunk("\"");
6655 Results.AddResult(Result(Builder.TakeString()));
6656
6657 // @[objects, ...]
6658 Builder.AddResultTypeChunk("NSArray *");
6659 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "[")((NeedAt) ? "@" "[" : "["));
6660 Builder.AddPlaceholderChunk("objects, ...");
6661 Builder.AddChunk(CodeCompletionString::CK_RightBracket);
6662 Results.AddResult(Result(Builder.TakeString()));
6663
6664 // @{key : object, ...}
6665 Builder.AddResultTypeChunk("NSDictionary *");
6666 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "{")((NeedAt) ? "@" "{" : "{"));
6667 Builder.AddPlaceholderChunk("key");
6668 Builder.AddChunk(CodeCompletionString::CK_Colon);
6669 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6670 Builder.AddPlaceholderChunk("object, ...");
6671 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
6672 Results.AddResult(Result(Builder.TakeString()));
6673
6674 // @(expression)
6675 Builder.AddResultTypeChunk("id");
6676 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "(")((NeedAt) ? "@" "(" : "("));
6677 Builder.AddPlaceholderChunk("expression");
6678 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6679 Results.AddResult(Result(Builder.TakeString()));
6680}
6681
6682static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
6683 typedef CodeCompletionResult Result;
6684 CodeCompletionBuilder Builder(Results.getAllocator(),
6685 Results.getCodeCompletionTUInfo());
6686
6687 if (Results.includeCodePatterns()) {
6688 // @try { statements } @catch ( declaration ) { statements } @finally
6689 // { statements }
6690 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "try")((NeedAt) ? "@" "try" : "try"));
6691 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
6692 Builder.AddPlaceholderChunk("statements");
6693 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
6694 Builder.AddTextChunk("@catch");
6695 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6696 Builder.AddPlaceholderChunk("parameter");
6697 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6698 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
6699 Builder.AddPlaceholderChunk("statements");
6700 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
6701 Builder.AddTextChunk("@finally");
6702 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
6703 Builder.AddPlaceholderChunk("statements");
6704 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
6705 Results.AddResult(Result(Builder.TakeString()));
6706 }
6707
6708 // @throw
6709 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "throw")((NeedAt) ? "@" "throw" : "throw"));
6710 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6711 Builder.AddPlaceholderChunk("expression");
6712 Results.AddResult(Result(Builder.TakeString()));
6713
6714 if (Results.includeCodePatterns()) {
6715 // @synchronized ( expression ) { statements }
6716 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "synchronized")((NeedAt) ? "@" "synchronized" : "synchronized"));
6717 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
6718 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6719 Builder.AddPlaceholderChunk("expression");
6720 Builder.AddChunk(CodeCompletionString::CK_RightParen);
6721 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
6722 Builder.AddPlaceholderChunk("statements");
6723 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
6724 Results.AddResult(Result(Builder.TakeString()));
6725 }
6726}
6727
6728static void AddObjCVisibilityResults(const LangOptions &LangOpts,
6729 ResultBuilder &Results, bool NeedAt) {
6730 typedef CodeCompletionResult Result;
6731 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "private")((NeedAt) ? "@" "private" : "private")));
6732 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "protected")((NeedAt) ? "@" "protected" : "protected")));
6733 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "public")((NeedAt) ? "@" "public" : "public")));
6734 if (LangOpts.ObjC)
6735 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "package")((NeedAt) ? "@" "package" : "package")));
6736}
6737
6738void Sema::CodeCompleteObjCAtVisibility(Scope *S) {
6739 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6740 CodeCompleter->getCodeCompletionTUInfo(),
6741 CodeCompletionContext::CCC_Other);
6742 Results.EnterNewScope();
6743 AddObjCVisibilityResults(getLangOpts(), Results, false);
6744 Results.ExitScope();
6745 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6746 Results.data(), Results.size());
6747}
6748
6749void Sema::CodeCompleteObjCAtStatement(Scope *S) {
6750 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6751 CodeCompleter->getCodeCompletionTUInfo(),
6752 CodeCompletionContext::CCC_Other);
6753 Results.EnterNewScope();
6754 AddObjCStatementResults(Results, false);
6755 AddObjCExpressionResults(Results, false);
6756 Results.ExitScope();
6757 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6758 Results.data(), Results.size());
6759}
6760
6761void Sema::CodeCompleteObjCAtExpression(Scope *S) {
6762 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6763 CodeCompleter->getCodeCompletionTUInfo(),
6764 CodeCompletionContext::CCC_Other);
6765 Results.EnterNewScope();
6766 AddObjCExpressionResults(Results, false);
6767 Results.ExitScope();
6768 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6769 Results.data(), Results.size());
6770}
6771
6772/// Determine whether the addition of the given flag to an Objective-C
6773/// property's attributes will cause a conflict.
6774static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
6775 // Check if we've already added this flag.
6776 if (Attributes & NewFlag)
6777 return true;
6778
6779 Attributes |= NewFlag;
6780
6781 // Check for collisions with "readonly".
6782 if ((Attributes & ObjCPropertyAttribute::kind_readonly) &&
6783 (Attributes & ObjCPropertyAttribute::kind_readwrite))
6784 return true;
6785
6786 // Check for more than one of { assign, copy, retain, strong, weak }.
6787 unsigned AssignCopyRetMask =
6788 Attributes &
6789 (ObjCPropertyAttribute::kind_assign |
6790 ObjCPropertyAttribute::kind_unsafe_unretained |
6791 ObjCPropertyAttribute::kind_copy | ObjCPropertyAttribute::kind_retain |
6792 ObjCPropertyAttribute::kind_strong | ObjCPropertyAttribute::kind_weak);
6793 if (AssignCopyRetMask &&
6794 AssignCopyRetMask != ObjCPropertyAttribute::kind_assign &&
6795 AssignCopyRetMask != ObjCPropertyAttribute::kind_unsafe_unretained &&
6796 AssignCopyRetMask != ObjCPropertyAttribute::kind_copy &&
6797 AssignCopyRetMask != ObjCPropertyAttribute::kind_retain &&
6798 AssignCopyRetMask != ObjCPropertyAttribute::kind_strong &&
6799 AssignCopyRetMask != ObjCPropertyAttribute::kind_weak)
6800 return true;
6801
6802 return false;
6803}
6804
6805void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) {
6806 if (!CodeCompleter)
6807 return;
6808
6809 unsigned Attributes = ODS.getPropertyAttributes();
6810
6811 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6812 CodeCompleter->getCodeCompletionTUInfo(),
6813 CodeCompletionContext::CCC_Other);
6814 Results.EnterNewScope();
6815 if (!ObjCPropertyFlagConflicts(Attributes,
6816 ObjCPropertyAttribute::kind_readonly))
6817 Results.AddResult(CodeCompletionResult("readonly"));
6818 if (!ObjCPropertyFlagConflicts(Attributes,
6819 ObjCPropertyAttribute::kind_assign))
6820 Results.AddResult(CodeCompletionResult("assign"));
6821 if (!ObjCPropertyFlagConflicts(Attributes,
6822 ObjCPropertyAttribute::kind_unsafe_unretained))
6823 Results.AddResult(CodeCompletionResult("unsafe_unretained"));
6824 if (!ObjCPropertyFlagConflicts(Attributes,
6825 ObjCPropertyAttribute::kind_readwrite))
6826 Results.AddResult(CodeCompletionResult("readwrite"));
6827 if (!ObjCPropertyFlagConflicts(Attributes,
6828 ObjCPropertyAttribute::kind_retain))
6829 Results.AddResult(CodeCompletionResult("retain"));
6830 if (!ObjCPropertyFlagConflicts(Attributes,
6831 ObjCPropertyAttribute::kind_strong))
6832 Results.AddResult(CodeCompletionResult("strong"));
6833 if (!ObjCPropertyFlagConflicts(Attributes, ObjCPropertyAttribute::kind_copy))
6834 Results.AddResult(CodeCompletionResult("copy"));
6835 if (!ObjCPropertyFlagConflicts(Attributes,
6836 ObjCPropertyAttribute::kind_nonatomic))
6837 Results.AddResult(CodeCompletionResult("nonatomic"));
6838 if (!ObjCPropertyFlagConflicts(Attributes,
6839 ObjCPropertyAttribute::kind_atomic))
6840 Results.AddResult(CodeCompletionResult("atomic"));
6841
6842 // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
6843 if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC)
6844 if (!ObjCPropertyFlagConflicts(Attributes,
6845 ObjCPropertyAttribute::kind_weak))
6846 Results.AddResult(CodeCompletionResult("weak"));
6847
6848 if (!ObjCPropertyFlagConflicts(Attributes,
6849 ObjCPropertyAttribute::kind_setter)) {
6850 CodeCompletionBuilder Setter(Results.getAllocator(),
6851 Results.getCodeCompletionTUInfo());
6852 Setter.AddTypedTextChunk("setter");
6853 Setter.AddTextChunk("=");
6854 Setter.AddPlaceholderChunk("method");
6855 Results.AddResult(CodeCompletionResult(Setter.TakeString()));
6856 }
6857 if (!ObjCPropertyFlagConflicts(Attributes,
6858 ObjCPropertyAttribute::kind_getter)) {
6859 CodeCompletionBuilder Getter(Results.getAllocator(),
6860 Results.getCodeCompletionTUInfo());
6861 Getter.AddTypedTextChunk("getter");
6862 Getter.AddTextChunk("=");
6863 Getter.AddPlaceholderChunk("method");
6864 Results.AddResult(CodeCompletionResult(Getter.TakeString()));
6865 }
6866 if (!ObjCPropertyFlagConflicts(Attributes,
6867 ObjCPropertyAttribute::kind_nullability)) {
6868 Results.AddResult(CodeCompletionResult("nonnull"));
6869 Results.AddResult(CodeCompletionResult("nullable"));
6870 Results.AddResult(CodeCompletionResult("null_unspecified"));
6871 Results.AddResult(CodeCompletionResult("null_resettable"));
6872 }
6873 Results.ExitScope();
6874 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6875 Results.data(), Results.size());
6876}
6877
6878/// Describes the kind of Objective-C method that we want to find
6879/// via code completion.
6880enum ObjCMethodKind {
6881 MK_Any, ///< Any kind of method, provided it means other specified criteria.
6882 MK_ZeroArgSelector, ///< Zero-argument (unary) selector.
6883 MK_OneArgSelector ///< One-argument selector.
6884};
6885
6886static bool isAcceptableObjCSelector(Selector Sel, ObjCMethodKind WantKind,
6887 ArrayRef<IdentifierInfo *> SelIdents,
6888 bool AllowSameLength = true) {
6889 unsigned NumSelIdents = SelIdents.size();
6890 if (NumSelIdents > Sel.getNumArgs())
6891 return false;
6892
6893 switch (WantKind) {
6894 case MK_Any:
6895 break;
6896 case MK_ZeroArgSelector:
6897 return Sel.isUnarySelector();
6898 case MK_OneArgSelector:
6899 return Sel.getNumArgs() == 1;
6900 }
6901
6902 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
6903 return false;
6904
6905 for (unsigned I = 0; I != NumSelIdents; ++I)
6906 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
6907 return false;
6908
6909 return true;
6910}
6911
6912static bool isAcceptableObjCMethod(ObjCMethodDecl *Method,
6913 ObjCMethodKind WantKind,
6914 ArrayRef<IdentifierInfo *> SelIdents,
6915 bool AllowSameLength = true) {
6916 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
6917 AllowSameLength);
6918}
6919
6920/// A set of selectors, which is used to avoid introducing multiple
6921/// completions with the same selector into the result set.
6922typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
6923
6924/// Add all of the Objective-C methods in the given Objective-C
6925/// container to the set of results.
6926///
6927/// The container will be a class, protocol, category, or implementation of
6928/// any of the above. This mether will recurse to include methods from
6929/// the superclasses of classes along with their categories, protocols, and
6930/// implementations.
6931///
6932/// \param Container the container in which we'll look to find methods.
6933///
6934/// \param WantInstanceMethods Whether to add instance methods (only); if
6935/// false, this routine will add factory methods (only).
6936///
6937/// \param CurContext the context in which we're performing the lookup that
6938/// finds methods.
6939///
6940/// \param AllowSameLength Whether we allow a method to be added to the list
6941/// when it has the same number of parameters as we have selector identifiers.
6942///
6943/// \param Results the structure into which we'll add results.
6944static void AddObjCMethods(ObjCContainerDecl *Container,
6945 bool WantInstanceMethods, ObjCMethodKind WantKind,
6946 ArrayRef<IdentifierInfo *> SelIdents,
6947 DeclContext *CurContext,
6948 VisitedSelectorSet &Selectors, bool AllowSameLength,
6949 ResultBuilder &Results, bool InOriginalClass = true,
6950 bool IsRootClass = false) {
6951 typedef CodeCompletionResult Result;
6952 Container = getContainerDef(Container);
6953 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
6954 IsRootClass = IsRootClass || (IFace && !IFace->getSuperClass());
6955 for (ObjCMethodDecl *M : Container->methods()) {
6956 // The instance methods on the root class can be messaged via the
6957 // metaclass.
6958 if (M->isInstanceMethod() == WantInstanceMethods ||
6959 (IsRootClass && !WantInstanceMethods)) {
6960 // Check whether the selector identifiers we've been given are a
6961 // subset of the identifiers for this particular method.
6962 if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength))
6963 continue;
6964
6965 if (!Selectors.insert(M->getSelector()).second)
6966 continue;
6967
6968 Result R = Result(M, Results.getBasePriority(M), nullptr);
6969 R.StartParameter = SelIdents.size();
6970 R.AllParametersAreInformative = (WantKind != MK_Any);
6971 if (!InOriginalClass)
6972 setInBaseClass(R);
6973 Results.MaybeAddResult(R, CurContext);
6974 }
6975 }
6976
6977 // Visit the protocols of protocols.
6978 if (const auto *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
6979 if (Protocol->hasDefinition()) {
6980 const ObjCList<ObjCProtocolDecl> &Protocols =
6981 Protocol->getReferencedProtocols();
6982 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6983 E = Protocols.end();
6984 I != E; ++I)
6985 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
6986 Selectors, AllowSameLength, Results, false, IsRootClass);
6987 }
6988 }
6989
6990 if (!IFace || !IFace->hasDefinition())
6991 return;
6992
6993 // Add methods in protocols.
6994 for (ObjCProtocolDecl *I : IFace->protocols())
6995 AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents, CurContext,
6996 Selectors, AllowSameLength, Results, false, IsRootClass);
6997
6998 // Add methods in categories.
6999 for (ObjCCategoryDecl *CatDecl : IFace->known_categories()) {
7000 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
7001 CurContext, Selectors, AllowSameLength, Results,
7002 InOriginalClass, IsRootClass);
7003
7004 // Add a categories protocol methods.
7005 const ObjCList<ObjCProtocolDecl> &Protocols =
7006 CatDecl->getReferencedProtocols();
7007 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
7008 E = Protocols.end();
7009 I != E; ++I)
7010 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
7011 Selectors, AllowSameLength, Results, false, IsRootClass);
7012
7013 // Add methods in category implementations.
7014 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
7015 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
7016 Selectors, AllowSameLength, Results, InOriginalClass,
7017 IsRootClass);
7018 }
7019
7020 // Add methods in superclass.
7021 // Avoid passing in IsRootClass since root classes won't have super classes.
7022 if (IFace->getSuperClass())
7023 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
7024 SelIdents, CurContext, Selectors, AllowSameLength, Results,
7025 /*IsRootClass=*/false);
7026
7027 // Add methods in our implementation, if any.
7028 if (ObjCImplementationDecl *Impl = IFace->getImplementation())
7029 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
7030 Selectors, AllowSameLength, Results, InOriginalClass,
7031 IsRootClass);
7032}
7033
7034void Sema::CodeCompleteObjCPropertyGetter(Scope *S) {
7035 // Try to find the interface where getters might live.
7036 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
7037 if (!Class) {
7038 if (ObjCCategoryDecl *Category =
7039 dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
7040 Class = Category->getClassInterface();
7041
7042 if (!Class)
7043 return;
7044 }
7045
7046 // Find all of the potential getters.
7047 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7048 CodeCompleter->getCodeCompletionTUInfo(),
7049 CodeCompletionContext::CCC_Other);
7050 Results.EnterNewScope();
7051
7052 VisitedSelectorSet Selectors;
7053 AddObjCMethods(Class, true, MK_ZeroArgSelector, None, CurContext, Selectors,
7054 /*AllowSameLength=*/true, Results);
7055 Results.ExitScope();
7056 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7057 Results.data(), Results.size());
7058}
7059
7060void Sema::CodeCompleteObjCPropertySetter(Scope *S) {
7061 // Try to find the interface where setters might live.
7062 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
7063 if (!Class) {
7064 if (ObjCCategoryDecl *Category =
7065 dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
7066 Class = Category->getClassInterface();
7067
7068 if (!Class)
7069 return;
7070 }
7071
7072 // Find all of the potential getters.
7073 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7074 CodeCompleter->getCodeCompletionTUInfo(),
7075 CodeCompletionContext::CCC_Other);
7076 Results.EnterNewScope();
7077
7078 VisitedSelectorSet Selectors;
7079 AddObjCMethods(Class, true, MK_OneArgSelector, None, CurContext, Selectors,
7080 /*AllowSameLength=*/true, Results);
7081
7082 Results.ExitScope();
7083 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7084 Results.data(), Results.size());
7085}
7086
7087void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
7088 bool IsParameter) {
7089 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7090 CodeCompleter->getCodeCompletionTUInfo(),
7091 CodeCompletionContext::CCC_Type);
7092 Results.EnterNewScope();
7093
7094 // Add context-sensitive, Objective-C parameter-passing keywords.
7095 bool AddedInOut = false;
7096 if ((DS.getObjCDeclQualifier() &
7097 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) {
7098 Results.AddResult("in");
7099 Results.AddResult("inout");
7100 AddedInOut = true;
7101 }
7102 if ((DS.getObjCDeclQualifier() &
7103 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) {
7104 Results.AddResult("out");
7105 if (!AddedInOut)
7106 Results.AddResult("inout");
7107 }
7108 if ((DS.getObjCDeclQualifier() &
7109 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref |
7110 ObjCDeclSpec::DQ_Oneway)) == 0) {
7111 Results.AddResult("bycopy");
7112 Results.AddResult("byref");
7113 Results.AddResult("oneway");
7114 }
7115 if ((DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) == 0) {
7116 Results.AddResult("nonnull");
7117 Results.AddResult("nullable");
7118 Results.AddResult("null_unspecified");
7119 }
7120
7121 // If we're completing the return type of an Objective-C method and the
7122 // identifier IBAction refers to a macro, provide a completion item for
7123 // an action, e.g.,
7124 // IBAction)<#selector#>:(id)sender
7125 if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
7126 PP.isMacroDefined("IBAction")) {
7127 CodeCompletionBuilder Builder(Results.getAllocator(),
7128 Results.getCodeCompletionTUInfo(),
7129 CCP_CodePattern, CXAvailability_Available);
7130 Builder.AddTypedTextChunk("IBAction");
7131 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7132 Builder.AddPlaceholderChunk("selector");
7133 Builder.AddChunk(CodeCompletionString::CK_Colon);
7134 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7135 Builder.AddTextChunk("id");
7136 Builder.AddChunk(CodeCompletionString::CK_RightParen);
7137 Builder.AddTextChunk("sender");
7138 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
7139 }
7140
7141 // If we're completing the return type, provide 'instancetype'.
7142 if (!IsParameter) {
7143 Results.AddResult(CodeCompletionResult("instancetype"));
7144 }
7145
7146 // Add various builtin type names and specifiers.
7147 AddOrdinaryNameResults(PCC_Type, S, *this, Results);
7148 Results.ExitScope();
7149
7150 // Add the various type names
7151 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
7152 CodeCompletionDeclConsumer Consumer(Results, CurContext);
7153 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
7154 CodeCompleter->includeGlobals(),
7155 CodeCompleter->loadExternal());
7156
7157 if (CodeCompleter->includeMacros())
7158 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
7159
7160 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7161 Results.data(), Results.size());
7162}
7163
7164/// When we have an expression with type "id", we may assume
7165/// that it has some more-specific class type based on knowledge of
7166/// common uses of Objective-C. This routine returns that class type,
7167/// or NULL if no better result could be determined.
7168static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) {
7169 auto *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
7170 if (!Msg)
7171 return nullptr;
7172
7173 Selector Sel = Msg->getSelector();
7174 if (Sel.isNull())
7175 return nullptr;
7176
7177 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0);
7178 if (!Id)
7179 return nullptr;
7180
7181 ObjCMethodDecl *Method = Msg->getMethodDecl();
7182 if (!Method)
7183 return nullptr;
7184
7185 // Determine the class that we're sending the message to.
7186 ObjCInterfaceDecl *IFace = nullptr;
7187 switch (Msg->getReceiverKind()) {
7188 case ObjCMessageExpr::Class:
7189 if (const ObjCObjectType *ObjType =
7190 Msg->getClassReceiver()->getAs<ObjCObjectType>())
7191 IFace = ObjType->getInterface();
7192 break;
7193
7194 case ObjCMessageExpr::Instance: {
7195 QualType T = Msg->getInstanceReceiver()->getType();
7196 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
7197 IFace = Ptr->getInterfaceDecl();
7198 break;
7199 }
7200
7201 case ObjCMessageExpr::SuperInstance:
7202 case ObjCMessageExpr::SuperClass:
7203 break;
7204 }
7205
7206 if (!IFace)
7207 return nullptr;
7208
7209 ObjCInterfaceDecl *Super = IFace->getSuperClass();
7210 if (Method->isInstanceMethod())
7211 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
7212 .Case("retain", IFace)
7213 .Case("strong", IFace)
7214 .Case("autorelease", IFace)
7215 .Case("copy", IFace)
7216 .Case("copyWithZone", IFace)
7217 .Case("mutableCopy", IFace)
7218 .Case("mutableCopyWithZone", IFace)
7219 .Case("awakeFromCoder", IFace)
7220 .Case("replacementObjectFromCoder", IFace)
7221 .Case("class", IFace)
7222 .Case("classForCoder", IFace)
7223 .Case("superclass", Super)
7224 .Default(nullptr);
7225
7226 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
7227 .Case("new", IFace)
7228 .Case("alloc", IFace)
7229 .Case("allocWithZone", IFace)
7230 .Case("class", IFace)
7231 .Case("superclass", Super)
7232 .Default(nullptr);
7233}
7234
7235// Add a special completion for a message send to "super", which fills in the
7236// most likely case of forwarding all of our arguments to the superclass
7237// function.
7238///
7239/// \param S The semantic analysis object.
7240///
7241/// \param NeedSuperKeyword Whether we need to prefix this completion with
7242/// the "super" keyword. Otherwise, we just need to provide the arguments.
7243///
7244/// \param SelIdents The identifiers in the selector that have already been
7245/// provided as arguments for a send to "super".
7246///
7247/// \param Results The set of results to augment.
7248///
7249/// \returns the Objective-C method declaration that would be invoked by
7250/// this "super" completion. If NULL, no completion was added.
7251static ObjCMethodDecl *
7252AddSuperSendCompletion(Sema &S, bool NeedSuperKeyword,
7253 ArrayRef<IdentifierInfo *> SelIdents,
7254 ResultBuilder &Results) {
7255 ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
7256 if (!CurMethod)
7257 return nullptr;
7258
7259 ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
7260 if (!Class)
7261 return nullptr;
7262
7263 // Try to find a superclass method with the same selector.
7264 ObjCMethodDecl *SuperMethod = nullptr;
7265 while ((Class = Class->getSuperClass()) && !SuperMethod) {
7266 // Check in the class
7267 SuperMethod = Class->getMethod(CurMethod->getSelector(),
7268 CurMethod->isInstanceMethod());
7269
7270 // Check in categories or class extensions.
7271 if (!SuperMethod) {
7272 for (const auto *Cat : Class->known_categories()) {
7273 if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(),
7274 CurMethod->isInstanceMethod())))
7275 break;
7276 }
7277 }
7278 }
7279
7280 if (!SuperMethod)
7281 return nullptr;
7282
7283 // Check whether the superclass method has the same signature.
7284 if (CurMethod->param_size() != SuperMethod->param_size() ||
7285 CurMethod->isVariadic() != SuperMethod->isVariadic())
7286 return nullptr;
7287
7288 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
7289 CurPEnd = CurMethod->param_end(),
7290 SuperP = SuperMethod->param_begin();
7291 CurP != CurPEnd; ++CurP, ++SuperP) {
7292 // Make sure the parameter types are compatible.
7293 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
7294 (*SuperP)->getType()))
7295 return nullptr;
7296
7297 // Make sure we have a parameter name to forward!
7298 if (!(*CurP)->getIdentifier())
7299 return nullptr;
7300 }
7301
7302 // We have a superclass method. Now, form the send-to-super completion.
7303 CodeCompletionBuilder Builder(Results.getAllocator(),
7304 Results.getCodeCompletionTUInfo());
7305
7306 // Give this completion a return type.
7307 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod,
7308 Results.getCompletionContext().getBaseType(), Builder);
7309
7310 // If we need the "super" keyword, add it (plus some spacing).
7311 if (NeedSuperKeyword) {
7312 Builder.AddTypedTextChunk("super");
7313 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7314 }
7315
7316 Selector Sel = CurMethod->getSelector();
7317 if (Sel.isUnarySelector()) {
7318 if (NeedSuperKeyword)
7319 Builder.AddTextChunk(
7320 Builder.getAllocator().CopyString(Sel.getNameForSlot(0)));
7321 else
7322 Builder.AddTypedTextChunk(
7323 Builder.getAllocator().CopyString(Sel.getNameForSlot(0)));
7324 } else {
7325 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
7326 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
7327 if (I > SelIdents.size())
7328 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7329
7330 if (I < SelIdents.size())
7331 Builder.AddInformativeChunk(
7332 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
7333 else if (NeedSuperKeyword || I > SelIdents.size()) {
7334 Builder.AddTextChunk(
7335 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
7336 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
7337 (*CurP)->getIdentifier()->getName()));
7338 } else {
7339 Builder.AddTypedTextChunk(
7340 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
7341 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
7342 (*CurP)->getIdentifier()->getName()));
7343 }
7344 }
7345 }
7346
7347 Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod,
7348 CCP_SuperCompletion));
7349 return SuperMethod;
7350}
7351
7352void Sema::CodeCompleteObjCMessageReceiver(Scope *S) {
7353 typedef CodeCompletionResult Result;
7354 ResultBuilder Results(
7355 *this, CodeCompleter->getAllocator(),
7356 CodeCompleter->getCodeCompletionTUInfo(),
7357 CodeCompletionContext::CCC_ObjCMessageReceiver,
7358 getLangOpts().CPlusPlus11
7359 ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture
7360 : &ResultBuilder::IsObjCMessageReceiver);
7361
7362 CodeCompletionDeclConsumer Consumer(Results, CurContext);
7363 Results.EnterNewScope();
7364 LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
7365 CodeCompleter->includeGlobals(),
7366 CodeCompleter->loadExternal());
7367
7368 // If we are in an Objective-C method inside a class that has a superclass,
7369 // add "super" as an option.
7370 if (ObjCMethodDecl *Method = getCurMethodDecl())
7371 if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
7372 if (Iface->getSuperClass()) {
7373 Results.AddResult(Result("super"));
7374
7375 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, None, Results);
7376 }
7377
7378 if (getLangOpts().CPlusPlus11)
7379 addThisCompletion(*this, Results);
7380
7381 Results.ExitScope();
7382
7383 if (CodeCompleter->includeMacros())
7384 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false);
7385 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7386 Results.data(), Results.size());
7387}
7388
7389void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
7390 ArrayRef<IdentifierInfo *> SelIdents,
7391 bool AtArgumentExpression) {
7392 ObjCInterfaceDecl *CDecl = nullptr;
7393 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
7394 // Figure out which interface we're in.
7395 CDecl = CurMethod->getClassInterface();
7396 if (!CDecl)
7397 return;
7398
7399 // Find the superclass of this class.
7400 CDecl = CDecl->getSuperClass();
7401 if (!CDecl)
7402 return;
7403
7404 if (CurMethod->isInstanceMethod()) {
7405 // We are inside an instance method, which means that the message
7406 // send [super ...] is actually calling an instance method on the
7407 // current object.
7408 return CodeCompleteObjCInstanceMessage(S, nullptr, SelIdents,
7409 AtArgumentExpression, CDecl);
7410 }
7411
7412 // Fall through to send to the superclass in CDecl.
7413 } else {
7414 // "super" may be the name of a type or variable. Figure out which
7415 // it is.
7416 IdentifierInfo *Super = getSuperIdentifier();
7417 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc, LookupOrdinaryName);
7418 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
7419 // "super" names an interface. Use it.
7420 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
7421 if (const ObjCObjectType *Iface =
7422 Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
7423 CDecl = Iface->getInterface();
7424 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
7425 // "super" names an unresolved type; we can't be more specific.
7426 } else {
7427 // Assume that "super" names some kind of value and parse that way.
7428 CXXScopeSpec SS;
7429 SourceLocation TemplateKWLoc;
7430 UnqualifiedId id;
7431 id.setIdentifier(Super, SuperLoc);
7432 ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id,
7433 /*HasTrailingLParen=*/false,
7434 /*IsAddressOfOperand=*/false);
7435 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
7436 SelIdents, AtArgumentExpression);
7437 }
7438
7439 // Fall through
7440 }
7441
7442 ParsedType Receiver;
7443 if (CDecl)
7444 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
7445 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
7446 AtArgumentExpression,
7447 /*IsSuper=*/true);
7448}
7449
7450/// Given a set of code-completion results for the argument of a message
7451/// send, determine the preferred type (if any) for that argument expression.
7452static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
7453 unsigned NumSelIdents) {
7454 typedef CodeCompletionResult Result;
7455 ASTContext &Context = Results.getSema().Context;
7456
7457 QualType PreferredType;
7458 unsigned BestPriority = CCP_Unlikely * 2;
7459 Result *ResultsData = Results.data();
7460 for (unsigned I = 0, N = Results.size(); I != N; ++I) {
7461 Result &R = ResultsData[I];
7462 if (R.Kind == Result::RK_Declaration &&
7463 isa<ObjCMethodDecl>(R.Declaration)) {
7464 if (R.Priority <= BestPriority) {
7465 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
7466 if (NumSelIdents <= Method->param_size()) {
7467 QualType MyPreferredType =
7468 Method->parameters()[NumSelIdents - 1]->getType();
7469 if (R.Priority < BestPriority || PreferredType.isNull()) {
7470 BestPriority = R.Priority;
7471 PreferredType = MyPreferredType;
7472 } else if (!Context.hasSameUnqualifiedType(PreferredType,
7473 MyPreferredType)) {
7474 PreferredType = QualType();
7475 }
7476 }
7477 }
7478 }
7479 }
7480
7481 return PreferredType;
7482}
7483
7484static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
7485 ParsedType Receiver,
7486 ArrayRef<IdentifierInfo *> SelIdents,
7487 bool AtArgumentExpression, bool IsSuper,
7488 ResultBuilder &Results) {
7489 typedef CodeCompletionResult Result;
7490 ObjCInterfaceDecl *CDecl = nullptr;
7491
7492 // If the given name refers to an interface type, retrieve the
7493 // corresponding declaration.
7494 if (Receiver) {
7495 QualType T = SemaRef.GetTypeFromParser(Receiver, nullptr);
7496 if (!T.isNull())
7497 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
7498 CDecl = Interface->getInterface();
7499 }
7500
7501 // Add all of the factory methods in this Objective-C class, its protocols,
7502 // superclasses, categories, implementation, etc.
7503 Results.EnterNewScope();
7504
7505 // If this is a send-to-super, try to add the special "super" send
7506 // completion.
7507 if (IsSuper) {
7508 if (ObjCMethodDecl *SuperMethod =
7509 AddSuperSendCompletion(SemaRef, false, SelIdents, Results))
7510 Results.Ignore(SuperMethod);
7511 }
7512
7513 // If we're inside an Objective-C method definition, prefer its selector to
7514 // others.
7515 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
7516 Results.setPreferredSelector(CurMethod->getSelector());
7517
7518 VisitedSelectorSet Selectors;
7519 if (CDecl)
7520 AddObjCMethods(CDecl, false, MK_Any, SelIdents, SemaRef.CurContext,
7521 Selectors, AtArgumentExpression, Results);
7522 else {
7523 // We're messaging "id" as a type; provide all class/factory methods.
7524
7525 // If we have an external source, load the entire class method
7526 // pool from the AST file.
7527 if (SemaRef.getExternalSource()) {
7528 for (uint32_t I = 0,
7529 N = SemaRef.getExternalSource()->GetNumExternalSelectors();
7530 I != N; ++I) {
7531 Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I);
7532 if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
7533 continue;
7534
7535 SemaRef.ReadMethodPool(Sel);
7536 }
7537 }
7538
7539 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
7540 MEnd = SemaRef.MethodPool.end();
7541 M != MEnd; ++M) {
7542 for (ObjCMethodList *MethList = &M->second.second;
7543 MethList && MethList->getMethod(); MethList = MethList->getNext()) {
7544 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
7545 continue;
7546
7547 Result R(MethList->getMethod(),
7548 Results.getBasePriority(MethList->getMethod()), nullptr);
7549 R.StartParameter = SelIdents.size();
7550 R.AllParametersAreInformative = false;
7551 Results.MaybeAddResult(R, SemaRef.CurContext);
7552 }
7553 }
7554 }
7555
7556 Results.ExitScope();
7557}
7558
7559void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
7560 ArrayRef<IdentifierInfo *> SelIdents,
7561 bool AtArgumentExpression,
7562 bool IsSuper) {
7563
7564 QualType T = this->GetTypeFromParser(Receiver);
7565
7566 ResultBuilder Results(
7567 *this, CodeCompleter->getAllocator(),
7568 CodeCompleter->getCodeCompletionTUInfo(),
7569 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage, T,
7570 SelIdents));
7571
7572 AddClassMessageCompletions(*this, S, Receiver, SelIdents,
7573 AtArgumentExpression, IsSuper, Results);
7574
7575 // If we're actually at the argument expression (rather than prior to the
7576 // selector), we're actually performing code completion for an expression.
7577 // Determine whether we have a single, best method. If so, we can
7578 // code-complete the expression using the corresponding parameter type as
7579 // our preferred type, improving completion results.
7580 if (AtArgumentExpression) {
7581 QualType PreferredType =
7582 getPreferredArgumentTypeForMessageSend(Results, SelIdents.size());
7583 if (PreferredType.isNull())
7584 CodeCompleteOrdinaryName(S, PCC_Expression);
7585 else
7586 CodeCompleteExpression(S, PreferredType);
7587 return;
7588 }
7589
7590 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7591 Results.data(), Results.size());
7592}
7593
7594void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
7595 ArrayRef<IdentifierInfo *> SelIdents,
7596 bool AtArgumentExpression,
7597 ObjCInterfaceDecl *Super) {
7598 typedef CodeCompletionResult Result;
7599
7600 Expr *RecExpr = static_cast<Expr *>(Receiver);
7601
7602 // If necessary, apply function/array conversion to the receiver.
7603 // C99 6.7.5.3p[7,8].
7604 if (RecExpr) {
7605 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
7606 if (Conv.isInvalid()) // conversion failed. bail.
7607 return;
7608 RecExpr = Conv.get();
7609 }
7610 QualType ReceiverType = RecExpr
7611 ? RecExpr->getType()
7612 : Super ? Context.getObjCObjectPointerType(
7613 Context.getObjCInterfaceType(Super))
7614 : Context.getObjCIdType();
7615
7616 // If we're messaging an expression with type "id" or "Class", check
7617 // whether we know something special about the receiver that allows
7618 // us to assume a more-specific receiver type.
7619 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) {
7620 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
7621 if (ReceiverType->isObjCClassType())
7622 return CodeCompleteObjCClassMessage(
7623 S, ParsedType::make(Context.getObjCInterfaceType(IFace)), SelIdents,
7624 AtArgumentExpression, Super);
7625
7626 ReceiverType =
7627 Context.getObjCObjectPointerType(Context.getObjCInterfaceType(IFace));
7628 }
7629 } else if (RecExpr && getLangOpts().CPlusPlus) {
7630 ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr);
7631 if (Conv.isUsable()) {
7632 RecExpr = Conv.get();
7633 ReceiverType = RecExpr->getType();
7634 }
7635 }
7636
7637 // Build the set of methods we can see.
7638 ResultBuilder Results(
7639 *this, CodeCompleter->getAllocator(),
7640 CodeCompleter->getCodeCompletionTUInfo(),
7641 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage,
7642 ReceiverType, SelIdents));
7643
7644 Results.EnterNewScope();
7645
7646 // If this is a send-to-super, try to add the special "super" send
7647 // completion.
7648 if (Super) {
7649 if (ObjCMethodDecl *SuperMethod =
7650 AddSuperSendCompletion(*this, false, SelIdents, Results))
7651 Results.Ignore(SuperMethod);
7652 }
7653
7654 // If we're inside an Objective-C method definition, prefer its selector to
7655 // others.
7656 if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
7657 Results.setPreferredSelector(CurMethod->getSelector());
7658
7659 // Keep track of the selectors we've already added.
7660 VisitedSelectorSet Selectors;
7661
7662 // Handle messages to Class. This really isn't a message to an instance
7663 // method, so we treat it the same way we would treat a message send to a
7664 // class method.
7665 if (ReceiverType->isObjCClassType() ||
7666 ReceiverType->isObjCQualifiedClassType()) {
7667 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
7668 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
7669 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents, CurContext,
7670 Selectors, AtArgumentExpression, Results);
7671 }
7672 }
7673 // Handle messages to a qualified ID ("id<foo>").
7674 else if (const ObjCObjectPointerType *QualID =
7675 ReceiverType->getAsObjCQualifiedIdType()) {
7676 // Search protocols for instance methods.
7677 for (auto *I : QualID->quals())
7678 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext, Selectors,
7679 AtArgumentExpression, Results);
7680 }
7681 // Handle messages to a pointer to interface type.
7682 else if (const ObjCObjectPointerType *IFacePtr =
7683 ReceiverType->getAsObjCInterfacePointerType()) {
7684 // Search the class, its superclasses, etc., for instance methods.
7685 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
7686 CurContext, Selectors, AtArgumentExpression, Results);
7687
7688 // Search protocols for instance methods.
7689 for (auto *I : IFacePtr->quals())
7690 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext, Selectors,
7691 AtArgumentExpression, Results);
7692 }
7693 // Handle messages to "id".
7694 else if (ReceiverType->isObjCIdType()) {
7695 // We're messaging "id", so provide all instance methods we know
7696 // about as code-completion results.
7697
7698 // If we have an external source, load the entire class method
7699 // pool from the AST file.
7700 if (ExternalSource) {
7701 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
7702 I != N; ++I) {
7703 Selector Sel = ExternalSource->GetExternalSelector(I);
7704 if (Sel.isNull() || MethodPool.count(Sel))
7705 continue;
7706
7707 ReadMethodPool(Sel);
7708 }
7709 }
7710
7711 for (GlobalMethodPool::iterator M = MethodPool.begin(),
7712 MEnd = MethodPool.end();
7713 M != MEnd; ++M) {
7714 for (ObjCMethodList *MethList = &M->second.first;
7715 MethList && MethList->getMethod(); MethList = MethList->getNext()) {
7716 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
7717 continue;
7718
7719 if (!Selectors.insert(MethList->getMethod()->getSelector()).second)
7720 continue;
7721
7722 Result R(MethList->getMethod(),
7723 Results.getBasePriority(MethList->getMethod()), nullptr);
7724 R.StartParameter = SelIdents.size();
7725 R.AllParametersAreInformative = false;
7726 Results.MaybeAddResult(R, CurContext);
7727 }
7728 }
7729 }
7730 Results.ExitScope();
7731
7732 // If we're actually at the argument expression (rather than prior to the
7733 // selector), we're actually performing code completion for an expression.
7734 // Determine whether we have a single, best method. If so, we can
7735 // code-complete the expression using the corresponding parameter type as
7736 // our preferred type, improving completion results.
7737 if (AtArgumentExpression) {
7738 QualType PreferredType =
7739 getPreferredArgumentTypeForMessageSend(Results, SelIdents.size());
7740 if (PreferredType.isNull())
7741 CodeCompleteOrdinaryName(S, PCC_Expression);
7742 else
7743 CodeCompleteExpression(S, PreferredType);
7744 return;
7745 }
7746
7747 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7748 Results.data(), Results.size());
7749}
7750
7751void Sema::CodeCompleteObjCForCollection(Scope *S,
7752 DeclGroupPtrTy IterationVar) {
7753 CodeCompleteExpressionData Data;
7754 Data.ObjCCollection = true;
7755
7756 if (IterationVar.getAsOpaquePtr()) {
7757 DeclGroupRef DG = IterationVar.get();
7758 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
7759 if (*I)
7760 Data.IgnoreDecls.push_back(*I);
7761 }
7762 }
7763
7764 CodeCompleteExpression(S, Data);
7765}
7766
7767void Sema::CodeCompleteObjCSelector(Scope *S,
7768 ArrayRef<IdentifierInfo *> SelIdents) {
7769 // If we have an external source, load the entire class method
7770 // pool from the AST file.
7771 if (ExternalSource) {
7772 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); I != N;
7773 ++I) {
7774 Selector Sel = ExternalSource->GetExternalSelector(I);
7775 if (Sel.isNull() || MethodPool.count(Sel))
7776 continue;
7777
7778 ReadMethodPool(Sel);
7779 }
7780 }
7781
7782 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7783 CodeCompleter->getCodeCompletionTUInfo(),
7784 CodeCompletionContext::CCC_SelectorName);
7785 Results.EnterNewScope();
7786 for (GlobalMethodPool::iterator M = MethodPool.begin(),
7787 MEnd = MethodPool.end();
7788 M != MEnd; ++M) {
7789
7790 Selector Sel = M->first;
7791 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents))
7792 continue;
7793
7794 CodeCompletionBuilder Builder(Results.getAllocator(),
7795 Results.getCodeCompletionTUInfo());
7796 if (Sel.isUnarySelector()) {
7797 Builder.AddTypedTextChunk(
7798 Builder.getAllocator().CopyString(Sel.getNameForSlot(0)));
7799 Results.AddResult(Builder.TakeString());
7800 continue;
7801 }
7802
7803 std::string Accumulator;
7804 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
7805 if (I == SelIdents.size()) {
7806 if (!Accumulator.empty()) {
7807 Builder.AddInformativeChunk(
7808 Builder.getAllocator().CopyString(Accumulator));
7809 Accumulator.clear();
7810 }
7811 }
7812
7813 Accumulator += Sel.getNameForSlot(I);
7814 Accumulator += ':';
7815 }
7816 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(Accumulator));
7817 Results.AddResult(Builder.TakeString());
7818 }
7819 Results.ExitScope();
7820
7821 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7822 Results.data(), Results.size());
7823}
7824
7825/// Add all of the protocol declarations that we find in the given
7826/// (translation unit) context.
7827static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
7828 bool OnlyForwardDeclarations,
7829 ResultBuilder &Results) {
7830 typedef CodeCompletionResult Result;
7831
7832 for (const auto *D : Ctx->decls()) {
7833 // Record any protocols we find.
7834 if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(D))
7835 if (!OnlyForwardDeclarations || !Proto->hasDefinition())
7836 Results.AddResult(
7837 Result(Proto, Results.getBasePriority(Proto), nullptr), CurContext,
7838 nullptr, false);
7839 }
7840}
7841
7842void Sema::CodeCompleteObjCProtocolReferences(
7843 ArrayRef<IdentifierLocPair> Protocols) {
7844 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7845 CodeCompleter->getCodeCompletionTUInfo(),
7846 CodeCompletionContext::CCC_ObjCProtocolName);
7847
7848 if (CodeCompleter->includeGlobals()) {
7849 Results.EnterNewScope();
7850
7851 // Tell the result set to ignore all of the protocols we have
7852 // already seen.
7853 // FIXME: This doesn't work when caching code-completion results.
7854 for (const IdentifierLocPair &Pair : Protocols)
7855 if (ObjCProtocolDecl *Protocol = LookupProtocol(Pair.first, Pair.second))
7856 Results.Ignore(Protocol);
7857
7858 // Add all protocols.
7859 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
7860 Results);
7861
7862 Results.ExitScope();
7863 }
7864
7865 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7866 Results.data(), Results.size());
7867}
7868
7869void Sema::CodeCompleteObjCProtocolDecl(Scope *) {
7870 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7871 CodeCompleter->getCodeCompletionTUInfo(),
7872 CodeCompletionContext::CCC_ObjCProtocolName);
7873
7874 if (CodeCompleter->includeGlobals()) {
7875 Results.EnterNewScope();
7876
7877 // Add all protocols.
7878 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
7879 Results);
7880
7881 Results.ExitScope();
7882 }
7883
7884 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7885 Results.data(), Results.size());
7886}
7887
7888/// Add all of the Objective-C interface declarations that we find in
7889/// the given (translation unit) context.
7890static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
7891 bool OnlyForwardDeclarations,
7892 bool OnlyUnimplemented,
7893 ResultBuilder &Results) {
7894 typedef CodeCompletionResult Result;
7895
7896 for (const auto *D : Ctx->decls()) {
7897 // Record any interfaces we find.
7898 if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(D))
7899 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
7900 (!OnlyUnimplemented || !Class->getImplementation()))
7901 Results.AddResult(
7902 Result(Class, Results.getBasePriority(Class), nullptr), CurContext,
7903 nullptr, false);
7904 }
7905}
7906
7907void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) {
7908 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7909 CodeCompleter->getCodeCompletionTUInfo(),
7910 CodeCompletionContext::CCC_ObjCInterfaceName);
7911 Results.EnterNewScope();
7912
7913 if (CodeCompleter->includeGlobals()) {
7914 // Add all classes.
7915 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
7916 false, Results);
7917 }
7918
7919 Results.ExitScope();
7920
7921 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7922 Results.data(), Results.size());
7923}
7924
7925void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName,
7926 SourceLocation ClassNameLoc) {
7927 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7928 CodeCompleter->getCodeCompletionTUInfo(),
7929 CodeCompletionContext::CCC_ObjCInterfaceName);
7930 Results.EnterNewScope();
7931
7932 // Make sure that we ignore the class we're currently defining.
7933 NamedDecl *CurClass =
7934 LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
7935 if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
7936 Results.Ignore(CurClass);
7937
7938 if (CodeCompleter->includeGlobals()) {
7939 // Add all classes.
7940 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
7941 false, Results);
7942 }
7943
7944 Results.ExitScope();
7945
7946 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7947 Results.data(), Results.size());
7948}
7949
7950void Sema::CodeCompleteObjCImplementationDecl(Scope *S) {
7951 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7952 CodeCompleter->getCodeCompletionTUInfo(),
7953 CodeCompletionContext::CCC_ObjCImplementation);
7954 Results.EnterNewScope();
7955
7956 if (CodeCompleter->includeGlobals()) {
7957 // Add all unimplemented classes.
7958 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
7959 true, Results);
7960 }
7961
7962 Results.ExitScope();
7963
7964 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7965 Results.data(), Results.size());
7966}
7967
7968void Sema::CodeCompleteObjCInterfaceCategory(Scope *S,
7969 IdentifierInfo *ClassName,
7970 SourceLocation ClassNameLoc) {
7971 typedef CodeCompletionResult Result;
7972
7973 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7974 CodeCompleter->getCodeCompletionTUInfo(),
7975 CodeCompletionContext::CCC_ObjCCategoryName);
7976
7977 // Ignore any categories we find that have already been implemented by this
7978 // interface.
7979 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
7980 NamedDecl *CurClass =
7981 LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
7982 if (ObjCInterfaceDecl *Class =
7983 dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)) {
7984 for (const auto *Cat : Class->visible_categories())
7985 CategoryNames.insert(Cat->getIdentifier());
7986 }
7987
7988 // Add all of the categories we know about.
7989 Results.EnterNewScope();
7990 TranslationUnitDecl *TU = Context.getTranslationUnitDecl();
7991 for (const auto *D : TU->decls())
7992 if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D))
7993 if (CategoryNames.insert(Category->getIdentifier()).second)
7994 Results.AddResult(
7995 Result(Category, Results.getBasePriority(Category), nullptr),
7996 CurContext, nullptr, false);
7997 Results.ExitScope();
7998
7999 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8000 Results.data(), Results.size());
8001}
8002
8003void Sema::CodeCompleteObjCImplementationCategory(Scope *S,
8004 IdentifierInfo *ClassName,
8005 SourceLocation ClassNameLoc) {
8006 typedef CodeCompletionResult Result;
8007
8008 // Find the corresponding interface. If we couldn't find the interface, the
8009 // program itself is ill-formed. However, we'll try to be helpful still by
8010 // providing the list of all of the categories we know about.
8011 NamedDecl *CurClass =
8012 LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
8013 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
8014 if (!Class)
8015 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
8016
8017 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8018 CodeCompleter->getCodeCompletionTUInfo(),
8019 CodeCompletionContext::CCC_ObjCCategoryName);
8020
8021 // Add all of the categories that have have corresponding interface
8022 // declarations in this class and any of its superclasses, except for
8023 // already-implemented categories in the class itself.
8024 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
8025 Results.EnterNewScope();
8026 bool IgnoreImplemented = true;
8027 while (Class) {
8028 for (const auto *Cat : Class->visible_categories()) {
8029 if ((!IgnoreImplemented || !Cat->getImplementation()) &&
8030 CategoryNames.insert(Cat->getIdentifier()).second)
8031 Results.AddResult(Result(Cat, Results.getBasePriority(Cat), nullptr),
8032 CurContext, nullptr, false);
8033 }
8034
8035 Class = Class->getSuperClass();
8036 IgnoreImplemented = false;
8037 }
8038 Results.ExitScope();
8039
8040 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8041 Results.data(), Results.size());
8042}
8043
8044void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) {
8045 CodeCompletionContext CCContext(CodeCompletionContext::CCC_Other);
8046 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8047 CodeCompleter->getCodeCompletionTUInfo(), CCContext);
8048
8049 // Figure out where this @synthesize lives.
8050 ObjCContainerDecl *Container =
8051 dyn_cast_or_null<ObjCContainerDecl>(CurContext);
8052 if (!Container || (!isa<ObjCImplementationDecl>(Container) &&
8053 !isa<ObjCCategoryImplDecl>(Container)))
8054 return;
8055
8056 // Ignore any properties that have already been implemented.
8057 Container = getContainerDef(Container);
8058 for (const auto *D : Container->decls())
8059 if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D))
8060 Results.Ignore(PropertyImpl->getPropertyDecl());
8061
8062 // Add any properties that we find.
8063 AddedPropertiesSet AddedProperties;
8064 Results.EnterNewScope();
8065 if (ObjCImplementationDecl *ClassImpl =
8066 dyn_cast<ObjCImplementationDecl>(Container))
8067 AddObjCProperties(CCContext, ClassImpl->getClassInterface(), false,
8068 /*AllowNullaryMethods=*/false, CurContext,
8069 AddedProperties, Results);
8070 else
8071 AddObjCProperties(CCContext,
8072 cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
8073 false, /*AllowNullaryMethods=*/false, CurContext,
8074 AddedProperties, Results);
8075 Results.ExitScope();
8076
8077 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8078 Results.data(), Results.size());
8079}
8080
8081void Sema::CodeCompleteObjCPropertySynthesizeIvar(
8082 Scope *S, IdentifierInfo *PropertyName) {
8083 typedef CodeCompletionResult Result;
8084 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8085 CodeCompleter->getCodeCompletionTUInfo(),
8086 CodeCompletionContext::CCC_Other);
8087
8088 // Figure out where this @synthesize lives.
8089 ObjCContainerDecl *Container =
8090 dyn_cast_or_null<ObjCContainerDecl>(CurContext);
8091 if (!Container || (!isa<ObjCImplementationDecl>(Container) &&
8092 !isa<ObjCCategoryImplDecl>(Container)))
8093 return;
8094
8095 // Figure out which interface we're looking into.
8096 ObjCInterfaceDecl *Class = nullptr;
8097 if (ObjCImplementationDecl *ClassImpl =
8098 dyn_cast<ObjCImplementationDecl>(Container))
8099 Class = ClassImpl->getClassInterface();
8100 else
8101 Class = cast<ObjCCategoryImplDecl>(Container)
8102 ->getCategoryDecl()
8103 ->getClassInterface();
8104
8105 // Determine the type of the property we're synthesizing.
8106 QualType PropertyType = Context.getObjCIdType();
8107 if (Class) {
8108 if (ObjCPropertyDecl *Property = Class->FindPropertyDeclaration(
8109 PropertyName, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
8110 PropertyType =
8111 Property->getType().getNonReferenceType().getUnqualifiedType();
8112
8113 // Give preference to ivars
8114 Results.setPreferredType(PropertyType);
8115 }
8116 }
8117
8118 // Add all of the instance variables in this class and its superclasses.
8119 Results.EnterNewScope();
8120 bool SawSimilarlyNamedIvar = false;
8121 std::string NameWithPrefix;
8122 NameWithPrefix += '_';
8123 NameWithPrefix += PropertyName->getName();
8124 std::string NameWithSuffix = PropertyName->getName().str();
8125 NameWithSuffix += '_';
8126 for (; Class; Class = Class->getSuperClass()) {
8127 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
8128 Ivar = Ivar->getNextIvar()) {
8129 Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), nullptr),
8130 CurContext, nullptr, false);
8131
8132 // Determine whether we've seen an ivar with a name similar to the
8133 // property.
8134 if ((PropertyName == Ivar->getIdentifier() ||
8135 NameWithPrefix == Ivar->getName() ||
8136 NameWithSuffix == Ivar->getName())) {
8137 SawSimilarlyNamedIvar = true;
8138
8139 // Reduce the priority of this result by one, to give it a slight
8140 // advantage over other results whose names don't match so closely.
8141 if (Results.size() &&
8142 Results.data()[Results.size() - 1].Kind ==
8143 CodeCompletionResult::RK_Declaration &&
8144 Results.data()[Results.size() - 1].Declaration == Ivar)
8145 Results.data()[Results.size() - 1].Priority--;
8146 }
8147 }
8148 }
8149
8150 if (!SawSimilarlyNamedIvar) {
8151 // Create ivar result _propName, that the user can use to synthesize
8152 // an ivar of the appropriate type.
8153 unsigned Priority = CCP_MemberDeclaration + 1;
8154 typedef CodeCompletionResult Result;
8155 CodeCompletionAllocator &Allocator = Results.getAllocator();
8156 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(),
8157 Priority, CXAvailability_Available);
8158
8159 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
8160 Builder.AddResultTypeChunk(
8161 GetCompletionTypeString(PropertyType, Context, Policy, Allocator));
8162 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
8163 Results.AddResult(
8164 Result(Builder.TakeString(), Priority, CXCursor_ObjCIvarDecl));
8165 }
8166
8167 Results.ExitScope();
8168
8169 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8170 Results.data(), Results.size());
8171}
8172
8173// Mapping from selectors to the methods that implement that selector, along
8174// with the "in original class" flag.
8175typedef llvm::DenseMap<Selector,
8176 llvm::PointerIntPair<ObjCMethodDecl *, 1, bool>>
8177 KnownMethodsMap;
8178
8179/// Find all of the methods that reside in the given container
8180/// (and its superclasses, protocols, etc.) that meet the given
8181/// criteria. Insert those methods into the map of known methods,
8182/// indexed by selector so they can be easily found.
8183static void FindImplementableMethods(ASTContext &Context,
8184 ObjCContainerDecl *Container,
8185 Optional<bool> WantInstanceMethods,
8186 QualType ReturnType,
8187 KnownMethodsMap &KnownMethods,
8188 bool InOriginalClass = true) {
8189 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
8190 // Make sure we have a definition; that's what we'll walk.
8191 if (!IFace->hasDefinition())
8192 return;
8193
8194 IFace = IFace->getDefinition();
8195 Container = IFace;
8196
8197 const ObjCList<ObjCProtocolDecl> &Protocols =
8198 IFace->getReferencedProtocols();
8199 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
8200 E = Protocols.end();
8201 I != E; ++I)
8202 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
8203 KnownMethods, InOriginalClass);
8204
8205 // Add methods from any class extensions and categories.
8206 for (auto *Cat : IFace->visible_categories()) {
8207 FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType,
8208 KnownMethods, false);
8209 }
8210
8211 // Visit the superclass.
8212 if (IFace->getSuperClass())
8213 FindImplementableMethods(Context, IFace->getSuperClass(),
8214 WantInstanceMethods, ReturnType, KnownMethods,
8215 false);
8216 }
8217
8218 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
8219 // Recurse into protocols.
8220 const ObjCList<ObjCProtocolDecl> &Protocols =
8221 Category->getReferencedProtocols();
8222 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
8223 E = Protocols.end();
8224 I != E; ++I)
8225 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
8226 KnownMethods, InOriginalClass);
8227
8228 // If this category is the original class, jump to the interface.
8229 if (InOriginalClass && Category->getClassInterface())
8230 FindImplementableMethods(Context, Category->getClassInterface(),
8231 WantInstanceMethods, ReturnType, KnownMethods,
8232 false);
8233 }
8234
8235 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
8236 // Make sure we have a definition; that's what we'll walk.
8237 if (!Protocol->hasDefinition())
8238 return;
8239 Protocol = Protocol->getDefinition();
8240 Container = Protocol;
8241
8242 // Recurse into protocols.
8243 const ObjCList<ObjCProtocolDecl> &Protocols =
8244 Protocol->getReferencedProtocols();
8245 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
8246 E = Protocols.end();
8247 I != E; ++I)
8248 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
8249 KnownMethods, false);
8250 }
8251
8252 // Add methods in this container. This operation occurs last because
8253 // we want the methods from this container to override any methods
8254 // we've previously seen with the same selector.
8255 for (auto *M : Container->methods()) {
8256 if (!WantInstanceMethods || M->isInstanceMethod() == *WantInstanceMethods) {
8257 if (!ReturnType.isNull() &&
8258 !Context.hasSameUnqualifiedType(ReturnType, M->getReturnType()))
8259 continue;
8260
8261 KnownMethods[M->getSelector()] =
8262 KnownMethodsMap::mapped_type(M, InOriginalClass);
8263 }
8264 }
8265}
8266
8267/// Add the parenthesized return or parameter type chunk to a code
8268/// completion string.
8269static void AddObjCPassingTypeChunk(QualType Type, unsigned ObjCDeclQuals,
8270 ASTContext &Context,
8271 const PrintingPolicy &Policy,
8272 CodeCompletionBuilder &Builder) {
8273 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8274 std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals, Type);
8275 if (!Quals.empty())
8276 Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals));
8277 Builder.AddTextChunk(
8278 GetCompletionTypeString(Type, Context, Policy, Builder.getAllocator()));
8279 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8280}
8281
8282/// Determine whether the given class is or inherits from a class by
8283/// the given name.
8284static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class, StringRef Name) {
8285 if (!Class)
8286 return false;
8287
8288 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
8289 return true;
8290
8291 return InheritsFromClassNamed(Class->getSuperClass(), Name);
8292}
8293
8294/// Add code completions for Objective-C Key-Value Coding (KVC) and
8295/// Key-Value Observing (KVO).
8296static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property,
8297 bool IsInstanceMethod,
8298 QualType ReturnType, ASTContext &Context,
8299 VisitedSelectorSet &KnownSelectors,
8300 ResultBuilder &Results) {
8301 IdentifierInfo *PropName = Property->getIdentifier();
8302 if (!PropName || PropName->getLength() == 0)
1
Assuming 'PropName' is non-null
2
Assuming the condition is false
3
Taking false branch
8303 return;
8304
8305 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
8306
8307 // Builder that will create each code completion.
8308 typedef CodeCompletionResult Result;
8309 CodeCompletionAllocator &Allocator = Results.getAllocator();
8310 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
8311
8312 // The selector table.
8313 SelectorTable &Selectors = Context.Selectors;
8314
8315 // The property name, copied into the code completion allocation region
8316 // on demand.
8317 struct KeyHolder {
8318 CodeCompletionAllocator &Allocator;
8319 StringRef Key;
8320 const char *CopiedKey;
8321
8322 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
8323 : Allocator(Allocator), Key(Key), CopiedKey(nullptr) {}
8324
8325 operator const char *() {
8326 if (CopiedKey)
8327 return CopiedKey;
8328
8329 return CopiedKey = Allocator.CopyString(Key);
8330 }
8331 } Key(Allocator, PropName->getName());
8332
8333 // The uppercased name of the property name.
8334 std::string UpperKey = std::string(PropName->getName());
8335 if (!UpperKey.empty())
4
Assuming the condition is false
5
Taking false branch
8336 UpperKey[0] = toUppercase(UpperKey[0]);
8337
8338 bool ReturnTypeMatchesProperty =
8339 ReturnType.isNull() ||
8340 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
8341 Property->getType());
8342 bool ReturnTypeMatchesVoid = ReturnType.isNull() || ReturnType->isVoidType();
8343
8344 // Add the normal accessor -(type)key.
8345 if (IsInstanceMethod &&
6
Assuming 'IsInstanceMethod' is true
8
Taking false branch
8346 KnownSelectors.insert(Selectors.getNullarySelector(PropName)).second &&
7
Assuming field 'second' is false
8347 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
8348 if (ReturnType.isNull())
8349 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0, Context, Policy,
8350 Builder);
8351
8352 Builder.AddTypedTextChunk(Key);
8353 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
8354 CXCursor_ObjCInstanceMethodDecl));
8355 }
8356
8357 // If we have an integral or boolean property (or the user has provided
8358 // an integral or boolean return type), add the accessor -(type)isKey.
8359 if (IsInstanceMethod
8.1
'IsInstanceMethod' is true
8.1
'IsInstanceMethod' is true
8.1
'IsInstanceMethod' is true
&&
9
Taking false branch
8360 ((!ReturnType.isNull() &&
8361 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
8362 (ReturnType.isNull() && (Property->getType()->isIntegerType() ||
8363 Property->getType()->isBooleanType())))) {
8364 std::string SelectorName = (Twine("is") + UpperKey).str();
8365 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8366 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
8367 .second) {
8368 if (ReturnType.isNull()) {
8369 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8370 Builder.AddTextChunk("BOOL");
8371 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8372 }
8373
8374 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorId->getName()));
8375 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
8376 CXCursor_ObjCInstanceMethodDecl));
8377 }
8378 }
8379
8380 // Add the normal mutator.
8381 if (IsInstanceMethod
9.1
'IsInstanceMethod' is true
9.1
'IsInstanceMethod' is true
9.1
'IsInstanceMethod' is true
&& ReturnTypeMatchesVoid
9.2
'ReturnTypeMatchesVoid' is false
9.2
'ReturnTypeMatchesVoid' is false
9.2
'ReturnTypeMatchesVoid' is false
&&
8382 !Property->getSetterMethodDecl()) {
8383 std::string SelectorName = (Twine("set") + UpperKey).str();
8384 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8385 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8386 if (ReturnType.isNull()) {
8387 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8388 Builder.AddTextChunk("void");
8389 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8390 }
8391
8392 Builder.AddTypedTextChunk(
8393 Allocator.CopyString(SelectorId->getName() + ":"));
8394 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0, Context, Policy,
8395 Builder);
8396 Builder.AddTextChunk(Key);
8397 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
8398 CXCursor_ObjCInstanceMethodDecl));
8399 }
8400 }
8401
8402 // Indexed and unordered accessors
8403 unsigned IndexedGetterPriority = CCP_CodePattern;
8404 unsigned IndexedSetterPriority = CCP_CodePattern;
8405 unsigned UnorderedGetterPriority = CCP_CodePattern;
8406 unsigned UnorderedSetterPriority = CCP_CodePattern;
8407 if (const auto *ObjCPointer =
11
Assuming 'ObjCPointer' is non-null
12
Taking true branch
8408 Property->getType()->getAs<ObjCObjectPointerType>()) {
10
Assuming the object is a 'ObjCObjectPointerType'
8409 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
13
Assuming 'IFace' is null
14
Taking false branch
8410 // If this interface type is not provably derived from a known
8411 // collection, penalize the corresponding completions.
8412 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
8413 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
8414 if (!InheritsFromClassNamed(IFace, "NSArray"))
8415 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
8416 }
8417
8418 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
8419 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
8420 if (!InheritsFromClassNamed(IFace, "NSSet"))
8421 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
8422 }
8423 }
8424 } else {
8425 IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
8426 IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
8427 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
8428 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
8429 }
8430
8431 // Add -(NSUInteger)countOf<key>
8432 if (IsInstanceMethod
14.1
'IsInstanceMethod' is true
14.1
'IsInstanceMethod' is true
14.1
'IsInstanceMethod' is true
&&
15
Taking false branch
8433 (ReturnType.isNull() || ReturnType->isIntegerType())) {
8434 std::string SelectorName = (Twine("countOf") + UpperKey).str();
8435 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8436 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
8437 .second) {
8438 if (ReturnType.isNull()) {
8439 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8440 Builder.AddTextChunk("NSUInteger");
8441 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8442 }
8443
8444 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorId->getName()));
8445 Results.AddResult(
8446 Result(Builder.TakeString(),
8447 std::min(IndexedGetterPriority, UnorderedGetterPriority),
8448 CXCursor_ObjCInstanceMethodDecl));
8449 }
8450 }
8451
8452 // Indexed getters
8453 // Add -(id)objectInKeyAtIndex:(NSUInteger)index
8454 if (IsInstanceMethod
15.1
'IsInstanceMethod' is true
15.1
'IsInstanceMethod' is true
15.1
'IsInstanceMethod' is true
&&
16
Taking false branch
8455 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
8456 std::string SelectorName = (Twine("objectIn") + UpperKey + "AtIndex").str();
8457 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8458 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8459 if (ReturnType.isNull()) {
8460 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8461 Builder.AddTextChunk("id");
8462 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8463 }
8464
8465 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8466 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8467 Builder.AddTextChunk("NSUInteger");
8468 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8469 Builder.AddTextChunk("index");
8470 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
8471 CXCursor_ObjCInstanceMethodDecl));
8472 }
8473 }
8474
8475 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
8476 if (IsInstanceMethod
16.1
'IsInstanceMethod' is true
16.1
'IsInstanceMethod' is true
16.1
'IsInstanceMethod' is true
&&
17
Taking false branch
8477 (ReturnType.isNull() ||
8478 (ReturnType->isObjCObjectPointerType() &&
8479 ReturnType->castAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
8480 ReturnType->castAs<ObjCObjectPointerType>()
8481 ->getInterfaceDecl()
8482 ->getName() == "NSArray"))) {
8483 std::string SelectorName = (Twine(Property->getName()) + "AtIndexes").str();
8484 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8485 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8486 if (ReturnType.isNull()) {
8487 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8488 Builder.AddTextChunk("NSArray *");
8489 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8490 }
8491
8492 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8493 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8494 Builder.AddTextChunk("NSIndexSet *");
8495 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8496 Builder.AddTextChunk("indexes");
8497 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
8498 CXCursor_ObjCInstanceMethodDecl));
8499 }
8500 }
8501
8502 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
8503 if (IsInstanceMethod
17.1
'IsInstanceMethod' is true
17.1
'IsInstanceMethod' is true
17.1
'IsInstanceMethod' is true
&& ReturnTypeMatchesVoid
17.2
'ReturnTypeMatchesVoid' is false
17.2
'ReturnTypeMatchesVoid' is false
17.2
'ReturnTypeMatchesVoid' is false
) {
18
Taking false branch
8504 std::string SelectorName = (Twine("get") + UpperKey).str();
8505 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName),
8506 &Context.Idents.get("range")};
8507
8508 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
8509 if (ReturnType.isNull()) {
8510 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8511 Builder.AddTextChunk("void");
8512 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8513 }
8514
8515 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8516 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8517 Builder.AddPlaceholderChunk("object-type");
8518 Builder.AddTextChunk(" **");
8519 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8520 Builder.AddTextChunk("buffer");
8521 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8522 Builder.AddTypedTextChunk("range:");
8523 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8524 Builder.AddTextChunk("NSRange");
8525 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8526 Builder.AddTextChunk("inRange");
8527 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
8528 CXCursor_ObjCInstanceMethodDecl));
8529 }
8530 }
8531
8532 // Mutable indexed accessors
8533
8534 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
8535 if (IsInstanceMethod
18.1
'IsInstanceMethod' is true
18.1
'IsInstanceMethod' is true
18.1
'IsInstanceMethod' is true
&& ReturnTypeMatchesVoid
18.2
'ReturnTypeMatchesVoid' is false
18.2
'ReturnTypeMatchesVoid' is false
18.2
'ReturnTypeMatchesVoid' is false
) {
19
Taking false branch
8536 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
8537 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get("insertObject"),
8538 &Context.Idents.get(SelectorName)};
8539
8540 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
8541 if (ReturnType.isNull()) {
8542 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8543 Builder.AddTextChunk("void");
8544 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8545 }
8546
8547 Builder.AddTypedTextChunk("insertObject:");
8548 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8549 Builder.AddPlaceholderChunk("object-type");
8550 Builder.AddTextChunk(" *");
8551 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8552 Builder.AddTextChunk("object");
8553 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8554 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8555 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8556 Builder.AddPlaceholderChunk("NSUInteger");
8557 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8558 Builder.AddTextChunk("index");
8559 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
8560 CXCursor_ObjCInstanceMethodDecl));
8561 }
8562 }
8563
8564 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
8565 if (IsInstanceMethod
19.1
'IsInstanceMethod' is true
19.1
'IsInstanceMethod' is true
19.1
'IsInstanceMethod' is true
&& ReturnTypeMatchesVoid
19.2
'ReturnTypeMatchesVoid' is false
19.2
'ReturnTypeMatchesVoid' is false
19.2
'ReturnTypeMatchesVoid' is false
) {
20
Taking false branch
8566 std::string SelectorName = (Twine("insert") + UpperKey).str();
8567 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName),
8568 &Context.Idents.get("atIndexes")};
8569
8570 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
8571 if (ReturnType.isNull()) {
8572 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8573 Builder.AddTextChunk("void");
8574 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8575 }
8576
8577 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8578 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8579 Builder.AddTextChunk("NSArray *");
8580 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8581 Builder.AddTextChunk("array");
8582 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8583 Builder.AddTypedTextChunk("atIndexes:");
8584 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8585 Builder.AddPlaceholderChunk("NSIndexSet *");
8586 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8587 Builder.AddTextChunk("indexes");
8588 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
8589 CXCursor_ObjCInstanceMethodDecl));
8590 }
8591 }
8592
8593 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
8594 if (IsInstanceMethod
20.1
'IsInstanceMethod' is true
20.1
'IsInstanceMethod' is true
20.1
'IsInstanceMethod' is true
&& ReturnTypeMatchesVoid
20.2
'ReturnTypeMatchesVoid' is false
20.2
'ReturnTypeMatchesVoid' is false
20.2
'ReturnTypeMatchesVoid' is false
) {
21
Taking false branch
8595 std::string SelectorName =
8596 (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
8597 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8598 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8599 if (ReturnType.isNull()) {
8600 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8601 Builder.AddTextChunk("void");
8602 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8603 }
8604
8605 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8606 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8607 Builder.AddTextChunk("NSUInteger");
8608 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8609 Builder.AddTextChunk("index");
8610 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
8611 CXCursor_ObjCInstanceMethodDecl));
8612 }
8613 }
8614
8615 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
8616 if (IsInstanceMethod
21.1
'IsInstanceMethod' is true
21.1
'IsInstanceMethod' is true
21.1
'IsInstanceMethod' is true
&& ReturnTypeMatchesVoid
21.2
'ReturnTypeMatchesVoid' is false
21.2
'ReturnTypeMatchesVoid' is false
21.2
'ReturnTypeMatchesVoid' is false
) {
22
Taking false branch
8617 std::string SelectorName = (Twine("remove") + UpperKey + "AtIndexes").str();
8618 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8619 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8620 if (ReturnType.isNull()) {
8621 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8622 Builder.AddTextChunk("void");
8623 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8624 }
8625
8626 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8627 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8628 Builder.AddTextChunk("NSIndexSet *");
8629 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8630 Builder.AddTextChunk("indexes");
8631 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
8632 CXCursor_ObjCInstanceMethodDecl));
8633 }
8634 }
8635
8636 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
8637 if (IsInstanceMethod
22.1
'IsInstanceMethod' is true
22.1
'IsInstanceMethod' is true
22.1
'IsInstanceMethod' is true
&& ReturnTypeMatchesVoid
22.2
'ReturnTypeMatchesVoid' is false
22.2
'ReturnTypeMatchesVoid' is false
22.2
'ReturnTypeMatchesVoid' is false
) {
23
Taking false branch
8638 std::string SelectorName =
8639 (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
8640 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName),
8641 &Context.Idents.get("withObject")};
8642
8643 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
8644 if (ReturnType.isNull()) {
8645 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8646 Builder.AddTextChunk("void");
8647 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8648 }
8649
8650 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8651 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8652 Builder.AddPlaceholderChunk("NSUInteger");
8653 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8654 Builder.AddTextChunk("index");
8655 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8656 Builder.AddTypedTextChunk("withObject:");
8657 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8658 Builder.AddTextChunk("id");
8659 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8660 Builder.AddTextChunk("object");
8661 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
8662 CXCursor_ObjCInstanceMethodDecl));
8663 }
8664 }
8665
8666 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
8667 if (IsInstanceMethod
23.1
'IsInstanceMethod' is true
23.1
'IsInstanceMethod' is true
23.1
'IsInstanceMethod' is true
&& ReturnTypeMatchesVoid
23.2
'ReturnTypeMatchesVoid' is false
23.2
'ReturnTypeMatchesVoid' is false
23.2
'ReturnTypeMatchesVoid' is false
) {
24
Taking false branch
8668 std::string SelectorName1 =
8669 (Twine("replace") + UpperKey + "AtIndexes").str();
8670 std::string SelectorName2 = (Twine("with") + UpperKey).str();
8671 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName1),
8672 &Context.Idents.get(SelectorName2)};
8673
8674 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
8675 if (ReturnType.isNull()) {
8676 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8677 Builder.AddTextChunk("void");
8678 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8679 }
8680
8681 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
8682 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8683 Builder.AddPlaceholderChunk("NSIndexSet *");
8684 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8685 Builder.AddTextChunk("indexes");
8686 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8687 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
8688 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8689 Builder.AddTextChunk("NSArray *");
8690 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8691 Builder.AddTextChunk("array");
8692 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
8693 CXCursor_ObjCInstanceMethodDecl));
8694 }
8695 }
8696
8697 // Unordered getters
8698 // - (NSEnumerator *)enumeratorOfKey
8699 if (IsInstanceMethod
24.1
'IsInstanceMethod' is true
24.1
'IsInstanceMethod' is true
24.1
'IsInstanceMethod' is true
&&
8700 (ReturnType.isNull() ||
25
Calling 'QualType::isNull'
31
Returning from 'QualType::isNull'
8701 (ReturnType->isObjCObjectPointerType() &&
32
Calling 'Type::isObjCObjectPointerType'
35
Returning from 'Type::isObjCObjectPointerType'
8702 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
36
Assuming the object is not a 'ObjCObjectPointerType'
37
Called C++ object pointer is null
8703 ReturnType->getAs<ObjCObjectPointerType>()
8704 ->getInterfaceDecl()
8705 ->getName() == "NSEnumerator"))) {
8706 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
8707 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8708 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
8709 .second) {
8710 if (ReturnType.isNull()) {
8711 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8712 Builder.AddTextChunk("NSEnumerator *");
8713 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8714 }
8715
8716 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
8717 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
8718 CXCursor_ObjCInstanceMethodDecl));
8719 }
8720 }
8721
8722 // - (type *)memberOfKey:(type *)object
8723 if (IsInstanceMethod &&
8724 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
8725 std::string SelectorName = (Twine("memberOf") + UpperKey).str();
8726 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8727 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8728 if (ReturnType.isNull()) {
8729 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8730 Builder.AddPlaceholderChunk("object-type");
8731 Builder.AddTextChunk(" *");
8732 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8733 }
8734
8735 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8736 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8737 if (ReturnType.isNull()) {
8738 Builder.AddPlaceholderChunk("object-type");
8739 Builder.AddTextChunk(" *");
8740 } else {
8741 Builder.AddTextChunk(GetCompletionTypeString(
8742 ReturnType, Context, Policy, Builder.getAllocator()));
8743 }
8744 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8745 Builder.AddTextChunk("object");
8746 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
8747 CXCursor_ObjCInstanceMethodDecl));
8748 }
8749 }
8750
8751 // Mutable unordered accessors
8752 // - (void)addKeyObject:(type *)object
8753 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
8754 std::string SelectorName =
8755 (Twine("add") + UpperKey + Twine("Object")).str();
8756 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8757 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8758 if (ReturnType.isNull()) {
8759 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8760 Builder.AddTextChunk("void");
8761 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8762 }
8763
8764 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8765 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8766 Builder.AddPlaceholderChunk("object-type");
8767 Builder.AddTextChunk(" *");
8768 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8769 Builder.AddTextChunk("object");
8770 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
8771 CXCursor_ObjCInstanceMethodDecl));
8772 }
8773 }
8774
8775 // - (void)addKey:(NSSet *)objects
8776 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
8777 std::string SelectorName = (Twine("add") + UpperKey).str();
8778 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8779 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8780 if (ReturnType.isNull()) {
8781 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8782 Builder.AddTextChunk("void");
8783 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8784 }
8785
8786 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8787 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8788 Builder.AddTextChunk("NSSet *");
8789 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8790 Builder.AddTextChunk("objects");
8791 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
8792 CXCursor_ObjCInstanceMethodDecl));
8793 }
8794 }
8795
8796 // - (void)removeKeyObject:(type *)object
8797 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
8798 std::string SelectorName =
8799 (Twine("remove") + UpperKey + Twine("Object")).str();
8800 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8801 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8802 if (ReturnType.isNull()) {
8803 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8804 Builder.AddTextChunk("void");
8805 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8806 }
8807
8808 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8809 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8810 Builder.AddPlaceholderChunk("object-type");
8811 Builder.AddTextChunk(" *");
8812 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8813 Builder.AddTextChunk("object");
8814 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
8815 CXCursor_ObjCInstanceMethodDecl));
8816 }
8817 }
8818
8819 // - (void)removeKey:(NSSet *)objects
8820 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
8821 std::string SelectorName = (Twine("remove") + UpperKey).str();
8822 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8823 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8824 if (ReturnType.isNull()) {
8825 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8826 Builder.AddTextChunk("void");
8827 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8828 }
8829
8830 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8831 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8832 Builder.AddTextChunk("NSSet *");
8833 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8834 Builder.AddTextChunk("objects");
8835 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
8836 CXCursor_ObjCInstanceMethodDecl));
8837 }
8838 }
8839
8840 // - (void)intersectKey:(NSSet *)objects
8841 if (IsInstanceMethod && ReturnTypeMatchesVoid) {
8842 std::string SelectorName = (Twine("intersect") + UpperKey).str();
8843 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8844 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
8845 if (ReturnType.isNull()) {
8846 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8847 Builder.AddTextChunk("void");
8848 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8849 }
8850
8851 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
8852 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8853 Builder.AddTextChunk("NSSet *");
8854 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8855 Builder.AddTextChunk("objects");
8856 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
8857 CXCursor_ObjCInstanceMethodDecl));
8858 }
8859 }
8860
8861 // Key-Value Observing
8862 // + (NSSet *)keyPathsForValuesAffectingKey
8863 if (!IsInstanceMethod &&
8864 (ReturnType.isNull() ||
8865 (ReturnType->isObjCObjectPointerType() &&
8866 ReturnType->castAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
8867 ReturnType->castAs<ObjCObjectPointerType>()
8868 ->getInterfaceDecl()
8869 ->getName() == "NSSet"))) {
8870 std::string SelectorName =
8871 (Twine("keyPathsForValuesAffecting") + UpperKey).str();
8872 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8873 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
8874 .second) {
8875 if (ReturnType.isNull()) {
8876 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8877 Builder.AddTextChunk("NSSet<NSString *> *");
8878 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8879 }
8880
8881 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
8882 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
8883 CXCursor_ObjCClassMethodDecl));
8884 }
8885 }
8886
8887 // + (BOOL)automaticallyNotifiesObserversForKey
8888 if (!IsInstanceMethod &&
8889 (ReturnType.isNull() || ReturnType->isIntegerType() ||
8890 ReturnType->isBooleanType())) {
8891 std::string SelectorName =
8892 (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
8893 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
8894 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
8895 .second) {
8896 if (ReturnType.isNull()) {
8897 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
8898 Builder.AddTextChunk("BOOL");
8899 Builder.AddChunk(CodeCompletionString::CK_RightParen);
8900 }
8901
8902 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
8903 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
8904 CXCursor_ObjCClassMethodDecl));
8905 }
8906 }
8907}
8908
8909void Sema::CodeCompleteObjCMethodDecl(Scope *S, Optional<bool> IsInstanceMethod,
8910 ParsedType ReturnTy) {
8911 // Determine the return type of the method we're declaring, if
8912 // provided.
8913 QualType ReturnType = GetTypeFromParser(ReturnTy);
8914 Decl *IDecl = nullptr;
8915 if (CurContext->isObjCContainer()) {
8916 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
8917 IDecl = OCD;
8918 }
8919 // Determine where we should start searching for methods.
8920 ObjCContainerDecl *SearchDecl = nullptr;
8921 bool IsInImplementation = false;
8922 if (Decl *D = IDecl) {
8923 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
8924 SearchDecl = Impl->getClassInterface();
8925 IsInImplementation = true;
8926 } else if (ObjCCategoryImplDecl *CatImpl =
8927 dyn_cast<ObjCCategoryImplDecl>(D)) {
8928 SearchDecl = CatImpl->getCategoryDecl();
8929 IsInImplementation = true;
8930 } else
8931 SearchDecl = dyn_cast<ObjCContainerDecl>(D);
8932 }
8933
8934 if (!SearchDecl && S) {
8935 if (DeclContext *DC = S->getEntity())
8936 SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
8937 }
8938
8939 if (!SearchDecl) {
8940 HandleCodeCompleteResults(this, CodeCompleter,
8941 CodeCompletionContext::CCC_Other, nullptr, 0);
8942 return;
8943 }
8944
8945 // Find all of the methods that we could declare/implement here.
8946 KnownMethodsMap KnownMethods;
8947 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod, ReturnType,
8948 KnownMethods);
8949
8950 // Add declarations or definitions for each of the known methods.
8951 typedef CodeCompletionResult Result;
8952 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
8953 CodeCompleter->getCodeCompletionTUInfo(),
8954 CodeCompletionContext::CCC_Other);
8955 Results.EnterNewScope();
8956 PrintingPolicy Policy = getCompletionPrintingPolicy(*this);
8957 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
8958 MEnd = KnownMethods.end();
8959 M != MEnd; ++M) {
8960 ObjCMethodDecl *Method = M->second.getPointer();
8961 CodeCompletionBuilder Builder(Results.getAllocator(),
8962 Results.getCodeCompletionTUInfo());
8963
8964 // Add the '-'/'+' prefix if it wasn't provided yet.
8965 if (!IsInstanceMethod) {
8966 Builder.AddTextChunk(Method->isInstanceMethod() ? "-" : "+");
8967 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8968 }
8969
8970 // If the result type was not already provided, add it to the
8971 // pattern as (type).
8972 if (ReturnType.isNull()) {
8973 QualType ResTy = Method->getSendResultType().stripObjCKindOfType(Context);
8974 AttributedType::stripOuterNullability(ResTy);
8975 AddObjCPassingTypeChunk(ResTy, Method->getObjCDeclQualifier(), Context,
8976 Policy, Builder);
8977 }
8978
8979 Selector Sel = Method->getSelector();
8980
8981 if (Sel.isUnarySelector()) {
8982 // Unary selectors have no arguments.
8983 Builder.AddTypedTextChunk(
8984 Builder.getAllocator().CopyString(Sel.getNameForSlot(0)));
8985 } else {
8986 // Add all parameters to the pattern.
8987 unsigned I = 0;
8988 for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
8989 PEnd = Method->param_end();
8990 P != PEnd; (void)++P, ++I) {
8991 // Add the part of the selector name.
8992 if (I == 0)
8993 Builder.AddTypedTextChunk(
8994 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
8995 else if (I < Sel.getNumArgs()) {
8996 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
8997 Builder.AddTypedTextChunk(
8998 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
8999 } else
9000 break;
9001
9002 // Add the parameter type.
9003 QualType ParamType;
9004 if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
9005 ParamType = (*P)->getType();
9006 else
9007 ParamType = (*P)->getOriginalType();
9008 ParamType = ParamType.substObjCTypeArgs(
9009 Context, {}, ObjCSubstitutionContext::Parameter);
9010 AttributedType::stripOuterNullability(ParamType);
9011 AddObjCPassingTypeChunk(ParamType, (*P)->getObjCDeclQualifier(),
9012 Context, Policy, Builder);
9013
9014 if (IdentifierInfo *Id = (*P)->getIdentifier())
9015 Builder.AddTextChunk(
9016 Builder.getAllocator().CopyString(Id->getName()));
9017 }
9018 }
9019
9020 if (Method->isVariadic()) {
9021 if (Method->param_size() > 0)
9022 Builder.AddChunk(CodeCompletionString::CK_Comma);
9023 Builder.AddTextChunk("...");
9024 }
9025
9026 if (IsInImplementation && Results.includeCodePatterns()) {
9027 // We will be defining the method here, so add a compound statement.
9028 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9029 Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
9030 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
9031 if (!Method->getReturnType()->isVoidType()) {
9032 // If the result type is not void, add a return clause.
9033 Builder.AddTextChunk("return");
9034 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9035 Builder.AddPlaceholderChunk("expression");
9036 Builder.AddChunk(CodeCompletionString::CK_SemiColon);
9037 } else
9038 Builder.AddPlaceholderChunk("statements");
9039
9040 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
9041 Builder.AddChunk(CodeCompletionString::CK_RightBrace);
9042 }
9043
9044 unsigned Priority = CCP_CodePattern;
9045 auto R = Result(Builder.TakeString(), Method, Priority);
9046 if (!M->second.getInt())
9047 setInBaseClass(R);
9048 Results.AddResult(std::move(R));
9049 }
9050
9051 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
9052 // the properties in this class and its categories.
9053 if (Context.getLangOpts().ObjC) {
9054 SmallVector<ObjCContainerDecl *, 4> Containers;
9055 Containers.push_back(SearchDecl);
9056
9057 VisitedSelectorSet KnownSelectors;
9058 for (KnownMethodsMap::iterator M = KnownMethods.begin(),
9059 MEnd = KnownMethods.end();
9060 M != MEnd; ++M)
9061 KnownSelectors.insert(M->first);
9062
9063 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
9064 if (!IFace)
9065 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
9066 IFace = Category->getClassInterface();
9067
9068 if (IFace)
9069 for (auto *Cat : IFace->visible_categories())
9070 Containers.push_back(Cat);
9071
9072 if (IsInstanceMethod) {
9073 for (unsigned I = 0, N = Containers.size(); I != N; ++I)
9074 for (auto *P : Containers[I]->instance_properties())
9075 AddObjCKeyValueCompletions(P, *IsInstanceMethod, ReturnType, Context,
9076 KnownSelectors, Results);
9077 }
9078 }
9079
9080 Results.ExitScope();
9081
9082 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
9083 Results.data(), Results.size());
9084}
9085
9086void Sema::CodeCompleteObjCMethodDeclSelector(
9087 Scope *S, bool IsInstanceMethod, bool AtParameterName, ParsedType ReturnTy,
9088 ArrayRef<IdentifierInfo *> SelIdents) {
9089 // If we have an external source, load the entire class method
9090 // pool from the AST file.
9091 if (ExternalSource) {
9092 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); I != N;
9093 ++I) {
9094 Selector Sel = ExternalSource->GetExternalSelector(I);
9095 if (Sel.isNull() || MethodPool.count(Sel))
9096 continue;
9097
9098 ReadMethodPool(Sel);
9099 }
9100 }
9101
9102 // Build the set of methods we can see.
9103 typedef CodeCompletionResult Result;
9104 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
9105 CodeCompleter->getCodeCompletionTUInfo(),
9106 CodeCompletionContext::CCC_Other);
9107
9108 if (ReturnTy)
9109 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
9110
9111 Results.EnterNewScope();
9112 for (GlobalMethodPool::iterator M = MethodPool.begin(),
9113 MEnd = MethodPool.end();
9114 M != MEnd; ++M) {
9115 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first
9116 : &M->second.second;
9117 MethList && MethList->getMethod(); MethList = MethList->getNext()) {
9118 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
9119 continue;
9120
9121 if (AtParameterName) {
9122 // Suggest parameter names we've seen before.
9123 unsigned NumSelIdents = SelIdents.size();
9124 if (NumSelIdents &&
9125 NumSelIdents <= MethList->getMethod()->param_size()) {
9126 ParmVarDecl *Param =
9127 MethList->getMethod()->parameters()[NumSelIdents - 1];
9128 if (Param->getIdentifier()) {
9129 CodeCompletionBuilder Builder(Results.getAllocator(),
9130 Results.getCodeCompletionTUInfo());
9131 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
9132 Param->getIdentifier()->getName()));
9133 Results.AddResult(Builder.TakeString());
9134 }
9135 }
9136
9137 continue;
9138 }
9139
9140 Result R(MethList->getMethod(),
9141 Results.getBasePriority(MethList->getMethod()), nullptr);
9142 R.StartParameter = SelIdents.size();
9143 R.AllParametersAreInformative = false;
9144 R.DeclaringEntity = true;
9145 Results.MaybeAddResult(R, CurContext);
9146 }
9147 }
9148
9149 Results.ExitScope();
9150
9151 if (!AtParameterName && !SelIdents.empty() &&
9152 SelIdents.front()->getName().startswith("init")) {
9153 for (const auto &M : PP.macros()) {
9154 if (M.first->getName() != "NS_DESIGNATED_INITIALIZER")
9155 continue;
9156 Results.EnterNewScope();
9157 CodeCompletionBuilder Builder(Results.getAllocator(),
9158 Results.getCodeCompletionTUInfo());
9159 Builder.AddTypedTextChunk(
9160 Builder.getAllocator().CopyString(M.first->getName()));
9161 Results.AddResult(CodeCompletionResult(Builder.TakeString(), CCP_Macro,
9162 CXCursor_MacroDefinition));
9163 Results.ExitScope();
9164 }
9165 }
9166
9167 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
9168 Results.data(), Results.size());
9169}
9170
9171void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
9172 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
9173 CodeCompleter->getCodeCompletionTUInfo(),
9174 CodeCompletionContext::CCC_PreprocessorDirective);
9175 Results.EnterNewScope();
9176
9177 // #if <condition>
9178 CodeCompletionBuilder Builder(Results.getAllocator(),
9179 Results.getCodeCompletionTUInfo());
9180 Builder.AddTypedTextChunk("if");
9181 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9182 Builder.AddPlaceholderChunk("condition");
9183 Results.AddResult(Builder.TakeString());
9184
9185 // #ifdef <macro>
9186 Builder.AddTypedTextChunk("ifdef");
9187 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9188 Builder.AddPlaceholderChunk("macro");
9189 Results.AddResult(Builder.TakeString());
9190
9191 // #ifndef <macro>
9192 Builder.AddTypedTextChunk("ifndef");
9193 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9194 Builder.AddPlaceholderChunk("macro");
9195 Results.AddResult(Builder.TakeString());
9196
9197 if (InConditional) {
9198 // #elif <condition>
9199 Builder.AddTypedTextChunk("elif");
9200 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9201 Builder.AddPlaceholderChunk("condition");
9202 Results.AddResult(Builder.TakeString());
9203
9204 // #elifdef <macro>
9205 Builder.AddTypedTextChunk("elifdef");
9206 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9207 Builder.AddPlaceholderChunk("macro");
9208 Results.AddResult(Builder.TakeString());
9209
9210 // #elifndef <macro>
9211 Builder.AddTypedTextChunk("elifndef");
9212 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9213 Builder.AddPlaceholderChunk("macro");
9214 Results.AddResult(Builder.TakeString());
9215
9216 // #else
9217 Builder.AddTypedTextChunk("else");
9218 Results.AddResult(Builder.TakeString());
9219
9220 // #endif
9221 Builder.AddTypedTextChunk("endif");
9222 Results.AddResult(Builder.TakeString());
9223 }
9224
9225 // #include "header"
9226 Builder.AddTypedTextChunk("include");
9227 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9228 Builder.AddTextChunk("\"");
9229 Builder.AddPlaceholderChunk("header");
9230 Builder.AddTextChunk("\"");
9231 Results.AddResult(Builder.TakeString());
9232
9233 // #include <header>
9234 Builder.AddTypedTextChunk("include");
9235 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9236 Builder.AddTextChunk("<");
9237 Builder.AddPlaceholderChunk("header");
9238 Builder.AddTextChunk(">");
9239 Results.AddResult(Builder.TakeString());
9240
9241 // #define <macro>
9242 Builder.AddTypedTextChunk("define");
9243 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9244 Builder.AddPlaceholderChunk("macro");
9245 Results.AddResult(Builder.TakeString());
9246
9247 // #define <macro>(<args>)
9248 Builder.AddTypedTextChunk("define");
9249 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9250 Builder.AddPlaceholderChunk("macro");
9251 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
9252 Builder.AddPlaceholderChunk("args");
9253 Builder.AddChunk(CodeCompletionString::CK_RightParen);
9254 Results.AddResult(Builder.TakeString());
9255
9256 // #undef <macro>
9257 Builder.AddTypedTextChunk("undef");
9258 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9259 Builder.AddPlaceholderChunk("macro");
9260 Results.AddResult(Builder.TakeString());
9261
9262 // #line <number>
9263 Builder.AddTypedTextChunk("line");
9264 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9265 Builder.AddPlaceholderChunk("number");
9266 Results.AddResult(Builder.TakeString());
9267
9268 // #line <number> "filename"
9269 Builder.AddTypedTextChunk("line");
9270 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9271 Builder.AddPlaceholderChunk("number");
9272 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9273 Builder.AddTextChunk("\"");
9274 Builder.AddPlaceholderChunk("filename");
9275 Builder.AddTextChunk("\"");
9276 Results.AddResult(Builder.TakeString());
9277
9278 // #error <message>
9279 Builder.AddTypedTextChunk("error");
9280 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9281 Builder.AddPlaceholderChunk("message");
9282 Results.AddResult(Builder.TakeString());
9283
9284 // #pragma <arguments>
9285 Builder.AddTypedTextChunk("pragma");
9286 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9287 Builder.AddPlaceholderChunk("arguments");
9288 Results.AddResult(Builder.TakeString());
9289
9290 if (getLangOpts().ObjC) {
9291 // #import "header"
9292 Builder.AddTypedTextChunk("import");
9293 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9294 Builder.AddTextChunk("\"");
9295 Builder.AddPlaceholderChunk("header");
9296 Builder.AddTextChunk("\"");
9297 Results.AddResult(Builder.TakeString());
9298
9299 // #import <header>
9300 Builder.AddTypedTextChunk("import");
9301 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9302 Builder.AddTextChunk("<");
9303 Builder.AddPlaceholderChunk("header");
9304 Builder.AddTextChunk(">");
9305 Results.AddResult(Builder.TakeString());
9306 }
9307
9308 // #include_next "header"
9309 Builder.AddTypedTextChunk("include_next");
9310 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9311 Builder.AddTextChunk("\"");
9312 Builder.AddPlaceholderChunk("header");
9313 Builder.AddTextChunk("\"");
9314 Results.AddResult(Builder.TakeString());
9315
9316 // #include_next <header>
9317 Builder.AddTypedTextChunk("include_next");
9318 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9319 Builder.AddTextChunk("<");
9320 Builder.AddPlaceholderChunk("header");
9321 Builder.AddTextChunk(">");
9322 Results.AddResult(Builder.TakeString());
9323
9324 // #warning <message>
9325 Builder.AddTypedTextChunk("warning");
9326 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9327 Builder.AddPlaceholderChunk("message");
9328 Results.AddResult(Builder.TakeString());
9329
9330 // Note: #ident and #sccs are such crazy anachronisms that we don't provide
9331 // completions for them. And __include_macros is a Clang-internal extension
9332 // that we don't want to encourage anyone to use.
9333
9334 // FIXME: we don't support #assert or #unassert, so don't suggest them.
9335 Results.ExitScope();
9336
9337 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
9338 Results.data(), Results.size());
9339}
9340
9341void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) {
9342 CodeCompleteOrdinaryName(S, S->getFnParent() ? Sema::PCC_RecoveryInFunction
9343 : Sema::PCC_Namespace);
9344}
9345
9346void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) {
9347 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
9348 CodeCompleter->getCodeCompletionTUInfo(),
9349 IsDefinition ? CodeCompletionContext::CCC_MacroName
9350 : CodeCompletionContext::CCC_MacroNameUse);
9351 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
9352 // Add just the names of macros, not their arguments.
9353 CodeCompletionBuilder Builder(Results.getAllocator(),
9354 Results.getCodeCompletionTUInfo());
9355 Results.EnterNewScope();
9356 for (Preprocessor::macro_iterator M = PP.macro_begin(),
9357 MEnd = PP.macro_end();
9358 M != MEnd; ++M) {
9359 Builder.AddTypedTextChunk(
9360 Builder.getAllocator().CopyString(M->first->getName()));
9361 Results.AddResult(CodeCompletionResult(
9362 Builder.TakeString(), CCP_CodePattern, CXCursor_MacroDefinition));
9363 }
9364 Results.ExitScope();
9365 } else if (IsDefinition) {
9366 // FIXME: Can we detect when the user just wrote an include guard above?
9367 }
9368
9369 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
9370 Results.data(), Results.size());
9371}
9372
9373void Sema::CodeCompletePreprocessorExpression() {
9374 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
9375 CodeCompleter->getCodeCompletionTUInfo(),
9376 CodeCompletionContext::CCC_PreprocessorExpression);
9377
9378 if (!CodeCompleter || CodeCompleter->includeMacros())
9379 AddMacroResults(PP, Results,
9380 !CodeCompleter || CodeCompleter->loadExternal(), true);
9381
9382 // defined (<macro>)
9383 Results.EnterNewScope();
9384 CodeCompletionBuilder Builder(Results.getAllocator(),
9385 Results.getCodeCompletionTUInfo());
9386 Builder.AddTypedTextChunk("defined");
9387 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
9388 Builder.AddChunk(CodeCompletionString::CK_LeftParen);
9389 Builder.AddPlaceholderChunk("macro");
9390 Builder.AddChunk(CodeCompletionString::CK_RightParen);
9391 Results.AddResult(Builder.TakeString());
9392 Results.ExitScope();
9393
9394 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
9395 Results.data(), Results.size());
9396}
9397
9398void Sema::CodeCompletePreprocessorMacroArgument(Scope *S,
9399 IdentifierInfo *Macro,
9400 MacroInfo *MacroInfo,
9401 unsigned Argument) {
9402 // FIXME: In the future, we could provide "overload" results, much like we
9403 // do for function calls.
9404
9405 // Now just ignore this. There will be another code-completion callback
9406 // for the expanded tokens.
9407}
9408
9409// This handles completion inside an #include filename, e.g. #include <foo/ba
9410// We look for the directory "foo" under each directory on the include path,
9411// list its files, and reassemble the appropriate #include.
9412void Sema::CodeCompleteIncludedFile(llvm::StringRef Dir, bool Angled) {
9413 // RelDir should use /, but unescaped \ is possible on windows!
9414 // Our completions will normalize to / for simplicity, this case is rare.
9415 std::string RelDir = llvm::sys::path::convert_to_slash(Dir);
9416 // We need the native slashes for the actual file system interactions.
9417 SmallString<128> NativeRelDir = StringRef(RelDir);
9418 llvm::sys::path::native(NativeRelDir);
9419 llvm::vfs::FileSystem &FS =
9420 getSourceManager().getFileManager().getVirtualFileSystem();
9421
9422 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
9423 CodeCompleter->getCodeCompletionTUInfo(),
9424 CodeCompletionContext::CCC_IncludedFile);
9425 llvm::DenseSet<StringRef> SeenResults; // To deduplicate results.
9426
9427 // Helper: adds one file or directory completion result.
9428 auto AddCompletion = [&](StringRef Filename, bool IsDirectory) {
9429 SmallString<64> TypedChunk = Filename;
9430 // Directory completion is up to the slash, e.g. <sys/
9431 TypedChunk.push_back(IsDirectory ? '/' : Angled ? '>' : '"');
9432 auto R = SeenResults.insert(TypedChunk);
9433 if (R.second) { // New completion
9434 const char *InternedTyped = Results.getAllocator().CopyString(TypedChunk);
9435 *R.first = InternedTyped; // Avoid dangling StringRef.
9436 CodeCompletionBuilder Builder(CodeCompleter->getAllocator(),
9437 CodeCompleter->getCodeCompletionTUInfo());
9438 Builder.AddTypedTextChunk(InternedTyped);
9439 // The result is a "Pattern", which is pretty opaque.
9440 // We may want to include the real filename to allow smart ranking.
9441 Results.AddResult(CodeCompletionResult(Builder.TakeString()));
9442 }
9443 };
9444
9445 // Helper: scans IncludeDir for nice files, and adds results for each.
9446 auto AddFilesFromIncludeDir = [&](StringRef IncludeDir,
9447 bool IsSystem,
9448 DirectoryLookup::LookupType_t LookupType) {
9449 llvm::SmallString<128> Dir = IncludeDir;
9450 if (!NativeRelDir.empty()) {
9451 if (LookupType == DirectoryLookup::LT_Framework) {
9452 // For a framework dir, #include <Foo/Bar/> actually maps to
9453 // a path of Foo.framework/Headers/Bar/.
9454 auto Begin = llvm::sys::path::begin(NativeRelDir);
9455 auto End = llvm::sys::path::end(NativeRelDir);
9456
9457 llvm::sys::path::append(Dir, *Begin + ".framework", "Headers");
9458 llvm::sys::path::append(Dir, ++Begin, End);
9459 } else {
9460 llvm::sys::path::append(Dir, NativeRelDir);
9461 }
9462 }
9463
9464 std::error_code EC;
9465 unsigned Count = 0;
9466 for (auto It = FS.dir_begin(Dir, EC);
9467 !EC && It != llvm::vfs::directory_iterator(); It.increment(EC)) {
9468 if (++Count == 2500) // If we happen to hit a huge directory,
9469 break; // bail out early so we're not too slow.
9470 StringRef Filename = llvm::sys::path::filename(It->path());
9471
9472 // To know whether a symlink should be treated as file or a directory, we
9473 // have to stat it. This should be cheap enough as there shouldn't be many
9474 // symlinks.
9475 llvm::sys::fs::file_type Type = It->type();
9476 if (Type == llvm::sys::fs::file_type::symlink_file) {
9477 if (auto FileStatus = FS.status(It->path()))
9478 Type = FileStatus->getType();
9479 }
9480 switch (Type) {
9481 case llvm::sys::fs::file_type::directory_file:
9482 // All entries in a framework directory must have a ".framework" suffix,
9483 // but the suffix does not appear in the source code's include/import.
9484 if (LookupType == DirectoryLookup::LT_Framework &&
9485 NativeRelDir.empty() && !Filename.consume_back(".framework"))
9486 break;
9487
9488 AddCompletion(Filename, /*IsDirectory=*/true);
9489 break;
9490 case llvm::sys::fs::file_type::regular_file:
9491 // Only files that really look like headers. (Except in system dirs).
9492 if (!IsSystem) {
9493 // Header extensions from Types.def, which we can't depend on here.
9494 if (!(Filename.endswith_insensitive(".h") ||
9495 Filename.endswith_insensitive(".hh") ||
9496 Filename.endswith_insensitive(".hpp") ||
9497 Filename.endswith_insensitive(".inc")))
9498 break;
9499 }
9500 AddCompletion(Filename, /*IsDirectory=*/false);
9501 break;
9502 default:
9503 break;
9504 }
9505 }
9506 };
9507
9508 // Helper: adds results relative to IncludeDir, if possible.
9509 auto AddFilesFromDirLookup = [&](const DirectoryLookup &IncludeDir,
9510 bool IsSystem) {
9511 switch (IncludeDir.getLookupType()) {
9512 case DirectoryLookup::LT_HeaderMap:
9513 // header maps are not (currently) enumerable.
9514 break;
9515 case DirectoryLookup::LT_NormalDir:
9516 AddFilesFromIncludeDir(IncludeDir.getDir()->getName(), IsSystem,
9517 DirectoryLookup::LT_NormalDir);
9518 break;
9519 case DirectoryLookup::LT_Framework:
9520 AddFilesFromIncludeDir(IncludeDir.getFrameworkDir()->getName(), IsSystem,
9521 DirectoryLookup::LT_Framework);
9522 break;
9523 }
9524 };
9525
9526 // Finally with all our helpers, we can scan the include path.
9527 // Do this in standard order so deduplication keeps the right file.
9528 // (In case we decide to add more details to the results later).
9529 const auto &S = PP.getHeaderSearchInfo();
9530 using llvm::make_range;
9531 if (!Angled) {
9532 // The current directory is on the include path for "quoted" includes.
9533 auto *CurFile = PP.getCurrentFileLexer()->getFileEntry();
9534 if (CurFile && CurFile->getDir())
9535 AddFilesFromIncludeDir(CurFile->getDir()->getName(), false,
9536 DirectoryLookup::LT_NormalDir);
9537 for (const auto &D : make_range(S.quoted_dir_begin(), S.quoted_dir_end()))
9538 AddFilesFromDirLookup(D, false);
9539 }
9540 for (const auto &D : make_range(S.angled_dir_begin(), S.angled_dir_end()))
9541 AddFilesFromDirLookup(D, false);
9542 for (const auto &D : make_range(S.system_dir_begin(), S.system_dir_end()))
9543 AddFilesFromDirLookup(D, true);
9544
9545 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
9546 Results.data(), Results.size());
9547}
9548
9549void Sema::CodeCompleteNaturalLanguage() {
9550 HandleCodeCompleteResults(this, CodeCompleter,
9551 CodeCompletionContext::CCC_NaturalLanguage, nullptr,
9552 0);
9553}
9554
9555void Sema::CodeCompleteAvailabilityPlatformName() {
9556 ResultBuilder Results(*this, CodeCompleter->getAllocator(),
9557 CodeCompleter->getCodeCompletionTUInfo(),
9558 CodeCompletionContext::CCC_Other);
9559 Results.EnterNewScope();
9560 static const char *Platforms[] = {"macOS", "iOS", "watchOS", "tvOS"};
9561 for (const char *Platform : llvm::makeArrayRef(Platforms)) {
9562 Results.AddResult(CodeCompletionResult(Platform));
9563 Results.AddResult(CodeCompletionResult(Results.getAllocator().CopyString(
9564 Twine(Platform) + "ApplicationExtension")));
9565 }
9566 Results.ExitScope();
9567 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
9568 Results.data(), Results.size());
9569}
9570
9571void Sema::GatherGlobalCodeCompletions(
9572 CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo,
9573 SmallVectorImpl<CodeCompletionResult> &Results) {
9574 ResultBuilder Builder(*this, Allocator, CCTUInfo,
9575 CodeCompletionContext::CCC_Recovery);
9576 if (!CodeCompleter || CodeCompleter->includeGlobals()) {
9577 CodeCompletionDeclConsumer Consumer(Builder,
9578 Context.getTranslationUnitDecl());
9579 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
9580 Consumer,
9581 !CodeCompleter || CodeCompleter->loadExternal());
9582 }
9583
9584 if (!CodeCompleter || CodeCompleter->includeMacros())
9585 AddMacroResults(PP, Builder,
9586 !CodeCompleter || CodeCompleter->loadExternal(), true);
9587
9588 Results.clear();
9589 Results.insert(Results.end(), Builder.data(),
9590 Builder.data() + Builder.size());
9591}

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

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/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 template <typename Derived, typename ValTy, int I, typename ...Types>
97 class PointerUnionMembers;
98
99 template <typename Derived, typename ValTy, int I>
100 class PointerUnionMembers<Derived, ValTy, I> {
101 protected:
102 ValTy Val;
103 PointerUnionMembers() = default;
104 PointerUnionMembers(ValTy Val) : Val(Val) {}
105
106 friend struct PointerLikeTypeTraits<Derived>;
107 };
108
109 template <typename Derived, typename ValTy, int I, typename Type,
110 typename ...Types>
111 class PointerUnionMembers<Derived, ValTy, I, Type, Types...>
112 : public PointerUnionMembers<Derived, ValTy, I + 1, Types...> {
113 using Base = PointerUnionMembers<Derived, ValTy, I + 1, Types...>;
114 public:
115 using Base::Base;
116 PointerUnionMembers() = default;
117 PointerUnionMembers(Type V)
118 : Base(ValTy(const_cast<void *>(
119 PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
120 I)) {}
121
122 using Base::operator=;
123 Derived &operator=(Type V) {
124 this->Val = ValTy(
125 const_cast<void *>(PointerLikeTypeTraits<Type>::getAsVoidPointer(V)),
126 I);
127 return static_cast<Derived &>(*this);
128 };
129 };
130}
131
132/// A discriminated union of two or more pointer types, with the discriminator
133/// in the low bit of the pointer.
134///
135/// This implementation is extremely efficient in space due to leveraging the
136/// low bits of the pointer, while exposing a natural and type-safe API.
137///
138/// Common use patterns would be something like this:
139/// PointerUnion<int*, float*> P;
140/// P = (int*)0;
141/// printf("%d %d", P.is<int*>(), P.is<float*>()); // prints "1 0"
142/// X = P.get<int*>(); // ok.
143/// Y = P.get<float*>(); // runtime assertion failure.
144/// Z = P.get<double*>(); // compile time failure.
145/// P = (float*)0;
146/// Y = P.get<float*>(); // ok.
147/// X = P.get<int*>(); // runtime assertion failure.
148template <typename... PTs>
149class PointerUnion
150 : public pointer_union_detail::PointerUnionMembers<
151 PointerUnion<PTs...>,
152 PointerIntPair<
153 void *, pointer_union_detail::bitsRequired(sizeof...(PTs)), int,
154 pointer_union_detail::PointerUnionUIntTraits<PTs...>>,
155 0, PTs...> {
156 // The first type is special because we want to directly cast a pointer to a
157 // default-initialized union to a pointer to the first type. But we don't
158 // want PointerUnion to be a 'template <typename First, typename ...Rest>'
159 // because it's much more convenient to have a name for the whole pack. So
160 // split off the first type here.
161 using First = typename pointer_union_detail::GetFirstType<PTs...>::type;
162 using Base = typename PointerUnion::PointerUnionMembers;
163
164public:
165 PointerUnion() = default;
166
167 PointerUnion(std::nullptr_t) : PointerUnion() {}
168 using Base::Base;
169
170 /// Test if the pointer held in the union is null, regardless of
171 /// which type it is.
172 bool isNull() const { return !this->Val.getPointer(); }
27
Assuming the condition is false
28
Returning zero, which participates in a condition later
173
174 explicit operator bool() const { return !isNull(); }
175
176 /// Test if the Union currently holds the type matching T.
177 template <typename T> bool is() const {
178 constexpr int Index = pointer_union_detail::TypeIndex<T, PTs...>::Index;
179 static_assert(Index < sizeof...(PTs),
180 "PointerUnion::is<T> given type not in the union");
181 return this->Val.getInt() == Index;
182 }
183
184 /// Returns the value of the specified pointer type.
185 ///
186 /// If the specified pointer type is incorrect, assert.
187 template <typename T> T get() const {
188 assert(is<T>() && "Invalid accessor called")((void)0);
189 return PointerLikeTypeTraits<T>::getFromVoidPointer(this->Val.getPointer());
190 }
191
192 /// Returns the current pointer if it is of the specified pointer type,
193 /// otherwise returns null.
194 template <typename T> T dyn_cast() const {
195 if (is<T>())
196 return get<T>();
197 return T();
198 }
199
200 /// If the union is set to the first pointer type get an address pointing to
201 /// it.
202 First const *getAddrOfPtr1() const {
203 return const_cast<PointerUnion *>(this)->getAddrOfPtr1();
204 }
205
206 /// If the union is set to the first pointer type get an address pointing to
207 /// it.
208 First *getAddrOfPtr1() {
209 assert(is<First>() && "Val is not the first pointer")((void)0);
210 assert(((void)0)
211 PointerLikeTypeTraits<First>::getAsVoidPointer(get<First>()) ==((void)0)
212 this->Val.getPointer() &&((void)0)
213 "Can't get the address because PointerLikeTypeTraits changes the ptr")((void)0);
214 return const_cast<First *>(
215 reinterpret_cast<const First *>(this->Val.getAddrOfPointer()));
216 }
217
218 /// Assignment from nullptr which just clears the union.
219 const PointerUnion &operator=(std::nullptr_t) {
220 this->Val.initWithPointer(nullptr);
221 return *this;
222 }
223
224 /// Assignment from elements of the union.
225 using Base::operator=;
226
227 void *getOpaqueValue() const { return this->Val.getOpaqueValue(); }
228 static inline PointerUnion getFromOpaqueValue(void *VP) {
229 PointerUnion V;
230 V.Val = decltype(V.Val)::getFromOpaqueValue(VP);
231 return V;
232 }
233};
234
235template <typename ...PTs>
236bool operator==(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
237 return lhs.getOpaqueValue() == rhs.getOpaqueValue();
238}
239
240template <typename ...PTs>
241bool operator!=(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
242 return lhs.getOpaqueValue() != rhs.getOpaqueValue();
243}
244
245template <typename ...PTs>
246bool operator<(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
247 return lhs.getOpaqueValue() < rhs.getOpaqueValue();
248}
249
250// Teach SmallPtrSet that PointerUnion is "basically a pointer", that has
251// # low bits available = min(PT1bits,PT2bits)-1.
252template <typename ...PTs>
253struct PointerLikeTypeTraits<PointerUnion<PTs...>> {
254 static inline void *getAsVoidPointer(const PointerUnion<PTs...> &P) {
255 return P.getOpaqueValue();
256 }
257
258 static inline PointerUnion<PTs...> getFromVoidPointer(void *P) {
259 return PointerUnion<PTs...>::getFromOpaqueValue(P);
260 }
261
262 // The number of bits available are the min of the pointer types minus the
263 // bits needed for the discriminator.
264 static constexpr int NumLowBitsAvailable = PointerLikeTypeTraits<decltype(
265 PointerUnion<PTs...>::Val)>::NumLowBitsAvailable;
266};
267
268// Teach DenseMap how to use PointerUnions as keys.
269template <typename ...PTs> struct DenseMapInfo<PointerUnion<PTs...>> {
270 using Union = PointerUnion<PTs...>;
271 using FirstInfo =
272 DenseMapInfo<typename pointer_union_detail::GetFirstType<PTs...>::type>;
273
274 static inline Union getEmptyKey() { return Union(FirstInfo::getEmptyKey()); }
275
276 static inline Union getTombstoneKey() {
277 return Union(FirstInfo::getTombstoneKey());
278 }
279
280 static unsigned getHashValue(const Union &UnionVal) {
281 intptr_t key = (intptr_t)UnionVal.getOpaqueValue();
282 return DenseMapInfo<intptr_t>::getHashValue(key);
283 }
284
285 static bool isEqual(const Union &LHS, const Union &RHS) {
286 return LHS == RHS;
287 }
288};
289
290} // end namespace llvm
291
292#endif // LLVM_ADT_POINTERUNION_H