Bug Summary

File:src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaExprCXX.cpp
Warning:line 1247, column 28
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 SemaExprCXX.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/SemaExprCXX.cpp

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaExprCXX.cpp

1//===--- SemaExprCXX.cpp - Semantic Analysis for Expressions --------------===//
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/// Implements semantic analysis for C++ expressions.
11///
12//===----------------------------------------------------------------------===//
13
14#include "clang/Sema/Template.h"
15#include "clang/Sema/SemaInternal.h"
16#include "TreeTransform.h"
17#include "TypeLocBuilder.h"
18#include "clang/AST/ASTContext.h"
19#include "clang/AST/ASTLambda.h"
20#include "clang/AST/CXXInheritance.h"
21#include "clang/AST/CharUnits.h"
22#include "clang/AST/DeclObjC.h"
23#include "clang/AST/ExprCXX.h"
24#include "clang/AST/ExprObjC.h"
25#include "clang/AST/RecursiveASTVisitor.h"
26#include "clang/AST/TypeLoc.h"
27#include "clang/Basic/AlignedAllocation.h"
28#include "clang/Basic/PartialDiagnostic.h"
29#include "clang/Basic/TargetInfo.h"
30#include "clang/Lex/Preprocessor.h"
31#include "clang/Sema/DeclSpec.h"
32#include "clang/Sema/Initialization.h"
33#include "clang/Sema/Lookup.h"
34#include "clang/Sema/ParsedTemplate.h"
35#include "clang/Sema/Scope.h"
36#include "clang/Sema/ScopeInfo.h"
37#include "clang/Sema/SemaLambda.h"
38#include "clang/Sema/TemplateDeduction.h"
39#include "llvm/ADT/APInt.h"
40#include "llvm/ADT/STLExtras.h"
41#include "llvm/Support/ErrorHandling.h"
42using namespace clang;
43using namespace sema;
44
45/// Handle the result of the special case name lookup for inheriting
46/// constructor declarations. 'NS::X::X' and 'NS::X<...>::X' are treated as
47/// constructor names in member using declarations, even if 'X' is not the
48/// name of the corresponding type.
49ParsedType Sema::getInheritingConstructorName(CXXScopeSpec &SS,
50 SourceLocation NameLoc,
51 IdentifierInfo &Name) {
52 NestedNameSpecifier *NNS = SS.getScopeRep();
53
54 // Convert the nested-name-specifier into a type.
55 QualType Type;
56 switch (NNS->getKind()) {
57 case NestedNameSpecifier::TypeSpec:
58 case NestedNameSpecifier::TypeSpecWithTemplate:
59 Type = QualType(NNS->getAsType(), 0);
60 break;
61
62 case NestedNameSpecifier::Identifier:
63 // Strip off the last layer of the nested-name-specifier and build a
64 // typename type for it.
65 assert(NNS->getAsIdentifier() == &Name && "not a constructor name")((void)0);
66 Type = Context.getDependentNameType(ETK_None, NNS->getPrefix(),
67 NNS->getAsIdentifier());
68 break;
69
70 case NestedNameSpecifier::Global:
71 case NestedNameSpecifier::Super:
72 case NestedNameSpecifier::Namespace:
73 case NestedNameSpecifier::NamespaceAlias:
74 llvm_unreachable("Nested name specifier is not a type for inheriting ctor")__builtin_unreachable();
75 }
76
77 // This reference to the type is located entirely at the location of the
78 // final identifier in the qualified-id.
79 return CreateParsedType(Type,
80 Context.getTrivialTypeSourceInfo(Type, NameLoc));
81}
82
83ParsedType Sema::getConstructorName(IdentifierInfo &II,
84 SourceLocation NameLoc,
85 Scope *S, CXXScopeSpec &SS,
86 bool EnteringContext) {
87 CXXRecordDecl *CurClass = getCurrentClass(S, &SS);
88 assert(CurClass && &II == CurClass->getIdentifier() &&((void)0)
89 "not a constructor name")((void)0);
90
91 // When naming a constructor as a member of a dependent context (eg, in a
92 // friend declaration or an inherited constructor declaration), form an
93 // unresolved "typename" type.
94 if (CurClass->isDependentContext() && !EnteringContext && SS.getScopeRep()) {
95 QualType T = Context.getDependentNameType(ETK_None, SS.getScopeRep(), &II);
96 return ParsedType::make(T);
97 }
98
99 if (SS.isNotEmpty() && RequireCompleteDeclContext(SS, CurClass))
100 return ParsedType();
101
102 // Find the injected-class-name declaration. Note that we make no attempt to
103 // diagnose cases where the injected-class-name is shadowed: the only
104 // declaration that can validly shadow the injected-class-name is a
105 // non-static data member, and if the class contains both a non-static data
106 // member and a constructor then it is ill-formed (we check that in
107 // CheckCompletedCXXClass).
108 CXXRecordDecl *InjectedClassName = nullptr;
109 for (NamedDecl *ND : CurClass->lookup(&II)) {
110 auto *RD = dyn_cast<CXXRecordDecl>(ND);
111 if (RD && RD->isInjectedClassName()) {
112 InjectedClassName = RD;
113 break;
114 }
115 }
116 if (!InjectedClassName) {
117 if (!CurClass->isInvalidDecl()) {
118 // FIXME: RequireCompleteDeclContext doesn't check dependent contexts
119 // properly. Work around it here for now.
120 Diag(SS.getLastQualifierNameLoc(),
121 diag::err_incomplete_nested_name_spec) << CurClass << SS.getRange();
122 }
123 return ParsedType();
124 }
125
126 QualType T = Context.getTypeDeclType(InjectedClassName);
127 DiagnoseUseOfDecl(InjectedClassName, NameLoc);
128 MarkAnyDeclReferenced(NameLoc, InjectedClassName, /*OdrUse=*/false);
129
130 return ParsedType::make(T);
131}
132
133ParsedType Sema::getDestructorName(SourceLocation TildeLoc,
134 IdentifierInfo &II,
135 SourceLocation NameLoc,
136 Scope *S, CXXScopeSpec &SS,
137 ParsedType ObjectTypePtr,
138 bool EnteringContext) {
139 // Determine where to perform name lookup.
140
141 // FIXME: This area of the standard is very messy, and the current
142 // wording is rather unclear about which scopes we search for the
143 // destructor name; see core issues 399 and 555. Issue 399 in
144 // particular shows where the current description of destructor name
145 // lookup is completely out of line with existing practice, e.g.,
146 // this appears to be ill-formed:
147 //
148 // namespace N {
149 // template <typename T> struct S {
150 // ~S();
151 // };
152 // }
153 //
154 // void f(N::S<int>* s) {
155 // s->N::S<int>::~S();
156 // }
157 //
158 // See also PR6358 and PR6359.
159 //
160 // For now, we accept all the cases in which the name given could plausibly
161 // be interpreted as a correct destructor name, issuing off-by-default
162 // extension diagnostics on the cases that don't strictly conform to the
163 // C++20 rules. This basically means we always consider looking in the
164 // nested-name-specifier prefix, the complete nested-name-specifier, and
165 // the scope, and accept if we find the expected type in any of the three
166 // places.
167
168 if (SS.isInvalid())
169 return nullptr;
170
171 // Whether we've failed with a diagnostic already.
172 bool Failed = false;
173
174 llvm::SmallVector<NamedDecl*, 8> FoundDecls;
175 llvm::SmallPtrSet<CanonicalDeclPtr<Decl>, 8> FoundDeclSet;
176
177 // If we have an object type, it's because we are in a
178 // pseudo-destructor-expression or a member access expression, and
179 // we know what type we're looking for.
180 QualType SearchType =
181 ObjectTypePtr ? GetTypeFromParser(ObjectTypePtr) : QualType();
182
183 auto CheckLookupResult = [&](LookupResult &Found) -> ParsedType {
184 auto IsAcceptableResult = [&](NamedDecl *D) -> bool {
185 auto *Type = dyn_cast<TypeDecl>(D->getUnderlyingDecl());
186 if (!Type)
187 return false;
188
189 if (SearchType.isNull() || SearchType->isDependentType())
190 return true;
191
192 QualType T = Context.getTypeDeclType(Type);
193 return Context.hasSameUnqualifiedType(T, SearchType);
194 };
195
196 unsigned NumAcceptableResults = 0;
197 for (NamedDecl *D : Found) {
198 if (IsAcceptableResult(D))
199 ++NumAcceptableResults;
200
201 // Don't list a class twice in the lookup failure diagnostic if it's
202 // found by both its injected-class-name and by the name in the enclosing
203 // scope.
204 if (auto *RD = dyn_cast<CXXRecordDecl>(D))
205 if (RD->isInjectedClassName())
206 D = cast<NamedDecl>(RD->getParent());
207
208 if (FoundDeclSet.insert(D).second)
209 FoundDecls.push_back(D);
210 }
211
212 // As an extension, attempt to "fix" an ambiguity by erasing all non-type
213 // results, and all non-matching results if we have a search type. It's not
214 // clear what the right behavior is if destructor lookup hits an ambiguity,
215 // but other compilers do generally accept at least some kinds of
216 // ambiguity.
217 if (Found.isAmbiguous() && NumAcceptableResults == 1) {
218 Diag(NameLoc, diag::ext_dtor_name_ambiguous);
219 LookupResult::Filter F = Found.makeFilter();
220 while (F.hasNext()) {
221 NamedDecl *D = F.next();
222 if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))
223 Diag(D->getLocation(), diag::note_destructor_type_here)
224 << Context.getTypeDeclType(TD);
225 else
226 Diag(D->getLocation(), diag::note_destructor_nontype_here);
227
228 if (!IsAcceptableResult(D))
229 F.erase();
230 }
231 F.done();
232 }
233
234 if (Found.isAmbiguous())
235 Failed = true;
236
237 if (TypeDecl *Type = Found.getAsSingle<TypeDecl>()) {
238 if (IsAcceptableResult(Type)) {
239 QualType T = Context.getTypeDeclType(Type);
240 MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
241 return CreateParsedType(T,
242 Context.getTrivialTypeSourceInfo(T, NameLoc));
243 }
244 }
245
246 return nullptr;
247 };
248
249 bool IsDependent = false;
250
251 auto LookupInObjectType = [&]() -> ParsedType {
252 if (Failed || SearchType.isNull())
253 return nullptr;
254
255 IsDependent |= SearchType->isDependentType();
256
257 LookupResult Found(*this, &II, NameLoc, LookupDestructorName);
258 DeclContext *LookupCtx = computeDeclContext(SearchType);
259 if (!LookupCtx)
260 return nullptr;
261 LookupQualifiedName(Found, LookupCtx);
262 return CheckLookupResult(Found);
263 };
264
265 auto LookupInNestedNameSpec = [&](CXXScopeSpec &LookupSS) -> ParsedType {
266 if (Failed)
267 return nullptr;
268
269 IsDependent |= isDependentScopeSpecifier(LookupSS);
270 DeclContext *LookupCtx = computeDeclContext(LookupSS, EnteringContext);
271 if (!LookupCtx)
272 return nullptr;
273
274 LookupResult Found(*this, &II, NameLoc, LookupDestructorName);
275 if (RequireCompleteDeclContext(LookupSS, LookupCtx)) {
276 Failed = true;
277 return nullptr;
278 }
279 LookupQualifiedName(Found, LookupCtx);
280 return CheckLookupResult(Found);
281 };
282
283 auto LookupInScope = [&]() -> ParsedType {
284 if (Failed || !S)
285 return nullptr;
286
287 LookupResult Found(*this, &II, NameLoc, LookupDestructorName);
288 LookupName(Found, S);
289 return CheckLookupResult(Found);
290 };
291
292 // C++2a [basic.lookup.qual]p6:
293 // In a qualified-id of the form
294 //
295 // nested-name-specifier[opt] type-name :: ~ type-name
296 //
297 // the second type-name is looked up in the same scope as the first.
298 //
299 // We interpret this as meaning that if you do a dual-scope lookup for the
300 // first name, you also do a dual-scope lookup for the second name, per
301 // C++ [basic.lookup.classref]p4:
302 //
303 // If the id-expression in a class member access is a qualified-id of the
304 // form
305 //
306 // class-name-or-namespace-name :: ...
307 //
308 // the class-name-or-namespace-name following the . or -> is first looked
309 // up in the class of the object expression and the name, if found, is used.
310 // Otherwise, it is looked up in the context of the entire
311 // postfix-expression.
312 //
313 // This looks in the same scopes as for an unqualified destructor name:
314 //
315 // C++ [basic.lookup.classref]p3:
316 // If the unqualified-id is ~ type-name, the type-name is looked up
317 // in the context of the entire postfix-expression. If the type T
318 // of the object expression is of a class type C, the type-name is
319 // also looked up in the scope of class C. At least one of the
320 // lookups shall find a name that refers to cv T.
321 //
322 // FIXME: The intent is unclear here. Should type-name::~type-name look in
323 // the scope anyway if it finds a non-matching name declared in the class?
324 // If both lookups succeed and find a dependent result, which result should
325 // we retain? (Same question for p->~type-name().)
326
327 if (NestedNameSpecifier *Prefix =
328 SS.isSet() ? SS.getScopeRep()->getPrefix() : nullptr) {
329 // This is
330 //
331 // nested-name-specifier type-name :: ~ type-name
332 //
333 // Look for the second type-name in the nested-name-specifier.
334 CXXScopeSpec PrefixSS;
335 PrefixSS.Adopt(NestedNameSpecifierLoc(Prefix, SS.location_data()));
336 if (ParsedType T = LookupInNestedNameSpec(PrefixSS))
337 return T;
338 } else {
339 // This is one of
340 //
341 // type-name :: ~ type-name
342 // ~ type-name
343 //
344 // Look in the scope and (if any) the object type.
345 if (ParsedType T = LookupInScope())
346 return T;
347 if (ParsedType T = LookupInObjectType())
348 return T;
349 }
350
351 if (Failed)
352 return nullptr;
353
354 if (IsDependent) {
355 // We didn't find our type, but that's OK: it's dependent anyway.
356
357 // FIXME: What if we have no nested-name-specifier?
358 QualType T = CheckTypenameType(ETK_None, SourceLocation(),
359 SS.getWithLocInContext(Context),
360 II, NameLoc);
361 return ParsedType::make(T);
362 }
363
364 // The remaining cases are all non-standard extensions imitating the behavior
365 // of various other compilers.
366 unsigned NumNonExtensionDecls = FoundDecls.size();
367
368 if (SS.isSet()) {
369 // For compatibility with older broken C++ rules and existing code,
370 //
371 // nested-name-specifier :: ~ type-name
372 //
373 // also looks for type-name within the nested-name-specifier.
374 if (ParsedType T = LookupInNestedNameSpec(SS)) {
375 Diag(SS.getEndLoc(), diag::ext_dtor_named_in_wrong_scope)
376 << SS.getRange()
377 << FixItHint::CreateInsertion(SS.getEndLoc(),
378 ("::" + II.getName()).str());
379 return T;
380 }
381
382 // For compatibility with other compilers and older versions of Clang,
383 //
384 // nested-name-specifier type-name :: ~ type-name
385 //
386 // also looks for type-name in the scope. Unfortunately, we can't
387 // reasonably apply this fallback for dependent nested-name-specifiers.
388 if (SS.getScopeRep()->getPrefix()) {
389 if (ParsedType T = LookupInScope()) {
390 Diag(SS.getEndLoc(), diag::ext_qualified_dtor_named_in_lexical_scope)
391 << FixItHint::CreateRemoval(SS.getRange());
392 Diag(FoundDecls.back()->getLocation(), diag::note_destructor_type_here)
393 << GetTypeFromParser(T);
394 return T;
395 }
396 }
397 }
398
399 // We didn't find anything matching; tell the user what we did find (if
400 // anything).
401
402 // Don't tell the user about declarations we shouldn't have found.
403 FoundDecls.resize(NumNonExtensionDecls);
404
405 // List types before non-types.
406 std::stable_sort(FoundDecls.begin(), FoundDecls.end(),
407 [](NamedDecl *A, NamedDecl *B) {
408 return isa<TypeDecl>(A->getUnderlyingDecl()) >
409 isa<TypeDecl>(B->getUnderlyingDecl());
410 });
411
412 // Suggest a fixit to properly name the destroyed type.
413 auto MakeFixItHint = [&]{
414 const CXXRecordDecl *Destroyed = nullptr;
415 // FIXME: If we have a scope specifier, suggest its last component?
416 if (!SearchType.isNull())
417 Destroyed = SearchType->getAsCXXRecordDecl();
418 else if (S)
419 Destroyed = dyn_cast_or_null<CXXRecordDecl>(S->getEntity());
420 if (Destroyed)
421 return FixItHint::CreateReplacement(SourceRange(NameLoc),
422 Destroyed->getNameAsString());
423 return FixItHint();
424 };
425
426 if (FoundDecls.empty()) {
427 // FIXME: Attempt typo-correction?
428 Diag(NameLoc, diag::err_undeclared_destructor_name)
429 << &II << MakeFixItHint();
430 } else if (!SearchType.isNull() && FoundDecls.size() == 1) {
431 if (auto *TD = dyn_cast<TypeDecl>(FoundDecls[0]->getUnderlyingDecl())) {
432 assert(!SearchType.isNull() &&((void)0)
433 "should only reject a type result if we have a search type")((void)0);
434 QualType T = Context.getTypeDeclType(TD);
435 Diag(NameLoc, diag::err_destructor_expr_type_mismatch)
436 << T << SearchType << MakeFixItHint();
437 } else {
438 Diag(NameLoc, diag::err_destructor_expr_nontype)
439 << &II << MakeFixItHint();
440 }
441 } else {
442 Diag(NameLoc, SearchType.isNull() ? diag::err_destructor_name_nontype
443 : diag::err_destructor_expr_mismatch)
444 << &II << SearchType << MakeFixItHint();
445 }
446
447 for (NamedDecl *FoundD : FoundDecls) {
448 if (auto *TD = dyn_cast<TypeDecl>(FoundD->getUnderlyingDecl()))
449 Diag(FoundD->getLocation(), diag::note_destructor_type_here)
450 << Context.getTypeDeclType(TD);
451 else
452 Diag(FoundD->getLocation(), diag::note_destructor_nontype_here)
453 << FoundD;
454 }
455
456 return nullptr;
457}
458
459ParsedType Sema::getDestructorTypeForDecltype(const DeclSpec &DS,
460 ParsedType ObjectType) {
461 if (DS.getTypeSpecType() == DeclSpec::TST_error)
462 return nullptr;
463
464 if (DS.getTypeSpecType() == DeclSpec::TST_decltype_auto) {
465 Diag(DS.getTypeSpecTypeLoc(), diag::err_decltype_auto_invalid);
466 return nullptr;
467 }
468
469 assert(DS.getTypeSpecType() == DeclSpec::TST_decltype &&((void)0)
470 "unexpected type in getDestructorType")((void)0);
471 QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
472
473 // If we know the type of the object, check that the correct destructor
474 // type was named now; we can give better diagnostics this way.
475 QualType SearchType = GetTypeFromParser(ObjectType);
476 if (!SearchType.isNull() && !SearchType->isDependentType() &&
477 !Context.hasSameUnqualifiedType(T, SearchType)) {
478 Diag(DS.getTypeSpecTypeLoc(), diag::err_destructor_expr_type_mismatch)
479 << T << SearchType;
480 return nullptr;
481 }
482
483 return ParsedType::make(T);
484}
485
486bool Sema::checkLiteralOperatorId(const CXXScopeSpec &SS,
487 const UnqualifiedId &Name, bool IsUDSuffix) {
488 assert(Name.getKind() == UnqualifiedIdKind::IK_LiteralOperatorId)((void)0);
489 if (!IsUDSuffix) {
490 // [over.literal] p8
491 //
492 // double operator""_Bq(long double); // OK: not a reserved identifier
493 // double operator"" _Bq(long double); // ill-formed, no diagnostic required
494 IdentifierInfo *II = Name.Identifier;
495 ReservedIdentifierStatus Status = II->isReserved(PP.getLangOpts());
496 SourceLocation Loc = Name.getEndLoc();
497 if (Status != ReservedIdentifierStatus::NotReserved &&
498 !PP.getSourceManager().isInSystemHeader(Loc)) {
499 Diag(Loc, diag::warn_reserved_extern_symbol)
500 << II << static_cast<int>(Status)
501 << FixItHint::CreateReplacement(
502 Name.getSourceRange(),
503 (StringRef("operator\"\"") + II->getName()).str());
504 }
505 }
506
507 if (!SS.isValid())
508 return false;
509
510 switch (SS.getScopeRep()->getKind()) {
511 case NestedNameSpecifier::Identifier:
512 case NestedNameSpecifier::TypeSpec:
513 case NestedNameSpecifier::TypeSpecWithTemplate:
514 // Per C++11 [over.literal]p2, literal operators can only be declared at
515 // namespace scope. Therefore, this unqualified-id cannot name anything.
516 // Reject it early, because we have no AST representation for this in the
517 // case where the scope is dependent.
518 Diag(Name.getBeginLoc(), diag::err_literal_operator_id_outside_namespace)
519 << SS.getScopeRep();
520 return true;
521
522 case NestedNameSpecifier::Global:
523 case NestedNameSpecifier::Super:
524 case NestedNameSpecifier::Namespace:
525 case NestedNameSpecifier::NamespaceAlias:
526 return false;
527 }
528
529 llvm_unreachable("unknown nested name specifier kind")__builtin_unreachable();
530}
531
532/// Build a C++ typeid expression with a type operand.
533ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,
534 SourceLocation TypeidLoc,
535 TypeSourceInfo *Operand,
536 SourceLocation RParenLoc) {
537 // C++ [expr.typeid]p4:
538 // The top-level cv-qualifiers of the lvalue expression or the type-id
539 // that is the operand of typeid are always ignored.
540 // If the type of the type-id is a class type or a reference to a class
541 // type, the class shall be completely-defined.
542 Qualifiers Quals;
543 QualType T
544 = Context.getUnqualifiedArrayType(Operand->getType().getNonReferenceType(),
545 Quals);
546 if (T->getAs<RecordType>() &&
547 RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
548 return ExprError();
549
550 if (T->isVariablyModifiedType())
551 return ExprError(Diag(TypeidLoc, diag::err_variably_modified_typeid) << T);
552
553 if (CheckQualifiedFunctionForTypeId(T, TypeidLoc))
554 return ExprError();
555
556 return new (Context) CXXTypeidExpr(TypeInfoType.withConst(), Operand,
557 SourceRange(TypeidLoc, RParenLoc));
558}
559
560/// Build a C++ typeid expression with an expression operand.
561ExprResult Sema::BuildCXXTypeId(QualType TypeInfoType,
562 SourceLocation TypeidLoc,
563 Expr *E,
564 SourceLocation RParenLoc) {
565 bool WasEvaluated = false;
566 if (E && !E->isTypeDependent()) {
567 if (E->getType()->isPlaceholderType()) {
568 ExprResult result = CheckPlaceholderExpr(E);
569 if (result.isInvalid()) return ExprError();
570 E = result.get();
571 }
572
573 QualType T = E->getType();
574 if (const RecordType *RecordT = T->getAs<RecordType>()) {
575 CXXRecordDecl *RecordD = cast<CXXRecordDecl>(RecordT->getDecl());
576 // C++ [expr.typeid]p3:
577 // [...] If the type of the expression is a class type, the class
578 // shall be completely-defined.
579 if (RequireCompleteType(TypeidLoc, T, diag::err_incomplete_typeid))
580 return ExprError();
581
582 // C++ [expr.typeid]p3:
583 // When typeid is applied to an expression other than an glvalue of a
584 // polymorphic class type [...] [the] expression is an unevaluated
585 // operand. [...]
586 if (RecordD->isPolymorphic() && E->isGLValue()) {
587 if (isUnevaluatedContext()) {
588 // The operand was processed in unevaluated context, switch the
589 // context and recheck the subexpression.
590 ExprResult Result = TransformToPotentiallyEvaluated(E);
591 if (Result.isInvalid())
592 return ExprError();
593 E = Result.get();
594 }
595
596 // We require a vtable to query the type at run time.
597 MarkVTableUsed(TypeidLoc, RecordD);
598 WasEvaluated = true;
599 }
600 }
601
602 ExprResult Result = CheckUnevaluatedOperand(E);
603 if (Result.isInvalid())
604 return ExprError();
605 E = Result.get();
606
607 // C++ [expr.typeid]p4:
608 // [...] If the type of the type-id is a reference to a possibly
609 // cv-qualified type, the result of the typeid expression refers to a
610 // std::type_info object representing the cv-unqualified referenced
611 // type.
612 Qualifiers Quals;
613 QualType UnqualT = Context.getUnqualifiedArrayType(T, Quals);
614 if (!Context.hasSameType(T, UnqualT)) {
615 T = UnqualT;
616 E = ImpCastExprToType(E, UnqualT, CK_NoOp, E->getValueKind()).get();
617 }
618 }
619
620 if (E->getType()->isVariablyModifiedType())
621 return ExprError(Diag(TypeidLoc, diag::err_variably_modified_typeid)
622 << E->getType());
623 else if (!inTemplateInstantiation() &&
624 E->HasSideEffects(Context, WasEvaluated)) {
625 // The expression operand for typeid is in an unevaluated expression
626 // context, so side effects could result in unintended consequences.
627 Diag(E->getExprLoc(), WasEvaluated
628 ? diag::warn_side_effects_typeid
629 : diag::warn_side_effects_unevaluated_context);
630 }
631
632 return new (Context) CXXTypeidExpr(TypeInfoType.withConst(), E,
633 SourceRange(TypeidLoc, RParenLoc));
634}
635
636/// ActOnCXXTypeidOfType - Parse typeid( type-id ) or typeid (expression);
637ExprResult
638Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc,
639 bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
640 // typeid is not supported in OpenCL.
641 if (getLangOpts().OpenCLCPlusPlus) {
642 return ExprError(Diag(OpLoc, diag::err_openclcxx_not_supported)
643 << "typeid");
644 }
645
646 // Find the std::type_info type.
647 if (!getStdNamespace())
648 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
649
650 if (!CXXTypeInfoDecl) {
651 IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get("type_info");
652 LookupResult R(*this, TypeInfoII, SourceLocation(), LookupTagName);
653 LookupQualifiedName(R, getStdNamespace());
654 CXXTypeInfoDecl = R.getAsSingle<RecordDecl>();
655 // Microsoft's typeinfo doesn't have type_info in std but in the global
656 // namespace if _HAS_EXCEPTIONS is defined to 0. See PR13153.
657 if (!CXXTypeInfoDecl && LangOpts.MSVCCompat) {
658 LookupQualifiedName(R, Context.getTranslationUnitDecl());
659 CXXTypeInfoDecl = R.getAsSingle<RecordDecl>();
660 }
661 if (!CXXTypeInfoDecl)
662 return ExprError(Diag(OpLoc, diag::err_need_header_before_typeid));
663 }
664
665 if (!getLangOpts().RTTI) {
666 return ExprError(Diag(OpLoc, diag::err_no_typeid_with_fno_rtti));
667 }
668
669 QualType TypeInfoType = Context.getTypeDeclType(CXXTypeInfoDecl);
670
671 if (isType) {
672 // The operand is a type; handle it as such.
673 TypeSourceInfo *TInfo = nullptr;
674 QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),
675 &TInfo);
676 if (T.isNull())
677 return ExprError();
678
679 if (!TInfo)
680 TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);
681
682 return BuildCXXTypeId(TypeInfoType, OpLoc, TInfo, RParenLoc);
683 }
684
685 // The operand is an expression.
686 ExprResult Result =
687 BuildCXXTypeId(TypeInfoType, OpLoc, (Expr *)TyOrExpr, RParenLoc);
688
689 if (!getLangOpts().RTTIData && !Result.isInvalid())
690 if (auto *CTE = dyn_cast<CXXTypeidExpr>(Result.get()))
691 if (CTE->isPotentiallyEvaluated() && !CTE->isMostDerived(Context))
692 Diag(OpLoc, diag::warn_no_typeid_with_rtti_disabled)
693 << (getDiagnostics().getDiagnosticOptions().getFormat() ==
694 DiagnosticOptions::MSVC);
695 return Result;
696}
697
698/// Grabs __declspec(uuid()) off a type, or returns 0 if we cannot resolve to
699/// a single GUID.
700static void
701getUuidAttrOfType(Sema &SemaRef, QualType QT,
702 llvm::SmallSetVector<const UuidAttr *, 1> &UuidAttrs) {
703 // Optionally remove one level of pointer, reference or array indirection.
704 const Type *Ty = QT.getTypePtr();
705 if (QT->isPointerType() || QT->isReferenceType())
706 Ty = QT->getPointeeType().getTypePtr();
707 else if (QT->isArrayType())
708 Ty = Ty->getBaseElementTypeUnsafe();
709
710 const auto *TD = Ty->getAsTagDecl();
711 if (!TD)
712 return;
713
714 if (const auto *Uuid = TD->getMostRecentDecl()->getAttr<UuidAttr>()) {
715 UuidAttrs.insert(Uuid);
716 return;
717 }
718
719 // __uuidof can grab UUIDs from template arguments.
720 if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(TD)) {
721 const TemplateArgumentList &TAL = CTSD->getTemplateArgs();
722 for (const TemplateArgument &TA : TAL.asArray()) {
723 const UuidAttr *UuidForTA = nullptr;
724 if (TA.getKind() == TemplateArgument::Type)
725 getUuidAttrOfType(SemaRef, TA.getAsType(), UuidAttrs);
726 else if (TA.getKind() == TemplateArgument::Declaration)
727 getUuidAttrOfType(SemaRef, TA.getAsDecl()->getType(), UuidAttrs);
728
729 if (UuidForTA)
730 UuidAttrs.insert(UuidForTA);
731 }
732 }
733}
734
735/// Build a Microsoft __uuidof expression with a type operand.
736ExprResult Sema::BuildCXXUuidof(QualType Type,
737 SourceLocation TypeidLoc,
738 TypeSourceInfo *Operand,
739 SourceLocation RParenLoc) {
740 MSGuidDecl *Guid = nullptr;
741 if (!Operand->getType()->isDependentType()) {
742 llvm::SmallSetVector<const UuidAttr *, 1> UuidAttrs;
743 getUuidAttrOfType(*this, Operand->getType(), UuidAttrs);
744 if (UuidAttrs.empty())
745 return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));
746 if (UuidAttrs.size() > 1)
747 return ExprError(Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
748 Guid = UuidAttrs.back()->getGuidDecl();
749 }
750
751 return new (Context)
752 CXXUuidofExpr(Type, Operand, Guid, SourceRange(TypeidLoc, RParenLoc));
753}
754
755/// Build a Microsoft __uuidof expression with an expression operand.
756ExprResult Sema::BuildCXXUuidof(QualType Type, SourceLocation TypeidLoc,
757 Expr *E, SourceLocation RParenLoc) {
758 MSGuidDecl *Guid = nullptr;
759 if (!E->getType()->isDependentType()) {
760 if (E->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {
761 // A null pointer results in {00000000-0000-0000-0000-000000000000}.
762 Guid = Context.getMSGuidDecl(MSGuidDecl::Parts{});
763 } else {
764 llvm::SmallSetVector<const UuidAttr *, 1> UuidAttrs;
765 getUuidAttrOfType(*this, E->getType(), UuidAttrs);
766 if (UuidAttrs.empty())
767 return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));
768 if (UuidAttrs.size() > 1)
769 return ExprError(Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));
770 Guid = UuidAttrs.back()->getGuidDecl();
771 }
772 }
773
774 return new (Context)
775 CXXUuidofExpr(Type, E, Guid, SourceRange(TypeidLoc, RParenLoc));
776}
777
778/// ActOnCXXUuidof - Parse __uuidof( type-id ) or __uuidof (expression);
779ExprResult
780Sema::ActOnCXXUuidof(SourceLocation OpLoc, SourceLocation LParenLoc,
781 bool isType, void *TyOrExpr, SourceLocation RParenLoc) {
782 QualType GuidType = Context.getMSGuidType();
783 GuidType.addConst();
784
785 if (isType) {
786 // The operand is a type; handle it as such.
787 TypeSourceInfo *TInfo = nullptr;
788 QualType T = GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrExpr),
789 &TInfo);
790 if (T.isNull())
791 return ExprError();
792
793 if (!TInfo)
794 TInfo = Context.getTrivialTypeSourceInfo(T, OpLoc);
795
796 return BuildCXXUuidof(GuidType, OpLoc, TInfo, RParenLoc);
797 }
798
799 // The operand is an expression.
800 return BuildCXXUuidof(GuidType, OpLoc, (Expr*)TyOrExpr, RParenLoc);
801}
802
803/// ActOnCXXBoolLiteral - Parse {true,false} literals.
804ExprResult
805Sema::ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) {
806 assert((Kind == tok::kw_true || Kind == tok::kw_false) &&((void)0)
807 "Unknown C++ Boolean value!")((void)0);
808 return new (Context)
809 CXXBoolLiteralExpr(Kind == tok::kw_true, Context.BoolTy, OpLoc);
810}
811
812/// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
813ExprResult
814Sema::ActOnCXXNullPtrLiteral(SourceLocation Loc) {
815 return new (Context) CXXNullPtrLiteralExpr(Context.NullPtrTy, Loc);
816}
817
818/// ActOnCXXThrow - Parse throw expressions.
819ExprResult
820Sema::ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *Ex) {
821 bool IsThrownVarInScope = false;
822 if (Ex) {
823 // C++0x [class.copymove]p31:
824 // When certain criteria are met, an implementation is allowed to omit the
825 // copy/move construction of a class object [...]
826 //
827 // - in a throw-expression, when the operand is the name of a
828 // non-volatile automatic object (other than a function or catch-
829 // clause parameter) whose scope does not extend beyond the end of the
830 // innermost enclosing try-block (if there is one), the copy/move
831 // operation from the operand to the exception object (15.1) can be
832 // omitted by constructing the automatic object directly into the
833 // exception object
834 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Ex->IgnoreParens()))
835 if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
836 if (Var->hasLocalStorage() && !Var->getType().isVolatileQualified()) {
837 for( ; S; S = S->getParent()) {
838 if (S->isDeclScope(Var)) {
839 IsThrownVarInScope = true;
840 break;
841 }
842
843 if (S->getFlags() &
844 (Scope::FnScope | Scope::ClassScope | Scope::BlockScope |
845 Scope::FunctionPrototypeScope | Scope::ObjCMethodScope |
846 Scope::TryScope))
847 break;
848 }
849 }
850 }
851 }
852
853 return BuildCXXThrow(OpLoc, Ex, IsThrownVarInScope);
854}
855
856ExprResult Sema::BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,
857 bool IsThrownVarInScope) {
858 // Don't report an error if 'throw' is used in system headers.
859 if (!getLangOpts().CXXExceptions &&
860 !getSourceManager().isInSystemHeader(OpLoc) && !getLangOpts().CUDA) {
861 // Delay error emission for the OpenMP device code.
862 targetDiag(OpLoc, diag::err_exceptions_disabled) << "throw";
863 }
864
865 // Exceptions aren't allowed in CUDA device code.
866 if (getLangOpts().CUDA)
867 CUDADiagIfDeviceCode(OpLoc, diag::err_cuda_device_exceptions)
868 << "throw" << CurrentCUDATarget();
869
870 if (getCurScope() && getCurScope()->isOpenMPSimdDirectiveScope())
871 Diag(OpLoc, diag::err_omp_simd_region_cannot_use_stmt) << "throw";
872
873 if (Ex && !Ex->isTypeDependent()) {
874 // Initialize the exception result. This implicitly weeds out
875 // abstract types or types with inaccessible copy constructors.
876
877 // C++0x [class.copymove]p31:
878 // When certain criteria are met, an implementation is allowed to omit the
879 // copy/move construction of a class object [...]
880 //
881 // - in a throw-expression, when the operand is the name of a
882 // non-volatile automatic object (other than a function or
883 // catch-clause
884 // parameter) whose scope does not extend beyond the end of the
885 // innermost enclosing try-block (if there is one), the copy/move
886 // operation from the operand to the exception object (15.1) can be
887 // omitted by constructing the automatic object directly into the
888 // exception object
889 NamedReturnInfo NRInfo =
890 IsThrownVarInScope ? getNamedReturnInfo(Ex) : NamedReturnInfo();
891
892 QualType ExceptionObjectTy = Context.getExceptionObjectType(Ex->getType());
893 if (CheckCXXThrowOperand(OpLoc, ExceptionObjectTy, Ex))
894 return ExprError();
895
896 InitializedEntity Entity =
897 InitializedEntity::InitializeException(OpLoc, ExceptionObjectTy);
898 ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRInfo, Ex);
899 if (Res.isInvalid())
900 return ExprError();
901 Ex = Res.get();
902 }
903
904 // PPC MMA non-pointer types are not allowed as throw expr types.
905 if (Ex && Context.getTargetInfo().getTriple().isPPC64())
906 CheckPPCMMAType(Ex->getType(), Ex->getBeginLoc());
907
908 return new (Context)
909 CXXThrowExpr(Ex, Context.VoidTy, OpLoc, IsThrownVarInScope);
910}
911
912static void
913collectPublicBases(CXXRecordDecl *RD,
914 llvm::DenseMap<CXXRecordDecl *, unsigned> &SubobjectsSeen,
915 llvm::SmallPtrSetImpl<CXXRecordDecl *> &VBases,
916 llvm::SetVector<CXXRecordDecl *> &PublicSubobjectsSeen,
917 bool ParentIsPublic) {
918 for (const CXXBaseSpecifier &BS : RD->bases()) {
919 CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
920 bool NewSubobject;
921 // Virtual bases constitute the same subobject. Non-virtual bases are
922 // always distinct subobjects.
923 if (BS.isVirtual())
924 NewSubobject = VBases.insert(BaseDecl).second;
925 else
926 NewSubobject = true;
927
928 if (NewSubobject)
929 ++SubobjectsSeen[BaseDecl];
930
931 // Only add subobjects which have public access throughout the entire chain.
932 bool PublicPath = ParentIsPublic && BS.getAccessSpecifier() == AS_public;
933 if (PublicPath)
934 PublicSubobjectsSeen.insert(BaseDecl);
935
936 // Recurse on to each base subobject.
937 collectPublicBases(BaseDecl, SubobjectsSeen, VBases, PublicSubobjectsSeen,
938 PublicPath);
939 }
940}
941
942static void getUnambiguousPublicSubobjects(
943 CXXRecordDecl *RD, llvm::SmallVectorImpl<CXXRecordDecl *> &Objects) {
944 llvm::DenseMap<CXXRecordDecl *, unsigned> SubobjectsSeen;
945 llvm::SmallSet<CXXRecordDecl *, 2> VBases;
946 llvm::SetVector<CXXRecordDecl *> PublicSubobjectsSeen;
947 SubobjectsSeen[RD] = 1;
948 PublicSubobjectsSeen.insert(RD);
949 collectPublicBases(RD, SubobjectsSeen, VBases, PublicSubobjectsSeen,
950 /*ParentIsPublic=*/true);
951
952 for (CXXRecordDecl *PublicSubobject : PublicSubobjectsSeen) {
953 // Skip ambiguous objects.
954 if (SubobjectsSeen[PublicSubobject] > 1)
955 continue;
956
957 Objects.push_back(PublicSubobject);
958 }
959}
960
961/// CheckCXXThrowOperand - Validate the operand of a throw.
962bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc,
963 QualType ExceptionObjectTy, Expr *E) {
964 // If the type of the exception would be an incomplete type or a pointer
965 // to an incomplete type other than (cv) void the program is ill-formed.
966 QualType Ty = ExceptionObjectTy;
967 bool isPointer = false;
968 if (const PointerType* Ptr = Ty->getAs<PointerType>()) {
969 Ty = Ptr->getPointeeType();
970 isPointer = true;
971 }
972 if (!isPointer || !Ty->isVoidType()) {
973 if (RequireCompleteType(ThrowLoc, Ty,
974 isPointer ? diag::err_throw_incomplete_ptr
975 : diag::err_throw_incomplete,
976 E->getSourceRange()))
977 return true;
978
979 if (!isPointer && Ty->isSizelessType()) {
980 Diag(ThrowLoc, diag::err_throw_sizeless) << Ty << E->getSourceRange();
981 return true;
982 }
983
984 if (RequireNonAbstractType(ThrowLoc, ExceptionObjectTy,
985 diag::err_throw_abstract_type, E))
986 return true;
987 }
988
989 // If the exception has class type, we need additional handling.
990 CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
991 if (!RD)
992 return false;
993
994 // If we are throwing a polymorphic class type or pointer thereof,
995 // exception handling will make use of the vtable.
996 MarkVTableUsed(ThrowLoc, RD);
997
998 // If a pointer is thrown, the referenced object will not be destroyed.
999 if (isPointer)
1000 return false;
1001
1002 // If the class has a destructor, we must be able to call it.
1003 if (!RD->hasIrrelevantDestructor()) {
1004 if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {
1005 MarkFunctionReferenced(E->getExprLoc(), Destructor);
1006 CheckDestructorAccess(E->getExprLoc(), Destructor,
1007 PDiag(diag::err_access_dtor_exception) << Ty);
1008 if (DiagnoseUseOfDecl(Destructor, E->getExprLoc()))
1009 return true;
1010 }
1011 }
1012
1013 // The MSVC ABI creates a list of all types which can catch the exception
1014 // object. This list also references the appropriate copy constructor to call
1015 // if the object is caught by value and has a non-trivial copy constructor.
1016 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
1017 // We are only interested in the public, unambiguous bases contained within
1018 // the exception object. Bases which are ambiguous or otherwise
1019 // inaccessible are not catchable types.
1020 llvm::SmallVector<CXXRecordDecl *, 2> UnambiguousPublicSubobjects;
1021 getUnambiguousPublicSubobjects(RD, UnambiguousPublicSubobjects);
1022
1023 for (CXXRecordDecl *Subobject : UnambiguousPublicSubobjects) {
1024 // Attempt to lookup the copy constructor. Various pieces of machinery
1025 // will spring into action, like template instantiation, which means this
1026 // cannot be a simple walk of the class's decls. Instead, we must perform
1027 // lookup and overload resolution.
1028 CXXConstructorDecl *CD = LookupCopyingConstructor(Subobject, 0);
1029 if (!CD || CD->isDeleted())
1030 continue;
1031
1032 // Mark the constructor referenced as it is used by this throw expression.
1033 MarkFunctionReferenced(E->getExprLoc(), CD);
1034
1035 // Skip this copy constructor if it is trivial, we don't need to record it
1036 // in the catchable type data.
1037 if (CD->isTrivial())
1038 continue;
1039
1040 // The copy constructor is non-trivial, create a mapping from this class
1041 // type to this constructor.
1042 // N.B. The selection of copy constructor is not sensitive to this
1043 // particular throw-site. Lookup will be performed at the catch-site to
1044 // ensure that the copy constructor is, in fact, accessible (via
1045 // friendship or any other means).
1046 Context.addCopyConstructorForExceptionObject(Subobject, CD);
1047
1048 // We don't keep the instantiated default argument expressions around so
1049 // we must rebuild them here.
1050 for (unsigned I = 1, E = CD->getNumParams(); I != E; ++I) {
1051 if (CheckCXXDefaultArgExpr(ThrowLoc, CD, CD->getParamDecl(I)))
1052 return true;
1053 }
1054 }
1055 }
1056
1057 // Under the Itanium C++ ABI, memory for the exception object is allocated by
1058 // the runtime with no ability for the compiler to request additional
1059 // alignment. Warn if the exception type requires alignment beyond the minimum
1060 // guaranteed by the target C++ runtime.
1061 if (Context.getTargetInfo().getCXXABI().isItaniumFamily()) {
1062 CharUnits TypeAlign = Context.getTypeAlignInChars(Ty);
1063 CharUnits ExnObjAlign = Context.getExnObjectAlignment();
1064 if (ExnObjAlign < TypeAlign) {
1065 Diag(ThrowLoc, diag::warn_throw_underaligned_obj);
1066 Diag(ThrowLoc, diag::note_throw_underaligned_obj)
1067 << Ty << (unsigned)TypeAlign.getQuantity()
1068 << (unsigned)ExnObjAlign.getQuantity();
1069 }
1070 }
1071
1072 return false;
1073}
1074
1075static QualType adjustCVQualifiersForCXXThisWithinLambda(
1076 ArrayRef<FunctionScopeInfo *> FunctionScopes, QualType ThisTy,
1077 DeclContext *CurSemaContext, ASTContext &ASTCtx) {
1078
1079 QualType ClassType = ThisTy->getPointeeType();
1080 LambdaScopeInfo *CurLSI = nullptr;
1081 DeclContext *CurDC = CurSemaContext;
1082
1083 // Iterate through the stack of lambdas starting from the innermost lambda to
1084 // the outermost lambda, checking if '*this' is ever captured by copy - since
1085 // that could change the cv-qualifiers of the '*this' object.
1086 // The object referred to by '*this' starts out with the cv-qualifiers of its
1087 // member function. We then start with the innermost lambda and iterate
1088 // outward checking to see if any lambda performs a by-copy capture of '*this'
1089 // - and if so, any nested lambda must respect the 'constness' of that
1090 // capturing lamdbda's call operator.
1091 //
1092
1093 // Since the FunctionScopeInfo stack is representative of the lexical
1094 // nesting of the lambda expressions during initial parsing (and is the best
1095 // place for querying information about captures about lambdas that are
1096 // partially processed) and perhaps during instantiation of function templates
1097 // that contain lambda expressions that need to be transformed BUT not
1098 // necessarily during instantiation of a nested generic lambda's function call
1099 // operator (which might even be instantiated at the end of the TU) - at which
1100 // time the DeclContext tree is mature enough to query capture information
1101 // reliably - we use a two pronged approach to walk through all the lexically
1102 // enclosing lambda expressions:
1103 //
1104 // 1) Climb down the FunctionScopeInfo stack as long as each item represents
1105 // a Lambda (i.e. LambdaScopeInfo) AND each LSI's 'closure-type' is lexically
1106 // enclosed by the call-operator of the LSI below it on the stack (while
1107 // tracking the enclosing DC for step 2 if needed). Note the topmost LSI on
1108 // the stack represents the innermost lambda.
1109 //
1110 // 2) If we run out of enclosing LSI's, check if the enclosing DeclContext
1111 // represents a lambda's call operator. If it does, we must be instantiating
1112 // a generic lambda's call operator (represented by the Current LSI, and
1113 // should be the only scenario where an inconsistency between the LSI and the
1114 // DeclContext should occur), so climb out the DeclContexts if they
1115 // represent lambdas, while querying the corresponding closure types
1116 // regarding capture information.
1117
1118 // 1) Climb down the function scope info stack.
1119 for (int I = FunctionScopes.size();
1120 I-- && isa<LambdaScopeInfo>(FunctionScopes[I]) &&
1121 (!CurLSI || !CurLSI->Lambda || CurLSI->Lambda->getDeclContext() ==
1122 cast<LambdaScopeInfo>(FunctionScopes[I])->CallOperator);
1123 CurDC = getLambdaAwareParentOfDeclContext(CurDC)) {
1124 CurLSI = cast<LambdaScopeInfo>(FunctionScopes[I]);
1125
1126 if (!CurLSI->isCXXThisCaptured())
1127 continue;
1128
1129 auto C = CurLSI->getCXXThisCapture();
1130
1131 if (C.isCopyCapture()) {
1132 ClassType.removeLocalCVRQualifiers(Qualifiers::CVRMask);
1133 if (CurLSI->CallOperator->isConst())
1134 ClassType.addConst();
1135 return ASTCtx.getPointerType(ClassType);
1136 }
1137 }
1138
1139 // 2) We've run out of ScopeInfos but check if CurDC is a lambda (which can
1140 // happen during instantiation of its nested generic lambda call operator)
1141 if (isLambdaCallOperator(CurDC)) {
1142 assert(CurLSI && "While computing 'this' capture-type for a generic "((void)0)
1143 "lambda, we must have a corresponding LambdaScopeInfo")((void)0);
1144 assert(isGenericLambdaCallOperatorSpecialization(CurLSI->CallOperator) &&((void)0)
1145 "While computing 'this' capture-type for a generic lambda, when we "((void)0)
1146 "run out of enclosing LSI's, yet the enclosing DC is a "((void)0)
1147 "lambda-call-operator we must be (i.e. Current LSI) in a generic "((void)0)
1148 "lambda call oeprator")((void)0);
1149 assert(CurDC == getLambdaAwareParentOfDeclContext(CurLSI->CallOperator))((void)0);
1150
1151 auto IsThisCaptured =
1152 [](CXXRecordDecl *Closure, bool &IsByCopy, bool &IsConst) {
1153 IsConst = false;
1154 IsByCopy = false;
1155 for (auto &&C : Closure->captures()) {
1156 if (C.capturesThis()) {
1157 if (C.getCaptureKind() == LCK_StarThis)
1158 IsByCopy = true;
1159 if (Closure->getLambdaCallOperator()->isConst())
1160 IsConst = true;
1161 return true;
1162 }
1163 }
1164 return false;
1165 };
1166
1167 bool IsByCopyCapture = false;
1168 bool IsConstCapture = false;
1169 CXXRecordDecl *Closure = cast<CXXRecordDecl>(CurDC->getParent());
1170 while (Closure &&
1171 IsThisCaptured(Closure, IsByCopyCapture, IsConstCapture)) {
1172 if (IsByCopyCapture) {
1173 ClassType.removeLocalCVRQualifiers(Qualifiers::CVRMask);
1174 if (IsConstCapture)
1175 ClassType.addConst();
1176 return ASTCtx.getPointerType(ClassType);
1177 }
1178 Closure = isLambdaCallOperator(Closure->getParent())
1179 ? cast<CXXRecordDecl>(Closure->getParent()->getParent())
1180 : nullptr;
1181 }
1182 }
1183 return ASTCtx.getPointerType(ClassType);
1184}
1185
1186QualType Sema::getCurrentThisType() {
1187 DeclContext *DC = getFunctionLevelDeclContext();
1188 QualType ThisTy = CXXThisTypeOverride;
1189
1190 if (CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(DC)) {
1191 if (method && method->isInstance())
1192 ThisTy = method->getThisType();
1193 }
1194
1195 if (ThisTy.isNull() && isLambdaCallOperator(CurContext) &&
1196 inTemplateInstantiation() && isa<CXXRecordDecl>(DC)) {
1197
1198 // This is a lambda call operator that is being instantiated as a default
1199 // initializer. DC must point to the enclosing class type, so we can recover
1200 // the 'this' type from it.
1201 QualType ClassTy = Context.getTypeDeclType(cast<CXXRecordDecl>(DC));
1202 // There are no cv-qualifiers for 'this' within default initializers,
1203 // per [expr.prim.general]p4.
1204 ThisTy = Context.getPointerType(ClassTy);
1205 }
1206
1207 // If we are within a lambda's call operator, the cv-qualifiers of 'this'
1208 // might need to be adjusted if the lambda or any of its enclosing lambda's
1209 // captures '*this' by copy.
1210 if (!ThisTy.isNull() && isLambdaCallOperator(CurContext))
1211 return adjustCVQualifiersForCXXThisWithinLambda(FunctionScopes, ThisTy,
1212 CurContext, Context);
1213 return ThisTy;
1214}
1215
1216Sema::CXXThisScopeRAII::CXXThisScopeRAII(Sema &S,
1217 Decl *ContextDecl,
1218 Qualifiers CXXThisTypeQuals,
1219 bool Enabled)
1220 : S(S), OldCXXThisTypeOverride(S.CXXThisTypeOverride), Enabled(false)
1221{
1222 if (!Enabled || !ContextDecl)
1223 return;
1224
1225 CXXRecordDecl *Record = nullptr;
1226 if (ClassTemplateDecl *Template = dyn_cast<ClassTemplateDecl>(ContextDecl))
1227 Record = Template->getTemplatedDecl();
1228 else
1229 Record = cast<CXXRecordDecl>(ContextDecl);
1230
1231 QualType T = S.Context.getRecordType(Record);
1232 T = S.getASTContext().getQualifiedType(T, CXXThisTypeQuals);
1233
1234 S.CXXThisTypeOverride = S.Context.getPointerType(T);
1235
1236 this->Enabled = true;
1237}
1238
1239
1240Sema::CXXThisScopeRAII::~CXXThisScopeRAII() {
1241 if (Enabled) {
1242 S.CXXThisTypeOverride = OldCXXThisTypeOverride;
1243 }
1244}
1245
1246static void buildLambdaThisCaptureFixit(Sema &Sema, LambdaScopeInfo *LSI) {
1247 SourceLocation DiagLoc = LSI->IntroducerRange.getEnd();
30
Called C++ object pointer is null
1248 assert(!LSI->isCXXThisCaptured())((void)0);
1249 // [=, this] {}; // until C++20: Error: this when = is the default
1250 if (LSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_LambdaByval &&
1251 !Sema.getLangOpts().CPlusPlus20)
1252 return;
1253 Sema.Diag(DiagLoc, diag::note_lambda_this_capture_fixit)
1254 << FixItHint::CreateInsertion(
1255 DiagLoc, LSI->NumExplicitCaptures > 0 ? ", this" : "this");
1256}
1257
1258bool Sema::CheckCXXThisCapture(SourceLocation Loc, const bool Explicit,
1259 bool BuildAndDiagnose, const unsigned *const FunctionScopeIndexToStopAt,
1260 const bool ByCopy) {
1261 // We don't need to capture this in an unevaluated context.
1262 if (isUnevaluatedContext() && !Explicit)
5
Calling 'Sema::isUnevaluatedContext'
13
Returning from 'Sema::isUnevaluatedContext'
1263 return true;
1264
1265 assert((!ByCopy || Explicit) && "cannot implicitly capture *this by value")((void)0);
1266
1267 const int MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
13.1
'FunctionScopeIndexToStopAt' is null
13.1
'FunctionScopeIndexToStopAt' is null
14
'?' condition is false
1268 ? *FunctionScopeIndexToStopAt 1269 : FunctionScopes.size() - 1; 1270 1271 // Check that we can capture the *enclosing object* (referred to by '*this') 1272 // by the capturing-entity/closure (lambda/block/etc) at 1273 // MaxFunctionScopesIndex-deep on the FunctionScopes stack. 1274 1275 // Note: The *enclosing object* can only be captured by-value by a 1276 // closure that is a lambda, using the explicit notation: 1277 // [*this] { ... }. 1278 // Every other capture of the *enclosing object* results in its by-reference 1279 // capture. 1280 1281 // For a closure 'L' (at MaxFunctionScopesIndex in the FunctionScopes 1282 // stack), we can capture the *enclosing object* only if: 1283 // - 'L' has an explicit byref or byval capture of the *enclosing object* 1284 // - or, 'L' has an implicit capture. 1285 // AND 1286 // -- there is no enclosing closure 1287 // -- or, there is some enclosing closure 'E' that has already captured the 1288 // *enclosing object*, and every intervening closure (if any) between 'E' 1289 // and 'L' can implicitly capture the *enclosing object*. 1290 // -- or, every enclosing closure can implicitly capture the 1291 // *enclosing object* 1292 1293 1294 unsigned NumCapturingClosures = 0; 1295 for (int idx = MaxFunctionScopesIndex; idx
14.1
'idx' is >= 0
14.1
'idx' is >= 0
>= 0; idx--) {
15
Loop condition is true. Entering loop body
1296 if (CapturingScopeInfo *CSI
16.1
'CSI' is non-null
16.1
'CSI' is non-null
=
17
Taking true branch
1297 dyn_cast<CapturingScopeInfo>(FunctionScopes[idx])) {
16
Assuming the object is a 'CapturingScopeInfo'
1298 if (CSI->CXXThisCaptureIndex != 0) {
18
Assuming field 'CXXThisCaptureIndex' is equal to 0
19
Taking false branch
1299 // 'this' is already being captured; there isn't anything more to do. 1300 CSI->Captures[CSI->CXXThisCaptureIndex - 1].markUsed(BuildAndDiagnose); 1301 break; 1302 } 1303 LambdaScopeInfo *LSI = dyn_cast<LambdaScopeInfo>(CSI);
20
Assuming 'CSI' is not a 'LambdaScopeInfo'
21
'LSI' initialized to a null pointer value
1304 if (LSI
21.1
'LSI' is null
21.1
'LSI' is null
&& isGenericLambdaCallOperatorSpecialization(LSI->CallOperator)) { 1305 // This context can't implicitly capture 'this'; fail out. 1306 if (BuildAndDiagnose) { 1307 Diag(Loc, diag::err_this_capture) 1308 << (Explicit && idx == MaxFunctionScopesIndex); 1309 if (!Explicit) 1310 buildLambdaThisCaptureFixit(*this, LSI); 1311 } 1312 return true; 1313 } 1314 if (CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_LambdaByref ||
22
Assuming field 'ImpCaptureStyle' is not equal to ImpCap_LambdaByref
1315 CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_LambdaByval ||
23
Assuming field 'ImpCaptureStyle' is not equal to ImpCap_LambdaByval
1316 CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_Block ||
24
Assuming field 'ImpCaptureStyle' is not equal to ImpCap_Block
1317 CSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_CapturedRegion ||
25
Assuming field 'ImpCaptureStyle' is not equal to ImpCap_CapturedRegion
1318 (Explicit
25.1
'Explicit' is false
25.1
'Explicit' is false
&& idx == MaxFunctionScopesIndex)) { 1319 // Regarding (Explicit && idx == MaxFunctionScopesIndex): only the first 1320 // iteration through can be an explicit capture, all enclosing closures, 1321 // if any, must perform implicit captures. 1322 1323 // This closure can capture 'this'; continue looking upwards. 1324 NumCapturingClosures++; 1325 continue; 1326 } 1327 // This context can't implicitly capture 'this'; fail out. 1328 if (BuildAndDiagnose
25.2
'BuildAndDiagnose' is true
25.2
'BuildAndDiagnose' is true
)
26
Taking true branch
1329 Diag(Loc, diag::err_this_capture) 1330 << (Explicit
26.1
'Explicit' is false
26.1
'Explicit' is false
&& idx == MaxFunctionScopesIndex); 1331 1332 if (!Explicit
26.2
'Explicit' is false
26.2
'Explicit' is false
)
27
Taking true branch
1333 buildLambdaThisCaptureFixit(*this, LSI);
28
Passing null pointer value via 2nd parameter 'LSI'
29
Calling 'buildLambdaThisCaptureFixit'
1334 return true; 1335 } 1336 break; 1337 } 1338 if (!BuildAndDiagnose) return false; 1339 1340 // If we got here, then the closure at MaxFunctionScopesIndex on the 1341 // FunctionScopes stack, can capture the *enclosing object*, so capture it 1342 // (including implicit by-reference captures in any enclosing closures). 1343 1344 // In the loop below, respect the ByCopy flag only for the closure requesting 1345 // the capture (i.e. first iteration through the loop below). Ignore it for 1346 // all enclosing closure's up to NumCapturingClosures (since they must be 1347 // implicitly capturing the *enclosing object* by reference (see loop 1348 // above)). 1349 assert((!ByCopy ||((void)0) 1350 dyn_cast<LambdaScopeInfo>(FunctionScopes[MaxFunctionScopesIndex])) &&((void)0) 1351 "Only a lambda can capture the enclosing object (referred to by "((void)0) 1352 "*this) by copy")((void)0); 1353 QualType ThisTy = getCurrentThisType(); 1354 for (int idx = MaxFunctionScopesIndex; NumCapturingClosures; 1355 --idx, --NumCapturingClosures) { 1356 CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FunctionScopes[idx]); 1357 1358 // The type of the corresponding data member (not a 'this' pointer if 'by 1359 // copy'). 1360 QualType CaptureType = ThisTy; 1361 if (ByCopy) { 1362 // If we are capturing the object referred to by '*this' by copy, ignore 1363 // any cv qualifiers inherited from the type of the member function for 1364 // the type of the closure-type's corresponding data member and any use 1365 // of 'this'. 1366 CaptureType = ThisTy->getPointeeType(); 1367 CaptureType.removeLocalCVRQualifiers(Qualifiers::CVRMask); 1368 } 1369 1370 bool isNested = NumCapturingClosures > 1; 1371 CSI->addThisCapture(isNested, Loc, CaptureType, ByCopy); 1372 } 1373 return false; 1374} 1375 1376ExprResult Sema::ActOnCXXThis(SourceLocation Loc) { 1377 /// C++ 9.3.2: In the body of a non-static member function, the keyword this 1378 /// is a non-lvalue expression whose value is the address of the object for 1379 /// which the function is called. 1380 1381 QualType ThisTy = getCurrentThisType(); 1382 if (ThisTy.isNull())
1
Taking false branch
1383 return Diag(Loc, diag::err_invalid_this_use); 1384 return BuildCXXThisExpr(Loc, ThisTy, /*IsImplicit=*/false);
2
Calling 'Sema::BuildCXXThisExpr'
1385} 1386 1387Expr *Sema::BuildCXXThisExpr(SourceLocation Loc, QualType Type, 1388 bool IsImplicit) { 1389 auto *This = new (Context) CXXThisExpr(Loc, Type, IsImplicit); 1390 MarkThisReferenced(This);
3
Calling 'Sema::MarkThisReferenced'
1391 return This; 1392} 1393 1394void Sema::MarkThisReferenced(CXXThisExpr *This) { 1395 CheckCXXThisCapture(This->getExprLoc());
4
Calling 'Sema::CheckCXXThisCapture'
1396} 1397 1398bool Sema::isThisOutsideMemberFunctionBody(QualType BaseType) { 1399 // If we're outside the body of a member function, then we'll have a specified 1400 // type for 'this'. 1401 if (CXXThisTypeOverride.isNull()) 1402 return false; 1403 1404 // Determine whether we're looking into a class that's currently being 1405 // defined. 1406 CXXRecordDecl *Class = BaseType->getAsCXXRecordDecl(); 1407 return Class && Class->isBeingDefined(); 1408} 1409 1410/// Parse construction of a specified type. 1411/// Can be interpreted either as function-style casting ("int(x)") 1412/// or class type construction ("ClassType(x,y,z)") 1413/// or creation of a value-initialized type ("int()"). 1414ExprResult 1415Sema::ActOnCXXTypeConstructExpr(ParsedType TypeRep, 1416 SourceLocation LParenOrBraceLoc, 1417 MultiExprArg exprs, 1418 SourceLocation RParenOrBraceLoc, 1419 bool ListInitialization) { 1420 if (!TypeRep) 1421 return ExprError(); 1422 1423 TypeSourceInfo *TInfo; 1424 QualType Ty = GetTypeFromParser(TypeRep, &TInfo); 1425 if (!TInfo) 1426 TInfo = Context.getTrivialTypeSourceInfo(Ty, SourceLocation()); 1427 1428 auto Result = BuildCXXTypeConstructExpr(TInfo, LParenOrBraceLoc, exprs, 1429 RParenOrBraceLoc, ListInitialization); 1430 // Avoid creating a non-type-dependent expression that contains typos. 1431 // Non-type-dependent expressions are liable to be discarded without 1432 // checking for embedded typos. 1433 if (!Result.isInvalid() && Result.get()->isInstantiationDependent() && 1434 !Result.get()->isTypeDependent()) 1435 Result = CorrectDelayedTyposInExpr(Result.get()); 1436 else if (Result.isInvalid()) 1437 Result = CreateRecoveryExpr(TInfo->getTypeLoc().getBeginLoc(), 1438 RParenOrBraceLoc, exprs, Ty); 1439 return Result; 1440} 1441 1442ExprResult 1443Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo, 1444 SourceLocation LParenOrBraceLoc, 1445 MultiExprArg Exprs, 1446 SourceLocation RParenOrBraceLoc, 1447 bool ListInitialization) { 1448 QualType Ty = TInfo->getType(); 1449 SourceLocation TyBeginLoc = TInfo->getTypeLoc().getBeginLoc(); 1450 1451 assert((!ListInitialization ||((void)0) 1452 (Exprs.size() == 1 && isa<InitListExpr>(Exprs[0]))) &&((void)0) 1453 "List initialization must have initializer list as expression.")((void)0); 1454 SourceRange FullRange = SourceRange(TyBeginLoc, RParenOrBraceLoc); 1455 1456 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TInfo); 1457 InitializationKind Kind = 1458 Exprs.size() 1459 ? ListInitialization 1460 ? InitializationKind::CreateDirectList( 1461 TyBeginLoc, LParenOrBraceLoc, RParenOrBraceLoc) 1462 : InitializationKind::CreateDirect(TyBeginLoc, LParenOrBraceLoc, 1463 RParenOrBraceLoc) 1464 : InitializationKind::CreateValue(TyBeginLoc, LParenOrBraceLoc, 1465 RParenOrBraceLoc); 1466 1467 // C++1z [expr.type.conv]p1: 1468 // If the type is a placeholder for a deduced class type, [...perform class 1469 // template argument deduction...] 1470 DeducedType *Deduced = Ty->getContainedDeducedType(); 1471 if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) { 1472 Ty = DeduceTemplateSpecializationFromInitializer(TInfo, Entity, 1473 Kind, Exprs); 1474 if (Ty.isNull()) 1475 return ExprError(); 1476 Entity = InitializedEntity::InitializeTemporary(TInfo, Ty); 1477 } 1478 1479 if (Ty->isDependentType() || CallExpr::hasAnyTypeDependentArguments(Exprs)) { 1480 // FIXME: CXXUnresolvedConstructExpr does not model list-initialization 1481 // directly. We work around this by dropping the locations of the braces. 1482 SourceRange Locs = ListInitialization 1483 ? SourceRange() 1484 : SourceRange(LParenOrBraceLoc, RParenOrBraceLoc); 1485 return CXXUnresolvedConstructExpr::Create(Context, Ty.getNonReferenceType(), 1486 TInfo, Locs.getBegin(), Exprs, 1487 Locs.getEnd()); 1488 } 1489 1490 // C++ [expr.type.conv]p1: 1491 // If the expression list is a parenthesized single expression, the type 1492 // conversion expression is equivalent (in definedness, and if defined in 1493 // meaning) to the corresponding cast expression. 1494 if (Exprs.size() == 1 && !ListInitialization && 1495 !isa<InitListExpr>(Exprs[0])) { 1496 Expr *Arg = Exprs[0]; 1497 return BuildCXXFunctionalCastExpr(TInfo, Ty, LParenOrBraceLoc, Arg, 1498 RParenOrBraceLoc); 1499 } 1500 1501 // For an expression of the form T(), T shall not be an array type. 1502 QualType ElemTy = Ty; 1503 if (Ty->isArrayType()) { 1504 if (!ListInitialization) 1505 return ExprError(Diag(TyBeginLoc, diag::err_value_init_for_array_type) 1506 << FullRange); 1507 ElemTy = Context.getBaseElementType(Ty); 1508 } 1509 1510 // There doesn't seem to be an explicit rule against this but sanity demands 1511 // we only construct objects with object types. 1512 if (Ty->isFunctionType()) 1513 return ExprError(Diag(TyBeginLoc, diag::err_init_for_function_type) 1514 << Ty << FullRange); 1515 1516 // C++17 [expr.type.conv]p2: 1517 // If the type is cv void and the initializer is (), the expression is a 1518 // prvalue of the specified type that performs no initialization. 1519 if (!Ty->isVoidType() && 1520 RequireCompleteType(TyBeginLoc, ElemTy, 1521 diag::err_invalid_incomplete_type_use, FullRange)) 1522 return ExprError(); 1523 1524 // Otherwise, the expression is a prvalue of the specified type whose 1525 // result object is direct-initialized (11.6) with the initializer. 1526 InitializationSequence InitSeq(*this, Entity, Kind, Exprs); 1527 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Exprs); 1528 1529 if (Result.isInvalid()) 1530 return Result; 1531 1532 Expr *Inner = Result.get(); 1533 if (CXXBindTemporaryExpr *BTE = dyn_cast_or_null<CXXBindTemporaryExpr>(Inner)) 1534 Inner = BTE->getSubExpr(); 1535 if (!isa<CXXTemporaryObjectExpr>(Inner) && 1536 !isa<CXXScalarValueInitExpr>(Inner)) { 1537 // If we created a CXXTemporaryObjectExpr, that node also represents the 1538 // functional cast. Otherwise, create an explicit cast to represent 1539 // the syntactic form of a functional-style cast that was used here. 1540 // 1541 // FIXME: Creating a CXXFunctionalCastExpr around a CXXConstructExpr 1542 // would give a more consistent AST representation than using a 1543 // CXXTemporaryObjectExpr. It's also weird that the functional cast 1544 // is sometimes handled by initialization and sometimes not. 1545 QualType ResultType = Result.get()->getType(); 1546 SourceRange Locs = ListInitialization 1547 ? SourceRange() 1548 : SourceRange(LParenOrBraceLoc, RParenOrBraceLoc); 1549 Result = CXXFunctionalCastExpr::Create( 1550 Context, ResultType, Expr::getValueKindForType(Ty), TInfo, CK_NoOp, 1551 Result.get(), /*Path=*/nullptr, CurFPFeatureOverrides(), 1552 Locs.getBegin(), Locs.getEnd()); 1553 } 1554 1555 return Result; 1556} 1557 1558bool Sema::isUsualDeallocationFunction(const CXXMethodDecl *Method) { 1559 // [CUDA] Ignore this function, if we can't call it. 1560 const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext); 1561 if (getLangOpts().CUDA) { 1562 auto CallPreference = IdentifyCUDAPreference(Caller, Method); 1563 // If it's not callable at all, it's not the right function. 1564 if (CallPreference < CFP_WrongSide) 1565 return false; 1566 if (CallPreference == CFP_WrongSide) { 1567 // Maybe. We have to check if there are better alternatives. 1568 DeclContext::lookup_result R = 1569 Method->getDeclContext()->lookup(Method->getDeclName()); 1570 for (const auto *D : R) { 1571 if (const auto *FD = dyn_cast<FunctionDecl>(D)) { 1572 if (IdentifyCUDAPreference(Caller, FD) > CFP_WrongSide) 1573 return false; 1574 } 1575 } 1576 // We've found no better variants. 1577 } 1578 } 1579 1580 SmallVector<const FunctionDecl*, 4> PreventedBy; 1581 bool Result = Method->isUsualDeallocationFunction(PreventedBy); 1582 1583 if (Result || !getLangOpts().CUDA || PreventedBy.empty()) 1584 return Result; 1585 1586 // In case of CUDA, return true if none of the 1-argument deallocator 1587 // functions are actually callable. 1588 return llvm::none_of(PreventedBy, [&](const FunctionDecl *FD) { 1589 assert(FD->getNumParams() == 1 &&((void)0) 1590 "Only single-operand functions should be in PreventedBy")((void)0); 1591 return IdentifyCUDAPreference(Caller, FD) >= CFP_HostDevice; 1592 }); 1593} 1594 1595/// Determine whether the given function is a non-placement 1596/// deallocation function. 1597static bool isNonPlacementDeallocationFunction(Sema &S, FunctionDecl *FD) { 1598 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD)) 1599 return S.isUsualDeallocationFunction(Method); 1600 1601 if (FD->getOverloadedOperator() != OO_Delete && 1602 FD->getOverloadedOperator() != OO_Array_Delete) 1603 return false; 1604 1605 unsigned UsualParams = 1; 1606 1607 if (S.getLangOpts().SizedDeallocation && UsualParams < FD->getNumParams() && 1608 S.Context.hasSameUnqualifiedType( 1609 FD->getParamDecl(UsualParams)->getType(), 1610 S.Context.getSizeType())) 1611 ++UsualParams; 1612 1613 if (S.getLangOpts().AlignedAllocation && UsualParams < FD->getNumParams() && 1614 S.Context.hasSameUnqualifiedType( 1615 FD->getParamDecl(UsualParams)->getType(), 1616 S.Context.getTypeDeclType(S.getStdAlignValT()))) 1617 ++UsualParams; 1618 1619 return UsualParams == FD->getNumParams(); 1620} 1621 1622namespace { 1623 struct UsualDeallocFnInfo { 1624 UsualDeallocFnInfo() : Found(), FD(nullptr) {} 1625 UsualDeallocFnInfo(Sema &S, DeclAccessPair Found) 1626 : Found(Found), FD(dyn_cast<FunctionDecl>(Found->getUnderlyingDecl())), 1627 Destroying(false), HasSizeT(false), HasAlignValT(false), 1628 CUDAPref(Sema::CFP_Native) { 1629 // A function template declaration is never a usual deallocation function. 1630 if (!FD) 1631 return; 1632 unsigned NumBaseParams = 1; 1633 if (FD->isDestroyingOperatorDelete()) { 1634 Destroying = true; 1635 ++NumBaseParams; 1636 } 1637 1638 if (NumBaseParams < FD->getNumParams() && 1639 S.Context.hasSameUnqualifiedType( 1640 FD->getParamDecl(NumBaseParams)->getType(), 1641 S.Context.getSizeType())) { 1642 ++NumBaseParams; 1643 HasSizeT = true; 1644 } 1645 1646 if (NumBaseParams < FD->getNumParams() && 1647 FD->getParamDecl(NumBaseParams)->getType()->isAlignValT()) { 1648 ++NumBaseParams; 1649 HasAlignValT = true; 1650 } 1651 1652 // In CUDA, determine how much we'd like / dislike to call this. 1653 if (S.getLangOpts().CUDA) 1654 if (auto *Caller = dyn_cast<FunctionDecl>(S.CurContext)) 1655 CUDAPref = S.IdentifyCUDAPreference(Caller, FD); 1656 } 1657 1658 explicit operator bool() const { return FD; } 1659 1660 bool isBetterThan(const UsualDeallocFnInfo &Other, bool WantSize, 1661 bool WantAlign) const { 1662 // C++ P0722: 1663 // A destroying operator delete is preferred over a non-destroying 1664 // operator delete. 1665 if (Destroying != Other.Destroying) 1666 return Destroying; 1667 1668 // C++17 [expr.delete]p10: 1669 // If the type has new-extended alignment, a function with a parameter 1670 // of type std::align_val_t is preferred; otherwise a function without 1671 // such a parameter is preferred 1672 if (HasAlignValT != Other.HasAlignValT) 1673 return HasAlignValT == WantAlign; 1674 1675 if (HasSizeT != Other.HasSizeT) 1676 return HasSizeT == WantSize; 1677 1678 // Use CUDA call preference as a tiebreaker. 1679 return CUDAPref > Other.CUDAPref; 1680 } 1681 1682 DeclAccessPair Found; 1683 FunctionDecl *FD; 1684 bool Destroying, HasSizeT, HasAlignValT; 1685 Sema::CUDAFunctionPreference CUDAPref; 1686 }; 1687} 1688 1689/// Determine whether a type has new-extended alignment. This may be called when 1690/// the type is incomplete (for a delete-expression with an incomplete pointee 1691/// type), in which case it will conservatively return false if the alignment is 1692/// not known. 1693static bool hasNewExtendedAlignment(Sema &S, QualType AllocType) { 1694 return S.getLangOpts().AlignedAllocation && 1695 S.getASTContext().getTypeAlignIfKnown(AllocType) > 1696 S.getASTContext().getTargetInfo().getNewAlign(); 1697} 1698 1699/// Select the correct "usual" deallocation function to use from a selection of 1700/// deallocation functions (either global or class-scope). 1701static UsualDeallocFnInfo resolveDeallocationOverload( 1702 Sema &S, LookupResult &R, bool WantSize, bool WantAlign, 1703 llvm::SmallVectorImpl<UsualDeallocFnInfo> *BestFns = nullptr) { 1704 UsualDeallocFnInfo Best; 1705 1706 for (auto I = R.begin(), E = R.end(); I != E; ++I) { 1707 UsualDeallocFnInfo Info(S, I.getPair()); 1708 if (!Info || !isNonPlacementDeallocationFunction(S, Info.FD) || 1709 Info.CUDAPref == Sema::CFP_Never) 1710 continue; 1711 1712 if (!Best) { 1713 Best = Info; 1714 if (BestFns) 1715 BestFns->push_back(Info); 1716 continue; 1717 } 1718 1719 if (Best.isBetterThan(Info, WantSize, WantAlign)) 1720 continue; 1721 1722 // If more than one preferred function is found, all non-preferred 1723 // functions are eliminated from further consideration. 1724 if (BestFns && Info.isBetterThan(Best, WantSize, WantAlign)) 1725 BestFns->clear(); 1726 1727 Best = Info; 1728 if (BestFns) 1729 BestFns->push_back(Info); 1730 } 1731 1732 return Best; 1733} 1734 1735/// Determine whether a given type is a class for which 'delete[]' would call 1736/// a member 'operator delete[]' with a 'size_t' parameter. This implies that 1737/// we need to store the array size (even if the type is 1738/// trivially-destructible). 1739static bool doesUsualArrayDeleteWantSize(Sema &S, SourceLocation loc, 1740 QualType allocType) { 1741 const RecordType *record = 1742 allocType->getBaseElementTypeUnsafe()->getAs<RecordType>(); 1743 if (!record) return false; 1744 1745 // Try to find an operator delete[] in class scope. 1746 1747 DeclarationName deleteName = 1748 S.Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete); 1749 LookupResult ops(S, deleteName, loc, Sema::LookupOrdinaryName); 1750 S.LookupQualifiedName(ops, record->getDecl()); 1751 1752 // We're just doing this for information. 1753 ops.suppressDiagnostics(); 1754 1755 // Very likely: there's no operator delete[]. 1756 if (ops.empty()) return false; 1757 1758 // If it's ambiguous, it should be illegal to call operator delete[] 1759 // on this thing, so it doesn't matter if we allocate extra space or not. 1760 if (ops.isAmbiguous()) return false; 1761 1762 // C++17 [expr.delete]p10: 1763 // If the deallocation functions have class scope, the one without a 1764 // parameter of type std::size_t is selected. 1765 auto Best = resolveDeallocationOverload( 1766 S, ops, /*WantSize*/false, 1767 /*WantAlign*/hasNewExtendedAlignment(S, allocType)); 1768 return Best && Best.HasSizeT; 1769} 1770 1771/// Parsed a C++ 'new' expression (C++ 5.3.4). 1772/// 1773/// E.g.: 1774/// @code new (memory) int[size][4] @endcode 1775/// or 1776/// @code ::new Foo(23, "hello") @endcode 1777/// 1778/// \param StartLoc The first location of the expression. 1779/// \param UseGlobal True if 'new' was prefixed with '::'. 1780/// \param PlacementLParen Opening paren of the placement arguments. 1781/// \param PlacementArgs Placement new arguments. 1782/// \param PlacementRParen Closing paren of the placement arguments. 1783/// \param TypeIdParens If the type is in parens, the source range. 1784/// \param D The type to be allocated, as well as array dimensions. 1785/// \param Initializer The initializing expression or initializer-list, or null 1786/// if there is none. 1787ExprResult 1788Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, 1789 SourceLocation PlacementLParen, MultiExprArg PlacementArgs, 1790 SourceLocation PlacementRParen, SourceRange TypeIdParens, 1791 Declarator &D, Expr *Initializer) { 1792 Optional<Expr *> ArraySize; 1793 // If the specified type is an array, unwrap it and save the expression. 1794 if (D.getNumTypeObjects() > 0 && 1795 D.getTypeObject(0).Kind == DeclaratorChunk::Array) { 1796 DeclaratorChunk &Chunk = D.getTypeObject(0); 1797 if (D.getDeclSpec().hasAutoTypeSpec()) 1798 return ExprError(Diag(Chunk.Loc, diag::err_new_array_of_auto) 1799 << D.getSourceRange()); 1800 if (Chunk.Arr.hasStatic) 1801 return ExprError(Diag(Chunk.Loc, diag::err_static_illegal_in_new) 1802 << D.getSourceRange()); 1803 if (!Chunk.Arr.NumElts && !Initializer) 1804 return ExprError(Diag(Chunk.Loc, diag::err_array_new_needs_size) 1805 << D.getSourceRange()); 1806 1807 ArraySize = static_cast<Expr*>(Chunk.Arr.NumElts); 1808 D.DropFirstTypeObject(); 1809 } 1810 1811 // Every dimension shall be of constant size. 1812 if (ArraySize) { 1813 for (unsigned I = 0, N = D.getNumTypeObjects(); I < N; ++I) { 1814 if (D.getTypeObject(I).Kind != DeclaratorChunk::Array) 1815 break; 1816 1817 DeclaratorChunk::ArrayTypeInfo &Array = D.getTypeObject(I).Arr; 1818 if (Expr *NumElts = (Expr *)Array.NumElts) { 1819 if (!NumElts->isTypeDependent() && !NumElts->isValueDependent()) { 1820 // FIXME: GCC permits constant folding here. We should either do so consistently 1821 // or not do so at all, rather than changing behavior in C++14 onwards. 1822 if (getLangOpts().CPlusPlus14) { 1823 // C++1y [expr.new]p6: Every constant-expression in a noptr-new-declarator 1824 // shall be a converted constant expression (5.19) of type std::size_t 1825 // and shall evaluate to a strictly positive value. 1826 llvm::APSInt Value(Context.getIntWidth(Context.getSizeType())); 1827 Array.NumElts 1828 = CheckConvertedConstantExpression(NumElts, Context.getSizeType(), Value, 1829 CCEK_ArrayBound) 1830 .get(); 1831 } else { 1832 Array.NumElts = 1833 VerifyIntegerConstantExpression( 1834 NumElts, nullptr, diag::err_new_array_nonconst, AllowFold) 1835 .get(); 1836 } 1837 if (!Array.NumElts) 1838 return ExprError(); 1839 } 1840 } 1841 } 1842 } 1843 1844 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, /*Scope=*/nullptr); 1845 QualType AllocType = TInfo->getType(); 1846 if (D.isInvalidType()) 1847 return ExprError(); 1848 1849 SourceRange DirectInitRange; 1850 if (ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer)) 1851 DirectInitRange = List->getSourceRange(); 1852 1853 return BuildCXXNew(SourceRange(StartLoc, D.getEndLoc()), UseGlobal, 1854 PlacementLParen, PlacementArgs, PlacementRParen, 1855 TypeIdParens, AllocType, TInfo, ArraySize, DirectInitRange, 1856 Initializer); 1857} 1858 1859static bool isLegalArrayNewInitializer(CXXNewExpr::InitializationStyle Style, 1860 Expr *Init) { 1861 if (!Init) 1862 return true; 1863 if (ParenListExpr *PLE = dyn_cast<ParenListExpr>(Init)) 1864 return PLE->getNumExprs() == 0; 1865 if (isa<ImplicitValueInitExpr>(Init)) 1866 return true; 1867 else if (CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init)) 1868 return !CCE->isListInitialization() && 1869 CCE->getConstructor()->isDefaultConstructor(); 1870 else if (Style == CXXNewExpr::ListInit) { 1871 assert(isa<InitListExpr>(Init) &&((void)0) 1872 "Shouldn't create list CXXConstructExprs for arrays.")((void)0); 1873 return true; 1874 } 1875 return false; 1876} 1877 1878bool 1879Sema::isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const { 1880 if (!getLangOpts().AlignedAllocationUnavailable) 1881 return false; 1882 if (FD.isDefined()) 1883 return false; 1884 Optional<unsigned> AlignmentParam; 1885 if (FD.isReplaceableGlobalAllocationFunction(&AlignmentParam) && 1886 AlignmentParam.hasValue()) 1887 return true; 1888 return false; 1889} 1890 1891// Emit a diagnostic if an aligned allocation/deallocation function that is not 1892// implemented in the standard library is selected. 1893void Sema::diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD, 1894 SourceLocation Loc) { 1895 if (isUnavailableAlignedAllocationFunction(FD)) { 1896 const llvm::Triple &T = getASTContext().getTargetInfo().getTriple(); 1897 StringRef OSName = AvailabilityAttr::getPlatformNameSourceSpelling( 1898 getASTContext().getTargetInfo().getPlatformName()); 1899 VersionTuple OSVersion = alignedAllocMinVersion(T.getOS()); 1900 1901 OverloadedOperatorKind Kind = FD.getDeclName().getCXXOverloadedOperator(); 1902 bool IsDelete = Kind == OO_Delete || Kind == OO_Array_Delete; 1903 Diag(Loc, diag::err_aligned_allocation_unavailable) 1904 << IsDelete << FD.getType().getAsString() << OSName 1905 << OSVersion.getAsString() << OSVersion.empty(); 1906 Diag(Loc, diag::note_silence_aligned_allocation_unavailable); 1907 } 1908} 1909 1910ExprResult 1911Sema::BuildCXXNew(SourceRange Range, bool UseGlobal, 1912 SourceLocation PlacementLParen, 1913 MultiExprArg PlacementArgs, 1914 SourceLocation PlacementRParen, 1915 SourceRange TypeIdParens, 1916 QualType AllocType, 1917 TypeSourceInfo *AllocTypeInfo, 1918 Optional<Expr *> ArraySize, 1919 SourceRange DirectInitRange, 1920 Expr *Initializer) { 1921 SourceRange TypeRange = AllocTypeInfo->getTypeLoc().getSourceRange(); 1922 SourceLocation StartLoc = Range.getBegin(); 1923 1924 CXXNewExpr::InitializationStyle initStyle; 1925 if (DirectInitRange.isValid()) { 1926 assert(Initializer && "Have parens but no initializer.")((void)0); 1927 initStyle = CXXNewExpr::CallInit; 1928 } else if (Initializer && isa<InitListExpr>(Initializer)) 1929 initStyle = CXXNewExpr::ListInit; 1930 else { 1931 assert((!Initializer || isa<ImplicitValueInitExpr>(Initializer) ||((void)0) 1932 isa<CXXConstructExpr>(Initializer)) &&((void)0) 1933 "Initializer expression that cannot have been implicitly created.")((void)0); 1934 initStyle = CXXNewExpr::NoInit; 1935 } 1936 1937 Expr **Inits = &Initializer; 1938 unsigned NumInits = Initializer ? 1 : 0; 1939 if (ParenListExpr *List = dyn_cast_or_null<ParenListExpr>(Initializer)) { 1940 assert(initStyle == CXXNewExpr::CallInit && "paren init for non-call init")((void)0); 1941 Inits = List->getExprs(); 1942 NumInits = List->getNumExprs(); 1943 } 1944 1945 // C++11 [expr.new]p15: 1946 // A new-expression that creates an object of type T initializes that 1947 // object as follows: 1948 InitializationKind Kind 1949 // - If the new-initializer is omitted, the object is default- 1950 // initialized (8.5); if no initialization is performed, 1951 // the object has indeterminate value 1952 = initStyle == CXXNewExpr::NoInit 1953 ? InitializationKind::CreateDefault(TypeRange.getBegin()) 1954 // - Otherwise, the new-initializer is interpreted according to 1955 // the 1956 // initialization rules of 8.5 for direct-initialization. 1957 : initStyle == CXXNewExpr::ListInit 1958 ? InitializationKind::CreateDirectList( 1959 TypeRange.getBegin(), Initializer->getBeginLoc(), 1960 Initializer->getEndLoc()) 1961 : InitializationKind::CreateDirect(TypeRange.getBegin(), 1962 DirectInitRange.getBegin(), 1963 DirectInitRange.getEnd()); 1964 1965 // C++11 [dcl.spec.auto]p6. Deduce the type which 'auto' stands in for. 1966 auto *Deduced = AllocType->getContainedDeducedType(); 1967 if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) { 1968 if (ArraySize) 1969 return ExprError( 1970 Diag(ArraySize ? (*ArraySize)->getExprLoc() : TypeRange.getBegin(), 1971 diag::err_deduced_class_template_compound_type) 1972 << /*array*/ 2 1973 << (ArraySize ? (*ArraySize)->getSourceRange() : TypeRange)); 1974 1975 InitializedEntity Entity 1976 = InitializedEntity::InitializeNew(StartLoc, AllocType); 1977 AllocType = DeduceTemplateSpecializationFromInitializer( 1978 AllocTypeInfo, Entity, Kind, MultiExprArg(Inits, NumInits)); 1979 if (AllocType.isNull()) 1980 return ExprError(); 1981 } else if (Deduced) { 1982 bool Braced = (initStyle == CXXNewExpr::ListInit); 1983 if (NumInits == 1) { 1984 if (auto p = dyn_cast_or_null<InitListExpr>(Inits[0])) { 1985 Inits = p->getInits(); 1986 NumInits = p->getNumInits(); 1987 Braced = true; 1988 } 1989 } 1990 1991 if (initStyle == CXXNewExpr::NoInit || NumInits == 0) 1992 return ExprError(Diag(StartLoc, diag::err_auto_new_requires_ctor_arg) 1993 << AllocType << TypeRange); 1994 if (NumInits > 1) { 1995 Expr *FirstBad = Inits[1]; 1996 return ExprError(Diag(FirstBad->getBeginLoc(), 1997 diag::err_auto_new_ctor_multiple_expressions) 1998 << AllocType << TypeRange); 1999 } 2000 if (Braced && !getLangOpts().CPlusPlus17) 2001 Diag(Initializer->getBeginLoc(), diag::ext_auto_new_list_init) 2002 << AllocType << TypeRange; 2003 Expr *Deduce = Inits[0]; 2004 QualType DeducedType; 2005 if (DeduceAutoType(AllocTypeInfo, Deduce, DeducedType) == DAR_Failed) 2006 return ExprError(Diag(StartLoc, diag::err_auto_new_deduction_failure) 2007 << AllocType << Deduce->getType() 2008 << TypeRange << Deduce->getSourceRange()); 2009 if (DeducedType.isNull()) 2010 return ExprError(); 2011 AllocType = DeducedType; 2012 } 2013 2014 // Per C++0x [expr.new]p5, the type being constructed may be a 2015 // typedef of an array type. 2016 if (!ArraySize) { 2017 if (const ConstantArrayType *Array 2018 = Context.getAsConstantArrayType(AllocType)) { 2019 ArraySize = IntegerLiteral::Create(Context, Array->getSize(), 2020 Context.getSizeType(), 2021 TypeRange.getEnd()); 2022 AllocType = Array->getElementType(); 2023 } 2024 } 2025 2026 if (CheckAllocatedType(AllocType, TypeRange.getBegin(), TypeRange)) 2027 return ExprError(); 2028 2029 // In ARC, infer 'retaining' for the allocated 2030 if (getLangOpts().ObjCAutoRefCount && 2031 AllocType.getObjCLifetime() == Qualifiers::OCL_None && 2032 AllocType->isObjCLifetimeType()) { 2033 AllocType = Context.getLifetimeQualifiedType(AllocType, 2034 AllocType->getObjCARCImplicitLifetime()); 2035 } 2036 2037 QualType ResultType = Context.getPointerType(AllocType); 2038 2039 if (ArraySize && *ArraySize && 2040 (*ArraySize)->getType()->isNonOverloadPlaceholderType()) { 2041 ExprResult result = CheckPlaceholderExpr(*ArraySize); 2042 if (result.isInvalid()) return ExprError(); 2043 ArraySize = result.get(); 2044 } 2045 // C++98 5.3.4p6: "The expression in a direct-new-declarator shall have 2046 // integral or enumeration type with a non-negative value." 2047 // C++11 [expr.new]p6: The expression [...] shall be of integral or unscoped 2048 // enumeration type, or a class type for which a single non-explicit 2049 // conversion function to integral or unscoped enumeration type exists. 2050 // C++1y [expr.new]p6: The expression [...] is implicitly converted to 2051 // std::size_t. 2052 llvm::Optional<uint64_t> KnownArraySize; 2053 if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) { 2054 ExprResult ConvertedSize; 2055 if (getLangOpts().CPlusPlus14) { 2056 assert(Context.getTargetInfo().getIntWidth() && "Builtin type of size 0?")((void)0); 2057 2058 ConvertedSize = PerformImplicitConversion(*ArraySize, Context.getSizeType(), 2059 AA_Converting); 2060 2061 if (!ConvertedSize.isInvalid() && 2062 (*ArraySize)->getType()->getAs<RecordType>()) 2063 // Diagnose the compatibility of this conversion. 2064 Diag(StartLoc, diag::warn_cxx98_compat_array_size_conversion) 2065 << (*ArraySize)->getType() << 0 << "'size_t'"; 2066 } else { 2067 class SizeConvertDiagnoser : public ICEConvertDiagnoser { 2068 protected: 2069 Expr *ArraySize; 2070 2071 public: 2072 SizeConvertDiagnoser(Expr *ArraySize) 2073 : ICEConvertDiagnoser(/*AllowScopedEnumerations*/false, false, false), 2074 ArraySize(ArraySize) {} 2075 2076 SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc, 2077 QualType T) override { 2078 return S.Diag(Loc, diag::err_array_size_not_integral) 2079 << S.getLangOpts().CPlusPlus11 << T; 2080 } 2081 2082 SemaDiagnosticBuilder diagnoseIncomplete( 2083 Sema &S, SourceLocation Loc, QualType T) override { 2084 return S.Diag(Loc, diag::err_array_size_incomplete_type) 2085 << T << ArraySize->getSourceRange(); 2086 } 2087 2088 SemaDiagnosticBuilder diagnoseExplicitConv( 2089 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override { 2090 return S.Diag(Loc, diag::err_array_size_explicit_conversion) << T << ConvTy; 2091 } 2092 2093 SemaDiagnosticBuilder noteExplicitConv( 2094 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override { 2095 return S.Diag(Conv->getLocation(), diag::note_array_size_conversion) 2096 << ConvTy->isEnumeralType() << ConvTy; 2097 } 2098 2099 SemaDiagnosticBuilder diagnoseAmbiguous( 2100 Sema &S, SourceLocation Loc, QualType T) override { 2101 return S.Diag(Loc, diag::err_array_size_ambiguous_conversion) << T; 2102 } 2103 2104 SemaDiagnosticBuilder noteAmbiguous( 2105 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override { 2106 return S.Diag(Conv->getLocation(), diag::note_array_size_conversion) 2107 << ConvTy->isEnumeralType() << ConvTy; 2108 } 2109 2110 SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc, 2111 QualType T, 2112 QualType ConvTy) override { 2113 return S.Diag(Loc, 2114 S.getLangOpts().CPlusPlus11 2115 ? diag::warn_cxx98_compat_array_size_conversion 2116 : diag::ext_array_size_conversion) 2117 << T << ConvTy->isEnumeralType() << ConvTy; 2118 } 2119 } SizeDiagnoser(*ArraySize); 2120 2121 ConvertedSize = PerformContextualImplicitConversion(StartLoc, *ArraySize, 2122 SizeDiagnoser); 2123 } 2124 if (ConvertedSize.isInvalid()) 2125 return ExprError(); 2126 2127 ArraySize = ConvertedSize.get(); 2128 QualType SizeType = (*ArraySize)->getType(); 2129 2130 if (!SizeType->isIntegralOrUnscopedEnumerationType()) 2131 return ExprError(); 2132 2133 // C++98 [expr.new]p7: 2134 // The expression in a direct-new-declarator shall have integral type 2135 // with a non-negative value. 2136 // 2137 // Let's see if this is a constant < 0. If so, we reject it out of hand, 2138 // per CWG1464. Otherwise, if it's not a constant, we must have an 2139 // unparenthesized array type. 2140 if (!(*ArraySize)->isValueDependent()) { 2141 // We've already performed any required implicit conversion to integer or 2142 // unscoped enumeration type. 2143 // FIXME: Per CWG1464, we are required to check the value prior to 2144 // converting to size_t. This will never find a negative array size in 2145 // C++14 onwards, because Value is always unsigned here! 2146 if (Optional<llvm::APSInt> Value = 2147 (*ArraySize)->getIntegerConstantExpr(Context)) { 2148 if (Value->isSigned() && Value->isNegative()) { 2149 return ExprError(Diag((*ArraySize)->getBeginLoc(), 2150 diag::err_typecheck_negative_array_size) 2151 << (*ArraySize)->getSourceRange()); 2152 } 2153 2154 if (!AllocType->isDependentType()) { 2155 unsigned ActiveSizeBits = ConstantArrayType::getNumAddressingBits( 2156 Context, AllocType, *Value); 2157 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) 2158 return ExprError( 2159 Diag((*ArraySize)->getBeginLoc(), diag::err_array_too_large) 2160 << toString(*Value, 10) << (*ArraySize)->getSourceRange()); 2161 } 2162 2163 KnownArraySize = Value->getZExtValue(); 2164 } else if (TypeIdParens.isValid()) { 2165 // Can't have dynamic array size when the type-id is in parentheses. 2166 Diag((*ArraySize)->getBeginLoc(), diag::ext_new_paren_array_nonconst) 2167 << (*ArraySize)->getSourceRange() 2168 << FixItHint::CreateRemoval(TypeIdParens.getBegin()) 2169 << FixItHint::CreateRemoval(TypeIdParens.getEnd()); 2170 2171 TypeIdParens = SourceRange(); 2172 } 2173 } 2174 2175 // Note that we do *not* convert the argument in any way. It can 2176 // be signed, larger than size_t, whatever. 2177 } 2178 2179 FunctionDecl *OperatorNew = nullptr; 2180 FunctionDecl *OperatorDelete = nullptr; 2181 unsigned Alignment = 2182 AllocType->isDependentType() ? 0 : Context.getTypeAlign(AllocType); 2183 unsigned NewAlignment = Context.getTargetInfo().getNewAlign(); 2184 bool PassAlignment = getLangOpts().AlignedAllocation && 2185 Alignment > NewAlignment; 2186 2187 AllocationFunctionScope Scope = UseGlobal ? AFS_Global : AFS_Both; 2188 if (!AllocType->isDependentType() && 2189 !Expr::hasAnyTypeDependentArguments(PlacementArgs) && 2190 FindAllocationFunctions( 2191 StartLoc, SourceRange(PlacementLParen, PlacementRParen), Scope, Scope, 2192 AllocType, ArraySize.hasValue(), PassAlignment, PlacementArgs, 2193 OperatorNew, OperatorDelete)) 2194 return ExprError(); 2195 2196 // If this is an array allocation, compute whether the usual array 2197 // deallocation function for the type has a size_t parameter. 2198 bool UsualArrayDeleteWantsSize = false; 2199 if (ArraySize && !AllocType->isDependentType()) 2200 UsualArrayDeleteWantsSize = 2201 doesUsualArrayDeleteWantSize(*this, StartLoc, AllocType); 2202 2203 SmallVector<Expr *, 8> AllPlaceArgs; 2204 if (OperatorNew) { 2205 auto *Proto = OperatorNew->getType()->castAs<FunctionProtoType>(); 2206 VariadicCallType CallType = Proto->isVariadic() ? VariadicFunction 2207 : VariadicDoesNotApply; 2208 2209 // We've already converted the placement args, just fill in any default 2210 // arguments. Skip the first parameter because we don't have a corresponding 2211 // argument. Skip the second parameter too if we're passing in the 2212 // alignment; we've already filled it in. 2213 unsigned NumImplicitArgs = PassAlignment ? 2 : 1; 2214 if (GatherArgumentsForCall(PlacementLParen, OperatorNew, Proto, 2215 NumImplicitArgs, PlacementArgs, AllPlaceArgs, 2216 CallType)) 2217 return ExprError(); 2218 2219 if (!AllPlaceArgs.empty()) 2220 PlacementArgs = AllPlaceArgs; 2221 2222 // We would like to perform some checking on the given `operator new` call, 2223 // but the PlacementArgs does not contain the implicit arguments, 2224 // namely allocation size and maybe allocation alignment, 2225 // so we need to conjure them. 2226 2227 QualType SizeTy = Context.getSizeType(); 2228 unsigned SizeTyWidth = Context.getTypeSize(SizeTy); 2229 2230 llvm::APInt SingleEltSize( 2231 SizeTyWidth, Context.getTypeSizeInChars(AllocType).getQuantity()); 2232 2233 // How many bytes do we want to allocate here? 2234 llvm::Optional<llvm::APInt> AllocationSize; 2235 if (!ArraySize.hasValue() && !AllocType->isDependentType()) { 2236 // For non-array operator new, we only want to allocate one element. 2237 AllocationSize = SingleEltSize; 2238 } else if (KnownArraySize.hasValue() && !AllocType->isDependentType()) { 2239 // For array operator new, only deal with static array size case. 2240 bool Overflow; 2241 AllocationSize = llvm::APInt(SizeTyWidth, *KnownArraySize) 2242 .umul_ov(SingleEltSize, Overflow); 2243 (void)Overflow; 2244 assert(((void)0) 2245 !Overflow &&((void)0) 2246 "Expected that all the overflows would have been handled already.")((void)0); 2247 } 2248 2249 IntegerLiteral AllocationSizeLiteral( 2250 Context, 2251 AllocationSize.getValueOr(llvm::APInt::getNullValue(SizeTyWidth)), 2252 SizeTy, SourceLocation()); 2253 // Otherwise, if we failed to constant-fold the allocation size, we'll 2254 // just give up and pass-in something opaque, that isn't a null pointer. 2255 OpaqueValueExpr OpaqueAllocationSize(SourceLocation(), SizeTy, VK_PRValue, 2256 OK_Ordinary, /*SourceExpr=*/nullptr); 2257 2258 // Let's synthesize the alignment argument in case we will need it. 2259 // Since we *really* want to allocate these on stack, this is slightly ugly 2260 // because there might not be a `std::align_val_t` type. 2261 EnumDecl *StdAlignValT = getStdAlignValT(); 2262 QualType AlignValT = 2263 StdAlignValT ? Context.getTypeDeclType(StdAlignValT) : SizeTy; 2264 IntegerLiteral AlignmentLiteral( 2265 Context, 2266 llvm::APInt(Context.getTypeSize(SizeTy), 2267 Alignment / Context.getCharWidth()), 2268 SizeTy, SourceLocation()); 2269 ImplicitCastExpr DesiredAlignment(ImplicitCastExpr::OnStack, AlignValT, 2270 CK_IntegralCast, &AlignmentLiteral, 2271 VK_PRValue, FPOptionsOverride()); 2272 2273 // Adjust placement args by prepending conjured size and alignment exprs. 2274 llvm::SmallVector<Expr *, 8> CallArgs; 2275 CallArgs.reserve(NumImplicitArgs + PlacementArgs.size()); 2276 CallArgs.emplace_back(AllocationSize.hasValue() 2277 ? static_cast<Expr *>(&AllocationSizeLiteral) 2278 : &OpaqueAllocationSize); 2279 if (PassAlignment) 2280 CallArgs.emplace_back(&DesiredAlignment); 2281 CallArgs.insert(CallArgs.end(), PlacementArgs.begin(), PlacementArgs.end()); 2282 2283 DiagnoseSentinelCalls(OperatorNew, PlacementLParen, CallArgs); 2284 2285 checkCall(OperatorNew, Proto, /*ThisArg=*/nullptr, CallArgs, 2286 /*IsMemberFunction=*/false, StartLoc, Range, CallType); 2287 2288 // Warn if the type is over-aligned and is being allocated by (unaligned) 2289 // global operator new. 2290 if (PlacementArgs.empty() && !PassAlignment && 2291 (OperatorNew->isImplicit() || 2292 (OperatorNew->getBeginLoc().isValid() && 2293 getSourceManager().isInSystemHeader(OperatorNew->getBeginLoc())))) { 2294 if (Alignment > NewAlignment) 2295 Diag(StartLoc, diag::warn_overaligned_type) 2296 << AllocType 2297 << unsigned(Alignment / Context.getCharWidth()) 2298 << unsigned(NewAlignment / Context.getCharWidth()); 2299 } 2300 } 2301 2302 // Array 'new' can't have any initializers except empty parentheses. 2303 // Initializer lists are also allowed, in C++11. Rely on the parser for the 2304 // dialect distinction. 2305 if (ArraySize && !isLegalArrayNewInitializer(initStyle, Initializer)) { 2306 SourceRange InitRange(Inits[0]->getBeginLoc(), 2307 Inits[NumInits - 1]->getEndLoc()); 2308 Diag(StartLoc, diag::err_new_array_init_args) << InitRange; 2309 return ExprError(); 2310 } 2311 2312 // If we can perform the initialization, and we've not already done so, 2313 // do it now. 2314 if (!AllocType->isDependentType() && 2315 !Expr::hasAnyTypeDependentArguments( 2316 llvm::makeArrayRef(Inits, NumInits))) { 2317 // The type we initialize is the complete type, including the array bound. 2318 QualType InitType; 2319 if (KnownArraySize) 2320 InitType = Context.getConstantArrayType( 2321 AllocType, 2322 llvm::APInt(Context.getTypeSize(Context.getSizeType()), 2323 *KnownArraySize), 2324 *ArraySize, ArrayType::Normal, 0); 2325 else if (ArraySize) 2326 InitType = 2327 Context.getIncompleteArrayType(AllocType, ArrayType::Normal, 0); 2328 else 2329 InitType = AllocType; 2330 2331 InitializedEntity Entity 2332 = InitializedEntity::InitializeNew(StartLoc, InitType); 2333 InitializationSequence InitSeq(*this, Entity, Kind, 2334 MultiExprArg(Inits, NumInits)); 2335 ExprResult FullInit = InitSeq.Perform(*this, Entity, Kind, 2336 MultiExprArg(Inits, NumInits)); 2337 if (FullInit.isInvalid()) 2338 return ExprError(); 2339 2340 // FullInit is our initializer; strip off CXXBindTemporaryExprs, because 2341 // we don't want the initialized object to be destructed. 2342 // FIXME: We should not create these in the first place. 2343 if (CXXBindTemporaryExpr *Binder = 2344 dyn_cast_or_null<CXXBindTemporaryExpr>(FullInit.get())) 2345 FullInit = Binder->getSubExpr(); 2346 2347 Initializer = FullInit.get(); 2348 2349 // FIXME: If we have a KnownArraySize, check that the array bound of the 2350 // initializer is no greater than that constant value. 2351 2352 if (ArraySize && !*ArraySize) { 2353 auto *CAT = Context.getAsConstantArrayType(Initializer->getType()); 2354 if (CAT) { 2355 // FIXME: Track that the array size was inferred rather than explicitly 2356 // specified. 2357 ArraySize = IntegerLiteral::Create( 2358 Context, CAT->getSize(), Context.getSizeType(), TypeRange.getEnd()); 2359 } else { 2360 Diag(TypeRange.getEnd(), diag::err_new_array_size_unknown_from_init) 2361 << Initializer->getSourceRange(); 2362 } 2363 } 2364 } 2365 2366 // Mark the new and delete operators as referenced. 2367 if (OperatorNew) { 2368 if (DiagnoseUseOfDecl(OperatorNew, StartLoc)) 2369 return ExprError(); 2370 MarkFunctionReferenced(StartLoc, OperatorNew); 2371 } 2372 if (OperatorDelete) { 2373 if (DiagnoseUseOfDecl(OperatorDelete, StartLoc)) 2374 return ExprError(); 2375 MarkFunctionReferenced(StartLoc, OperatorDelete); 2376 } 2377 2378 return CXXNewExpr::Create(Context, UseGlobal, OperatorNew, OperatorDelete, 2379 PassAlignment, UsualArrayDeleteWantsSize, 2380 PlacementArgs, TypeIdParens, ArraySize, initStyle, 2381 Initializer, ResultType, AllocTypeInfo, Range, 2382 DirectInitRange); 2383} 2384 2385/// Checks that a type is suitable as the allocated type 2386/// in a new-expression. 2387bool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc, 2388 SourceRange R) { 2389 // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an 2390 // abstract class type or array thereof. 2391 if (AllocType->isFunctionType()) 2392 return Diag(Loc, diag::err_bad_new_type) 2393 << AllocType << 0 << R; 2394 else if (AllocType->isReferenceType()) 2395 return Diag(Loc, diag::err_bad_new_type) 2396 << AllocType << 1 << R; 2397 else if (!AllocType->isDependentType() && 2398 RequireCompleteSizedType( 2399 Loc, AllocType, diag::err_new_incomplete_or_sizeless_type, R)) 2400 return true; 2401 else if (RequireNonAbstractType(Loc, AllocType, 2402 diag::err_allocation_of_abstract_type)) 2403 return true; 2404 else if (AllocType->isVariablyModifiedType()) 2405 return Diag(Loc, diag::err_variably_modified_new_type) 2406 << AllocType; 2407 else if (AllocType.getAddressSpace() != LangAS::Default && 2408 !getLangOpts().OpenCLCPlusPlus) 2409 return Diag(Loc, diag::err_address_space_qualified_new) 2410 << AllocType.getUnqualifiedType() 2411 << AllocType.getQualifiers().getAddressSpaceAttributePrintValue(); 2412 else if (getLangOpts().ObjCAutoRefCount) { 2413 if (const ArrayType *AT = Context.getAsArrayType(AllocType)) { 2414 QualType BaseAllocType = Context.getBaseElementType(AT); 2415 if (BaseAllocType.getObjCLifetime() == Qualifiers::OCL_None && 2416 BaseAllocType->isObjCLifetimeType()) 2417 return Diag(Loc, diag::err_arc_new_array_without_ownership) 2418 << BaseAllocType; 2419 } 2420 } 2421 2422 return false; 2423} 2424 2425static bool resolveAllocationOverload( 2426 Sema &S, LookupResult &R, SourceRange Range, SmallVectorImpl<Expr *> &Args, 2427 bool &PassAlignment, FunctionDecl *&Operator, 2428 OverloadCandidateSet *AlignedCandidates, Expr *AlignArg, bool Diagnose) { 2429 OverloadCandidateSet Candidates(R.getNameLoc(), 2430 OverloadCandidateSet::CSK_Normal); 2431 for (LookupResult::iterator Alloc = R.begin(), AllocEnd = R.end(); 2432 Alloc != AllocEnd; ++Alloc) { 2433 // Even member operator new/delete are implicitly treated as 2434 // static, so don't use AddMemberCandidate. 2435 NamedDecl *D = (*Alloc)->getUnderlyingDecl(); 2436 2437 if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) { 2438 S.AddTemplateOverloadCandidate(FnTemplate, Alloc.getPair(), 2439 /*ExplicitTemplateArgs=*/nullptr, Args, 2440 Candidates, 2441 /*SuppressUserConversions=*/false); 2442 continue; 2443 } 2444 2445 FunctionDecl *Fn = cast<FunctionDecl>(D); 2446 S.AddOverloadCandidate(Fn, Alloc.getPair(), Args, Candidates, 2447 /*SuppressUserConversions=*/false); 2448 } 2449 2450 // Do the resolution. 2451 OverloadCandidateSet::iterator Best; 2452 switch (Candidates.BestViableFunction(S, R.getNameLoc(), Best)) { 2453 case OR_Success: { 2454 // Got one! 2455 FunctionDecl *FnDecl = Best->Function; 2456 if (S.CheckAllocationAccess(R.getNameLoc(), Range, R.getNamingClass(), 2457 Best->FoundDecl) == Sema::AR_inaccessible) 2458 return true; 2459 2460 Operator = FnDecl; 2461 return false; 2462 } 2463 2464 case OR_No_Viable_Function: 2465 // C++17 [expr.new]p13: 2466 // If no matching function is found and the allocated object type has 2467 // new-extended alignment, the alignment argument is removed from the 2468 // argument list, and overload resolution is performed again. 2469 if (PassAlignment) { 2470 PassAlignment = false; 2471 AlignArg = Args[1]; 2472 Args.erase(Args.begin() + 1); 2473 return resolveAllocationOverload(S, R, Range, Args, PassAlignment, 2474 Operator, &Candidates, AlignArg, 2475 Diagnose); 2476 } 2477 2478 // MSVC will fall back on trying to find a matching global operator new 2479 // if operator new[] cannot be found. Also, MSVC will leak by not 2480 // generating a call to operator delete or operator delete[], but we 2481 // will not replicate that bug. 2482 // FIXME: Find out how this interacts with the std::align_val_t fallback 2483 // once MSVC implements it. 2484 if (R.getLookupName().getCXXOverloadedOperator() == OO_Array_New && 2485 S.Context.getLangOpts().MSVCCompat) { 2486 R.clear(); 2487 R.setLookupName(S.Context.DeclarationNames.getCXXOperatorName(OO_New)); 2488 S.LookupQualifiedName(R, S.Context.getTranslationUnitDecl()); 2489 // FIXME: This will give bad diagnostics pointing at the wrong functions. 2490 return resolveAllocationOverload(S, R, Range, Args, PassAlignment, 2491 Operator, /*Candidates=*/nullptr, 2492 /*AlignArg=*/nullptr, Diagnose); 2493 } 2494 2495 if (Diagnose) { 2496 // If this is an allocation of the form 'new (p) X' for some object 2497 // pointer p (or an expression that will decay to such a pointer), 2498 // diagnose the missing inclusion of <new>. 2499 if (!R.isClassLookup() && Args.size() == 2 && 2500 (Args[1]->getType()->isObjectPointerType() || 2501 Args[1]->getType()->isArrayType())) { 2502 S.Diag(R.getNameLoc(), diag::err_need_header_before_placement_new) 2503 << R.getLookupName() << Range; 2504 // Listing the candidates is unlikely to be useful; skip it. 2505 return true; 2506 } 2507 2508 // Finish checking all candidates before we note any. This checking can 2509 // produce additional diagnostics so can't be interleaved with our 2510 // emission of notes. 2511 // 2512 // For an aligned allocation, separately check the aligned and unaligned 2513 // candidates with their respective argument lists. 2514 SmallVector<OverloadCandidate*, 32> Cands; 2515 SmallVector<OverloadCandidate*, 32> AlignedCands; 2516 llvm::SmallVector<Expr*, 4> AlignedArgs; 2517 if (AlignedCandidates) { 2518 auto IsAligned = [](OverloadCandidate &C) { 2519 return C.Function->getNumParams() > 1 && 2520 C.Function->getParamDecl(1)->getType()->isAlignValT(); 2521 }; 2522 auto IsUnaligned = [&](OverloadCandidate &C) { return !IsAligned(C); }; 2523 2524 AlignedArgs.reserve(Args.size() + 1); 2525 AlignedArgs.push_back(Args[0]); 2526 AlignedArgs.push_back(AlignArg); 2527 AlignedArgs.append(Args.begin() + 1, Args.end()); 2528 AlignedCands = AlignedCandidates->CompleteCandidates( 2529 S, OCD_AllCandidates, AlignedArgs, R.getNameLoc(), IsAligned); 2530 2531 Cands = Candidates.CompleteCandidates(S, OCD_AllCandidates, Args, 2532 R.getNameLoc(), IsUnaligned); 2533 } else { 2534 Cands = Candidates.CompleteCandidates(S, OCD_AllCandidates, Args, 2535 R.getNameLoc()); 2536 } 2537 2538 S.Diag(R.getNameLoc(), diag::err_ovl_no_viable_function_in_call) 2539 << R.getLookupName() << Range; 2540 if (AlignedCandidates) 2541 AlignedCandidates->NoteCandidates(S, AlignedArgs, AlignedCands, "", 2542 R.getNameLoc()); 2543 Candidates.NoteCandidates(S, Args, Cands, "", R.getNameLoc()); 2544 } 2545 return true; 2546 2547 case OR_Ambiguous: 2548 if (Diagnose) { 2549 Candidates.NoteCandidates( 2550 PartialDiagnosticAt(R.getNameLoc(), 2551 S.PDiag(diag::err_ovl_ambiguous_call) 2552 << R.getLookupName() << Range), 2553 S, OCD_AmbiguousCandidates, Args); 2554 } 2555 return true; 2556 2557 case OR_Deleted: { 2558 if (Diagnose) { 2559 Candidates.NoteCandidates( 2560 PartialDiagnosticAt(R.getNameLoc(), 2561 S.PDiag(diag::err_ovl_deleted_call) 2562 << R.getLookupName() << Range), 2563 S, OCD_AllCandidates, Args); 2564 } 2565 return true; 2566 } 2567 } 2568 llvm_unreachable("Unreachable, bad result from BestViableFunction")__builtin_unreachable(); 2569} 2570 2571bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, 2572 AllocationFunctionScope NewScope, 2573 AllocationFunctionScope DeleteScope, 2574 QualType AllocType, bool IsArray, 2575 bool &PassAlignment, MultiExprArg PlaceArgs, 2576 FunctionDecl *&OperatorNew, 2577 FunctionDecl *&OperatorDelete, 2578 bool Diagnose) { 2579 // --- Choosing an allocation function --- 2580 // C++ 5.3.4p8 - 14 & 18 2581 // 1) If looking in AFS_Global scope for allocation functions, only look in 2582 // the global scope. Else, if AFS_Class, only look in the scope of the 2583 // allocated class. If AFS_Both, look in both. 2584 // 2) If an array size is given, look for operator new[], else look for 2585 // operator new. 2586 // 3) The first argument is always size_t. Append the arguments from the 2587 // placement form. 2588 2589 SmallVector<Expr*, 8> AllocArgs; 2590 AllocArgs.reserve((PassAlignment ? 2 : 1) + PlaceArgs.size()); 2591 2592 // We don't care about the actual value of these arguments. 2593 // FIXME: Should the Sema create the expression and embed it in the syntax 2594 // tree? Or should the consumer just recalculate the value? 2595 // FIXME: Using a dummy value will interact poorly with attribute enable_if. 2596 IntegerLiteral Size(Context, llvm::APInt::getNullValue( 2597 Context.getTargetInfo().getPointerWidth(0)), 2598 Context.getSizeType(), 2599 SourceLocation()); 2600 AllocArgs.push_back(&Size); 2601 2602 QualType AlignValT = Context.VoidTy; 2603 if (PassAlignment) { 2604 DeclareGlobalNewDelete(); 2605 AlignValT = Context.getTypeDeclType(getStdAlignValT()); 2606 } 2607 CXXScalarValueInitExpr Align(AlignValT, nullptr, SourceLocation()); 2608 if (PassAlignment) 2609 AllocArgs.push_back(&Align); 2610 2611 AllocArgs.insert(AllocArgs.end(), PlaceArgs.begin(), PlaceArgs.end()); 2612 2613 // C++ [expr.new]p8: 2614 // If the allocated type is a non-array type, the allocation 2615 // function's name is operator new and the deallocation function's 2616 // name is operator delete. If the allocated type is an array 2617 // type, the allocation function's name is operator new[] and the 2618 // deallocation function's name is operator delete[]. 2619 DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName( 2620 IsArray ? OO_Array_New : OO_New); 2621 2622 QualType AllocElemType = Context.getBaseElementType(AllocType); 2623 2624 // Find the allocation function. 2625 { 2626 LookupResult R(*this, NewName, StartLoc, LookupOrdinaryName); 2627 2628 // C++1z [expr.new]p9: 2629 // If the new-expression begins with a unary :: operator, the allocation 2630 // function's name is looked up in the global scope. Otherwise, if the 2631 // allocated type is a class type T or array thereof, the allocation 2632 // function's name is looked up in the scope of T. 2633 if (AllocElemType->isRecordType() && NewScope != AFS_Global) 2634 LookupQualifiedName(R, AllocElemType->getAsCXXRecordDecl()); 2635 2636 // We can see ambiguity here if the allocation function is found in 2637 // multiple base classes. 2638 if (R.isAmbiguous()) 2639 return true; 2640 2641 // If this lookup fails to find the name, or if the allocated type is not 2642 // a class type, the allocation function's name is looked up in the 2643 // global scope. 2644 if (R.empty()) { 2645 if (NewScope == AFS_Class) 2646 return true; 2647 2648 LookupQualifiedName(R, Context.getTranslationUnitDecl()); 2649 } 2650 2651 if (getLangOpts().OpenCLCPlusPlus && R.empty()) { 2652 if (PlaceArgs.empty()) { 2653 Diag(StartLoc, diag::err_openclcxx_not_supported) << "default new"; 2654 } else { 2655 Diag(StartLoc, diag::err_openclcxx_placement_new); 2656 } 2657 return true; 2658 } 2659 2660 assert(!R.empty() && "implicitly declared allocation functions not found")((void)0); 2661 assert(!R.isAmbiguous() && "global allocation functions are ambiguous")((void)0); 2662 2663 // We do our own custom access checks below. 2664 R.suppressDiagnostics(); 2665 2666 if (resolveAllocationOverload(*this, R, Range, AllocArgs, PassAlignment, 2667 OperatorNew, /*Candidates=*/nullptr, 2668 /*AlignArg=*/nullptr, Diagnose)) 2669 return true; 2670 } 2671 2672 // We don't need an operator delete if we're running under -fno-exceptions. 2673 if (!getLangOpts().Exceptions) { 2674 OperatorDelete = nullptr; 2675 return false; 2676 } 2677 2678 // Note, the name of OperatorNew might have been changed from array to 2679 // non-array by resolveAllocationOverload. 2680 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName( 2681 OperatorNew->getDeclName().getCXXOverloadedOperator() == OO_Array_New 2682 ? OO_Array_Delete 2683 : OO_Delete); 2684 2685 // C++ [expr.new]p19: 2686 // 2687 // If the new-expression begins with a unary :: operator, the 2688 // deallocation function's name is looked up in the global 2689 // scope. Otherwise, if the allocated type is a class type T or an 2690 // array thereof, the deallocation function's name is looked up in 2691 // the scope of T. If this lookup fails to find the name, or if 2692 // the allocated type is not a class type or array thereof, the 2693 // deallocation function's name is looked up in the global scope. 2694 LookupResult FoundDelete(*this, DeleteName, StartLoc, LookupOrdinaryName); 2695 if (AllocElemType->isRecordType() && DeleteScope != AFS_Global) { 2696 auto *RD = 2697 cast<CXXRecordDecl>(AllocElemType->castAs<RecordType>()->getDecl()); 2698 LookupQualifiedName(FoundDelete, RD); 2699 } 2700 if (FoundDelete.isAmbiguous()) 2701 return true; // FIXME: clean up expressions? 2702 2703 // Filter out any destroying operator deletes. We can't possibly call such a 2704 // function in this context, because we're handling the case where the object 2705 // was not successfully constructed. 2706 // FIXME: This is not covered by the language rules yet. 2707 { 2708 LookupResult::Filter Filter = FoundDelete.makeFilter(); 2709 while (Filter.hasNext()) { 2710 auto *FD = dyn_cast<FunctionDecl>(Filter.next()->getUnderlyingDecl()); 2711 if (FD && FD->isDestroyingOperatorDelete()) 2712 Filter.erase(); 2713 } 2714 Filter.done(); 2715 } 2716 2717 bool FoundGlobalDelete = FoundDelete.empty(); 2718 if (FoundDelete.empty()) { 2719 FoundDelete.clear(LookupOrdinaryName); 2720 2721 if (DeleteScope == AFS_Class) 2722 return true; 2723 2724 DeclareGlobalNewDelete(); 2725 LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl()); 2726 } 2727 2728 FoundDelete.suppressDiagnostics(); 2729 2730 SmallVector<std::pair<DeclAccessPair,FunctionDecl*>, 2> Matches; 2731 2732 // Whether we're looking for a placement operator delete is dictated 2733 // by whether we selected a placement operator new, not by whether 2734 // we had explicit placement arguments. This matters for things like 2735 // struct A { void *operator new(size_t, int = 0); ... }; 2736 // A *a = new A() 2737 // 2738 // We don't have any definition for what a "placement allocation function" 2739 // is, but we assume it's any allocation function whose 2740 // parameter-declaration-clause is anything other than (size_t). 2741 // 2742 // FIXME: Should (size_t, std::align_val_t) also be considered non-placement? 2743 // This affects whether an exception from the constructor of an overaligned 2744 // type uses the sized or non-sized form of aligned operator delete. 2745 bool isPlacementNew = !PlaceArgs.empty() || OperatorNew->param_size() != 1 || 2746 OperatorNew->isVariadic(); 2747 2748 if (isPlacementNew) { 2749 // C++ [expr.new]p20: 2750 // A declaration of a placement deallocation function matches the 2751 // declaration of a placement allocation function if it has the 2752 // same number of parameters and, after parameter transformations 2753 // (8.3.5), all parameter types except the first are 2754 // identical. [...] 2755 // 2756 // To perform this comparison, we compute the function type that 2757 // the deallocation function should have, and use that type both 2758 // for template argument deduction and for comparison purposes. 2759 QualType ExpectedFunctionType; 2760 { 2761 auto *Proto = OperatorNew->getType()->castAs<FunctionProtoType>(); 2762 2763 SmallVector<QualType, 4> ArgTypes; 2764 ArgTypes.push_back(Context.VoidPtrTy); 2765 for (unsigned I = 1, N = Proto->getNumParams(); I < N; ++I) 2766 ArgTypes.push_back(Proto->getParamType(I)); 2767 2768 FunctionProtoType::ExtProtoInfo EPI; 2769 // FIXME: This is not part of the standard's rule. 2770 EPI.Variadic = Proto->isVariadic(); 2771 2772 ExpectedFunctionType 2773 = Context.getFunctionType(Context.VoidTy, ArgTypes, EPI); 2774 } 2775 2776 for (LookupResult::iterator D = FoundDelete.begin(), 2777 DEnd = FoundDelete.end(); 2778 D != DEnd; ++D) { 2779 FunctionDecl *Fn = nullptr; 2780 if (FunctionTemplateDecl *FnTmpl = 2781 dyn_cast<FunctionTemplateDecl>((*D)->getUnderlyingDecl())) { 2782 // Perform template argument deduction to try to match the 2783 // expected function type. 2784 TemplateDeductionInfo Info(StartLoc); 2785 if (DeduceTemplateArguments(FnTmpl, nullptr, ExpectedFunctionType, Fn, 2786 Info)) 2787 continue; 2788 } else 2789 Fn = cast<FunctionDecl>((*D)->getUnderlyingDecl()); 2790 2791 if (Context.hasSameType(adjustCCAndNoReturn(Fn->getType(), 2792 ExpectedFunctionType, 2793 /*AdjustExcpetionSpec*/true), 2794 ExpectedFunctionType)) 2795 Matches.push_back(std::make_pair(D.getPair(), Fn)); 2796 } 2797 2798 if (getLangOpts().CUDA) 2799 EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(CurContext), Matches); 2800 } else { 2801 // C++1y [expr.new]p22: 2802 // For a non-placement allocation function, the normal deallocation 2803 // function lookup is used 2804 // 2805 // Per [expr.delete]p10, this lookup prefers a member operator delete 2806 // without a size_t argument, but prefers a non-member operator delete 2807 // with a size_t where possible (which it always is in this case). 2808 llvm::SmallVector<UsualDeallocFnInfo, 4> BestDeallocFns; 2809 UsualDeallocFnInfo Selected = resolveDeallocationOverload( 2810 *this, FoundDelete, /*WantSize*/ FoundGlobalDelete, 2811 /*WantAlign*/ hasNewExtendedAlignment(*this, AllocElemType), 2812 &BestDeallocFns); 2813 if (Selected) 2814 Matches.push_back(std::make_pair(Selected.Found, Selected.FD)); 2815 else { 2816 // If we failed to select an operator, all remaining functions are viable 2817 // but ambiguous. 2818 for (auto Fn : BestDeallocFns) 2819 Matches.push_back(std::make_pair(Fn.Found, Fn.FD)); 2820 } 2821 } 2822 2823 // C++ [expr.new]p20: 2824 // [...] If the lookup finds a single matching deallocation 2825 // function, that function will be called; otherwise, no 2826 // deallocation function will be called. 2827 if (Matches.size() == 1) { 2828 OperatorDelete = Matches[0].second; 2829 2830 // C++1z [expr.new]p23: 2831 // If the lookup finds a usual deallocation function (3.7.4.2) 2832 // with a parameter of type std::size_t and that function, considered 2833 // as a placement deallocation function, would have been 2834 // selected as a match for the allocation function, the program 2835 // is ill-formed. 2836 if (getLangOpts().CPlusPlus11 && isPlacementNew && 2837 isNonPlacementDeallocationFunction(*this, OperatorDelete)) { 2838 UsualDeallocFnInfo Info(*this, 2839 DeclAccessPair::make(OperatorDelete, AS_public)); 2840 // Core issue, per mail to core reflector, 2016-10-09: 2841 // If this is a member operator delete, and there is a corresponding 2842 // non-sized member operator delete, this isn't /really/ a sized 2843 // deallocation function, it just happens to have a size_t parameter. 2844 bool IsSizedDelete = Info.HasSizeT; 2845 if (IsSizedDelete && !FoundGlobalDelete) { 2846 auto NonSizedDelete = 2847 resolveDeallocationOverload(*this, FoundDelete, /*WantSize*/false, 2848 /*WantAlign*/Info.HasAlignValT); 2849 if (NonSizedDelete && !NonSizedDelete.HasSizeT && 2850 NonSizedDelete.HasAlignValT == Info.HasAlignValT) 2851 IsSizedDelete = false; 2852 } 2853 2854 if (IsSizedDelete) { 2855 SourceRange R = PlaceArgs.empty() 2856 ? SourceRange() 2857 : SourceRange(PlaceArgs.front()->getBeginLoc(), 2858 PlaceArgs.back()->getEndLoc()); 2859 Diag(StartLoc, diag::err_placement_new_non_placement_delete) << R; 2860 if (!OperatorDelete->isImplicit()) 2861 Diag(OperatorDelete->getLocation(), diag::note_previous_decl) 2862 << DeleteName; 2863 } 2864 } 2865 2866 CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(), 2867 Matches[0].first); 2868 } else if (!Matches.empty()) { 2869 // We found multiple suitable operators. Per [expr.new]p20, that means we 2870 // call no 'operator delete' function, but we should at least warn the user. 2871 // FIXME: Suppress this warning if the construction cannot throw. 2872 Diag(StartLoc, diag::warn_ambiguous_suitable_delete_function_found) 2873 << DeleteName << AllocElemType; 2874 2875 for (auto &Match : Matches) 2876 Diag(Match.second->getLocation(), 2877 diag::note_member_declared_here) << DeleteName; 2878 } 2879 2880 return false; 2881} 2882 2883/// DeclareGlobalNewDelete - Declare the global forms of operator new and 2884/// delete. These are: 2885/// @code 2886/// // C++03: 2887/// void* operator new(std::size_t) throw(std::bad_alloc); 2888/// void* operator new[](std::size_t) throw(std::bad_alloc); 2889/// void operator delete(void *) throw(); 2890/// void operator delete[](void *) throw(); 2891/// // C++11: 2892/// void* operator new(std::size_t); 2893/// void* operator new[](std::size_t); 2894/// void operator delete(void *) noexcept; 2895/// void operator delete[](void *) noexcept; 2896/// // C++1y: 2897/// void* operator new(std::size_t); 2898/// void* operator new[](std::size_t); 2899/// void operator delete(void *) noexcept; 2900/// void operator delete[](void *) noexcept; 2901/// void operator delete(void *, std::size_t) noexcept; 2902/// void operator delete[](void *, std::size_t) noexcept; 2903/// @endcode 2904/// Note that the placement and nothrow forms of new are *not* implicitly 2905/// declared. Their use requires including \<new\>. 2906void Sema::DeclareGlobalNewDelete() { 2907 if (GlobalNewDeleteDeclared) 2908 return; 2909 2910 // The implicitly declared new and delete operators 2911 // are not supported in OpenCL. 2912 if (getLangOpts().OpenCLCPlusPlus) 2913 return; 2914 2915 // C++ [basic.std.dynamic]p2: 2916 // [...] The following allocation and deallocation functions (18.4) are 2917 // implicitly declared in global scope in each translation unit of a 2918 // program 2919 // 2920 // C++03: 2921 // void* operator new(std::size_t) throw(std::bad_alloc); 2922 // void* operator new[](std::size_t) throw(std::bad_alloc); 2923 // void operator delete(void*) throw(); 2924 // void operator delete[](void*) throw(); 2925 // C++11: 2926 // void* operator new(std::size_t); 2927 // void* operator new[](std::size_t); 2928 // void operator delete(void*) noexcept; 2929 // void operator delete[](void*) noexcept; 2930 // C++1y: 2931 // void* operator new(std::size_t); 2932 // void* operator new[](std::size_t); 2933 // void operator delete(void*) noexcept; 2934 // void operator delete[](void*) noexcept; 2935 // void operator delete(void*, std::size_t) noexcept; 2936 // void operator delete[](void*, std::size_t) noexcept; 2937 // 2938 // These implicit declarations introduce only the function names operator 2939 // new, operator new[], operator delete, operator delete[]. 2940 // 2941 // Here, we need to refer to std::bad_alloc, so we will implicitly declare 2942 // "std" or "bad_alloc" as necessary to form the exception specification. 2943 // However, we do not make these implicit declarations visible to name 2944 // lookup. 2945 if (!StdBadAlloc && !getLangOpts().CPlusPlus11) { 2946 // The "std::bad_alloc" class has not yet been declared, so build it 2947 // implicitly. 2948 StdBadAlloc = CXXRecordDecl::Create(Context, TTK_Class, 2949 getOrCreateStdNamespace(), 2950 SourceLocation(), SourceLocation(), 2951 &PP.getIdentifierTable().get("bad_alloc"), 2952 nullptr); 2953 getStdBadAlloc()->setImplicit(true); 2954 } 2955 if (!StdAlignValT && getLangOpts().AlignedAllocation) { 2956 // The "std::align_val_t" enum class has not yet been declared, so build it 2957 // implicitly. 2958 auto *AlignValT = EnumDecl::Create( 2959 Context, getOrCreateStdNamespace(), SourceLocation(), SourceLocation(), 2960 &PP.getIdentifierTable().get("align_val_t"), nullptr, true, true, true); 2961 AlignValT->setIntegerType(Context.getSizeType()); 2962 AlignValT->setPromotionType(Context.getSizeType()); 2963 AlignValT->setImplicit(true); 2964 StdAlignValT = AlignValT; 2965 } 2966 2967 GlobalNewDeleteDeclared = true; 2968 2969 QualType VoidPtr = Context.getPointerType(Context.VoidTy); 2970 QualType SizeT = Context.getSizeType(); 2971 2972 auto DeclareGlobalAllocationFunctions = [&](OverloadedOperatorKind Kind, 2973 QualType Return, QualType Param) { 2974 llvm::SmallVector<QualType, 3> Params; 2975 Params.push_back(Param); 2976 2977 // Create up to four variants of the function (sized/aligned). 2978 bool HasSizedVariant = getLangOpts().SizedDeallocation && 2979 (Kind == OO_Delete || Kind == OO_Array_Delete); 2980 bool HasAlignedVariant = getLangOpts().AlignedAllocation; 2981 2982 int NumSizeVariants = (HasSizedVariant ? 2 : 1); 2983 int NumAlignVariants = (HasAlignedVariant ? 2 : 1); 2984 for (int Sized = 0; Sized < NumSizeVariants; ++Sized) { 2985 if (Sized) 2986 Params.push_back(SizeT); 2987 2988 for (int Aligned = 0; Aligned < NumAlignVariants; ++Aligned) { 2989 if (Aligned) 2990 Params.push_back(Context.getTypeDeclType(getStdAlignValT())); 2991 2992 DeclareGlobalAllocationFunction( 2993 Context.DeclarationNames.getCXXOperatorName(Kind), Return, Params); 2994 2995 if (Aligned) 2996 Params.pop_back(); 2997 } 2998 } 2999 }; 3000 3001 DeclareGlobalAllocationFunctions(OO_New, VoidPtr, SizeT); 3002 DeclareGlobalAllocationFunctions(OO_Array_New, VoidPtr, SizeT); 3003 DeclareGlobalAllocationFunctions(OO_Delete, Context.VoidTy, VoidPtr); 3004 DeclareGlobalAllocationFunctions(OO_Array_Delete, Context.VoidTy, VoidPtr); 3005} 3006 3007/// DeclareGlobalAllocationFunction - Declares a single implicit global 3008/// allocation function if it doesn't already exist. 3009void Sema::DeclareGlobalAllocationFunction(DeclarationName Name, 3010 QualType Return, 3011 ArrayRef<QualType> Params) { 3012 DeclContext *GlobalCtx = Context.getTranslationUnitDecl(); 3013 3014 // Check if this function is already declared. 3015 DeclContext::lookup_result R = GlobalCtx->lookup(Name); 3016 for (DeclContext::lookup_iterator Alloc = R.begin(), AllocEnd = R.end(); 3017 Alloc != AllocEnd; ++Alloc) { 3018 // Only look at non-template functions, as it is the predefined, 3019 // non-templated allocation function we are trying to declare here. 3020 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(*Alloc)) { 3021 if (Func->getNumParams() == Params.size()) { 3022 llvm::SmallVector<QualType, 3> FuncParams; 3023 for (auto *P : Func->parameters()) 3024 FuncParams.push_back( 3025 Context.getCanonicalType(P->getType().getUnqualifiedType())); 3026 if (llvm::makeArrayRef(FuncParams) == Params) { 3027 // Make the function visible to name lookup, even if we found it in 3028 // an unimported module. It either is an implicitly-declared global 3029 // allocation function, or is suppressing that function. 3030 Func->setVisibleDespiteOwningModule(); 3031 return; 3032 } 3033 } 3034 } 3035 } 3036 3037 FunctionProtoType::ExtProtoInfo EPI(Context.getDefaultCallingConvention( 3038 /*IsVariadic=*/false, /*IsCXXMethod=*/false, /*IsBuiltin=*/true)); 3039 3040 QualType BadAllocType; 3041 bool HasBadAllocExceptionSpec 3042 = (Name.getCXXOverloadedOperator() == OO_New || 3043 Name.getCXXOverloadedOperator() == OO_Array_New); 3044 if (HasBadAllocExceptionSpec) { 3045 if (!getLangOpts().CPlusPlus11) { 3046 BadAllocType = Context.getTypeDeclType(getStdBadAlloc()); 3047 assert(StdBadAlloc && "Must have std::bad_alloc declared")((void)0); 3048 EPI.ExceptionSpec.Type = EST_Dynamic; 3049 EPI.ExceptionSpec.Exceptions = llvm::makeArrayRef(BadAllocType); 3050 } 3051 } else { 3052 EPI.ExceptionSpec = 3053 getLangOpts().CPlusPlus11 ? EST_BasicNoexcept : EST_DynamicNone; 3054 } 3055 3056 auto CreateAllocationFunctionDecl = [&](Attr *ExtraAttr) { 3057 QualType FnType = Context.getFunctionType(Return, Params, EPI); 3058 FunctionDecl *Alloc = FunctionDecl::Create( 3059 Context, GlobalCtx, SourceLocation(), SourceLocation(), Name, 3060 FnType, /*TInfo=*/nullptr, SC_None, false, true); 3061 Alloc->setImplicit(); 3062 // Global allocation functions should always be visible. 3063 Alloc->setVisibleDespiteOwningModule(); 3064 3065 Alloc->addAttr(VisibilityAttr::CreateImplicit( 3066 Context, LangOpts.GlobalAllocationFunctionVisibilityHidden 3067 ? VisibilityAttr::Hidden 3068 : VisibilityAttr::Default)); 3069 3070 llvm::SmallVector<ParmVarDecl *, 3> ParamDecls; 3071 for (QualType T : Params) { 3072 ParamDecls.push_back(ParmVarDecl::Create( 3073 Context, Alloc, SourceLocation(), SourceLocation(), nullptr, T, 3074 /*TInfo=*/nullptr, SC_None, nullptr)); 3075 ParamDecls.back()->setImplicit(); 3076 } 3077 Alloc->setParams(ParamDecls); 3078 if (ExtraAttr) 3079 Alloc->addAttr(ExtraAttr); 3080 AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(Alloc); 3081 Context.getTranslationUnitDecl()->addDecl(Alloc); 3082 IdResolver.tryAddTopLevelDecl(Alloc, Name); 3083 }; 3084 3085 if (!LangOpts.CUDA) 3086 CreateAllocationFunctionDecl(nullptr); 3087 else { 3088 // Host and device get their own declaration so each can be 3089 // defined or re-declared independently. 3090 CreateAllocationFunctionDecl(CUDAHostAttr::CreateImplicit(Context)); 3091 CreateAllocationFunctionDecl(CUDADeviceAttr::CreateImplicit(Context)); 3092 } 3093} 3094 3095FunctionDecl *Sema::FindUsualDeallocationFunction(SourceLocation StartLoc, 3096 bool CanProvideSize, 3097 bool Overaligned, 3098 DeclarationName Name) { 3099 DeclareGlobalNewDelete(); 3100 3101 LookupResult FoundDelete(*this, Name, StartLoc, LookupOrdinaryName); 3102 LookupQualifiedName(FoundDelete, Context.getTranslationUnitDecl()); 3103 3104 // FIXME: It's possible for this to result in ambiguity, through a 3105 // user-declared variadic operator delete or the enable_if attribute. We 3106 // should probably not consider those cases to be usual deallocation 3107 // functions. But for now we just make an arbitrary choice in that case. 3108 auto Result = resolveDeallocationOverload(*this, FoundDelete, CanProvideSize, 3109 Overaligned); 3110 assert(Result.FD && "operator delete missing from global scope?")((void)0); 3111 return Result.FD; 3112} 3113 3114FunctionDecl *Sema::FindDeallocationFunctionForDestructor(SourceLocation Loc, 3115 CXXRecordDecl *RD) { 3116 DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Delete); 3117 3118 FunctionDecl *OperatorDelete = nullptr; 3119 if (FindDeallocationFunction(Loc, RD, Name, OperatorDelete)) 3120 return nullptr; 3121 if (OperatorDelete) 3122 return OperatorDelete; 3123 3124 // If there's no class-specific operator delete, look up the global 3125 // non-array delete. 3126 return FindUsualDeallocationFunction( 3127 Loc, true, hasNewExtendedAlignment(*this, Context.getRecordType(RD)), 3128 Name); 3129} 3130 3131bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, 3132 DeclarationName Name, 3133 FunctionDecl *&Operator, bool Diagnose) { 3134 LookupResult Found(*this, Name, StartLoc, LookupOrdinaryName); 3135 // Try to find operator delete/operator delete[] in class scope. 3136 LookupQualifiedName(Found, RD); 3137 3138 if (Found.isAmbiguous()) 3139 return true; 3140 3141 Found.suppressDiagnostics(); 3142 3143 bool Overaligned = hasNewExtendedAlignment(*this, Context.getRecordType(RD)); 3144 3145 // C++17 [expr.delete]p10: 3146 // If the deallocation functions have class scope, the one without a 3147 // parameter of type std::size_t is selected. 3148 llvm::SmallVector<UsualDeallocFnInfo, 4> Matches; 3149 resolveDeallocationOverload(*this, Found, /*WantSize*/ false, 3150 /*WantAlign*/ Overaligned, &Matches); 3151 3152 // If we could find an overload, use it. 3153 if (Matches.size() == 1) { 3154 Operator = cast<CXXMethodDecl>(Matches[0].FD); 3155 3156 // FIXME: DiagnoseUseOfDecl? 3157 if (Operator->isDeleted()) { 3158 if (Diagnose) { 3159 Diag(StartLoc, diag::err_deleted_function_use); 3160 NoteDeletedFunction(Operator); 3161 } 3162 return true; 3163 } 3164 3165 if (CheckAllocationAccess(StartLoc, SourceRange(), Found.getNamingClass(), 3166 Matches[0].Found, Diagnose) == AR_inaccessible) 3167 return true; 3168 3169 return false; 3170 } 3171 3172 // We found multiple suitable operators; complain about the ambiguity. 3173 // FIXME: The standard doesn't say to do this; it appears that the intent 3174 // is that this should never happen. 3175 if (!Matches.empty()) { 3176 if (Diagnose) { 3177 Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found) 3178 << Name << RD; 3179 for (auto &Match : Matches) 3180 Diag(Match.FD->getLocation(), diag::note_member_declared_here) << Name; 3181 } 3182 return true; 3183 } 3184 3185 // We did find operator delete/operator delete[] declarations, but 3186 // none of them were suitable. 3187 if (!Found.empty()) { 3188 if (Diagnose) { 3189 Diag(StartLoc, diag::err_no_suitable_delete_member_function_found) 3190 << Name << RD; 3191 3192 for (NamedDecl *D : Found) 3193 Diag(D->getUnderlyingDecl()->getLocation(), 3194 diag::note_member_declared_here) << Name; 3195 } 3196 return true; 3197 } 3198 3199 Operator = nullptr; 3200 return false; 3201} 3202 3203namespace { 3204/// Checks whether delete-expression, and new-expression used for 3205/// initializing deletee have the same array form. 3206class MismatchingNewDeleteDetector { 3207public: 3208 enum MismatchResult { 3209 /// Indicates that there is no mismatch or a mismatch cannot be proven. 3210 NoMismatch, 3211 /// Indicates that variable is initialized with mismatching form of \a new. 3212 VarInitMismatches, 3213 /// Indicates that member is initialized with mismatching form of \a new. 3214 MemberInitMismatches, 3215 /// Indicates that 1 or more constructors' definitions could not been 3216 /// analyzed, and they will be checked again at the end of translation unit. 3217 AnalyzeLater 3218 }; 3219 3220 /// \param EndOfTU True, if this is the final analysis at the end of 3221 /// translation unit. False, if this is the initial analysis at the point 3222 /// delete-expression was encountered. 3223 explicit MismatchingNewDeleteDetector(bool EndOfTU) 3224 : Field(nullptr), IsArrayForm(false), EndOfTU(EndOfTU), 3225 HasUndefinedConstructors(false) {} 3226 3227 /// Checks whether pointee of a delete-expression is initialized with 3228 /// matching form of new-expression. 3229 /// 3230 /// If return value is \c VarInitMismatches or \c MemberInitMismatches at the 3231 /// point where delete-expression is encountered, then a warning will be 3232 /// issued immediately. If return value is \c AnalyzeLater at the point where 3233 /// delete-expression is seen, then member will be analyzed at the end of 3234 /// translation unit. \c AnalyzeLater is returned iff at least one constructor 3235 /// couldn't be analyzed. If at least one constructor initializes the member 3236 /// with matching type of new, the return value is \c NoMismatch. 3237 MismatchResult analyzeDeleteExpr(const CXXDeleteExpr *DE); 3238 /// Analyzes a class member. 3239 /// \param Field Class member to analyze. 3240 /// \param DeleteWasArrayForm Array form-ness of the delete-expression used 3241 /// for deleting the \p Field. 3242 MismatchResult analyzeField(FieldDecl *Field, bool DeleteWasArrayForm); 3243 FieldDecl *Field; 3244 /// List of mismatching new-expressions used for initialization of the pointee 3245 llvm::SmallVector<const CXXNewExpr *, 4> NewExprs; 3246 /// Indicates whether delete-expression was in array form. 3247 bool IsArrayForm; 3248 3249private: 3250 const bool EndOfTU; 3251 /// Indicates that there is at least one constructor without body. 3252 bool HasUndefinedConstructors; 3253 /// Returns \c CXXNewExpr from given initialization expression. 3254 /// \param E Expression used for initializing pointee in delete-expression. 3255 /// E can be a single-element \c InitListExpr consisting of new-expression. 3256 const CXXNewExpr *getNewExprFromInitListOrExpr(const Expr *E); 3257 /// Returns whether member is initialized with mismatching form of 3258 /// \c new either by the member initializer or in-class initialization. 3259 /// 3260 /// If bodies of all constructors are not visible at the end of translation 3261 /// unit or at least one constructor initializes member with the matching 3262 /// form of \c new, mismatch cannot be proven, and this function will return 3263 /// \c NoMismatch. 3264 MismatchResult analyzeMemberExpr(const MemberExpr *ME); 3265 /// Returns whether variable is initialized with mismatching form of 3266 /// \c new. 3267 /// 3268 /// If variable is initialized with matching form of \c new or variable is not 3269 /// initialized with a \c new expression, this function will return true. 3270 /// If variable is initialized with mismatching form of \c new, returns false. 3271 /// \param D Variable to analyze. 3272 bool hasMatchingVarInit(const DeclRefExpr *D); 3273 /// Checks whether the constructor initializes pointee with mismatching 3274 /// form of \c new. 3275 /// 3276 /// Returns true, if member is initialized with matching form of \c new in 3277 /// member initializer list. Returns false, if member is initialized with the 3278 /// matching form of \c new in this constructor's initializer or given 3279 /// constructor isn't defined at the point where delete-expression is seen, or 3280 /// member isn't initialized by the constructor. 3281 bool hasMatchingNewInCtor(const CXXConstructorDecl *CD); 3282 /// Checks whether member is initialized with matching form of 3283 /// \c new in member initializer list. 3284 bool hasMatchingNewInCtorInit(const CXXCtorInitializer *CI); 3285 /// Checks whether member is initialized with mismatching form of \c new by 3286 /// in-class initializer. 3287 MismatchResult analyzeInClassInitializer(); 3288}; 3289} 3290 3291MismatchingNewDeleteDetector::MismatchResult 3292MismatchingNewDeleteDetector::analyzeDeleteExpr(const CXXDeleteExpr *DE) { 3293 NewExprs.clear(); 3294 assert(DE && "Expected delete-expression")((void)0); 3295 IsArrayForm = DE->isArrayForm(); 3296 const Expr *E = DE->getArgument()->IgnoreParenImpCasts(); 3297 if (const MemberExpr *ME = dyn_cast<const MemberExpr>(E)) { 3298 return analyzeMemberExpr(ME); 3299 } else if (const DeclRefExpr *D = dyn_cast<const DeclRefExpr>(E)) { 3300 if (!hasMatchingVarInit(D)) 3301 return VarInitMismatches; 3302 } 3303 return NoMismatch; 3304} 3305 3306const CXXNewExpr * 3307MismatchingNewDeleteDetector::getNewExprFromInitListOrExpr(const Expr *E) { 3308 assert(E != nullptr && "Expected a valid initializer expression")((void)0); 3309 E = E->IgnoreParenImpCasts(); 3310 if (const InitListExpr *ILE = dyn_cast<const InitListExpr>(E)) { 3311 if (ILE->getNumInits() == 1) 3312 E = dyn_cast<const CXXNewExpr>(ILE->getInit(0)->IgnoreParenImpCasts()); 3313 } 3314 3315 return dyn_cast_or_null<const CXXNewExpr>(E); 3316} 3317 3318bool MismatchingNewDeleteDetector::hasMatchingNewInCtorInit( 3319 const CXXCtorInitializer *CI) { 3320 const CXXNewExpr *NE = nullptr; 3321 if (Field == CI->getMember() && 3322 (NE = getNewExprFromInitListOrExpr(CI->getInit()))) { 3323 if (NE->isArray() == IsArrayForm) 3324 return true; 3325 else 3326 NewExprs.push_back(NE); 3327 } 3328 return false; 3329} 3330 3331bool MismatchingNewDeleteDetector::hasMatchingNewInCtor( 3332 const CXXConstructorDecl *CD) { 3333 if (CD->isImplicit()) 3334 return false; 3335 const FunctionDecl *Definition = CD; 3336 if (!CD->isThisDeclarationADefinition() && !CD->isDefined(Definition)) { 3337 HasUndefinedConstructors = true; 3338 return EndOfTU; 3339 } 3340 for (const auto *CI : cast<const CXXConstructorDecl>(Definition)->inits()) { 3341 if (hasMatchingNewInCtorInit(CI)) 3342 return true; 3343 } 3344 return false; 3345} 3346 3347MismatchingNewDeleteDetector::MismatchResult 3348MismatchingNewDeleteDetector::analyzeInClassInitializer() { 3349 assert(Field != nullptr && "This should be called only for members")((void)0); 3350 const Expr *InitExpr = Field->getInClassInitializer(); 3351 if (!InitExpr) 3352 return EndOfTU ? NoMismatch : AnalyzeLater; 3353 if (const CXXNewExpr *NE = getNewExprFromInitListOrExpr(InitExpr)) { 3354 if (NE->isArray() != IsArrayForm) { 3355 NewExprs.push_back(NE); 3356 return MemberInitMismatches; 3357 } 3358 } 3359 return NoMismatch; 3360} 3361 3362MismatchingNewDeleteDetector::MismatchResult 3363MismatchingNewDeleteDetector::analyzeField(FieldDecl *Field, 3364 bool DeleteWasArrayForm) { 3365 assert(Field != nullptr && "Analysis requires a valid class member.")((void)0); 3366 this->Field = Field; 3367 IsArrayForm = DeleteWasArrayForm; 3368 const CXXRecordDecl *RD = cast<const CXXRecordDecl>(Field->getParent()); 3369 for (const auto *CD : RD->ctors()) { 3370 if (hasMatchingNewInCtor(CD)) 3371 return NoMismatch; 3372 } 3373 if (HasUndefinedConstructors) 3374 return EndOfTU ? NoMismatch : AnalyzeLater; 3375 if (!NewExprs.empty()) 3376 return MemberInitMismatches; 3377 return Field->hasInClassInitializer() ? analyzeInClassInitializer() 3378 : NoMismatch; 3379} 3380 3381MismatchingNewDeleteDetector::MismatchResult 3382MismatchingNewDeleteDetector::analyzeMemberExpr(const MemberExpr *ME) { 3383 assert(ME != nullptr && "Expected a member expression")((void)0); 3384 if (FieldDecl *F = dyn_cast<FieldDecl>(ME->getMemberDecl())) 3385 return analyzeField(F, IsArrayForm); 3386 return NoMismatch; 3387} 3388 3389bool MismatchingNewDeleteDetector::hasMatchingVarInit(const DeclRefExpr *D) { 3390 const CXXNewExpr *NE = nullptr; 3391 if (const VarDecl *VD = dyn_cast<const VarDecl>(D->getDecl())) { 3392 if (VD->hasInit() && (NE = getNewExprFromInitListOrExpr(VD->getInit())) && 3393 NE->isArray() != IsArrayForm) { 3394 NewExprs.push_back(NE); 3395 } 3396 } 3397 return NewExprs.empty(); 3398} 3399 3400static void 3401DiagnoseMismatchedNewDelete(Sema &SemaRef, SourceLocation DeleteLoc, 3402 const MismatchingNewDeleteDetector &Detector) { 3403 SourceLocation EndOfDelete = SemaRef.getLocForEndOfToken(DeleteLoc); 3404 FixItHint H; 3405 if (!Detector.IsArrayForm) 3406 H = FixItHint::CreateInsertion(EndOfDelete, "[]"); 3407 else { 3408 SourceLocation RSquare = Lexer::findLocationAfterToken( 3409 DeleteLoc, tok::l_square, SemaRef.getSourceManager(), 3410 SemaRef.getLangOpts(), true); 3411 if (RSquare.isValid()) 3412 H = FixItHint::CreateRemoval(SourceRange(EndOfDelete, RSquare)); 3413 } 3414 SemaRef.Diag(DeleteLoc, diag::warn_mismatched_delete_new) 3415 << Detector.IsArrayForm << H; 3416 3417 for (const auto *NE : Detector.NewExprs) 3418 SemaRef.Diag(NE->getExprLoc(), diag::note_allocated_here) 3419 << Detector.IsArrayForm; 3420} 3421 3422void Sema::AnalyzeDeleteExprMismatch(const CXXDeleteExpr *DE) { 3423 if (Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) 3424 return; 3425 MismatchingNewDeleteDetector Detector(/*EndOfTU=*/false); 3426 switch (Detector.analyzeDeleteExpr(DE)) { 3427 case MismatchingNewDeleteDetector::VarInitMismatches: 3428 case MismatchingNewDeleteDetector::MemberInitMismatches: { 3429 DiagnoseMismatchedNewDelete(*this, DE->getBeginLoc(), Detector); 3430 break; 3431 } 3432 case MismatchingNewDeleteDetector::AnalyzeLater: { 3433 DeleteExprs[Detector.Field].push_back( 3434 std::make_pair(DE->getBeginLoc(), DE->isArrayForm())); 3435 break; 3436 } 3437 case MismatchingNewDeleteDetector::NoMismatch: 3438 break; 3439 } 3440} 3441 3442void Sema::AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc, 3443 bool DeleteWasArrayForm) { 3444 MismatchingNewDeleteDetector Detector(/*EndOfTU=*/true); 3445 switch (Detector.analyzeField(Field, DeleteWasArrayForm)) { 3446 case MismatchingNewDeleteDetector::VarInitMismatches: 3447 llvm_unreachable("This analysis should have been done for class members.")__builtin_unreachable(); 3448 case MismatchingNewDeleteDetector::AnalyzeLater: 3449 llvm_unreachable("Analysis cannot be postponed any point beyond end of "__builtin_unreachable() 3450 "translation unit.")__builtin_unreachable(); 3451 case MismatchingNewDeleteDetector::MemberInitMismatches: 3452 DiagnoseMismatchedNewDelete(*this, DeleteLoc, Detector); 3453 break; 3454 case MismatchingNewDeleteDetector::NoMismatch: 3455 break; 3456 } 3457} 3458 3459/// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in: 3460/// @code ::delete ptr; @endcode 3461/// or 3462/// @code delete [] ptr; @endcode 3463ExprResult 3464Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, 3465 bool ArrayForm, Expr *ExE) { 3466 // C++ [expr.delete]p1: 3467 // The operand shall have a pointer type, or a class type having a single 3468 // non-explicit conversion function to a pointer type. The result has type 3469 // void. 3470 // 3471 // DR599 amends "pointer type" to "pointer to object type" in both cases. 3472 3473 ExprResult Ex = ExE; 3474 FunctionDecl *OperatorDelete = nullptr; 3475 bool ArrayFormAsWritten = ArrayForm; 3476 bool UsualArrayDeleteWantsSize = false; 3477 3478 if (!Ex.get()->isTypeDependent()) { 3479 // Perform lvalue-to-rvalue cast, if needed. 3480 Ex = DefaultLvalueConversion(Ex.get()); 3481 if (Ex.isInvalid()) 3482 return ExprError(); 3483 3484 QualType Type = Ex.get()->getType(); 3485 3486 class DeleteConverter : public ContextualImplicitConverter { 3487 public: 3488 DeleteConverter() : ContextualImplicitConverter(false, true) {} 3489 3490 bool match(QualType ConvType) override { 3491 // FIXME: If we have an operator T* and an operator void*, we must pick 3492 // the operator T*. 3493 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>()) 3494 if (ConvPtrType->getPointeeType()->isIncompleteOrObjectType()) 3495 return true; 3496 return false; 3497 } 3498 3499 SemaDiagnosticBuilder diagnoseNoMatch(Sema &S, SourceLocation Loc, 3500 QualType T) override { 3501 return S.Diag(Loc, diag::err_delete_operand) << T; 3502 } 3503 3504 SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc, 3505 QualType T) override { 3506 return S.Diag(Loc, diag::err_delete_incomplete_class_type) << T; 3507 } 3508 3509 SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc, 3510 QualType T, 3511 QualType ConvTy) override { 3512 return S.Diag(Loc, diag::err_delete_explicit_conversion) << T << ConvTy; 3513 } 3514 3515 SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv, 3516 QualType ConvTy) override { 3517 return S.Diag(Conv->getLocation(), diag::note_delete_conversion) 3518 << ConvTy; 3519 } 3520 3521 SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc, 3522 QualType T) override { 3523 return S.Diag(Loc, diag::err_ambiguous_delete_operand) << T; 3524 } 3525 3526 SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv, 3527 QualType ConvTy) override { 3528 return S.Diag(Conv->getLocation(), diag::note_delete_conversion) 3529 << ConvTy; 3530 } 3531 3532 SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc, 3533 QualType T, 3534 QualType ConvTy) override { 3535 llvm_unreachable("conversion functions are permitted")__builtin_unreachable(); 3536 } 3537 } Converter; 3538 3539 Ex = PerformContextualImplicitConversion(StartLoc, Ex.get(), Converter); 3540 if (Ex.isInvalid()) 3541 return ExprError(); 3542 Type = Ex.get()->getType(); 3543 if (!Converter.match(Type)) 3544 // FIXME: PerformContextualImplicitConversion should return ExprError 3545 // itself in this case. 3546 return ExprError(); 3547 3548 QualType Pointee = Type->castAs<PointerType>()->getPointeeType(); 3549 QualType PointeeElem = Context.getBaseElementType(Pointee); 3550 3551 if (Pointee.getAddressSpace() != LangAS::Default && 3552 !getLangOpts().OpenCLCPlusPlus) 3553 return Diag(Ex.get()->getBeginLoc(), 3554 diag::err_address_space_qualified_delete) 3555 << Pointee.getUnqualifiedType() 3556 << Pointee.getQualifiers().getAddressSpaceAttributePrintValue(); 3557 3558 CXXRecordDecl *PointeeRD = nullptr; 3559 if (Pointee->isVoidType() && !isSFINAEContext()) { 3560 // The C++ standard bans deleting a pointer to a non-object type, which 3561 // effectively bans deletion of "void*". However, most compilers support 3562 // this, so we treat it as a warning unless we're in a SFINAE context. 3563 Diag(StartLoc, diag::ext_delete_void_ptr_operand) 3564 << Type << Ex.get()->getSourceRange(); 3565 } else if (Pointee->isFunctionType() || Pointee->isVoidType() || 3566 Pointee->isSizelessType()) { 3567 return ExprError(Diag(StartLoc, diag::err_delete_operand) 3568 << Type << Ex.get()->getSourceRange()); 3569 } else if (!Pointee->isDependentType()) { 3570 // FIXME: This can result in errors if the definition was imported from a 3571 // module but is hidden. 3572 if (!RequireCompleteType(StartLoc, Pointee, 3573 diag::warn_delete_incomplete, Ex.get())) { 3574 if (const RecordType *RT = PointeeElem->getAs<RecordType>()) 3575 PointeeRD = cast<CXXRecordDecl>(RT->getDecl()); 3576 } 3577 } 3578 3579 if (Pointee->isArrayType() && !ArrayForm) { 3580 Diag(StartLoc, diag::warn_delete_array_type) 3581 << Type << Ex.get()->getSourceRange() 3582 << FixItHint::CreateInsertion(getLocForEndOfToken(StartLoc), "[]"); 3583 ArrayForm = true; 3584 } 3585 3586 DeclarationName DeleteName = Context.DeclarationNames.getCXXOperatorName( 3587 ArrayForm ? OO_Array_Delete : OO_Delete); 3588 3589 if (PointeeRD) { 3590 if (!UseGlobal && 3591 FindDeallocationFunction(StartLoc, PointeeRD, DeleteName, 3592 OperatorDelete)) 3593 return ExprError(); 3594 3595 // If we're allocating an array of records, check whether the 3596 // usual operator delete[] has a size_t parameter. 3597 if (ArrayForm) { 3598 // If the user specifically asked to use the global allocator, 3599 // we'll need to do the lookup into the class. 3600 if (UseGlobal) 3601 UsualArrayDeleteWantsSize = 3602 doesUsualArrayDeleteWantSize(*this, StartLoc, PointeeElem); 3603 3604 // Otherwise, the usual operator delete[] should be the 3605 // function we just found. 3606 else if (OperatorDelete && isa<CXXMethodDecl>(OperatorDelete)) 3607 UsualArrayDeleteWantsSize = 3608 UsualDeallocFnInfo(*this, 3609 DeclAccessPair::make(OperatorDelete, AS_public)) 3610 .HasSizeT; 3611 } 3612 3613 if (!PointeeRD->hasIrrelevantDestructor()) 3614 if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) { 3615 MarkFunctionReferenced(StartLoc, 3616 const_cast<CXXDestructorDecl*>(Dtor)); 3617 if (DiagnoseUseOfDecl(Dtor, StartLoc)) 3618 return ExprError(); 3619 } 3620 3621 CheckVirtualDtorCall(PointeeRD->getDestructor(), StartLoc, 3622 /*IsDelete=*/true, /*CallCanBeVirtual=*/true, 3623 /*WarnOnNonAbstractTypes=*/!ArrayForm, 3624 SourceLocation()); 3625 } 3626 3627 if (!OperatorDelete) { 3628 if (getLangOpts().OpenCLCPlusPlus) { 3629 Diag(StartLoc, diag::err_openclcxx_not_supported) << "default delete"; 3630 return ExprError(); 3631 } 3632 3633 bool IsComplete = isCompleteType(StartLoc, Pointee); 3634 bool CanProvideSize = 3635 IsComplete && (!ArrayForm || UsualArrayDeleteWantsSize || 3636 Pointee.isDestructedType()); 3637 bool Overaligned = hasNewExtendedAlignment(*this, Pointee); 3638 3639 // Look for a global declaration. 3640 OperatorDelete = FindUsualDeallocationFunction(StartLoc, CanProvideSize, 3641 Overaligned, DeleteName); 3642 } 3643 3644 MarkFunctionReferenced(StartLoc, OperatorDelete); 3645 3646 // Check access and ambiguity of destructor if we're going to call it. 3647 // Note that this is required even for a virtual delete. 3648 bool IsVirtualDelete = false; 3649 if (PointeeRD) { 3650 if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) { 3651 CheckDestructorAccess(Ex.get()->getExprLoc(), Dtor, 3652 PDiag(diag::err_access_dtor) << PointeeElem); 3653 IsVirtualDelete = Dtor->isVirtual(); 3654 } 3655 } 3656 3657 DiagnoseUseOfDecl(OperatorDelete, StartLoc); 3658 3659 // Convert the operand to the type of the first parameter of operator 3660 // delete. This is only necessary if we selected a destroying operator 3661 // delete that we are going to call (non-virtually); converting to void* 3662 // is trivial and left to AST consumers to handle. 3663 QualType ParamType = OperatorDelete->getParamDecl(0)->getType(); 3664 if (!IsVirtualDelete && !ParamType->getPointeeType()->isVoidType()) { 3665 Qualifiers Qs = Pointee.getQualifiers(); 3666 if (Qs.hasCVRQualifiers()) { 3667 // Qualifiers are irrelevant to this conversion; we're only looking 3668 // for access and ambiguity. 3669 Qs.removeCVRQualifiers(); 3670 QualType Unqual = Context.getPointerType( 3671 Context.getQualifiedType(Pointee.getUnqualifiedType(), Qs)); 3672 Ex = ImpCastExprToType(Ex.get(), Unqual, CK_NoOp); 3673 } 3674 Ex = PerformImplicitConversion(Ex.get(), ParamType, AA_Passing); 3675 if (Ex.isInvalid()) 3676 return ExprError(); 3677 } 3678 } 3679 3680 CXXDeleteExpr *Result = new (Context) CXXDeleteExpr( 3681 Context.VoidTy, UseGlobal, ArrayForm, ArrayFormAsWritten, 3682 UsualArrayDeleteWantsSize, OperatorDelete, Ex.get(), StartLoc); 3683 AnalyzeDeleteExprMismatch(Result); 3684 return Result; 3685} 3686 3687static bool resolveBuiltinNewDeleteOverload(Sema &S, CallExpr *TheCall, 3688 bool IsDelete, 3689 FunctionDecl *&Operator) { 3690 3691 DeclarationName NewName = S.Context.DeclarationNames.getCXXOperatorName( 3692 IsDelete ? OO_Delete : OO_New); 3693 3694 LookupResult R(S, NewName, TheCall->getBeginLoc(), Sema::LookupOrdinaryName); 3695 S.LookupQualifiedName(R, S.Context.getTranslationUnitDecl()); 3696 assert(!R.empty() && "implicitly declared allocation functions not found")((void)0); 3697 assert(!R.isAmbiguous() && "global allocation functions are ambiguous")((void)0); 3698 3699 // We do our own custom access checks below. 3700 R.suppressDiagnostics(); 3701 3702 SmallVector<Expr *, 8> Args(TheCall->arg_begin(), TheCall->arg_end()); 3703 OverloadCandidateSet Candidates(R.getNameLoc(), 3704 OverloadCandidateSet::CSK_Normal); 3705 for (LookupResult::iterator FnOvl = R.begin(), FnOvlEnd = R.end(); 3706 FnOvl != FnOvlEnd; ++FnOvl) { 3707 // Even member operator new/delete are implicitly treated as 3708 // static, so don't use AddMemberCandidate. 3709 NamedDecl *D = (*FnOvl)->getUnderlyingDecl(); 3710 3711 if (FunctionTemplateDecl *FnTemplate = dyn_cast<FunctionTemplateDecl>(D)) { 3712 S.AddTemplateOverloadCandidate(FnTemplate, FnOvl.getPair(), 3713 /*ExplicitTemplateArgs=*/nullptr, Args, 3714 Candidates, 3715 /*SuppressUserConversions=*/false); 3716 continue; 3717 } 3718 3719 FunctionDecl *Fn = cast<FunctionDecl>(D); 3720 S.AddOverloadCandidate(Fn, FnOvl.getPair(), Args, Candidates, 3721 /*SuppressUserConversions=*/false); 3722 } 3723 3724 SourceRange Range = TheCall->getSourceRange(); 3725 3726 // Do the resolution. 3727 OverloadCandidateSet::iterator Best; 3728 switch (Candidates.BestViableFunction(S, R.getNameLoc(), Best)) { 3729 case OR_Success: { 3730 // Got one! 3731 FunctionDecl *FnDecl = Best->Function; 3732 assert(R.getNamingClass() == nullptr &&((void)0) 3733 "class members should not be considered")((void)0); 3734 3735 if (!FnDecl->isReplaceableGlobalAllocationFunction()) { 3736 S.Diag(R.getNameLoc(), diag::err_builtin_operator_new_delete_not_usual) 3737 << (IsDelete ? 1 : 0) << Range; 3738 S.Diag(FnDecl->getLocation(), diag::note_non_usual_function_declared_here) 3739 << R.getLookupName() << FnDecl->getSourceRange(); 3740 return true; 3741 } 3742 3743 Operator = FnDecl; 3744 return false; 3745 } 3746 3747 case OR_No_Viable_Function: 3748 Candidates.NoteCandidates( 3749 PartialDiagnosticAt(R.getNameLoc(), 3750 S.PDiag(diag::err_ovl_no_viable_function_in_call) 3751 << R.getLookupName() << Range), 3752 S, OCD_AllCandidates, Args); 3753 return true; 3754 3755 case OR_Ambiguous: 3756 Candidates.NoteCandidates( 3757 PartialDiagnosticAt(R.getNameLoc(), 3758 S.PDiag(diag::err_ovl_ambiguous_call) 3759 << R.getLookupName() << Range), 3760 S, OCD_AmbiguousCandidates, Args); 3761 return true; 3762 3763 case OR_Deleted: { 3764 Candidates.NoteCandidates( 3765 PartialDiagnosticAt(R.getNameLoc(), S.PDiag(diag::err_ovl_deleted_call) 3766 << R.getLookupName() << Range), 3767 S, OCD_AllCandidates, Args); 3768 return true; 3769 } 3770 } 3771 llvm_unreachable("Unreachable, bad result from BestViableFunction")__builtin_unreachable(); 3772} 3773 3774ExprResult 3775Sema::SemaBuiltinOperatorNewDeleteOverloaded(ExprResult TheCallResult, 3776 bool IsDelete) { 3777 CallExpr *TheCall = cast<CallExpr>(TheCallResult.get()); 3778 if (!getLangOpts().CPlusPlus) { 3779 Diag(TheCall->getExprLoc(), diag::err_builtin_requires_language) 3780 << (IsDelete ? "__builtin_operator_delete" : "__builtin_operator_new") 3781 << "C++"; 3782 return ExprError(); 3783 } 3784 // CodeGen assumes it can find the global new and delete to call, 3785 // so ensure that they are declared. 3786 DeclareGlobalNewDelete(); 3787 3788 FunctionDecl *OperatorNewOrDelete = nullptr; 3789 if (resolveBuiltinNewDeleteOverload(*this, TheCall, IsDelete, 3790 OperatorNewOrDelete)) 3791 return ExprError(); 3792 assert(OperatorNewOrDelete && "should be found")((void)0); 3793 3794 DiagnoseUseOfDecl(OperatorNewOrDelete, TheCall->getExprLoc()); 3795 MarkFunctionReferenced(TheCall->getExprLoc(), OperatorNewOrDelete); 3796 3797 TheCall->setType(OperatorNewOrDelete->getReturnType()); 3798 for (unsigned i = 0; i != TheCall->getNumArgs(); ++i) { 3799 QualType ParamTy = OperatorNewOrDelete->getParamDecl(i)->getType(); 3800 InitializedEntity Entity = 3801 InitializedEntity::InitializeParameter(Context, ParamTy, false); 3802 ExprResult Arg = PerformCopyInitialization( 3803 Entity, TheCall->getArg(i)->getBeginLoc(), TheCall->getArg(i)); 3804 if (Arg.isInvalid()) 3805 return ExprError(); 3806 TheCall->setArg(i, Arg.get()); 3807 } 3808 auto Callee = dyn_cast<ImplicitCastExpr>(TheCall->getCallee()); 3809 assert(Callee && Callee->getCastKind() == CK_BuiltinFnToFnPtr &&((void)0) 3810 "Callee expected to be implicit cast to a builtin function pointer")((void)0); 3811 Callee->setType(OperatorNewOrDelete->getType()); 3812 3813 return TheCallResult; 3814} 3815 3816void Sema::CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc, 3817 bool IsDelete, bool CallCanBeVirtual, 3818 bool WarnOnNonAbstractTypes, 3819 SourceLocation DtorLoc) { 3820 if (!dtor || dtor->isVirtual() || !CallCanBeVirtual || isUnevaluatedContext()) 3821 return; 3822 3823 // C++ [expr.delete]p3: 3824 // In the first alternative (delete object), if the static type of the 3825 // object to be deleted is different from its dynamic type, the static 3826 // type shall be a base class of the dynamic type of the object to be 3827 // deleted and the static type shall have a virtual destructor or the 3828 // behavior is undefined. 3829 // 3830 const CXXRecordDecl *PointeeRD = dtor->getParent(); 3831 // Note: a final class cannot be derived from, no issue there 3832 if (!PointeeRD->isPolymorphic() || PointeeRD->hasAttr<FinalAttr>()) 3833 return; 3834 3835 // If the superclass is in a system header, there's nothing that can be done. 3836 // The `delete` (where we emit the warning) can be in a system header, 3837 // what matters for this warning is where the deleted type is defined. 3838 if (getSourceManager().isInSystemHeader(PointeeRD->getLocation())) 3839 return; 3840 3841 QualType ClassType = dtor->getThisType()->getPointeeType(); 3842 if (PointeeRD->isAbstract()) { 3843 // If the class is abstract, we warn by default, because we're 3844 // sure the code has undefined behavior. 3845 Diag(Loc, diag::warn_delete_abstract_non_virtual_dtor) << (IsDelete ? 0 : 1) 3846 << ClassType; 3847 } else if (WarnOnNonAbstractTypes) { 3848 // Otherwise, if this is not an array delete, it's a bit suspect, 3849 // but not necessarily wrong. 3850 Diag(Loc, diag::warn_delete_non_virtual_dtor) << (IsDelete ? 0 : 1) 3851 << ClassType; 3852 } 3853 if (!IsDelete) { 3854 std::string TypeStr; 3855 ClassType.getAsStringInternal(TypeStr, getPrintingPolicy()); 3856 Diag(DtorLoc, diag::note_delete_non_virtual) 3857 << FixItHint::CreateInsertion(DtorLoc, TypeStr + "::"); 3858 } 3859} 3860 3861Sema::ConditionResult Sema::ActOnConditionVariable(Decl *ConditionVar, 3862 SourceLocation StmtLoc, 3863 ConditionKind CK) { 3864 ExprResult E = 3865 CheckConditionVariable(cast<VarDecl>(ConditionVar), StmtLoc, CK); 3866 if (E.isInvalid()) 3867 return ConditionError(); 3868 return ConditionResult(*this, ConditionVar, MakeFullExpr(E.get(), StmtLoc), 3869 CK == ConditionKind::ConstexprIf); 3870} 3871 3872/// Check the use of the given variable as a C++ condition in an if, 3873/// while, do-while, or switch statement. 3874ExprResult Sema::CheckConditionVariable(VarDecl *ConditionVar, 3875 SourceLocation StmtLoc, 3876 ConditionKind CK) { 3877 if (ConditionVar->isInvalidDecl()) 3878 return ExprError(); 3879 3880 QualType T = ConditionVar->getType(); 3881 3882 // C++ [stmt.select]p2: 3883 // The declarator shall not specify a function or an array. 3884 if (T->isFunctionType()) 3885 return ExprError(Diag(ConditionVar->getLocation(), 3886 diag::err_invalid_use_of_function_type) 3887 << ConditionVar->getSourceRange()); 3888 else if (T->isArrayType()) 3889 return ExprError(Diag(ConditionVar->getLocation(), 3890 diag::err_invalid_use_of_array_type) 3891 << ConditionVar->getSourceRange()); 3892 3893 ExprResult Condition = BuildDeclRefExpr( 3894 ConditionVar, ConditionVar->getType().getNonReferenceType(), VK_LValue, 3895 ConditionVar->getLocation()); 3896 3897 switch (CK) { 3898 case ConditionKind::Boolean: 3899 return CheckBooleanCondition(StmtLoc, Condition.get()); 3900 3901 case ConditionKind::ConstexprIf: 3902 return CheckBooleanCondition(StmtLoc, Condition.get(), true); 3903 3904 case ConditionKind::Switch: 3905 return CheckSwitchCondition(StmtLoc, Condition.get()); 3906 } 3907 3908 llvm_unreachable("unexpected condition kind")__builtin_unreachable(); 3909} 3910 3911/// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid. 3912ExprResult Sema::CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr) { 3913 // C++11 6.4p4: 3914 // The value of a condition that is an initialized declaration in a statement 3915 // other than a switch statement is the value of the declared variable 3916 // implicitly converted to type bool. If that conversion is ill-formed, the 3917 // program is ill-formed. 3918 // The value of a condition that is an expression is the value of the 3919 // expression, implicitly converted to bool. 3920 // 3921 // C++2b 8.5.2p2 3922 // If the if statement is of the form if constexpr, the value of the condition 3923 // is contextually converted to bool and the converted expression shall be 3924 // a constant expression. 3925 // 3926 3927 ExprResult E = PerformContextuallyConvertToBool(CondExpr); 3928 if (!IsConstexpr || E.isInvalid() || E.get()->isValueDependent()) 3929 return E; 3930 3931 // FIXME: Return this value to the caller so they don't need to recompute it. 3932 llvm::APSInt Cond; 3933 E = VerifyIntegerConstantExpression( 3934 E.get(), &Cond, 3935 diag::err_constexpr_if_condition_expression_is_not_constant); 3936 return E; 3937} 3938 3939/// Helper function to determine whether this is the (deprecated) C++ 3940/// conversion from a string literal to a pointer to non-const char or 3941/// non-const wchar_t (for narrow and wide string literals, 3942/// respectively). 3943bool 3944Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) { 3945 // Look inside the implicit cast, if it exists. 3946 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From)) 3947 From = Cast->getSubExpr(); 3948 3949 // A string literal (2.13.4) that is not a wide string literal can 3950 // be converted to an rvalue of type "pointer to char"; a wide 3951 // string literal can be converted to an rvalue of type "pointer 3952 // to wchar_t" (C++ 4.2p2). 3953 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From->IgnoreParens())) 3954 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) 3955 if (const BuiltinType *ToPointeeType 3956 = ToPtrType->getPointeeType()->getAs<BuiltinType>()) { 3957 // This conversion is considered only when there is an 3958 // explicit appropriate pointer target type (C++ 4.2p2). 3959 if (!ToPtrType->getPointeeType().hasQualifiers()) { 3960 switch (StrLit->getKind()) { 3961 case StringLiteral::UTF8: 3962 case StringLiteral::UTF16: 3963 case StringLiteral::UTF32: 3964 // We don't allow UTF literals to be implicitly converted 3965 break; 3966 case StringLiteral::Ascii: 3967 return (ToPointeeType->getKind() == BuiltinType::Char_U || 3968 ToPointeeType->getKind() == BuiltinType::Char_S); 3969 case StringLiteral::Wide: 3970 return Context.typesAreCompatible(Context.getWideCharType(), 3971 QualType(ToPointeeType, 0)); 3972 } 3973 } 3974 } 3975 3976 return false; 3977} 3978 3979static ExprResult BuildCXXCastArgument(Sema &S, 3980 SourceLocation CastLoc, 3981 QualType Ty, 3982 CastKind Kind, 3983 CXXMethodDecl *Method, 3984 DeclAccessPair FoundDecl, 3985 bool HadMultipleCandidates, 3986 Expr *From) { 3987 switch (Kind) { 3988 default: llvm_unreachable("Unhandled cast kind!")__builtin_unreachable(); 3989 case CK_ConstructorConversion: { 3990 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Method); 3991 SmallVector<Expr*, 8> ConstructorArgs; 3992 3993 if (S.RequireNonAbstractType(CastLoc, Ty, 3994 diag::err_allocation_of_abstract_type)) 3995 return ExprError(); 3996 3997 if (S.CompleteConstructorCall(Constructor, Ty, From, CastLoc, 3998 ConstructorArgs)) 3999 return ExprError(); 4000 4001 S.CheckConstructorAccess(CastLoc, Constructor, FoundDecl, 4002 InitializedEntity::InitializeTemporary(Ty)); 4003 if (S.DiagnoseUseOfDecl(Method, CastLoc)) 4004 return ExprError(); 4005 4006 ExprResult Result = S.BuildCXXConstructExpr( 4007 CastLoc, Ty, FoundDecl, cast<CXXConstructorDecl>(Method), 4008 ConstructorArgs, HadMultipleCandidates, 4009 /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false, 4010 CXXConstructExpr::CK_Complete, SourceRange()); 4011 if (Result.isInvalid()) 4012 return ExprError(); 4013 4014 return S.MaybeBindToTemporary(Result.getAs<Expr>()); 4015 } 4016 4017 case CK_UserDefinedConversion: { 4018 assert(!From->getType()->isPointerType() && "Arg can't have pointer type!")((void)0); 4019 4020 S.CheckMemberOperatorAccess(CastLoc, From, /*arg*/ nullptr, FoundDecl); 4021 if (S.DiagnoseUseOfDecl(Method, CastLoc)) 4022 return ExprError(); 4023 4024 // Create an implicit call expr that calls it. 4025 CXXConversionDecl *Conv = cast<CXXConversionDecl>(Method); 4026 ExprResult Result = S.BuildCXXMemberCallExpr(From, FoundDecl, Conv, 4027 HadMultipleCandidates); 4028 if (Result.isInvalid()) 4029 return ExprError(); 4030 // Record usage of conversion in an implicit cast. 4031 Result = ImplicitCastExpr::Create(S.Context, Result.get()->getType(), 4032 CK_UserDefinedConversion, Result.get(), 4033 nullptr, Result.get()->getValueKind(), 4034 S.CurFPFeatureOverrides()); 4035 4036 return S.MaybeBindToTemporary(Result.get()); 4037 } 4038 } 4039} 4040 4041/// PerformImplicitConversion - Perform an implicit conversion of the 4042/// expression From to the type ToType using the pre-computed implicit 4043/// conversion sequence ICS. Returns the converted 4044/// expression. Action is the kind of conversion we're performing, 4045/// used in the error message. 4046ExprResult 4047Sema::PerformImplicitConversion(Expr *From, QualType ToType, 4048 const ImplicitConversionSequence &ICS, 4049 AssignmentAction Action, 4050 CheckedConversionKind CCK) { 4051 // C++ [over.match.oper]p7: [...] operands of class type are converted [...] 4052 if (CCK == CCK_ForBuiltinOverloadedOp && !From->getType()->isRecordType()) 4053 return From; 4054 4055 switch (ICS.getKind()) { 4056 case ImplicitConversionSequence::StandardConversion: { 4057 ExprResult Res = PerformImplicitConversion(From, ToType, ICS.Standard, 4058 Action, CCK); 4059 if (Res.isInvalid()) 4060 return ExprError(); 4061 From = Res.get(); 4062 break; 4063 } 4064 4065 case ImplicitConversionSequence::UserDefinedConversion: { 4066 4067 FunctionDecl *FD = ICS.UserDefined.ConversionFunction; 4068 CastKind CastKind; 4069 QualType BeforeToType; 4070 assert(FD && "no conversion function for user-defined conversion seq")((void)0); 4071 if (const CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(FD)) { 4072 CastKind = CK_UserDefinedConversion; 4073 4074 // If the user-defined conversion is specified by a conversion function, 4075 // the initial standard conversion sequence converts the source type to 4076 // the implicit object parameter of the conversion function. 4077 BeforeToType = Context.getTagDeclType(Conv->getParent()); 4078 } else { 4079 const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(FD); 4080 CastKind = CK_ConstructorConversion; 4081 // Do no conversion if dealing with ... for the first conversion. 4082 if (!ICS.UserDefined.EllipsisConversion) { 4083 // If the user-defined conversion is specified by a constructor, the 4084 // initial standard conversion sequence converts the source type to 4085 // the type required by the argument of the constructor 4086 BeforeToType = Ctor->getParamDecl(0)->getType().getNonReferenceType(); 4087 } 4088 } 4089 // Watch out for ellipsis conversion. 4090 if (!ICS.UserDefined.EllipsisConversion) { 4091 ExprResult Res = 4092 PerformImplicitConversion(From, BeforeToType, 4093 ICS.UserDefined.Before, AA_Converting, 4094 CCK); 4095 if (Res.isInvalid()) 4096 return ExprError(); 4097 From = Res.get(); 4098 } 4099 4100 ExprResult CastArg = BuildCXXCastArgument( 4101 *this, From->getBeginLoc(), ToType.getNonReferenceType(), CastKind, 4102 cast<CXXMethodDecl>(FD), ICS.UserDefined.FoundConversionFunction, 4103 ICS.UserDefined.HadMultipleCandidates, From); 4104 4105 if (CastArg.isInvalid()) 4106 return ExprError(); 4107 4108 From = CastArg.get(); 4109 4110 // C++ [over.match.oper]p7: 4111 // [...] the second standard conversion sequence of a user-defined 4112 // conversion sequence is not applied. 4113 if (CCK == CCK_ForBuiltinOverloadedOp) 4114 return From; 4115 4116 return PerformImplicitConversion(From, ToType, ICS.UserDefined.After, 4117 AA_Converting, CCK); 4118 } 4119 4120 case ImplicitConversionSequence::AmbiguousConversion: 4121 ICS.DiagnoseAmbiguousConversion(*this, From->getExprLoc(), 4122 PDiag(diag::err_typecheck_ambiguous_condition) 4123 << From->getSourceRange()); 4124 return ExprError(); 4125 4126 case ImplicitConversionSequence::EllipsisConversion: 4127 llvm_unreachable("Cannot perform an ellipsis conversion")__builtin_unreachable(); 4128 4129 case ImplicitConversionSequence::BadConversion: 4130 Sema::AssignConvertType ConvTy = 4131 CheckAssignmentConstraints(From->getExprLoc(), ToType, From->getType()); 4132 bool Diagnosed = DiagnoseAssignmentResult( 4133 ConvTy == Compatible ? Incompatible : ConvTy, From->getExprLoc(), 4134 ToType, From->getType(), From, Action); 4135 assert(Diagnosed && "failed to diagnose bad conversion")((void)0); (void)Diagnosed; 4136 return ExprError(); 4137 } 4138 4139 // Everything went well. 4140 return From; 4141} 4142 4143/// PerformImplicitConversion - Perform an implicit conversion of the 4144/// expression From to the type ToType by following the standard 4145/// conversion sequence SCS. Returns the converted 4146/// expression. Flavor is the context in which we're performing this 4147/// conversion, for use in error messages. 4148ExprResult 4149Sema::PerformImplicitConversion(Expr *From, QualType ToType, 4150 const StandardConversionSequence& SCS, 4151 AssignmentAction Action, 4152 CheckedConversionKind CCK) { 4153 bool CStyle = (CCK == CCK_CStyleCast || CCK == CCK_FunctionalCast); 4154 4155 // Overall FIXME: we are recomputing too many types here and doing far too 4156 // much extra work. What this means is that we need to keep track of more 4157 // information that is computed when we try the implicit conversion initially, 4158 // so that we don't need to recompute anything here. 4159 QualType FromType = From->getType(); 4160 4161 if (SCS.CopyConstructor) { 4162 // FIXME: When can ToType be a reference type? 4163 assert(!ToType->isReferenceType())((void)0); 4164 if (SCS.Second == ICK_Derived_To_Base) { 4165 SmallVector<Expr*, 8> ConstructorArgs; 4166 if (CompleteConstructorCall( 4167 cast<CXXConstructorDecl>(SCS.CopyConstructor), ToType, From, 4168 /*FIXME:ConstructLoc*/ SourceLocation(), ConstructorArgs)) 4169 return ExprError(); 4170 return BuildCXXConstructExpr( 4171 /*FIXME:ConstructLoc*/ SourceLocation(), ToType, 4172 SCS.FoundCopyConstructor, SCS.CopyConstructor, 4173 ConstructorArgs, /*HadMultipleCandidates*/ false, 4174 /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false, 4175 CXXConstructExpr::CK_Complete, SourceRange()); 4176 } 4177 return BuildCXXConstructExpr( 4178 /*FIXME:ConstructLoc*/ SourceLocation(), ToType, 4179 SCS.FoundCopyConstructor, SCS.CopyConstructor, 4180 From, /*HadMultipleCandidates*/ false, 4181 /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false, 4182 CXXConstructExpr::CK_Complete, SourceRange()); 4183 } 4184 4185 // Resolve overloaded function references. 4186 if (Context.hasSameType(FromType, Context.OverloadTy)) { 4187 DeclAccessPair Found; 4188 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, 4189 true, Found); 4190 if (!Fn) 4191 return ExprError(); 4192 4193 if (DiagnoseUseOfDecl(Fn, From->getBeginLoc())) 4194 return ExprError(); 4195 4196 From = FixOverloadedFunctionReference(From, Found, Fn); 4197 FromType = From->getType(); 4198 } 4199 4200 // If we're converting to an atomic type, first convert to the corresponding 4201 // non-atomic type. 4202 QualType ToAtomicType; 4203 if (const AtomicType *ToAtomic = ToType->getAs<AtomicType>()) { 4204 ToAtomicType = ToType; 4205 ToType = ToAtomic->getValueType(); 4206 } 4207 4208 QualType InitialFromType = FromType; 4209 // Perform the first implicit conversion. 4210 switch (SCS.First) { 4211 case ICK_Identity: 4212 if (const AtomicType *FromAtomic = FromType->getAs<AtomicType>()) { 4213 FromType = FromAtomic->getValueType().getUnqualifiedType(); 4214 From = ImplicitCastExpr::Create(Context, FromType, CK_AtomicToNonAtomic, 4215 From, /*BasePath=*/nullptr, VK_PRValue, 4216 FPOptionsOverride()); 4217 } 4218 break; 4219 4220 case ICK_Lvalue_To_Rvalue: { 4221 assert(From->getObjectKind() != OK_ObjCProperty)((void)0); 4222 ExprResult FromRes = DefaultLvalueConversion(From); 4223 if (FromRes.isInvalid()) 4224 return ExprError(); 4225 4226 From = FromRes.get(); 4227 FromType = From->getType(); 4228 break; 4229 } 4230 4231 case ICK_Array_To_Pointer: 4232 FromType = Context.getArrayDecayedType(FromType); 4233 From = ImpCastExprToType(From, FromType, CK_ArrayToPointerDecay, VK_PRValue, 4234 /*BasePath=*/nullptr, CCK) 4235 .get(); 4236 break; 4237 4238 case ICK_Function_To_Pointer: 4239 FromType = Context.getPointerType(FromType); 4240 From = ImpCastExprToType(From, FromType, CK_FunctionToPointerDecay, 4241 VK_PRValue, /*BasePath=*/nullptr, CCK) 4242 .get(); 4243 break; 4244 4245 default: 4246 llvm_unreachable("Improper first standard conversion")__builtin_unreachable(); 4247 } 4248 4249 // Perform the second implicit conversion 4250 switch (SCS.Second) { 4251 case ICK_Identity: 4252 // C++ [except.spec]p5: 4253 // [For] assignment to and initialization of pointers to functions, 4254 // pointers to member functions, and references to functions: the 4255 // target entity shall allow at least the exceptions allowed by the 4256 // source value in the assignment or initialization. 4257 switch (Action) { 4258 case AA_Assigning: 4259 case AA_Initializing: 4260 // Note, function argument passing and returning are initialization. 4261 case AA_Passing: 4262 case AA_Returning: 4263 case AA_Sending: 4264 case AA_Passing_CFAudited: 4265 if (CheckExceptionSpecCompatibility(From, ToType)) 4266 return ExprError(); 4267 break; 4268 4269 case AA_Casting: 4270 case AA_Converting: 4271 // Casts and implicit conversions are not initialization, so are not 4272 // checked for exception specification mismatches. 4273 break; 4274 } 4275 // Nothing else to do. 4276 break; 4277 4278 case ICK_Integral_Promotion: 4279 case ICK_Integral_Conversion: 4280 if (ToType->isBooleanType()) { 4281 assert(FromType->castAs<EnumType>()->getDecl()->isFixed() &&((void)0) 4282 SCS.Second == ICK_Integral_Promotion &&((void)0) 4283 "only enums with fixed underlying type can promote to bool")((void)0); 4284 From = ImpCastExprToType(From, ToType, CK_IntegralToBoolean, VK_PRValue, 4285 /*BasePath=*/nullptr, CCK) 4286 .get(); 4287 } else { 4288 From = ImpCastExprToType(From, ToType, CK_IntegralCast, VK_PRValue, 4289 /*BasePath=*/nullptr, CCK) 4290 .get(); 4291 } 4292 break; 4293 4294 case ICK_Floating_Promotion: 4295 case ICK_Floating_Conversion: 4296 From = ImpCastExprToType(From, ToType, CK_FloatingCast, VK_PRValue, 4297 /*BasePath=*/nullptr, CCK) 4298 .get(); 4299 break; 4300 4301 case ICK_Complex_Promotion: 4302 case ICK_Complex_Conversion: { 4303 QualType FromEl = From->getType()->castAs<ComplexType>()->getElementType(); 4304 QualType ToEl = ToType->castAs<ComplexType>()->getElementType(); 4305 CastKind CK; 4306 if (FromEl->isRealFloatingType()) { 4307 if (ToEl->isRealFloatingType()) 4308 CK = CK_FloatingComplexCast; 4309 else 4310 CK = CK_FloatingComplexToIntegralComplex; 4311 } else if (ToEl->isRealFloatingType()) { 4312 CK = CK_IntegralComplexToFloatingComplex; 4313 } else { 4314 CK = CK_IntegralComplexCast; 4315 } 4316 From = ImpCastExprToType(From, ToType, CK, VK_PRValue, /*BasePath=*/nullptr, 4317 CCK) 4318 .get(); 4319 break; 4320 } 4321 4322 case ICK_Floating_Integral: 4323 if (ToType->isRealFloatingType()) 4324 From = ImpCastExprToType(From, ToType, CK_IntegralToFloating, VK_PRValue, 4325 /*BasePath=*/nullptr, CCK) 4326 .get(); 4327 else 4328 From = ImpCastExprToType(From, ToType, CK_FloatingToIntegral, VK_PRValue, 4329 /*BasePath=*/nullptr, CCK) 4330 .get(); 4331 break; 4332 4333 case ICK_Compatible_Conversion: 4334 From = ImpCastExprToType(From, ToType, CK_NoOp, From->getValueKind(), 4335 /*BasePath=*/nullptr, CCK).get(); 4336 break; 4337 4338 case ICK_Writeback_Conversion: 4339 case ICK_Pointer_Conversion: { 4340 if (SCS.IncompatibleObjC && Action != AA_Casting) { 4341 // Diagnose incompatible Objective-C conversions 4342 if (Action == AA_Initializing || Action == AA_Assigning) 4343 Diag(From->getBeginLoc(), 4344 diag::ext_typecheck_convert_incompatible_pointer) 4345 << ToType << From->getType() << Action << From->getSourceRange() 4346 << 0; 4347 else 4348 Diag(From->getBeginLoc(), 4349 diag::ext_typecheck_convert_incompatible_pointer) 4350 << From->getType() << ToType << Action << From->getSourceRange() 4351 << 0; 4352 4353 if (From->getType()->isObjCObjectPointerType() && 4354 ToType->isObjCObjectPointerType()) 4355 EmitRelatedResultTypeNote(From); 4356 } else if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() && 4357 !CheckObjCARCUnavailableWeakConversion(ToType, 4358 From->getType())) { 4359 if (Action == AA_Initializing) 4360 Diag(From->getBeginLoc(), diag::err_arc_weak_unavailable_assign); 4361 else 4362 Diag(From->getBeginLoc(), diag::err_arc_convesion_of_weak_unavailable) 4363 << (Action == AA_Casting) << From->getType() << ToType 4364 << From->getSourceRange(); 4365 } 4366 4367 // Defer address space conversion to the third conversion. 4368 QualType FromPteeType = From->getType()->getPointeeType(); 4369 QualType ToPteeType = ToType->getPointeeType(); 4370 QualType NewToType = ToType; 4371 if (!FromPteeType.isNull() && !ToPteeType.isNull() && 4372 FromPteeType.getAddressSpace() != ToPteeType.getAddressSpace()) { 4373 NewToType = Context.removeAddrSpaceQualType(ToPteeType); 4374 NewToType = Context.getAddrSpaceQualType(NewToType, 4375 FromPteeType.getAddressSpace()); 4376 if (ToType->isObjCObjectPointerType()) 4377 NewToType = Context.getObjCObjectPointerType(NewToType); 4378 else if (ToType->isBlockPointerType()) 4379 NewToType = Context.getBlockPointerType(NewToType); 4380 else 4381 NewToType = Context.getPointerType(NewToType); 4382 } 4383 4384 CastKind Kind; 4385 CXXCastPath BasePath; 4386 if (CheckPointerConversion(From, NewToType, Kind, BasePath, CStyle)) 4387 return ExprError(); 4388 4389 // Make sure we extend blocks if necessary. 4390 // FIXME: doing this here is really ugly. 4391 if (Kind == CK_BlockPointerToObjCPointerCast) { 4392 ExprResult E = From; 4393 (void) PrepareCastToObjCObjectPointer(E); 4394 From = E.get(); 4395 } 4396 if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers()) 4397 CheckObjCConversion(SourceRange(), NewToType, From, CCK); 4398 From = ImpCastExprToType(From, NewToType, Kind, VK_PRValue, &BasePath, CCK) 4399 .get(); 4400 break; 4401 } 4402 4403 case ICK_Pointer_Member: { 4404 CastKind Kind; 4405 CXXCastPath BasePath; 4406 if (CheckMemberPointerConversion(From, ToType, Kind, BasePath, CStyle)) 4407 return ExprError(); 4408 if (CheckExceptionSpecCompatibility(From, ToType)) 4409 return ExprError(); 4410 4411 // We may not have been able to figure out what this member pointer resolved 4412 // to up until this exact point. Attempt to lock-in it's inheritance model. 4413 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) { 4414 (void)isCompleteType(From->getExprLoc(), From->getType()); 4415 (void)isCompleteType(From->getExprLoc(), ToType); 4416 } 4417 4418 From = 4419 ImpCastExprToType(From, ToType, Kind, VK_PRValue, &BasePath, CCK).get(); 4420 break; 4421 } 4422 4423 case ICK_Boolean_Conversion: 4424 // Perform half-to-boolean conversion via float. 4425 if (From->getType()->isHalfType()) { 4426 From = ImpCastExprToType(From, Context.FloatTy, CK_FloatingCast).get(); 4427 FromType = Context.FloatTy; 4428 } 4429 4430 From = ImpCastExprToType(From, Context.BoolTy, 4431 ScalarTypeToBooleanCastKind(FromType), VK_PRValue, 4432 /*BasePath=*/nullptr, CCK) 4433 .get(); 4434 break; 4435 4436 case ICK_Derived_To_Base: { 4437 CXXCastPath BasePath; 4438 if (CheckDerivedToBaseConversion( 4439 From->getType(), ToType.getNonReferenceType(), From->getBeginLoc(), 4440 From->getSourceRange(), &BasePath, CStyle)) 4441 return ExprError(); 4442 4443 From = ImpCastExprToType(From, ToType.getNonReferenceType(), 4444 CK_DerivedToBase, From->getValueKind(), 4445 &BasePath, CCK).get(); 4446 break; 4447 } 4448 4449 case ICK_Vector_Conversion: 4450 From = ImpCastExprToType(From, ToType, CK_BitCast, VK_PRValue, 4451 /*BasePath=*/nullptr, CCK) 4452 .get(); 4453 break; 4454 4455 case ICK_SVE_Vector_Conversion: 4456 From = ImpCastExprToType(From, ToType, CK_BitCast, VK_PRValue, 4457 /*BasePath=*/nullptr, CCK) 4458 .get(); 4459 break; 4460 4461 case ICK_Vector_Splat: { 4462 // Vector splat from any arithmetic type to a vector. 4463 Expr *Elem = prepareVectorSplat(ToType, From).get(); 4464 From = ImpCastExprToType(Elem, ToType, CK_VectorSplat, VK_PRValue, 4465 /*BasePath=*/nullptr, CCK) 4466 .get(); 4467 break; 4468 } 4469 4470 case ICK_Complex_Real: 4471 // Case 1. x -> _Complex y 4472 if (const ComplexType *ToComplex = ToType->getAs<ComplexType>()) { 4473 QualType ElType = ToComplex->getElementType(); 4474 bool isFloatingComplex = ElType->isRealFloatingType(); 4475 4476 // x -> y 4477 if (Context.hasSameUnqualifiedType(ElType, From->getType())) { 4478 // do nothing 4479 } else if (From->getType()->isRealFloatingType()) { 4480 From = ImpCastExprToType(From, ElType, 4481 isFloatingComplex ? CK_FloatingCast : CK_FloatingToIntegral).get(); 4482 } else { 4483 assert(From->getType()->isIntegerType())((void)0); 4484 From = ImpCastExprToType(From, ElType, 4485 isFloatingComplex ? CK_IntegralToFloating : CK_IntegralCast).get(); 4486 } 4487 // y -> _Complex y 4488 From = ImpCastExprToType(From, ToType, 4489 isFloatingComplex ? CK_FloatingRealToComplex 4490 : CK_IntegralRealToComplex).get(); 4491 4492 // Case 2. _Complex x -> y 4493 } else { 4494 auto *FromComplex = From->getType()->castAs<ComplexType>(); 4495 QualType ElType = FromComplex->getElementType(); 4496 bool isFloatingComplex = ElType->isRealFloatingType(); 4497 4498 // _Complex x -> x 4499 From = ImpCastExprToType(From, ElType, 4500 isFloatingComplex ? CK_FloatingComplexToReal 4501 : CK_IntegralComplexToReal, 4502 VK_PRValue, /*BasePath=*/nullptr, CCK) 4503 .get(); 4504 4505 // x -> y 4506 if (Context.hasSameUnqualifiedType(ElType, ToType)) { 4507 // do nothing 4508 } else if (ToType->isRealFloatingType()) { 4509 From = ImpCastExprToType(From, ToType, 4510 isFloatingComplex ? CK_FloatingCast 4511 : CK_IntegralToFloating, 4512 VK_PRValue, /*BasePath=*/nullptr, CCK) 4513 .get(); 4514 } else { 4515 assert(ToType->isIntegerType())((void)0); 4516 From = ImpCastExprToType(From, ToType, 4517 isFloatingComplex ? CK_FloatingToIntegral 4518 : CK_IntegralCast, 4519 VK_PRValue, /*BasePath=*/nullptr, CCK) 4520 .get(); 4521 } 4522 } 4523 break; 4524 4525 case ICK_Block_Pointer_Conversion: { 4526 LangAS AddrSpaceL = 4527 ToType->castAs<BlockPointerType>()->getPointeeType().getAddressSpace(); 4528 LangAS AddrSpaceR = 4529 FromType->castAs<BlockPointerType>()->getPointeeType().getAddressSpace(); 4530 assert(Qualifiers::isAddressSpaceSupersetOf(AddrSpaceL, AddrSpaceR) &&((void)0) 4531 "Invalid cast")((void)0); 4532 CastKind Kind = 4533 AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast; 4534 From = ImpCastExprToType(From, ToType.getUnqualifiedType(), Kind, 4535 VK_PRValue, /*BasePath=*/nullptr, CCK) 4536 .get(); 4537 break; 4538 } 4539 4540 case ICK_TransparentUnionConversion: { 4541 ExprResult FromRes = From; 4542 Sema::AssignConvertType ConvTy = 4543 CheckTransparentUnionArgumentConstraints(ToType, FromRes); 4544 if (FromRes.isInvalid()) 4545 return ExprError(); 4546 From = FromRes.get(); 4547 assert ((ConvTy == Sema::Compatible) &&((void)0) 4548 "Improper transparent union conversion")((void)0); 4549 (void)ConvTy; 4550 break; 4551 } 4552 4553 case ICK_Zero_Event_Conversion: 4554 case ICK_Zero_Queue_Conversion: 4555 From = ImpCastExprToType(From, ToType, 4556 CK_ZeroToOCLOpaqueType, 4557 From->getValueKind()).get(); 4558 break; 4559 4560 case ICK_Lvalue_To_Rvalue: 4561 case ICK_Array_To_Pointer: 4562 case ICK_Function_To_Pointer: 4563 case ICK_Function_Conversion: 4564 case ICK_Qualification: 4565 case ICK_Num_Conversion_Kinds: 4566 case ICK_C_Only_Conversion: 4567 case ICK_Incompatible_Pointer_Conversion: 4568 llvm_unreachable("Improper second standard conversion")__builtin_unreachable(); 4569 } 4570 4571 switch (SCS.Third) { 4572 case ICK_Identity: 4573 // Nothing to do. 4574 break; 4575 4576 case ICK_Function_Conversion: 4577 // If both sides are functions (or pointers/references to them), there could 4578 // be incompatible exception declarations. 4579 if (CheckExceptionSpecCompatibility(From, ToType)) 4580 return ExprError(); 4581 4582 From = ImpCastExprToType(From, ToType, CK_NoOp, VK_PRValue, 4583 /*BasePath=*/nullptr, CCK) 4584 .get(); 4585 break; 4586 4587 case ICK_Qualification: { 4588 ExprValueKind VK = From->getValueKind(); 4589 CastKind CK = CK_NoOp; 4590 4591 if (ToType->isReferenceType() && 4592 ToType->getPointeeType().getAddressSpace() != 4593 From->getType().getAddressSpace()) 4594 CK = CK_AddressSpaceConversion; 4595 4596 if (ToType->isPointerType() && 4597 ToType->getPointeeType().getAddressSpace() != 4598 From->getType()->getPointeeType().getAddressSpace()) 4599 CK = CK_AddressSpaceConversion; 4600 4601 From = ImpCastExprToType(From, ToType.getNonLValueExprType(Context), CK, VK, 4602 /*BasePath=*/nullptr, CCK) 4603 .get(); 4604 4605 if (SCS.DeprecatedStringLiteralToCharPtr && 4606 !getLangOpts().WritableStrings) { 4607 Diag(From->getBeginLoc(), 4608 getLangOpts().CPlusPlus11 4609 ? diag::ext_deprecated_string_literal_conversion 4610 : diag::warn_deprecated_string_literal_conversion) 4611 << ToType.getNonReferenceType(); 4612 } 4613 4614 break; 4615 } 4616 4617 default: 4618 llvm_unreachable("Improper third standard conversion")__builtin_unreachable(); 4619 } 4620 4621 // If this conversion sequence involved a scalar -> atomic conversion, perform 4622 // that conversion now. 4623 if (!ToAtomicType.isNull()) { 4624 assert(Context.hasSameType(((void)0) 4625 ToAtomicType->castAs<AtomicType>()->getValueType(), From->getType()))((void)0); 4626 From = ImpCastExprToType(From, ToAtomicType, CK_NonAtomicToAtomic, 4627 VK_PRValue, nullptr, CCK) 4628 .get(); 4629 } 4630 4631 // Materialize a temporary if we're implicitly converting to a reference 4632 // type. This is not required by the C++ rules but is necessary to maintain 4633 // AST invariants. 4634 if (ToType->isReferenceType() && From->isPRValue()) { 4635 ExprResult Res = TemporaryMaterializationConversion(From); 4636 if (Res.isInvalid()) 4637 return ExprError(); 4638 From = Res.get(); 4639 } 4640 4641 // If this conversion sequence succeeded and involved implicitly converting a 4642 // _Nullable type to a _Nonnull one, complain. 4643 if (!isCast(CCK)) 4644 diagnoseNullableToNonnullConversion(ToType, InitialFromType, 4645 From->getBeginLoc()); 4646 4647 return From; 4648} 4649 4650/// Check the completeness of a type in a unary type trait. 4651/// 4652/// If the particular type trait requires a complete type, tries to complete 4653/// it. If completing the type fails, a diagnostic is emitted and false 4654/// returned. If completing the type succeeds or no completion was required, 4655/// returns true. 4656static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT, 4657 SourceLocation Loc, 4658 QualType ArgTy) { 4659 // C++0x [meta.unary.prop]p3: 4660 // For all of the class templates X declared in this Clause, instantiating 4661 // that template with a template argument that is a class template 4662 // specialization may result in the implicit instantiation of the template 4663 // argument if and only if the semantics of X require that the argument 4664 // must be a complete type. 4665 // We apply this rule to all the type trait expressions used to implement 4666 // these class templates. We also try to follow any GCC documented behavior 4667 // in these expressions to ensure portability of standard libraries. 4668 switch (UTT) { 4669 default: llvm_unreachable("not a UTT")__builtin_unreachable(); 4670 // is_complete_type somewhat obviously cannot require a complete type. 4671 case UTT_IsCompleteType: 4672 // Fall-through 4673 4674 // These traits are modeled on the type predicates in C++0x 4675 // [meta.unary.cat] and [meta.unary.comp]. They are not specified as 4676 // requiring a complete type, as whether or not they return true cannot be 4677 // impacted by the completeness of the type. 4678 case UTT_IsVoid: 4679 case UTT_IsIntegral: 4680 case UTT_IsFloatingPoint: 4681 case UTT_IsArray: 4682 case UTT_IsPointer: 4683 case UTT_IsLvalueReference: 4684 case UTT_IsRvalueReference: 4685 case UTT_IsMemberFunctionPointer: 4686 case UTT_IsMemberObjectPointer: 4687 case UTT_IsEnum: 4688 case UTT_IsUnion: 4689 case UTT_IsClass: 4690 case UTT_IsFunction: 4691 case UTT_IsReference: 4692 case UTT_IsArithmetic: 4693 case UTT_IsFundamental: 4694 case UTT_IsObject: 4695 case UTT_IsScalar: 4696 case UTT_IsCompound: 4697 case UTT_IsMemberPointer: 4698 // Fall-through 4699 4700 // These traits are modeled on type predicates in C++0x [meta.unary.prop] 4701 // which requires some of its traits to have the complete type. However, 4702 // the completeness of the type cannot impact these traits' semantics, and 4703 // so they don't require it. This matches the comments on these traits in 4704 // Table 49. 4705 case UTT_IsConst: 4706 case UTT_IsVolatile: 4707 case UTT_IsSigned: 4708 case UTT_IsUnsigned: 4709 4710 // This type trait always returns false, checking the type is moot. 4711 case UTT_IsInterfaceClass: 4712 return true; 4713 4714 // C++14 [meta.unary.prop]: 4715 // If T is a non-union class type, T shall be a complete type. 4716 case UTT_IsEmpty: 4717 case UTT_IsPolymorphic: 4718 case UTT_IsAbstract: 4719 if (const auto *RD = ArgTy->getAsCXXRecordDecl()) 4720 if (!RD->isUnion()) 4721 return !S.RequireCompleteType( 4722 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr); 4723 return true; 4724 4725 // C++14 [meta.unary.prop]: 4726 // If T is a class type, T shall be a complete type. 4727 case UTT_IsFinal: 4728 case UTT_IsSealed: 4729 if (ArgTy->getAsCXXRecordDecl()) 4730 return !S.RequireCompleteType( 4731 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr); 4732 return true; 4733 4734 // C++1z [meta.unary.prop]: 4735 // remove_all_extents_t<T> shall be a complete type or cv void. 4736 case UTT_IsAggregate: 4737 case UTT_IsTrivial: 4738 case UTT_IsTriviallyCopyable: 4739 case UTT_IsStandardLayout: 4740 case UTT_IsPOD: 4741 case UTT_IsLiteral: 4742 // Per the GCC type traits documentation, T shall be a complete type, cv void, 4743 // or an array of unknown bound. But GCC actually imposes the same constraints 4744 // as above. 4745 case UTT_HasNothrowAssign: 4746 case UTT_HasNothrowMoveAssign: 4747 case UTT_HasNothrowConstructor: 4748 case UTT_HasNothrowCopy: 4749 case UTT_HasTrivialAssign: 4750 case UTT_HasTrivialMoveAssign: 4751 case UTT_HasTrivialDefaultConstructor: 4752 case UTT_HasTrivialMoveConstructor: 4753 case UTT_HasTrivialCopy: 4754 case UTT_HasTrivialDestructor: 4755 case UTT_HasVirtualDestructor: 4756 ArgTy = QualType(ArgTy->getBaseElementTypeUnsafe(), 0); 4757 LLVM_FALLTHROUGH[[gnu::fallthrough]]; 4758 4759 // C++1z [meta.unary.prop]: 4760 // T shall be a complete type, cv void, or an array of unknown bound. 4761 case UTT_IsDestructible: 4762 case UTT_IsNothrowDestructible: 4763 case UTT_IsTriviallyDestructible: 4764 case UTT_HasUniqueObjectRepresentations: 4765 if (ArgTy->isIncompleteArrayType() || ArgTy->isVoidType()) 4766 return true; 4767 4768 return !S.RequireCompleteType( 4769 Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr); 4770 } 4771} 4772 4773static bool HasNoThrowOperator(const RecordType *RT, OverloadedOperatorKind Op, 4774 Sema &Self, SourceLocation KeyLoc, ASTContext &C, 4775 bool (CXXRecordDecl::*HasTrivial)() const, 4776 bool (CXXRecordDecl::*HasNonTrivial)() const, 4777 bool (CXXMethodDecl::*IsDesiredOp)() const) 4778{ 4779 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 4780 if ((RD->*HasTrivial)() && !(RD->*HasNonTrivial)()) 4781 return true; 4782 4783 DeclarationName Name = C.DeclarationNames.getCXXOperatorName(Op); 4784 DeclarationNameInfo NameInfo(Name, KeyLoc); 4785 LookupResult Res(Self, NameInfo, Sema::LookupOrdinaryName); 4786 if (Self.LookupQualifiedName(Res, RD)) { 4787 bool FoundOperator = false; 4788 Res.suppressDiagnostics(); 4789 for (LookupResult::iterator Op = Res.begin(), OpEnd = Res.end(); 4790 Op != OpEnd; ++Op) { 4791 if (isa<FunctionTemplateDecl>(*Op)) 4792 continue; 4793 4794 CXXMethodDecl *Operator = cast<CXXMethodDecl>(*Op); 4795 if((Operator->*IsDesiredOp)()) { 4796 FoundOperator = true; 4797 auto *CPT = Operator->getType()->castAs<FunctionProtoType>(); 4798 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT); 4799 if (!CPT || !CPT->isNothrow()) 4800 return false; 4801 } 4802 } 4803 return FoundOperator; 4804 } 4805 return false; 4806} 4807 4808static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT, 4809 SourceLocation KeyLoc, QualType T) { 4810 assert(!T->isDependentType() && "Cannot evaluate traits of dependent type")((void)0); 4811 4812 ASTContext &C = Self.Context; 4813 switch(UTT) { 4814 default: llvm_unreachable("not a UTT")__builtin_unreachable(); 4815 // Type trait expressions corresponding to the primary type category 4816 // predicates in C++0x [meta.unary.cat]. 4817 case UTT_IsVoid: 4818 return T->isVoidType(); 4819 case UTT_IsIntegral: 4820 return T->isIntegralType(C); 4821 case UTT_IsFloatingPoint: 4822 return T->isFloatingType(); 4823 case UTT_IsArray: 4824 return T->isArrayType(); 4825 case UTT_IsPointer: 4826 return T->isAnyPointerType(); 4827 case UTT_IsLvalueReference: 4828 return T->isLValueReferenceType(); 4829 case UTT_IsRvalueReference: 4830 return T->isRValueReferenceType(); 4831 case UTT_IsMemberFunctionPointer: 4832 return T->isMemberFunctionPointerType(); 4833 case UTT_IsMemberObjectPointer: 4834 return T->isMemberDataPointerType(); 4835 case UTT_IsEnum: 4836 return T->isEnumeralType(); 4837 case UTT_IsUnion: 4838 return T->isUnionType(); 4839 case UTT_IsClass: 4840 return T->isClassType() || T->isStructureType() || T->isInterfaceType(); 4841 case UTT_IsFunction: 4842 return T->isFunctionType(); 4843 4844 // Type trait expressions which correspond to the convenient composition 4845 // predicates in C++0x [meta.unary.comp]. 4846 case UTT_IsReference: 4847 return T->isReferenceType(); 4848 case UTT_IsArithmetic: 4849 return T->isArithmeticType() && !T->isEnumeralType(); 4850 case UTT_IsFundamental: 4851 return T->isFundamentalType(); 4852 case UTT_IsObject: 4853 return T->isObjectType(); 4854 case UTT_IsScalar: 4855 // Note: semantic analysis depends on Objective-C lifetime types to be 4856 // considered scalar types. However, such types do not actually behave 4857 // like scalar types at run time (since they may require retain/release 4858 // operations), so we report them as non-scalar. 4859 if (T->isObjCLifetimeType()) { 4860 switch (T.getObjCLifetime()) { 4861 case Qualifiers::OCL_None: 4862 case Qualifiers::OCL_ExplicitNone: 4863 return true; 4864 4865 case Qualifiers::OCL_Strong: 4866 case Qualifiers::OCL_Weak: 4867 case Qualifiers::OCL_Autoreleasing: 4868 return false; 4869 } 4870 } 4871 4872 return T->isScalarType(); 4873 case UTT_IsCompound: 4874 return T->isCompoundType(); 4875 case UTT_IsMemberPointer: 4876 return T->isMemberPointerType(); 4877 4878 // Type trait expressions which correspond to the type property predicates 4879 // in C++0x [meta.unary.prop]. 4880 case UTT_IsConst: 4881 return T.isConstQualified(); 4882 case UTT_IsVolatile: 4883 return T.isVolatileQualified(); 4884 case UTT_IsTrivial: 4885 return T.isTrivialType(C); 4886 case UTT_IsTriviallyCopyable: 4887 return T.isTriviallyCopyableType(C); 4888 case UTT_IsStandardLayout: 4889 return T->isStandardLayoutType(); 4890 case UTT_IsPOD: 4891 return T.isPODType(C); 4892 case UTT_IsLiteral: 4893 return T->isLiteralType(C); 4894 case UTT_IsEmpty: 4895 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 4896 return !RD->isUnion() && RD->isEmpty(); 4897 return false; 4898 case UTT_IsPolymorphic: 4899 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 4900 return !RD->isUnion() && RD->isPolymorphic(); 4901 return false; 4902 case UTT_IsAbstract: 4903 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 4904 return !RD->isUnion() && RD->isAbstract(); 4905 return false; 4906 case UTT_IsAggregate: 4907 // Report vector extensions and complex types as aggregates because they 4908 // support aggregate initialization. GCC mirrors this behavior for vectors 4909 // but not _Complex. 4910 return T->isAggregateType() || T->isVectorType() || T->isExtVectorType() || 4911 T->isAnyComplexType(); 4912 // __is_interface_class only returns true when CL is invoked in /CLR mode and 4913 // even then only when it is used with the 'interface struct ...' syntax 4914 // Clang doesn't support /CLR which makes this type trait moot. 4915 case UTT_IsInterfaceClass: 4916 return false; 4917 case UTT_IsFinal: 4918 case UTT_IsSealed: 4919 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 4920 return RD->hasAttr<FinalAttr>(); 4921 return false; 4922 case UTT_IsSigned: 4923 // Enum types should always return false. 4924 // Floating points should always return true. 4925 return T->isFloatingType() || 4926 (T->isSignedIntegerType() && !T->isEnumeralType()); 4927 case UTT_IsUnsigned: 4928 // Enum types should always return false. 4929 return T->isUnsignedIntegerType() && !T->isEnumeralType(); 4930 4931 // Type trait expressions which query classes regarding their construction, 4932 // destruction, and copying. Rather than being based directly on the 4933 // related type predicates in the standard, they are specified by both 4934 // GCC[1] and the Embarcadero C++ compiler[2], and Clang implements those 4935 // specifications. 4936 // 4937 // 1: http://gcc.gnu/.org/onlinedocs/gcc/Type-Traits.html 4938 // 2: http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index 4939 // 4940 // Note that these builtins do not behave as documented in g++: if a class 4941 // has both a trivial and a non-trivial special member of a particular kind, 4942 // they return false! For now, we emulate this behavior. 4943 // FIXME: This appears to be a g++ bug: more complex cases reveal that it 4944 // does not correctly compute triviality in the presence of multiple special 4945 // members of the same kind. Revisit this once the g++ bug is fixed. 4946 case UTT_HasTrivialDefaultConstructor: 4947 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 4948 // If __is_pod (type) is true then the trait is true, else if type is 4949 // a cv class or union type (or array thereof) with a trivial default 4950 // constructor ([class.ctor]) then the trait is true, else it is false. 4951 if (T.isPODType(C)) 4952 return true; 4953 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) 4954 return RD->hasTrivialDefaultConstructor() && 4955 !RD->hasNonTrivialDefaultConstructor(); 4956 return false; 4957 case UTT_HasTrivialMoveConstructor: 4958 // This trait is implemented by MSVC 2012 and needed to parse the 4959 // standard library headers. Specifically this is used as the logic 4960 // behind std::is_trivially_move_constructible (20.9.4.3). 4961 if (T.isPODType(C)) 4962 return true; 4963 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) 4964 return RD->hasTrivialMoveConstructor() && !RD->hasNonTrivialMoveConstructor(); 4965 return false; 4966 case UTT_HasTrivialCopy: 4967 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 4968 // If __is_pod (type) is true or type is a reference type then 4969 // the trait is true, else if type is a cv class or union type 4970 // with a trivial copy constructor ([class.copy]) then the trait 4971 // is true, else it is false. 4972 if (T.isPODType(C) || T->isReferenceType()) 4973 return true; 4974 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 4975 return RD->hasTrivialCopyConstructor() && 4976 !RD->hasNonTrivialCopyConstructor(); 4977 return false; 4978 case UTT_HasTrivialMoveAssign: 4979 // This trait is implemented by MSVC 2012 and needed to parse the 4980 // standard library headers. Specifically it is used as the logic 4981 // behind std::is_trivially_move_assignable (20.9.4.3) 4982 if (T.isPODType(C)) 4983 return true; 4984 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) 4985 return RD->hasTrivialMoveAssignment() && !RD->hasNonTrivialMoveAssignment(); 4986 return false; 4987 case UTT_HasTrivialAssign: 4988 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 4989 // If type is const qualified or is a reference type then the 4990 // trait is false. Otherwise if __is_pod (type) is true then the 4991 // trait is true, else if type is a cv class or union type with 4992 // a trivial copy assignment ([class.copy]) then the trait is 4993 // true, else it is false. 4994 // Note: the const and reference restrictions are interesting, 4995 // given that const and reference members don't prevent a class 4996 // from having a trivial copy assignment operator (but do cause 4997 // errors if the copy assignment operator is actually used, q.v. 4998 // [class.copy]p12). 4999 5000 if (T.isConstQualified()) 5001 return false; 5002 if (T.isPODType(C)) 5003 return true; 5004 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 5005 return RD->hasTrivialCopyAssignment() && 5006 !RD->hasNonTrivialCopyAssignment(); 5007 return false; 5008 case UTT_IsDestructible: 5009 case UTT_IsTriviallyDestructible: 5010 case UTT_IsNothrowDestructible: 5011 // C++14 [meta.unary.prop]: 5012 // For reference types, is_destructible<T>::value is true. 5013 if (T->isReferenceType()) 5014 return true; 5015 5016 // Objective-C++ ARC: autorelease types don't require destruction. 5017 if (T->isObjCLifetimeType() && 5018 T.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) 5019 return true; 5020 5021 // C++14 [meta.unary.prop]: 5022 // For incomplete types and function types, is_destructible<T>::value is 5023 // false. 5024 if (T->isIncompleteType() || T->isFunctionType()) 5025 return false; 5026 5027 // A type that requires destruction (via a non-trivial destructor or ARC 5028 // lifetime semantics) is not trivially-destructible. 5029 if (UTT == UTT_IsTriviallyDestructible && T.isDestructedType()) 5030 return false; 5031 5032 // C++14 [meta.unary.prop]: 5033 // For object types and given U equal to remove_all_extents_t<T>, if the 5034 // expression std::declval<U&>().~U() is well-formed when treated as an 5035 // unevaluated operand (Clause 5), then is_destructible<T>::value is true 5036 if (auto *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) { 5037 CXXDestructorDecl *Destructor = Self.LookupDestructor(RD); 5038 if (!Destructor) 5039 return false; 5040 // C++14 [dcl.fct.def.delete]p2: 5041 // A program that refers to a deleted function implicitly or 5042 // explicitly, other than to declare it, is ill-formed. 5043 if (Destructor->isDeleted()) 5044 return false; 5045 if (C.getLangOpts().AccessControl && Destructor->getAccess() != AS_public) 5046 return false; 5047 if (UTT == UTT_IsNothrowDestructible) { 5048 auto *CPT = Destructor->getType()->castAs<FunctionProtoType>(); 5049 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT); 5050 if (!CPT || !CPT->isNothrow()) 5051 return false; 5052 } 5053 } 5054 return true; 5055 5056 case UTT_HasTrivialDestructor: 5057 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html 5058 // If __is_pod (type) is true or type is a reference type 5059 // then the trait is true, else if type is a cv class or union 5060 // type (or array thereof) with a trivial destructor 5061 // ([class.dtor]) then the trait is true, else it is 5062 // false. 5063 if (T.isPODType(C) || T->isReferenceType()) 5064 return true; 5065 5066 // Objective-C++ ARC: autorelease types don't require destruction. 5067 if (T->isObjCLifetimeType() && 5068 T.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) 5069 return true; 5070 5071 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) 5072 return RD->hasTrivialDestructor(); 5073 return false; 5074 // TODO: Propagate nothrowness for implicitly declared special members. 5075 case UTT_HasNothrowAssign: 5076 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 5077 // If type is const qualified or is a reference type then the 5078 // trait is false. Otherwise if __has_trivial_assign (type) 5079 // is true then the trait is true, else if type is a cv class 5080 // or union type with copy assignment operators that are known 5081 // not to throw an exception then the trait is true, else it is 5082 // false. 5083 if (C.getBaseElementType(T).isConstQualified()) 5084 return false; 5085 if (T->isReferenceType()) 5086 return false; 5087 if (T.isPODType(C) || T->isObjCLifetimeType()) 5088 return true; 5089 5090 if (const RecordType *RT = T->getAs<RecordType>()) 5091 return HasNoThrowOperator(RT, OO_Equal, Self, KeyLoc, C, 5092 &CXXRecordDecl::hasTrivialCopyAssignment, 5093 &CXXRecordDecl::hasNonTrivialCopyAssignment, 5094 &CXXMethodDecl::isCopyAssignmentOperator); 5095 return false; 5096 case UTT_HasNothrowMoveAssign: 5097 // This trait is implemented by MSVC 2012 and needed to parse the 5098 // standard library headers. Specifically this is used as the logic 5099 // behind std::is_nothrow_move_assignable (20.9.4.3). 5100 if (T.isPODType(C)) 5101 return true; 5102 5103 if (const RecordType *RT = C.getBaseElementType(T)->getAs<RecordType>()) 5104 return HasNoThrowOperator(RT, OO_Equal, Self, KeyLoc, C, 5105 &CXXRecordDecl::hasTrivialMoveAssignment, 5106 &CXXRecordDecl::hasNonTrivialMoveAssignment, 5107 &CXXMethodDecl::isMoveAssignmentOperator); 5108 return false; 5109 case UTT_HasNothrowCopy: 5110 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 5111 // If __has_trivial_copy (type) is true then the trait is true, else 5112 // if type is a cv class or union type with copy constructors that are 5113 // known not to throw an exception then the trait is true, else it is 5114 // false. 5115 if (T.isPODType(C) || T->isReferenceType() || T->isObjCLifetimeType()) 5116 return true; 5117 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl()) { 5118 if (RD->hasTrivialCopyConstructor() && 5119 !RD->hasNonTrivialCopyConstructor()) 5120 return true; 5121 5122 bool FoundConstructor = false; 5123 unsigned FoundTQs; 5124 for (const auto *ND : Self.LookupConstructors(RD)) { 5125 // A template constructor is never a copy constructor. 5126 // FIXME: However, it may actually be selected at the actual overload 5127 // resolution point. 5128 if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl())) 5129 continue; 5130 // UsingDecl itself is not a constructor 5131 if (isa<UsingDecl>(ND)) 5132 continue; 5133 auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl()); 5134 if (Constructor->isCopyConstructor(FoundTQs)) { 5135 FoundConstructor = true; 5136 auto *CPT = Constructor->getType()->castAs<FunctionProtoType>(); 5137 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT); 5138 if (!CPT) 5139 return false; 5140 // TODO: check whether evaluating default arguments can throw. 5141 // For now, we'll be conservative and assume that they can throw. 5142 if (!CPT->isNothrow() || CPT->getNumParams() > 1) 5143 return false; 5144 } 5145 } 5146 5147 return FoundConstructor; 5148 } 5149 return false; 5150 case UTT_HasNothrowConstructor: 5151 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html 5152 // If __has_trivial_constructor (type) is true then the trait is 5153 // true, else if type is a cv class or union type (or array 5154 // thereof) with a default constructor that is known not to 5155 // throw an exception then the trait is true, else it is false. 5156 if (T.isPODType(C) || T->isObjCLifetimeType()) 5157 return true; 5158 if (CXXRecordDecl *RD = C.getBaseElementType(T)->getAsCXXRecordDecl()) { 5159 if (RD->hasTrivialDefaultConstructor() && 5160 !RD->hasNonTrivialDefaultConstructor()) 5161 return true; 5162 5163 bool FoundConstructor = false; 5164 for (const auto *ND : Self.LookupConstructors(RD)) { 5165 // FIXME: In C++0x, a constructor template can be a default constructor. 5166 if (isa<FunctionTemplateDecl>(ND->getUnderlyingDecl())) 5167 continue; 5168 // UsingDecl itself is not a constructor 5169 if (isa<UsingDecl>(ND)) 5170 continue; 5171 auto *Constructor = cast<CXXConstructorDecl>(ND->getUnderlyingDecl()); 5172 if (Constructor->isDefaultConstructor()) { 5173 FoundConstructor = true; 5174 auto *CPT = Constructor->getType()->castAs<FunctionProtoType>(); 5175 CPT = Self.ResolveExceptionSpec(KeyLoc, CPT); 5176 if (!CPT) 5177 return false; 5178 // FIXME: check whether evaluating default arguments can throw. 5179 // For now, we'll be conservative and assume that they can throw. 5180 if (!CPT->isNothrow() || CPT->getNumParams() > 0) 5181 return false; 5182 } 5183 } 5184 return FoundConstructor; 5185 } 5186 return false; 5187 case UTT_HasVirtualDestructor: 5188 // http://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html: 5189 // If type is a class type with a virtual destructor ([class.dtor]) 5190 // then the trait is true, else it is false. 5191 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 5192 if (CXXDestructorDecl *Destructor = Self.LookupDestructor(RD)) 5193 return Destructor->isVirtual(); 5194 return false; 5195 5196 // These type trait expressions are modeled on the specifications for the 5197 // Embarcadero C++0x type trait functions: 5198 // http://docwiki.embarcadero.com/RADStudio/XE/en/Type_Trait_Functions_(C%2B%2B0x)_Index 5199 case UTT_IsCompleteType: 5200 // http://docwiki.embarcadero.com/RADStudio/XE/en/Is_complete_type_(typename_T_): 5201 // Returns True if and only if T is a complete type at the point of the 5202 // function call. 5203 return !T->isIncompleteType(); 5204 case UTT_HasUniqueObjectRepresentations: 5205 return C.hasUniqueObjectRepresentations(T); 5206 } 5207} 5208 5209static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT, 5210 QualType RhsT, SourceLocation KeyLoc); 5211 5212static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc, 5213 ArrayRef<TypeSourceInfo *> Args, 5214 SourceLocation RParenLoc) { 5215 if (Kind <= UTT_Last) 5216 return EvaluateUnaryTypeTrait(S, Kind, KWLoc, Args[0]->getType()); 5217 5218 // Evaluate BTT_ReferenceBindsToTemporary alongside the IsConstructible 5219 // traits to avoid duplication. 5220 if (Kind <= BTT_Last && Kind != BTT_ReferenceBindsToTemporary) 5221 return EvaluateBinaryTypeTrait(S, Kind, Args[0]->getType(), 5222 Args[1]->getType(), RParenLoc); 5223 5224 switch (Kind) { 5225 case clang::BTT_ReferenceBindsToTemporary: 5226 case clang::TT_IsConstructible: 5227 case clang::TT_IsNothrowConstructible: 5228 case clang::TT_IsTriviallyConstructible: { 5229 // C++11 [meta.unary.prop]: 5230 // is_trivially_constructible is defined as: 5231 // 5232 // is_constructible<T, Args...>::value is true and the variable 5233 // definition for is_constructible, as defined below, is known to call 5234 // no operation that is not trivial. 5235 // 5236 // The predicate condition for a template specialization 5237 // is_constructible<T, Args...> shall be satisfied if and only if the 5238 // following variable definition would be well-formed for some invented 5239 // variable t: 5240 // 5241 // T t(create<Args>()...); 5242 assert(!Args.empty())((void)0); 5243 5244 // Precondition: T and all types in the parameter pack Args shall be 5245 // complete types, (possibly cv-qualified) void, or arrays of 5246 // unknown bound. 5247 for (const auto *TSI : Args) { 5248 QualType ArgTy = TSI->getType(); 5249 if (ArgTy->isVoidType() || ArgTy->isIncompleteArrayType()) 5250 continue; 5251 5252 if (S.RequireCompleteType(KWLoc, ArgTy, 5253 diag::err_incomplete_type_used_in_type_trait_expr)) 5254 return false; 5255 } 5256 5257 // Make sure the first argument is not incomplete nor a function type. 5258 QualType T = Args[0]->getType(); 5259 if (T->isIncompleteType() || T->isFunctionType()) 5260 return false; 5261 5262 // Make sure the first argument is not an abstract type. 5263 CXXRecordDecl *RD = T->getAsCXXRecordDecl(); 5264 if (RD && RD->isAbstract()) 5265 return false; 5266 5267 llvm::BumpPtrAllocator OpaqueExprAllocator; 5268 SmallVector<Expr *, 2> ArgExprs; 5269 ArgExprs.reserve(Args.size() - 1); 5270 for (unsigned I = 1, N = Args.size(); I != N; ++I) { 5271 QualType ArgTy = Args[I]->getType(); 5272 if (ArgTy->isObjectType() || ArgTy->isFunctionType()) 5273 ArgTy = S.Context.getRValueReferenceType(ArgTy); 5274 ArgExprs.push_back( 5275 new (OpaqueExprAllocator.Allocate<OpaqueValueExpr>()) 5276 OpaqueValueExpr(Args[I]->getTypeLoc().getBeginLoc(), 5277 ArgTy.getNonLValueExprType(S.Context), 5278 Expr::getValueKindForType(ArgTy))); 5279 } 5280 5281 // Perform the initialization in an unevaluated context within a SFINAE 5282 // trap at translation unit scope. 5283 EnterExpressionEvaluationContext Unevaluated( 5284 S, Sema::ExpressionEvaluationContext::Unevaluated); 5285 Sema::SFINAETrap SFINAE(S, /*AccessCheckingSFINAE=*/true); 5286 Sema::ContextRAII TUContext(S, S.Context.getTranslationUnitDecl()); 5287 InitializedEntity To(InitializedEntity::InitializeTemporary(Args[0])); 5288 InitializationKind InitKind(InitializationKind::CreateDirect(KWLoc, KWLoc, 5289 RParenLoc)); 5290 InitializationSequence Init(S, To, InitKind, ArgExprs); 5291 if (Init.Failed()) 5292 return false; 5293 5294 ExprResult Result = Init.Perform(S, To, InitKind, ArgExprs); 5295 if (Result.isInvalid() || SFINAE.hasErrorOccurred()) 5296 return false; 5297 5298 if (Kind == clang::TT_IsConstructible) 5299 return true; 5300 5301 if (Kind == clang::BTT_ReferenceBindsToTemporary) { 5302 if (!T->isReferenceType()) 5303 return false; 5304 5305 return !Init.isDirectReferenceBinding(); 5306 } 5307 5308 if (Kind == clang::TT_IsNothrowConstructible) 5309 return S.canThrow(Result.get()) == CT_Cannot; 5310 5311 if (Kind == clang::TT_IsTriviallyConstructible) { 5312 // Under Objective-C ARC and Weak, if the destination has non-trivial 5313 // Objective-C lifetime, this is a non-trivial construction. 5314 if (T.getNonReferenceType().hasNonTrivialObjCLifetime()) 5315 return false; 5316 5317 // The initialization succeeded; now make sure there are no non-trivial 5318 // calls. 5319 return !Result.get()->hasNonTrivialCall(S.Context); 5320 } 5321 5322 llvm_unreachable("unhandled type trait")__builtin_unreachable(); 5323 return false; 5324 } 5325 default: llvm_unreachable("not a TT")__builtin_unreachable(); 5326 } 5327 5328 return false; 5329} 5330 5331ExprResult Sema::BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc, 5332 ArrayRef<TypeSourceInfo *> Args, 5333 SourceLocation RParenLoc) { 5334 QualType ResultType = Context.getLogicalOperationType(); 5335 5336 if (Kind <= UTT_Last && !CheckUnaryTypeTraitTypeCompleteness( 5337 *this, Kind, KWLoc, Args[0]->getType())) 5338 return ExprError(); 5339 5340 bool Dependent = false; 5341 for (unsigned I = 0, N = Args.size(); I != N; ++I) { 5342 if (Args[I]->getType()->isDependentType()) { 5343 Dependent = true; 5344 break; 5345 } 5346 } 5347 5348 bool Result = false; 5349 if (!Dependent) 5350 Result = evaluateTypeTrait(*this, Kind, KWLoc, Args, RParenLoc); 5351 5352 return TypeTraitExpr::Create(Context, ResultType, KWLoc, Kind, Args, 5353 RParenLoc, Result); 5354} 5355 5356ExprResult Sema::ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc, 5357 ArrayRef<ParsedType> Args, 5358 SourceLocation RParenLoc) { 5359 SmallVector<TypeSourceInfo *, 4> ConvertedArgs; 5360 ConvertedArgs.reserve(Args.size()); 5361 5362 for (unsigned I = 0, N = Args.size(); I != N; ++I) { 5363 TypeSourceInfo *TInfo; 5364 QualType T = GetTypeFromParser(Args[I], &TInfo); 5365 if (!TInfo) 5366 TInfo = Context.getTrivialTypeSourceInfo(T, KWLoc); 5367 5368 ConvertedArgs.push_back(TInfo); 5369 } 5370 5371 return BuildTypeTrait(Kind, KWLoc, ConvertedArgs, RParenLoc); 5372} 5373 5374static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT, 5375 QualType RhsT, SourceLocation KeyLoc) { 5376 assert(!LhsT->isDependentType() && !RhsT->isDependentType() &&((void)0) 5377 "Cannot evaluate traits of dependent types")((void)0); 5378 5379 switch(BTT) { 5380 case BTT_IsBaseOf: { 5381 // C++0x [meta.rel]p2 5382 // Base is a base class of Derived without regard to cv-qualifiers or 5383 // Base and Derived are not unions and name the same class type without 5384 // regard to cv-qualifiers. 5385 5386 const RecordType *lhsRecord = LhsT->getAs<RecordType>(); 5387 const RecordType *rhsRecord = RhsT->getAs<RecordType>(); 5388 if (!rhsRecord || !lhsRecord) { 5389 const ObjCObjectType *LHSObjTy = LhsT->getAs<ObjCObjectType>(); 5390 const ObjCObjectType *RHSObjTy = RhsT->getAs<ObjCObjectType>(); 5391 if (!LHSObjTy || !RHSObjTy) 5392 return false; 5393 5394 ObjCInterfaceDecl *BaseInterface = LHSObjTy->getInterface(); 5395 ObjCInterfaceDecl *DerivedInterface = RHSObjTy->getInterface(); 5396 if (!BaseInterface || !DerivedInterface) 5397 return false; 5398 5399 if (Self.RequireCompleteType( 5400 KeyLoc, RhsT, diag::err_incomplete_type_used_in_type_trait_expr)) 5401 return false; 5402 5403 return BaseInterface->isSuperClassOf(DerivedInterface); 5404 } 5405 5406 assert(Self.Context.hasSameUnqualifiedType(LhsT, RhsT)((void)0) 5407 == (lhsRecord == rhsRecord))((void)0); 5408 5409 // Unions are never base classes, and never have base classes. 5410 // It doesn't matter if they are complete or not. See PR#41843 5411 if (lhsRecord && lhsRecord->getDecl()->isUnion()) 5412 return false; 5413 if (rhsRecord && rhsRecord->getDecl()->isUnion()) 5414 return false; 5415 5416 if (lhsRecord == rhsRecord) 5417 return true; 5418 5419 // C++0x [meta.rel]p2: 5420 // If Base and Derived are class types and are different types 5421 // (ignoring possible cv-qualifiers) then Derived shall be a 5422 // complete type. 5423 if (Self.RequireCompleteType(KeyLoc, RhsT, 5424 diag::err_incomplete_type_used_in_type_trait_expr)) 5425 return false; 5426 5427 return cast<CXXRecordDecl>(rhsRecord->getDecl()) 5428 ->isDerivedFrom(cast<CXXRecordDecl>(lhsRecord->getDecl())); 5429 } 5430 case BTT_IsSame: 5431 return Self.Context.hasSameType(LhsT, RhsT); 5432 case BTT_TypeCompatible: { 5433 // GCC ignores cv-qualifiers on arrays for this builtin. 5434 Qualifiers LhsQuals, RhsQuals; 5435 QualType Lhs = Self.getASTContext().getUnqualifiedArrayType(LhsT, LhsQuals); 5436 QualType Rhs = Self.getASTContext().getUnqualifiedArrayType(RhsT, RhsQuals); 5437 return Self.Context.typesAreCompatible(Lhs, Rhs); 5438 } 5439 case BTT_IsConvertible: 5440 case BTT_IsConvertibleTo: { 5441 // C++0x [meta.rel]p4: 5442 // Given the following function prototype: 5443 // 5444 // template <class T> 5445 // typename add_rvalue_reference<T>::type create(); 5446 // 5447 // the predicate condition for a template specialization 5448 // is_convertible<From, To> shall be satisfied if and only if 5449 // the return expression in the following code would be 5450 // well-formed, including any implicit conversions to the return 5451 // type of the function: 5452 // 5453 // To test() { 5454 // return create<From>(); 5455 // } 5456 // 5457 // Access checking is performed as if in a context unrelated to To and 5458 // From. Only the validity of the immediate context of the expression 5459 // of the return-statement (including conversions to the return type) 5460 // is considered. 5461 // 5462 // We model the initialization as a copy-initialization of a temporary 5463 // of the appropriate type, which for this expression is identical to the 5464 // return statement (since NRVO doesn't apply). 5465 5466 // Functions aren't allowed to return function or array types. 5467 if (RhsT->isFunctionType() || RhsT->isArrayType()) 5468 return false; 5469 5470 // A return statement in a void function must have void type. 5471 if (RhsT->isVoidType()) 5472 return LhsT->isVoidType(); 5473 5474 // A function definition requires a complete, non-abstract return type. 5475 if (!Self.isCompleteType(KeyLoc, RhsT) || Self.isAbstractType(KeyLoc, RhsT)) 5476 return false; 5477 5478 // Compute the result of add_rvalue_reference. 5479 if (LhsT->isObjectType() || LhsT->isFunctionType()) 5480 LhsT = Self.Context.getRValueReferenceType(LhsT); 5481 5482 // Build a fake source and destination for initialization. 5483 InitializedEntity To(InitializedEntity::InitializeTemporary(RhsT)); 5484 OpaqueValueExpr From(KeyLoc, LhsT.getNonLValueExprType(Self.Context), 5485 Expr::getValueKindForType(LhsT)); 5486 Expr *FromPtr = &From; 5487 InitializationKind Kind(InitializationKind::CreateCopy(KeyLoc, 5488 SourceLocation())); 5489 5490 // Perform the initialization in an unevaluated context within a SFINAE 5491 // trap at translation unit scope. 5492 EnterExpressionEvaluationContext Unevaluated( 5493 Self, Sema::ExpressionEvaluationContext::Unevaluated); 5494 Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true); 5495 Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl()); 5496 InitializationSequence Init(Self, To, Kind, FromPtr); 5497 if (Init.Failed()) 5498 return false; 5499 5500 ExprResult Result = Init.Perform(Self, To, Kind, FromPtr); 5501 return !Result.isInvalid() && !SFINAE.hasErrorOccurred(); 5502 } 5503 5504 case BTT_IsAssignable: 5505 case BTT_IsNothrowAssignable: 5506 case BTT_IsTriviallyAssignable: { 5507 // C++11 [meta.unary.prop]p3: 5508 // is_trivially_assignable is defined as: 5509 // is_assignable<T, U>::value is true and the assignment, as defined by 5510 // is_assignable, is known to call no operation that is not trivial 5511 // 5512 // is_assignable is defined as: 5513 // The expression declval<T>() = declval<U>() is well-formed when 5514 // treated as an unevaluated operand (Clause 5). 5515 // 5516 // For both, T and U shall be complete types, (possibly cv-qualified) 5517 // void, or arrays of unknown bound. 5518 if (!LhsT->isVoidType() && !LhsT->isIncompleteArrayType() && 5519 Self.RequireCompleteType(KeyLoc, LhsT, 5520 diag::err_incomplete_type_used_in_type_trait_expr)) 5521 return false; 5522 if (!RhsT->isVoidType() && !RhsT->isIncompleteArrayType() && 5523 Self.RequireCompleteType(KeyLoc, RhsT, 5524 diag::err_incomplete_type_used_in_type_trait_expr)) 5525 return false; 5526 5527 // cv void is never assignable. 5528 if (LhsT->isVoidType() || RhsT->isVoidType()) 5529 return false; 5530 5531 // Build expressions that emulate the effect of declval<T>() and 5532 // declval<U>(). 5533 if (LhsT->isObjectType() || LhsT->isFunctionType()) 5534 LhsT = Self.Context.getRValueReferenceType(LhsT); 5535 if (RhsT->isObjectType() || RhsT->isFunctionType()) 5536 RhsT = Self.Context.getRValueReferenceType(RhsT); 5537 OpaqueValueExpr Lhs(KeyLoc, LhsT.getNonLValueExprType(Self.Context), 5538 Expr::getValueKindForType(LhsT)); 5539 OpaqueValueExpr Rhs(KeyLoc, RhsT.getNonLValueExprType(Self.Context), 5540 Expr::getValueKindForType(RhsT)); 5541 5542 // Attempt the assignment in an unevaluated context within a SFINAE 5543 // trap at translation unit scope. 5544 EnterExpressionEvaluationContext Unevaluated( 5545 Self, Sema::ExpressionEvaluationContext::Unevaluated); 5546 Sema::SFINAETrap SFINAE(Self, /*AccessCheckingSFINAE=*/true); 5547 Sema::ContextRAII TUContext(Self, Self.Context.getTranslationUnitDecl()); 5548 ExprResult Result = Self.BuildBinOp(/*S=*/nullptr, KeyLoc, BO_Assign, &Lhs, 5549 &Rhs); 5550 if (Result.isInvalid()) 5551 return false; 5552 5553 // Treat the assignment as unused for the purpose of -Wdeprecated-volatile. 5554 Self.CheckUnusedVolatileAssignment(Result.get()); 5555 5556 if (SFINAE.hasErrorOccurred()) 5557 return false; 5558 5559 if (BTT == BTT_IsAssignable) 5560 return true; 5561 5562 if (BTT == BTT_IsNothrowAssignable) 5563 return Self.canThrow(Result.get()) == CT_Cannot; 5564 5565 if (BTT == BTT_IsTriviallyAssignable) { 5566 // Under Objective-C ARC and Weak, if the destination has non-trivial 5567 // Objective-C lifetime, this is a non-trivial assignment. 5568 if (LhsT.getNonReferenceType().hasNonTrivialObjCLifetime()) 5569 return false; 5570 5571 return !Result.get()->hasNonTrivialCall(Self.Context); 5572 } 5573 5574 llvm_unreachable("unhandled type trait")__builtin_unreachable(); 5575 return false; 5576 } 5577 default: llvm_unreachable("not a BTT")__builtin_unreachable(); 5578 } 5579 llvm_unreachable("Unknown type trait or not implemented")__builtin_unreachable(); 5580} 5581 5582ExprResult Sema::ActOnArrayTypeTrait(ArrayTypeTrait ATT, 5583 SourceLocation KWLoc, 5584 ParsedType Ty, 5585 Expr* DimExpr, 5586 SourceLocation RParen) { 5587 TypeSourceInfo *TSInfo; 5588 QualType T = GetTypeFromParser(Ty, &TSInfo); 5589 if (!TSInfo) 5590 TSInfo = Context.getTrivialTypeSourceInfo(T); 5591 5592 return BuildArrayTypeTrait(ATT, KWLoc, TSInfo, DimExpr, RParen); 5593} 5594 5595static uint64_t EvaluateArrayTypeTrait(Sema &Self, ArrayTypeTrait ATT, 5596 QualType T, Expr *DimExpr, 5597 SourceLocation KeyLoc) { 5598 assert(!T->isDependentType() && "Cannot evaluate traits of dependent type")((void)0); 5599 5600 switch(ATT) { 5601 case ATT_ArrayRank: 5602 if (T->isArrayType()) { 5603 unsigned Dim = 0; 5604 while (const ArrayType *AT = Self.Context.getAsArrayType(T)) { 5605 ++Dim; 5606 T = AT->getElementType(); 5607 } 5608 return Dim; 5609 } 5610 return 0; 5611 5612 case ATT_ArrayExtent: { 5613 llvm::APSInt Value; 5614 uint64_t Dim; 5615 if (Self.VerifyIntegerConstantExpression( 5616 DimExpr, &Value, diag::err_dimension_expr_not_constant_integer) 5617 .isInvalid()) 5618 return 0; 5619 if (Value.isSigned() && Value.isNegative()) { 5620 Self.Diag(KeyLoc, diag::err_dimension_expr_not_constant_integer) 5621 << DimExpr->getSourceRange(); 5622 return 0; 5623 } 5624 Dim = Value.getLimitedValue(); 5625 5626 if (T->isArrayType()) { 5627 unsigned D = 0; 5628 bool Matched = false; 5629 while (const ArrayType *AT = Self.Context.getAsArrayType(T)) { 5630 if (Dim == D) { 5631 Matched = true; 5632 break; 5633 } 5634 ++D; 5635 T = AT->getElementType(); 5636 } 5637 5638 if (Matched && T->isArrayType()) { 5639 if (const ConstantArrayType *CAT = Self.Context.getAsConstantArrayType(T)) 5640 return CAT->getSize().getLimitedValue(); 5641 } 5642 } 5643 return 0; 5644 } 5645 } 5646 llvm_unreachable("Unknown type trait or not implemented")__builtin_unreachable(); 5647} 5648 5649ExprResult Sema::BuildArrayTypeTrait(ArrayTypeTrait ATT, 5650 SourceLocation KWLoc, 5651 TypeSourceInfo *TSInfo, 5652 Expr* DimExpr, 5653 SourceLocation RParen) { 5654 QualType T = TSInfo->getType(); 5655 5656 // FIXME: This should likely be tracked as an APInt to remove any host 5657 // assumptions about the width of size_t on the target. 5658 uint64_t Value = 0; 5659 if (!T->isDependentType()) 5660 Value = EvaluateArrayTypeTrait(*this, ATT, T, DimExpr, KWLoc); 5661 5662 // While the specification for these traits from the Embarcadero C++ 5663 // compiler's documentation says the return type is 'unsigned int', Clang 5664 // returns 'size_t'. On Windows, the primary platform for the Embarcadero 5665 // compiler, there is no difference. On several other platforms this is an 5666 // important distinction. 5667 return new (Context) ArrayTypeTraitExpr(KWLoc, ATT, TSInfo, Value, DimExpr, 5668 RParen, Context.getSizeType()); 5669} 5670 5671ExprResult Sema::ActOnExpressionTrait(ExpressionTrait ET, 5672 SourceLocation KWLoc, 5673 Expr *Queried, 5674 SourceLocation RParen) { 5675 // If error parsing the expression, ignore. 5676 if (!Queried) 5677 return ExprError(); 5678 5679 ExprResult Result = BuildExpressionTrait(ET, KWLoc, Queried, RParen); 5680 5681 return Result; 5682} 5683 5684static bool EvaluateExpressionTrait(ExpressionTrait ET, Expr *E) { 5685 switch (ET) { 5686 case ET_IsLValueExpr: return E->isLValue(); 5687 case ET_IsRValueExpr: 5688 return E->isPRValue(); 5689 } 5690 llvm_unreachable("Expression trait not covered by switch")__builtin_unreachable(); 5691} 5692 5693ExprResult Sema::BuildExpressionTrait(ExpressionTrait ET, 5694 SourceLocation KWLoc, 5695 Expr *Queried, 5696 SourceLocation RParen) { 5697 if (Queried->isTypeDependent()) { 5698 // Delay type-checking for type-dependent expressions. 5699 } else if (Queried->getType()->isPlaceholderType()) { 5700 ExprResult PE = CheckPlaceholderExpr(Queried); 5701 if (PE.isInvalid()) return ExprError(); 5702 return BuildExpressionTrait(ET, KWLoc, PE.get(), RParen); 5703 } 5704 5705 bool Value = EvaluateExpressionTrait(ET, Queried); 5706 5707 return new (Context) 5708 ExpressionTraitExpr(KWLoc, ET, Queried, Value, RParen, Context.BoolTy); 5709} 5710 5711QualType Sema::CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS, 5712 ExprValueKind &VK, 5713 SourceLocation Loc, 5714 bool isIndirect) { 5715 assert(!LHS.get()->getType()->isPlaceholderType() &&((void)0) 5716 !RHS.get()->getType()->isPlaceholderType() &&((void)0) 5717 "placeholders should have been weeded out by now")((void)0); 5718 5719 // The LHS undergoes lvalue conversions if this is ->*, and undergoes the 5720 // temporary materialization conversion otherwise. 5721 if (isIndirect) 5722 LHS = DefaultLvalueConversion(LHS.get()); 5723 else if (LHS.get()->isPRValue()) 5724 LHS = TemporaryMaterializationConversion(LHS.get()); 5725 if (LHS.isInvalid()) 5726 return QualType(); 5727 5728 // The RHS always undergoes lvalue conversions. 5729 RHS = DefaultLvalueConversion(RHS.get()); 5730 if (RHS.isInvalid()) return QualType(); 5731 5732 const char *OpSpelling = isIndirect ? "->*" : ".*"; 5733 // C++ 5.5p2 5734 // The binary operator .* [p3: ->*] binds its second operand, which shall 5735 // be of type "pointer to member of T" (where T is a completely-defined 5736 // class type) [...] 5737 QualType RHSType = RHS.get()->getType(); 5738 const MemberPointerType *MemPtr = RHSType->getAs<MemberPointerType>(); 5739 if (!MemPtr) { 5740 Diag(Loc, diag::err_bad_memptr_rhs) 5741 << OpSpelling << RHSType << RHS.get()->getSourceRange(); 5742 return QualType(); 5743 } 5744 5745 QualType Class(MemPtr->getClass(), 0); 5746 5747 // Note: C++ [expr.mptr.oper]p2-3 says that the class type into which the 5748 // member pointer points must be completely-defined. However, there is no 5749 // reason for this semantic distinction, and the rule is not enforced by 5750 // other compilers. Therefore, we do not check this property, as it is 5751 // likely to be considered a defect. 5752 5753 // C++ 5.5p2 5754 // [...] to its first operand, which shall be of class T or of a class of 5755 // which T is an unambiguous and accessible base class. [p3: a pointer to 5756 // such a class] 5757 QualType LHSType = LHS.get()->getType(); 5758 if (isIndirect) { 5759 if (const PointerType *Ptr = LHSType->getAs<PointerType>()) 5760 LHSType = Ptr->getPointeeType(); 5761 else { 5762 Diag(Loc, diag::err_bad_memptr_lhs) 5763 << OpSpelling << 1 << LHSType 5764 << FixItHint::CreateReplacement(SourceRange(Loc), ".*"); 5765 return QualType(); 5766 } 5767 } 5768 5769 if (!Context.hasSameUnqualifiedType(Class, LHSType)) { 5770 // If we want to check the hierarchy, we need a complete type. 5771 if (RequireCompleteType(Loc, LHSType, diag::err_bad_memptr_lhs, 5772 OpSpelling, (int)isIndirect)) { 5773 return QualType(); 5774 } 5775 5776 if (!IsDerivedFrom(Loc, LHSType, Class)) { 5777 Diag(Loc, diag::err_bad_memptr_lhs) << OpSpelling 5778 << (int)isIndirect << LHS.get()->getType(); 5779 return QualType(); 5780 } 5781 5782 CXXCastPath BasePath; 5783 if (CheckDerivedToBaseConversion( 5784 LHSType, Class, Loc, 5785 SourceRange(LHS.get()->getBeginLoc(), RHS.get()->getEndLoc()), 5786 &BasePath)) 5787 return QualType(); 5788 5789 // Cast LHS to type of use. 5790 QualType UseType = Context.getQualifiedType(Class, LHSType.getQualifiers()); 5791 if (isIndirect) 5792 UseType = Context.getPointerType(UseType); 5793 ExprValueKind VK = isIndirect ? VK_PRValue : LHS.get()->getValueKind(); 5794 LHS = ImpCastExprToType(LHS.get(), UseType, CK_DerivedToBase, VK, 5795 &BasePath); 5796 } 5797 5798 if (isa<CXXScalarValueInitExpr>(RHS.get()->IgnoreParens())) { 5799 // Diagnose use of pointer-to-member type which when used as 5800 // the functional cast in a pointer-to-member expression. 5801 Diag(Loc, diag::err_pointer_to_member_type) << isIndirect; 5802 return QualType(); 5803 } 5804 5805 // C++ 5.5p2 5806 // The result is an object or a function of the type specified by the 5807 // second operand. 5808 // The cv qualifiers are the union of those in the pointer and the left side, 5809 // in accordance with 5.5p5 and 5.2.5. 5810 QualType Result = MemPtr->getPointeeType(); 5811 Result = Context.getCVRQualifiedType(Result, LHSType.getCVRQualifiers()); 5812 5813 // C++0x [expr.mptr.oper]p6: 5814 // In a .* expression whose object expression is an rvalue, the program is 5815 // ill-formed if the second operand is a pointer to member function with 5816 // ref-qualifier &. In a ->* expression or in a .* expression whose object 5817 // expression is an lvalue, the program is ill-formed if the second operand 5818 // is a pointer to member function with ref-qualifier &&. 5819 if (const FunctionProtoType *Proto = Result->getAs<FunctionProtoType>()) { 5820 switch (Proto->getRefQualifier()) { 5821 case RQ_None: 5822 // Do nothing 5823 break; 5824 5825 case RQ_LValue: 5826 if (!isIndirect && !LHS.get()->Classify(Context).isLValue()) { 5827 // C++2a allows functions with ref-qualifier & if their cv-qualifier-seq 5828 // is (exactly) 'const'. 5829 if (Proto->isConst() && !Proto->isVolatile()) 5830 Diag(Loc, getLangOpts().CPlusPlus20 5831 ? diag::warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue 5832 : diag::ext_pointer_to_const_ref_member_on_rvalue); 5833 else 5834 Diag(Loc, diag::err_pointer_to_member_oper_value_classify) 5835 << RHSType << 1 << LHS.get()->getSourceRange(); 5836 } 5837 break; 5838 5839 case RQ_RValue: 5840 if (isIndirect || !LHS.get()->Classify(Context).isRValue()) 5841 Diag(Loc, diag::err_pointer_to_member_oper_value_classify) 5842 << RHSType << 0 << LHS.get()->getSourceRange(); 5843 break; 5844 } 5845 } 5846 5847 // C++ [expr.mptr.oper]p6: 5848 // The result of a .* expression whose second operand is a pointer 5849 // to a data member is of the same value category as its 5850 // first operand. The result of a .* expression whose second 5851 // operand is a pointer to a member function is a prvalue. The 5852 // result of an ->* expression is an lvalue if its second operand 5853 // is a pointer to data member and a prvalue otherwise. 5854 if (Result->isFunctionType()) { 5855 VK = VK_PRValue; 5856 return Context.BoundMemberTy; 5857 } else if (isIndirect) { 5858 VK = VK_LValue; 5859 } else { 5860 VK = LHS.get()->getValueKind(); 5861 } 5862 5863 return Result; 5864} 5865 5866/// Try to convert a type to another according to C++11 5.16p3. 5867/// 5868/// This is part of the parameter validation for the ? operator. If either 5869/// value operand is a class type, the two operands are attempted to be 5870/// converted to each other. This function does the conversion in one direction. 5871/// It returns true if the program is ill-formed and has already been diagnosed 5872/// as such. 5873static bool TryClassUnification(Sema &Self, Expr *From, Expr *To, 5874 SourceLocation QuestionLoc, 5875 bool &HaveConversion, 5876 QualType &ToType) { 5877 HaveConversion = false; 5878 ToType = To->getType(); 5879 5880 InitializationKind Kind = 5881 InitializationKind::CreateCopy(To->getBeginLoc(), SourceLocation()); 5882 // C++11 5.16p3 5883 // The process for determining whether an operand expression E1 of type T1 5884 // can be converted to match an operand expression E2 of type T2 is defined 5885 // as follows: 5886 // -- If E2 is an lvalue: E1 can be converted to match E2 if E1 can be 5887 // implicitly converted to type "lvalue reference to T2", subject to the 5888 // constraint that in the conversion the reference must bind directly to 5889 // an lvalue. 5890 // -- If E2 is an xvalue: E1 can be converted to match E2 if E1 can be 5891 // implicitly converted to the type "rvalue reference to R2", subject to 5892 // the constraint that the reference must bind directly. 5893 if (To->isLValue() || To->isXValue()) { 5894 QualType T = To->isLValue() ? Self.Context.getLValueReferenceType(ToType) 5895 : Self.Context.getRValueReferenceType(ToType); 5896 5897 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 5898 5899 InitializationSequence InitSeq(Self, Entity, Kind, From); 5900 if (InitSeq.isDirectReferenceBinding()) { 5901 ToType = T; 5902 HaveConversion = true; 5903 return false; 5904 } 5905 5906 if (InitSeq.isAmbiguous()) 5907 return InitSeq.Diagnose(Self, Entity, Kind, From); 5908 } 5909 5910 // -- If E2 is an rvalue, or if the conversion above cannot be done: 5911 // -- if E1 and E2 have class type, and the underlying class types are 5912 // the same or one is a base class of the other: 5913 QualType FTy = From->getType(); 5914 QualType TTy = To->getType(); 5915 const RecordType *FRec = FTy->getAs<RecordType>(); 5916 const RecordType *TRec = TTy->getAs<RecordType>(); 5917 bool FDerivedFromT = FRec && TRec && FRec != TRec && 5918 Self.IsDerivedFrom(QuestionLoc, FTy, TTy); 5919 if (FRec && TRec && (FRec == TRec || FDerivedFromT || 5920 Self.IsDerivedFrom(QuestionLoc, TTy, FTy))) { 5921 // E1 can be converted to match E2 if the class of T2 is the 5922 // same type as, or a base class of, the class of T1, and 5923 // [cv2 > cv1]. 5924 if (FRec == TRec || FDerivedFromT) { 5925 if (TTy.isAtLeastAsQualifiedAs(FTy)) { 5926 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 5927 InitializationSequence InitSeq(Self, Entity, Kind, From); 5928 if (InitSeq) { 5929 HaveConversion = true; 5930 return false; 5931 } 5932 5933 if (InitSeq.isAmbiguous()) 5934 return InitSeq.Diagnose(Self, Entity, Kind, From); 5935 } 5936 } 5937 5938 return false; 5939 } 5940 5941 // -- Otherwise: E1 can be converted to match E2 if E1 can be 5942 // implicitly converted to the type that expression E2 would have 5943 // if E2 were converted to an rvalue (or the type it has, if E2 is 5944 // an rvalue). 5945 // 5946 // This actually refers very narrowly to the lvalue-to-rvalue conversion, not 5947 // to the array-to-pointer or function-to-pointer conversions. 5948 TTy = TTy.getNonLValueExprType(Self.Context); 5949 5950 InitializedEntity Entity = InitializedEntity::InitializeTemporary(TTy); 5951 InitializationSequence InitSeq(Self, Entity, Kind, From); 5952 HaveConversion = !InitSeq.Failed(); 5953 ToType = TTy; 5954 if (InitSeq.isAmbiguous()) 5955 return InitSeq.Diagnose(Self, Entity, Kind, From); 5956 5957 return false; 5958} 5959 5960/// Try to find a common type for two according to C++0x 5.16p5. 5961/// 5962/// This is part of the parameter validation for the ? operator. If either 5963/// value operand is a class type, overload resolution is used to find a 5964/// conversion to a common type. 5965static bool FindConditionalOverload(Sema &Self, ExprResult &LHS, ExprResult &RHS, 5966 SourceLocation QuestionLoc) { 5967 Expr *Args[2] = { LHS.get(), RHS.get() }; 5968 OverloadCandidateSet CandidateSet(QuestionLoc, 5969 OverloadCandidateSet::CSK_Operator); 5970 Self.AddBuiltinOperatorCandidates(OO_Conditional, QuestionLoc, Args, 5971 CandidateSet); 5972 5973 OverloadCandidateSet::iterator Best; 5974 switch (CandidateSet.BestViableFunction(Self, QuestionLoc, Best)) { 5975 case OR_Success: { 5976 // We found a match. Perform the conversions on the arguments and move on. 5977 ExprResult LHSRes = Self.PerformImplicitConversion( 5978 LHS.get(), Best->BuiltinParamTypes[0], Best->Conversions[0], 5979 Sema::AA_Converting); 5980 if (LHSRes.isInvalid()) 5981 break; 5982 LHS = LHSRes; 5983 5984 ExprResult RHSRes = Self.PerformImplicitConversion( 5985 RHS.get(), Best->BuiltinParamTypes[1], Best->Conversions[1], 5986 Sema::AA_Converting); 5987 if (RHSRes.isInvalid()) 5988 break; 5989 RHS = RHSRes; 5990 if (Best->Function) 5991 Self.MarkFunctionReferenced(QuestionLoc, Best->Function); 5992 return false; 5993 } 5994 5995 case OR_No_Viable_Function: 5996 5997 // Emit a better diagnostic if one of the expressions is a null pointer 5998 // constant and the other is a pointer type. In this case, the user most 5999 // likely forgot to take the address of the other expression. 6000 if (Self.DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc)) 6001 return true; 6002 6003 Self.Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 6004 << LHS.get()->getType() << RHS.get()->getType() 6005 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6006 return true; 6007 6008 case OR_Ambiguous: 6009 Self.Diag(QuestionLoc, diag::err_conditional_ambiguous_ovl) 6010 << LHS.get()->getType() << RHS.get()->getType() 6011 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6012 // FIXME: Print the possible common types by printing the return types of 6013 // the viable candidates. 6014 break; 6015 6016 case OR_Deleted: 6017 llvm_unreachable("Conditional operator has only built-in overloads")__builtin_unreachable(); 6018 } 6019 return true; 6020} 6021 6022/// Perform an "extended" implicit conversion as returned by 6023/// TryClassUnification. 6024static bool ConvertForConditional(Sema &Self, ExprResult &E, QualType T) { 6025 InitializedEntity Entity = InitializedEntity::InitializeTemporary(T); 6026 InitializationKind Kind = 6027 InitializationKind::CreateCopy(E.get()->getBeginLoc(), SourceLocation()); 6028 Expr *Arg = E.get(); 6029 InitializationSequence InitSeq(Self, Entity, Kind, Arg); 6030 ExprResult Result = InitSeq.Perform(Self, Entity, Kind, Arg); 6031 if (Result.isInvalid()) 6032 return true; 6033 6034 E = Result; 6035 return false; 6036} 6037 6038// Check the condition operand of ?: to see if it is valid for the GCC 6039// extension. 6040static bool isValidVectorForConditionalCondition(ASTContext &Ctx, 6041 QualType CondTy) { 6042 if (!CondTy->isVectorType() && !CondTy->isExtVectorType()) 6043 return false; 6044 const QualType EltTy = 6045 cast<VectorType>(CondTy.getCanonicalType())->getElementType(); 6046 assert(!EltTy->isBooleanType() && !EltTy->isEnumeralType() &&((void)0) 6047 "Vectors cant be boolean or enum types")((void)0); 6048 return EltTy->isIntegralType(Ctx); 6049} 6050 6051QualType Sema::CheckVectorConditionalTypes(ExprResult &Cond, ExprResult &LHS, 6052 ExprResult &RHS, 6053 SourceLocation QuestionLoc) { 6054 LHS = DefaultFunctionArrayLvalueConversion(LHS.get()); 6055 RHS = DefaultFunctionArrayLvalueConversion(RHS.get()); 6056 6057 QualType CondType = Cond.get()->getType(); 6058 const auto *CondVT = CondType->castAs<VectorType>(); 6059 QualType CondElementTy = CondVT->getElementType(); 6060 unsigned CondElementCount = CondVT->getNumElements(); 6061 QualType LHSType = LHS.get()->getType(); 6062 const auto *LHSVT = LHSType->getAs<VectorType>(); 6063 QualType RHSType = RHS.get()->getType(); 6064 const auto *RHSVT = RHSType->getAs<VectorType>(); 6065 6066 QualType ResultType; 6067 6068 6069 if (LHSVT && RHSVT) { 6070 if (isa<ExtVectorType>(CondVT) != isa<ExtVectorType>(LHSVT)) { 6071 Diag(QuestionLoc, diag::err_conditional_vector_cond_result_mismatch) 6072 << /*isExtVector*/ isa<ExtVectorType>(CondVT); 6073 return {}; 6074 } 6075 6076 // If both are vector types, they must be the same type. 6077 if (!Context.hasSameType(LHSType, RHSType)) { 6078 Diag(QuestionLoc, diag::err_conditional_vector_mismatched) 6079 << LHSType << RHSType; 6080 return {}; 6081 } 6082 ResultType = LHSType; 6083 } else if (LHSVT || RHSVT) { 6084 ResultType = CheckVectorOperands( 6085 LHS, RHS, QuestionLoc, /*isCompAssign*/ false, /*AllowBothBool*/ true, 6086 /*AllowBoolConversions*/ false); 6087 if (ResultType.isNull()) 6088 return {}; 6089 } else { 6090 // Both are scalar. 6091 QualType ResultElementTy; 6092 LHSType = LHSType.getCanonicalType().getUnqualifiedType(); 6093 RHSType = RHSType.getCanonicalType().getUnqualifiedType(); 6094 6095 if (Context.hasSameType(LHSType, RHSType)) 6096 ResultElementTy = LHSType; 6097 else 6098 ResultElementTy = 6099 UsualArithmeticConversions(LHS, RHS, QuestionLoc, ACK_Conditional); 6100 6101 if (ResultElementTy->isEnumeralType()) { 6102 Diag(QuestionLoc, diag::err_conditional_vector_operand_type) 6103 << ResultElementTy; 6104 return {}; 6105 } 6106 if (CondType->isExtVectorType()) 6107 ResultType = 6108 Context.getExtVectorType(ResultElementTy, CondVT->getNumElements()); 6109 else 6110 ResultType = Context.getVectorType( 6111 ResultElementTy, CondVT->getNumElements(), VectorType::GenericVector); 6112 6113 LHS = ImpCastExprToType(LHS.get(), ResultType, CK_VectorSplat); 6114 RHS = ImpCastExprToType(RHS.get(), ResultType, CK_VectorSplat); 6115 } 6116 6117 assert(!ResultType.isNull() && ResultType->isVectorType() &&((void)0) 6118 (!CondType->isExtVectorType() || ResultType->isExtVectorType()) &&((void)0) 6119 "Result should have been a vector type")((void)0); 6120 auto *ResultVectorTy = ResultType->castAs<VectorType>(); 6121 QualType ResultElementTy = ResultVectorTy->getElementType(); 6122 unsigned ResultElementCount = ResultVectorTy->getNumElements(); 6123 6124 if (ResultElementCount != CondElementCount) { 6125 Diag(QuestionLoc, diag::err_conditional_vector_size) << CondType 6126 << ResultType; 6127 return {}; 6128 } 6129 6130 if (Context.getTypeSize(ResultElementTy) != 6131 Context.getTypeSize(CondElementTy)) { 6132 Diag(QuestionLoc, diag::err_conditional_vector_element_size) << CondType 6133 << ResultType; 6134 return {}; 6135 } 6136 6137 return ResultType; 6138} 6139 6140/// Check the operands of ?: under C++ semantics. 6141/// 6142/// See C++ [expr.cond]. Note that LHS is never null, even for the GNU x ?: y 6143/// extension. In this case, LHS == Cond. (But they're not aliases.) 6144/// 6145/// This function also implements GCC's vector extension and the 6146/// OpenCL/ext_vector_type extension for conditionals. The vector extensions 6147/// permit the use of a?b:c where the type of a is that of a integer vector with 6148/// the same number of elements and size as the vectors of b and c. If one of 6149/// either b or c is a scalar it is implicitly converted to match the type of 6150/// the vector. Otherwise the expression is ill-formed. If both b and c are 6151/// scalars, then b and c are checked and converted to the type of a if 6152/// possible. 6153/// 6154/// The expressions are evaluated differently for GCC's and OpenCL's extensions. 6155/// For the GCC extension, the ?: operator is evaluated as 6156/// (a[0] != 0 ? b[0] : c[0], .. , a[n] != 0 ? b[n] : c[n]). 6157/// For the OpenCL extensions, the ?: operator is evaluated as 6158/// (most-significant-bit-set(a[0]) ? b[0] : c[0], .. , 6159/// most-significant-bit-set(a[n]) ? b[n] : c[n]). 6160QualType Sema::CXXCheckConditionalOperands(ExprResult &Cond, ExprResult &LHS, 6161 ExprResult &RHS, ExprValueKind &VK, 6162 ExprObjectKind &OK, 6163 SourceLocation QuestionLoc) { 6164 // FIXME: Handle C99's complex types, block pointers and Obj-C++ interface 6165 // pointers. 6166 6167 // Assume r-value. 6168 VK = VK_PRValue; 6169 OK = OK_Ordinary; 6170 bool IsVectorConditional = 6171 isValidVectorForConditionalCondition(Context, Cond.get()->getType()); 6172 6173 // C++11 [expr.cond]p1 6174 // The first expression is contextually converted to bool. 6175 if (!Cond.get()->isTypeDependent()) { 6176 ExprResult CondRes = IsVectorConditional 6177 ? DefaultFunctionArrayLvalueConversion(Cond.get()) 6178 : CheckCXXBooleanCondition(Cond.get()); 6179 if (CondRes.isInvalid()) 6180 return QualType(); 6181 Cond = CondRes; 6182 } else { 6183 // To implement C++, the first expression typically doesn't alter the result 6184 // type of the conditional, however the GCC compatible vector extension 6185 // changes the result type to be that of the conditional. Since we cannot 6186 // know if this is a vector extension here, delay the conversion of the 6187 // LHS/RHS below until later. 6188 return Context.DependentTy; 6189 } 6190 6191 6192 // Either of the arguments dependent? 6193 if (LHS.get()->isTypeDependent() || RHS.get()->isTypeDependent()) 6194 return Context.DependentTy; 6195 6196 // C++11 [expr.cond]p2 6197 // If either the second or the third operand has type (cv) void, ... 6198 QualType LTy = LHS.get()->getType(); 6199 QualType RTy = RHS.get()->getType(); 6200 bool LVoid = LTy->isVoidType(); 6201 bool RVoid = RTy->isVoidType(); 6202 if (LVoid || RVoid) { 6203 // ... one of the following shall hold: 6204 // -- The second or the third operand (but not both) is a (possibly 6205 // parenthesized) throw-expression; the result is of the type 6206 // and value category of the other. 6207 bool LThrow = isa<CXXThrowExpr>(LHS.get()->IgnoreParenImpCasts()); 6208 bool RThrow = isa<CXXThrowExpr>(RHS.get()->IgnoreParenImpCasts()); 6209 6210 // Void expressions aren't legal in the vector-conditional expressions. 6211 if (IsVectorConditional) { 6212 SourceRange DiagLoc = 6213 LVoid ? LHS.get()->getSourceRange() : RHS.get()->getSourceRange(); 6214 bool IsThrow = LVoid ? LThrow : RThrow; 6215 Diag(DiagLoc.getBegin(), diag::err_conditional_vector_has_void) 6216 << DiagLoc << IsThrow; 6217 return QualType(); 6218 } 6219 6220 if (LThrow != RThrow) { 6221 Expr *NonThrow = LThrow ? RHS.get() : LHS.get(); 6222 VK = NonThrow->getValueKind(); 6223 // DR (no number yet): the result is a bit-field if the 6224 // non-throw-expression operand is a bit-field. 6225 OK = NonThrow->getObjectKind(); 6226 return NonThrow->getType(); 6227 } 6228 6229 // -- Both the second and third operands have type void; the result is of 6230 // type void and is a prvalue. 6231 if (LVoid && RVoid) 6232 return Context.VoidTy; 6233 6234 // Neither holds, error. 6235 Diag(QuestionLoc, diag::err_conditional_void_nonvoid) 6236 << (LVoid ? RTy : LTy) << (LVoid ? 0 : 1) 6237 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6238 return QualType(); 6239 } 6240 6241 // Neither is void. 6242 if (IsVectorConditional) 6243 return CheckVectorConditionalTypes(Cond, LHS, RHS, QuestionLoc); 6244 6245 // C++11 [expr.cond]p3 6246 // Otherwise, if the second and third operand have different types, and 6247 // either has (cv) class type [...] an attempt is made to convert each of 6248 // those operands to the type of the other. 6249 if (!Context.hasSameType(LTy, RTy) && 6250 (LTy->isRecordType() || RTy->isRecordType())) { 6251 // These return true if a single direction is already ambiguous. 6252 QualType L2RType, R2LType; 6253 bool HaveL2R, HaveR2L; 6254 if (TryClassUnification(*this, LHS.get(), RHS.get(), QuestionLoc, HaveL2R, L2RType)) 6255 return QualType(); 6256 if (TryClassUnification(*this, RHS.get(), LHS.get(), QuestionLoc, HaveR2L, R2LType)) 6257 return QualType(); 6258 6259 // If both can be converted, [...] the program is ill-formed. 6260 if (HaveL2R && HaveR2L) { 6261 Diag(QuestionLoc, diag::err_conditional_ambiguous) 6262 << LTy << RTy << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6263 return QualType(); 6264 } 6265 6266 // If exactly one conversion is possible, that conversion is applied to 6267 // the chosen operand and the converted operands are used in place of the 6268 // original operands for the remainder of this section. 6269 if (HaveL2R) { 6270 if (ConvertForConditional(*this, LHS, L2RType) || LHS.isInvalid()) 6271 return QualType(); 6272 LTy = LHS.get()->getType(); 6273 } else if (HaveR2L) { 6274 if (ConvertForConditional(*this, RHS, R2LType) || RHS.isInvalid()) 6275 return QualType(); 6276 RTy = RHS.get()->getType(); 6277 } 6278 } 6279 6280 // C++11 [expr.cond]p3 6281 // if both are glvalues of the same value category and the same type except 6282 // for cv-qualification, an attempt is made to convert each of those 6283 // operands to the type of the other. 6284 // FIXME: 6285 // Resolving a defect in P0012R1: we extend this to cover all cases where 6286 // one of the operands is reference-compatible with the other, in order 6287 // to support conditionals between functions differing in noexcept. This 6288 // will similarly cover difference in array bounds after P0388R4. 6289 // FIXME: If LTy and RTy have a composite pointer type, should we convert to 6290 // that instead? 6291 ExprValueKind LVK = LHS.get()->getValueKind(); 6292 ExprValueKind RVK = RHS.get()->getValueKind(); 6293 if (!Context.hasSameType(LTy, RTy) && LVK == RVK && LVK != VK_PRValue) { 6294 // DerivedToBase was already handled by the class-specific case above. 6295 // FIXME: Should we allow ObjC conversions here? 6296 const ReferenceConversions AllowedConversions = 6297 ReferenceConversions::Qualification | 6298 ReferenceConversions::NestedQualification | 6299 ReferenceConversions::Function; 6300 6301 ReferenceConversions RefConv; 6302 if (CompareReferenceRelationship(QuestionLoc, LTy, RTy, &RefConv) == 6303 Ref_Compatible && 6304 !(RefConv & ~AllowedConversions) && 6305 // [...] subject to the constraint that the reference must bind 6306 // directly [...] 6307 !RHS.get()->refersToBitField() && !RHS.get()->refersToVectorElement()) { 6308 RHS = ImpCastExprToType(RHS.get(), LTy, CK_NoOp, RVK); 6309 RTy = RHS.get()->getType(); 6310 } else if (CompareReferenceRelationship(QuestionLoc, RTy, LTy, &RefConv) == 6311 Ref_Compatible && 6312 !(RefConv & ~AllowedConversions) && 6313 !LHS.get()->refersToBitField() && 6314 !LHS.get()->refersToVectorElement()) { 6315 LHS = ImpCastExprToType(LHS.get(), RTy, CK_NoOp, LVK); 6316 LTy = LHS.get()->getType(); 6317 } 6318 } 6319 6320 // C++11 [expr.cond]p4 6321 // If the second and third operands are glvalues of the same value 6322 // category and have the same type, the result is of that type and 6323 // value category and it is a bit-field if the second or the third 6324 // operand is a bit-field, or if both are bit-fields. 6325 // We only extend this to bitfields, not to the crazy other kinds of 6326 // l-values. 6327 bool Same = Context.hasSameType(LTy, RTy); 6328 if (Same && LVK == RVK && LVK != VK_PRValue && 6329 LHS.get()->isOrdinaryOrBitFieldObject() && 6330 RHS.get()->isOrdinaryOrBitFieldObject()) { 6331 VK = LHS.get()->getValueKind(); 6332 if (LHS.get()->getObjectKind() == OK_BitField || 6333 RHS.get()->getObjectKind() == OK_BitField) 6334 OK = OK_BitField; 6335 6336 // If we have function pointer types, unify them anyway to unify their 6337 // exception specifications, if any. 6338 if (LTy->isFunctionPointerType() || LTy->isMemberFunctionPointerType()) { 6339 Qualifiers Qs = LTy.getQualifiers(); 6340 LTy = FindCompositePointerType(QuestionLoc, LHS, RHS, 6341 /*ConvertArgs*/false); 6342 LTy = Context.getQualifiedType(LTy, Qs); 6343 6344 assert(!LTy.isNull() && "failed to find composite pointer type for "((void)0) 6345 "canonically equivalent function ptr types")((void)0); 6346 assert(Context.hasSameType(LTy, RTy) && "bad composite pointer type")((void)0); 6347 } 6348 6349 return LTy; 6350 } 6351 6352 // C++11 [expr.cond]p5 6353 // Otherwise, the result is a prvalue. If the second and third operands 6354 // do not have the same type, and either has (cv) class type, ... 6355 if (!Same && (LTy->isRecordType() || RTy->isRecordType())) { 6356 // ... overload resolution is used to determine the conversions (if any) 6357 // to be applied to the operands. If the overload resolution fails, the 6358 // program is ill-formed. 6359 if (FindConditionalOverload(*this, LHS, RHS, QuestionLoc)) 6360 return QualType(); 6361 } 6362 6363 // C++11 [expr.cond]p6 6364 // Lvalue-to-rvalue, array-to-pointer, and function-to-pointer standard 6365 // conversions are performed on the second and third operands. 6366 LHS = DefaultFunctionArrayLvalueConversion(LHS.get()); 6367 RHS = DefaultFunctionArrayLvalueConversion(RHS.get()); 6368 if (LHS.isInvalid() || RHS.isInvalid()) 6369 return QualType(); 6370 LTy = LHS.get()->getType(); 6371 RTy = RHS.get()->getType(); 6372 6373 // After those conversions, one of the following shall hold: 6374 // -- The second and third operands have the same type; the result 6375 // is of that type. If the operands have class type, the result 6376 // is a prvalue temporary of the result type, which is 6377 // copy-initialized from either the second operand or the third 6378 // operand depending on the value of the first operand. 6379 if (Context.getCanonicalType(LTy) == Context.getCanonicalType(RTy)) { 6380 if (LTy->isRecordType()) { 6381 // The operands have class type. Make a temporary copy. 6382 InitializedEntity Entity = InitializedEntity::InitializeTemporary(LTy); 6383 6384 ExprResult LHSCopy = PerformCopyInitialization(Entity, 6385 SourceLocation(), 6386 LHS); 6387 if (LHSCopy.isInvalid()) 6388 return QualType(); 6389 6390 ExprResult RHSCopy = PerformCopyInitialization(Entity, 6391 SourceLocation(), 6392 RHS); 6393 if (RHSCopy.isInvalid()) 6394 return QualType(); 6395 6396 LHS = LHSCopy; 6397 RHS = RHSCopy; 6398 } 6399 6400 // If we have function pointer types, unify them anyway to unify their 6401 // exception specifications, if any. 6402 if (LTy->isFunctionPointerType() || LTy->isMemberFunctionPointerType()) { 6403 LTy = FindCompositePointerType(QuestionLoc, LHS, RHS); 6404 assert(!LTy.isNull() && "failed to find composite pointer type for "((void)0) 6405 "canonically equivalent function ptr types")((void)0); 6406 } 6407 6408 return LTy; 6409 } 6410 6411 // Extension: conditional operator involving vector types. 6412 if (LTy->isVectorType() || RTy->isVectorType()) 6413 return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/false, 6414 /*AllowBothBool*/true, 6415 /*AllowBoolConversions*/false); 6416 6417 // -- The second and third operands have arithmetic or enumeration type; 6418 // the usual arithmetic conversions are performed to bring them to a 6419 // common type, and the result is of that type. 6420 if (LTy->isArithmeticType() && RTy->isArithmeticType()) { 6421 QualType ResTy = 6422 UsualArithmeticConversions(LHS, RHS, QuestionLoc, ACK_Conditional); 6423 if (LHS.isInvalid() || RHS.isInvalid()) 6424 return QualType(); 6425 if (ResTy.isNull()) { 6426 Diag(QuestionLoc, 6427 diag::err_typecheck_cond_incompatible_operands) << LTy << RTy 6428 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6429 return QualType(); 6430 } 6431 6432 LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy)); 6433 RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy)); 6434 6435 return ResTy; 6436 } 6437 6438 // -- The second and third operands have pointer type, or one has pointer 6439 // type and the other is a null pointer constant, or both are null 6440 // pointer constants, at least one of which is non-integral; pointer 6441 // conversions and qualification conversions are performed to bring them 6442 // to their composite pointer type. The result is of the composite 6443 // pointer type. 6444 // -- The second and third operands have pointer to member type, or one has 6445 // pointer to member type and the other is a null pointer constant; 6446 // pointer to member conversions and qualification conversions are 6447 // performed to bring them to a common type, whose cv-qualification 6448 // shall match the cv-qualification of either the second or the third 6449 // operand. The result is of the common type. 6450 QualType Composite = FindCompositePointerType(QuestionLoc, LHS, RHS); 6451 if (!Composite.isNull()) 6452 return Composite; 6453 6454 // Similarly, attempt to find composite type of two objective-c pointers. 6455 Composite = FindCompositeObjCPointerType(LHS, RHS, QuestionLoc); 6456 if (LHS.isInvalid() || RHS.isInvalid()) 6457 return QualType(); 6458 if (!Composite.isNull()) 6459 return Composite; 6460 6461 // Check if we are using a null with a non-pointer type. 6462 if (DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc)) 6463 return QualType(); 6464 6465 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 6466 << LHS.get()->getType() << RHS.get()->getType() 6467 << LHS.get()->getSourceRange() << RHS.get()->getSourceRange(); 6468 return QualType(); 6469} 6470 6471static FunctionProtoType::ExceptionSpecInfo 6472mergeExceptionSpecs(Sema &S, FunctionProtoType::ExceptionSpecInfo ESI1, 6473 FunctionProtoType::ExceptionSpecInfo ESI2, 6474 SmallVectorImpl<QualType> &ExceptionTypeStorage) { 6475 ExceptionSpecificationType EST1 = ESI1.Type; 6476 ExceptionSpecificationType EST2 = ESI2.Type; 6477 6478 // If either of them can throw anything, that is the result. 6479 if (EST1 == EST_None) return ESI1; 6480 if (EST2 == EST_None) return ESI2; 6481 if (EST1 == EST_MSAny) return ESI1; 6482 if (EST2 == EST_MSAny) return ESI2; 6483 if (EST1 == EST_NoexceptFalse) return ESI1; 6484 if (EST2 == EST_NoexceptFalse) return ESI2; 6485 6486 // If either of them is non-throwing, the result is the other. 6487 if (EST1 == EST_NoThrow) return ESI2; 6488 if (EST2 == EST_NoThrow) return ESI1; 6489 if (EST1 == EST_DynamicNone) return ESI2; 6490 if (EST2 == EST_DynamicNone) return ESI1; 6491 if (EST1 == EST_BasicNoexcept) return ESI2; 6492 if (EST2 == EST_BasicNoexcept) return ESI1; 6493 if (EST1 == EST_NoexceptTrue) return ESI2; 6494 if (EST2 == EST_NoexceptTrue) return ESI1; 6495 6496 // If we're left with value-dependent computed noexcept expressions, we're 6497 // stuck. Before C++17, we can just drop the exception specification entirely, 6498 // since it's not actually part of the canonical type. And this should never 6499 // happen in C++17, because it would mean we were computing the composite 6500 // pointer type of dependent types, which should never happen. 6501 if (EST1 == EST_DependentNoexcept || EST2 == EST_DependentNoexcept) { 6502 assert(!S.getLangOpts().CPlusPlus17 &&((void)0) 6503 "computing composite pointer type of dependent types")((void)0); 6504 return FunctionProtoType::ExceptionSpecInfo(); 6505 } 6506 6507 // Switch over the possibilities so that people adding new values know to 6508 // update this function. 6509 switch (EST1) { 6510 case EST_None: 6511 case EST_DynamicNone: 6512 case EST_MSAny: 6513 case EST_BasicNoexcept: 6514 case EST_DependentNoexcept: 6515 case EST_NoexceptFalse: 6516 case EST_NoexceptTrue: 6517 case EST_NoThrow: 6518 llvm_unreachable("handled above")__builtin_unreachable(); 6519 6520 case EST_Dynamic: { 6521 // This is the fun case: both exception specifications are dynamic. Form 6522 // the union of the two lists. 6523 assert(EST2 == EST_Dynamic && "other cases should already be handled")((void)0); 6524 llvm::SmallPtrSet<QualType, 8> Found; 6525 for (auto &Exceptions : {ESI1.Exceptions, ESI2.Exceptions}) 6526 for (QualType E : Exceptions) 6527 if (Found.insert(S.Context.getCanonicalType(E)).second) 6528 ExceptionTypeStorage.push_back(E); 6529 6530 FunctionProtoType::ExceptionSpecInfo Result(EST_Dynamic); 6531 Result.Exceptions = ExceptionTypeStorage; 6532 return Result; 6533 } 6534 6535 case EST_Unevaluated: 6536 case EST_Uninstantiated: 6537 case EST_Unparsed: 6538 llvm_unreachable("shouldn't see unresolved exception specifications here")__builtin_unreachable(); 6539 } 6540 6541 llvm_unreachable("invalid ExceptionSpecificationType")__builtin_unreachable(); 6542} 6543 6544/// Find a merged pointer type and convert the two expressions to it. 6545/// 6546/// This finds the composite pointer type for \p E1 and \p E2 according to 6547/// C++2a [expr.type]p3. It converts both expressions to this type and returns 6548/// it. It does not emit diagnostics (FIXME: that's not true if \p ConvertArgs 6549/// is \c true). 6550/// 6551/// \param Loc The location of the operator requiring these two expressions to 6552/// be converted to the composite pointer type. 6553/// 6554/// \param ConvertArgs If \c false, do not convert E1 and E2 to the target type. 6555QualType Sema::FindCompositePointerType(SourceLocation Loc, 6556 Expr *&E1, Expr *&E2, 6557 bool ConvertArgs) { 6558 assert(getLangOpts().CPlusPlus && "This function assumes C++")((void)0); 6559 6560 // C++1z [expr]p14: 6561 // The composite pointer type of two operands p1 and p2 having types T1 6562 // and T2 6563 QualType T1 = E1->getType(), T2 = E2->getType(); 6564 6565 // where at least one is a pointer or pointer to member type or 6566 // std::nullptr_t is: 6567 bool T1IsPointerLike = T1->isAnyPointerType() || T1->isMemberPointerType() || 6568 T1->isNullPtrType(); 6569 bool T2IsPointerLike = T2->isAnyPointerType() || T2->isMemberPointerType() || 6570 T2->isNullPtrType(); 6571 if (!T1IsPointerLike && !T2IsPointerLike) 6572 return QualType(); 6573 6574 // - if both p1 and p2 are null pointer constants, std::nullptr_t; 6575 // This can't actually happen, following the standard, but we also use this 6576 // to implement the end of [expr.conv], which hits this case. 6577 // 6578 // - if either p1 or p2 is a null pointer constant, T2 or T1, respectively; 6579 if (T1IsPointerLike && 6580 E2->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 6581 if (ConvertArgs) 6582 E2 = ImpCastExprToType(E2, T1, T1->isMemberPointerType() 6583 ? CK_NullToMemberPointer 6584 : CK_NullToPointer).get(); 6585 return T1; 6586 } 6587 if (T2IsPointerLike && 6588 E1->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) { 6589 if (ConvertArgs) 6590 E1 = ImpCastExprToType(E1, T2, T2->isMemberPointerType() 6591 ? CK_NullToMemberPointer 6592 : CK_NullToPointer).get(); 6593 return T2; 6594 } 6595 6596 // Now both have to be pointers or member pointers. 6597 if (!T1IsPointerLike || !T2IsPointerLike) 6598 return QualType(); 6599 assert(!T1->isNullPtrType() && !T2->isNullPtrType() &&((void)0) 6600 "nullptr_t should be a null pointer constant")((void)0); 6601 6602 struct Step { 6603 enum Kind { Pointer, ObjCPointer, MemberPointer, Array } K; 6604 // Qualifiers to apply under the step kind. 6605 Qualifiers Quals; 6606 /// The class for a pointer-to-member; a constant array type with a bound 6607 /// (if any) for an array. 6608 const Type *ClassOrBound; 6609 6610 Step(Kind K, const Type *ClassOrBound = nullptr) 6611 : K(K), Quals(), ClassOrBound(ClassOrBound) {} 6612 QualType rebuild(ASTContext &Ctx, QualType T) const { 6613 T = Ctx.getQualifiedType(T, Quals); 6614 switch (K) { 6615 case Pointer: 6616 return Ctx.getPointerType(T); 6617 case MemberPointer: 6618 return Ctx.getMemberPointerType(T, ClassOrBound); 6619 case ObjCPointer: 6620 return Ctx.getObjCObjectPointerType(T); 6621 case Array: 6622 if (auto *CAT = cast_or_null<ConstantArrayType>(ClassOrBound)) 6623 return Ctx.getConstantArrayType(T, CAT->getSize(), nullptr, 6624 ArrayType::Normal, 0); 6625 else 6626 return Ctx.getIncompleteArrayType(T, ArrayType::Normal, 0); 6627 } 6628 llvm_unreachable("unknown step kind")__builtin_unreachable(); 6629 } 6630 }; 6631 6632 SmallVector<Step, 8> Steps; 6633 6634 // - if T1 is "pointer to cv1 C1" and T2 is "pointer to cv2 C2", where C1 6635 // is reference-related to C2 or C2 is reference-related to C1 (8.6.3), 6636 // the cv-combined type of T1 and T2 or the cv-combined type of T2 and T1, 6637 // respectively; 6638 // - if T1 is "pointer to member of C1 of type cv1 U1" and T2 is "pointer 6639 // to member of C2 of type cv2 U2" for some non-function type U, where 6640 // C1 is reference-related to C2 or C2 is reference-related to C1, the 6641 // cv-combined type of T2 and T1 or the cv-combined type of T1 and T2, 6642 // respectively; 6643 // - if T1 and T2 are similar types (4.5), the cv-combined type of T1 and 6644 // T2; 6645 // 6646 // Dismantle T1 and T2 to simultaneously determine whether they are similar 6647 // and to prepare to form the cv-combined type if so. 6648 QualType Composite1 = T1; 6649 QualType Composite2 = T2; 6650 unsigned NeedConstBefore = 0; 6651 while (true) { 6652 assert(!Composite1.isNull() && !Composite2.isNull())((void)0); 6653 6654 Qualifiers Q1, Q2; 6655 Composite1 = Context.getUnqualifiedArrayType(Composite1, Q1); 6656 Composite2 = Context.getUnqualifiedArrayType(Composite2, Q2); 6657 6658 // Top-level qualifiers are ignored. Merge at all lower levels. 6659 if (!Steps.empty()) { 6660 // Find the qualifier union: (approximately) the unique minimal set of 6661 // qualifiers that is compatible with both types. 6662 Qualifiers Quals = Qualifiers::fromCVRUMask(Q1.getCVRUQualifiers() | 6663 Q2.getCVRUQualifiers()); 6664 6665 // Under one level of pointer or pointer-to-member, we can change to an 6666 // unambiguous compatible address space. 6667 if (Q1.getAddressSpace() == Q2.getAddressSpace()) { 6668 Quals.setAddressSpace(Q1.getAddressSpace()); 6669 } else if (Steps.size() == 1) { 6670 bool MaybeQ1 = Q1.isAddressSpaceSupersetOf(Q2); 6671 bool MaybeQ2 = Q2.isAddressSpaceSupersetOf(Q1); 6672 if (MaybeQ1 == MaybeQ2) 6673 return QualType(); // No unique best address space. 6674 Quals.setAddressSpace(MaybeQ1 ? Q1.getAddressSpace() 6675 : Q2.getAddressSpace()); 6676 } else { 6677 return QualType(); 6678 } 6679 6680 // FIXME: In C, we merge __strong and none to __strong at the top level. 6681 if (Q1.getObjCGCAttr() == Q2.getObjCGCAttr()) 6682 Quals.setObjCGCAttr(Q1.getObjCGCAttr()); 6683 else if (T1->isVoidPointerType() || T2->isVoidPointerType()) 6684 assert(Steps.size() == 1)((void)0); 6685 else 6686 return QualType(); 6687 6688 // Mismatched lifetime qualifiers never compatibly include each other. 6689 if (Q1.getObjCLifetime() == Q2.getObjCLifetime()) 6690 Quals.setObjCLifetime(Q1.getObjCLifetime()); 6691 else if (T1->isVoidPointerType() || T2->isVoidPointerType()) 6692 assert(Steps.size() == 1)((void)0); 6693 else 6694 return QualType(); 6695 6696 Steps.back().Quals = Quals; 6697 if (Q1 != Quals || Q2 != Quals) 6698 NeedConstBefore = Steps.size() - 1; 6699 } 6700 6701 // FIXME: Can we unify the following with UnwrapSimilarTypes? 6702 const PointerType *Ptr1, *Ptr2; 6703 if ((Ptr1 = Composite1->getAs<PointerType>()) && 6704 (Ptr2 = Composite2->getAs<PointerType>())) { 6705 Composite1 = Ptr1->getPointeeType(); 6706 Composite2 = Ptr2->getPointeeType(); 6707 Steps.emplace_back(Step::Pointer); 6708 continue; 6709 } 6710 6711 const ObjCObjectPointerType *ObjPtr1, *ObjPtr2; 6712 if ((ObjPtr1 = Composite1->getAs<ObjCObjectPointerType>()) && 6713 (ObjPtr2 = Composite2->getAs<ObjCObjectPointerType>())) { 6714 Composite1 = ObjPtr1->getPointeeType(); 6715 Composite2 = ObjPtr2->getPointeeType(); 6716 Steps.emplace_back(Step::ObjCPointer); 6717 continue; 6718 } 6719 6720 const MemberPointerType *MemPtr1, *MemPtr2; 6721 if ((MemPtr1 = Composite1->getAs<MemberPointerType>()) && 6722 (MemPtr2 = Composite2->getAs<MemberPointerType>())) { 6723 Composite1 = MemPtr1->getPointeeType(); 6724 Composite2 = MemPtr2->getPointeeType(); 6725 6726 // At the top level, we can perform a base-to-derived pointer-to-member 6727 // conversion: 6728 // 6729 // - [...] where C1 is reference-related to C2 or C2 is 6730 // reference-related to C1 6731 // 6732 // (Note that the only kinds of reference-relatedness in scope here are 6733 // "same type or derived from".) At any other level, the class must 6734 // exactly match. 6735 const Type *Class = nullptr; 6736 QualType Cls1(MemPtr1->getClass(), 0); 6737 QualType Cls2(MemPtr2->getClass(), 0); 6738 if (Context.hasSameType(Cls1, Cls2)) 6739 Class = MemPtr1->getClass(); 6740 else if (Steps.empty()) 6741 Class = IsDerivedFrom(Loc, Cls1, Cls2) ? MemPtr1->getClass() : 6742 IsDerivedFrom(Loc, Cls2, Cls1) ? MemPtr2->getClass() : nullptr; 6743 if (!Class) 6744 return QualType(); 6745 6746 Steps.emplace_back(Step::MemberPointer, Class); 6747 continue; 6748 } 6749 6750 // Special case: at the top level, we can decompose an Objective-C pointer 6751 // and a 'cv void *'. Unify the qualifiers. 6752 if (Steps.empty() && ((Composite1->isVoidPointerType() && 6753 Composite2->isObjCObjectPointerType()) || 6754 (Composite1->isObjCObjectPointerType() && 6755 Composite2->isVoidPointerType()))) { 6756 Composite1 = Composite1->getPointeeType(); 6757 Composite2 = Composite2->getPointeeType(); 6758 Steps.emplace_back(Step::Pointer); 6759 continue; 6760 } 6761 6762 // FIXME: arrays 6763 6764 // FIXME: block pointer types? 6765 6766 // Cannot unwrap any more types. 6767 break; 6768 } 6769 6770 // - if T1 or T2 is "pointer to noexcept function" and the other type is 6771 // "pointer to function", where the function types are otherwise the same, 6772 // "pointer to function"; 6773 // - if T1 or T2 is "pointer to member of C1 of type function", the other 6774 // type is "pointer to member of C2 of type noexcept function", and C1 6775 // is reference-related to C2 or C2 is reference-related to C1, where 6776 // the function types are otherwise the same, "pointer to member of C2 of 6777 // type function" or "pointer to member of C1 of type function", 6778 // respectively; 6779 // 6780 // We also support 'noreturn' here, so as a Clang extension we generalize the 6781 // above to: 6782 // 6783 // - [Clang] If T1 and T2 are both of type "pointer to function" or 6784 // "pointer to member function" and the pointee types can be unified 6785 // by a function pointer conversion, that conversion is applied 6786 // before checking the following rules. 6787 // 6788 // We've already unwrapped down to the function types, and we want to merge 6789 // rather than just convert, so do this ourselves rather than calling 6790 // IsFunctionConversion. 6791 // 6792 // FIXME: In order to match the standard wording as closely as possible, we 6793 // currently only do this under a single level of pointers. Ideally, we would 6794 // allow this in general, and set NeedConstBefore to the relevant depth on 6795 // the side(s) where we changed anything. If we permit that, we should also 6796 // consider this conversion when determining type similarity and model it as 6797 // a qualification conversion. 6798 if (Steps.size() == 1) { 6799 if (auto *FPT1 = Composite1->getAs<FunctionProtoType>()) { 6800 if (auto *FPT2 = Composite2->getAs<FunctionProtoType>()) { 6801 FunctionProtoType::ExtProtoInfo EPI1 = FPT1->getExtProtoInfo(); 6802 FunctionProtoType::ExtProtoInfo EPI2 = FPT2->getExtProtoInfo(); 6803 6804 // The result is noreturn if both operands are. 6805 bool Noreturn = 6806 EPI1.ExtInfo.getNoReturn() && EPI2.ExtInfo.getNoReturn(); 6807 EPI1.ExtInfo = EPI1.ExtInfo.withNoReturn(Noreturn); 6808 EPI2.ExtInfo = EPI2.ExtInfo.withNoReturn(Noreturn); 6809 6810 // The result is nothrow if both operands are. 6811 SmallVector<QualType, 8> ExceptionTypeStorage; 6812 EPI1.ExceptionSpec = EPI2.ExceptionSpec = 6813 mergeExceptionSpecs(*this, EPI1.ExceptionSpec, EPI2.ExceptionSpec, 6814 ExceptionTypeStorage); 6815 6816 Composite1 = Context.getFunctionType(FPT1->getReturnType(), 6817 FPT1->getParamTypes(), EPI1); 6818 Composite2 = Context.getFunctionType(FPT2->getReturnType(), 6819 FPT2->getParamTypes(), EPI2); 6820 } 6821 } 6822 } 6823 6824 // There are some more conversions we can perform under exactly one pointer. 6825 if (Steps.size() == 1 && Steps.front().K == Step::Pointer && 6826 !Context.hasSameType(Composite1, Composite2)) { 6827 // - if T1 or T2 is "pointer to cv1 void" and the other type is 6828 // "pointer to cv2 T", where T is an object type or void, 6829 // "pointer to cv12 void", where cv12 is the union of cv1 and cv2; 6830 if (Composite1->isVoidType() && Composite2->isObjectType()) 6831 Composite2 = Composite1; 6832 else if (Composite2->isVoidType() && Composite1->isObjectType()) 6833 Composite1 = Composite2; 6834 // - if T1 is "pointer to cv1 C1" and T2 is "pointer to cv2 C2", where C1 6835 // is reference-related to C2 or C2 is reference-related to C1 (8.6.3), 6836 // the cv-combined type of T1 and T2 or the cv-combined type of T2 and 6837 // T1, respectively; 6838 // 6839 // The "similar type" handling covers all of this except for the "T1 is a 6840 // base class of T2" case in the definition of reference-related. 6841 else if (IsDerivedFrom(Loc, Composite1, Composite2)) 6842 Composite1 = Composite2; 6843 else if (IsDerivedFrom(Loc, Composite2, Composite1)) 6844 Composite2 = Composite1; 6845 } 6846 6847 // At this point, either the inner types are the same or we have failed to 6848 // find a composite pointer type. 6849 if (!Context.hasSameType(Composite1, Composite2)) 6850 return QualType(); 6851 6852 // Per C++ [conv.qual]p3, add 'const' to every level before the last 6853 // differing qualifier. 6854 for (unsigned I = 0; I != NeedConstBefore; ++I) 6855 Steps[I].Quals.addConst(); 6856 6857 // Rebuild the composite type. 6858 QualType Composite = Composite1; 6859 for (auto &S : llvm::reverse(Steps)) 6860 Composite = S.rebuild(Context, Composite); 6861 6862 if (ConvertArgs) { 6863 // Convert the expressions to the composite pointer type. 6864 InitializedEntity Entity = 6865 InitializedEntity::InitializeTemporary(Composite); 6866 InitializationKind Kind = 6867 InitializationKind::CreateCopy(Loc, SourceLocation()); 6868 6869 InitializationSequence E1ToC(*this, Entity, Kind, E1); 6870 if (!E1ToC) 6871 return QualType(); 6872 6873 InitializationSequence E2ToC(*this, Entity, Kind, E2); 6874 if (!E2ToC) 6875 return QualType(); 6876 6877 // FIXME: Let the caller know if these fail to avoid duplicate diagnostics. 6878 ExprResult E1Result = E1ToC.Perform(*this, Entity, Kind, E1); 6879 if (E1Result.isInvalid()) 6880 return QualType(); 6881 E1 = E1Result.get(); 6882 6883 ExprResult E2Result = E2ToC.Perform(*this, Entity, Kind, E2); 6884 if (E2Result.isInvalid()) 6885 return QualType(); 6886 E2 = E2Result.get(); 6887 } 6888 6889 return Composite; 6890} 6891 6892ExprResult Sema::MaybeBindToTemporary(Expr *E) { 6893 if (!E) 6894 return ExprError(); 6895 6896 assert(!isa<CXXBindTemporaryExpr>(E) && "Double-bound temporary?")((void)0); 6897 6898 // If the result is a glvalue, we shouldn't bind it. 6899 if (E->isGLValue()) 6900 return E; 6901 6902 // In ARC, calls that return a retainable type can return retained, 6903 // in which case we have to insert a consuming cast. 6904 if (getLangOpts().ObjCAutoRefCount && 6905 E->getType()->isObjCRetainableType()) { 6906 6907 bool ReturnsRetained; 6908 6909 // For actual calls, we compute this by examining the type of the 6910 // called value. 6911 if (CallExpr *Call = dyn_cast<CallExpr>(E)) { 6912 Expr *Callee = Call->getCallee()->IgnoreParens(); 6913 QualType T = Callee->getType(); 6914 6915 if (T == Context.BoundMemberTy) { 6916 // Handle pointer-to-members. 6917 if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(Callee)) 6918 T = BinOp->getRHS()->getType(); 6919 else if (MemberExpr *Mem = dyn_cast<MemberExpr>(Callee)) 6920 T = Mem->getMemberDecl()->getType(); 6921 } 6922 6923 if (const PointerType *Ptr = T->getAs<PointerType>()) 6924 T = Ptr->getPointeeType(); 6925 else if (const BlockPointerType *Ptr = T->getAs<BlockPointerType>()) 6926 T = Ptr->getPointeeType(); 6927 else if (const MemberPointerType *MemPtr = T->getAs<MemberPointerType>()) 6928 T = MemPtr->getPointeeType(); 6929 6930 auto *FTy = T->castAs<FunctionType>(); 6931 ReturnsRetained = FTy->getExtInfo().getProducesResult(); 6932 6933 // ActOnStmtExpr arranges things so that StmtExprs of retainable 6934 // type always produce a +1 object. 6935 } else if (isa<StmtExpr>(E)) { 6936 ReturnsRetained = true; 6937 6938 // We hit this case with the lambda conversion-to-block optimization; 6939 // we don't want any extra casts here. 6940 } else if (isa<CastExpr>(E) && 6941 isa<BlockExpr>(cast<CastExpr>(E)->getSubExpr())) { 6942 return E; 6943 6944 // For message sends and property references, we try to find an 6945 // actual method. FIXME: we should infer retention by selector in 6946 // cases where we don't have an actual method. 6947 } else { 6948 ObjCMethodDecl *D = nullptr; 6949 if (ObjCMessageExpr *Send = dyn_cast<ObjCMessageExpr>(E)) { 6950 D = Send->getMethodDecl(); 6951 } else if (ObjCBoxedExpr *BoxedExpr = dyn_cast<ObjCBoxedExpr>(E)) { 6952 D = BoxedExpr->getBoxingMethod(); 6953 } else if (ObjCArrayLiteral *ArrayLit = dyn_cast<ObjCArrayLiteral>(E)) { 6954 // Don't do reclaims if we're using the zero-element array 6955 // constant. 6956 if (ArrayLit->getNumElements() == 0 && 6957 Context.getLangOpts().ObjCRuntime.hasEmptyCollections()) 6958 return E; 6959 6960 D = ArrayLit->getArrayWithObjectsMethod(); 6961 } else if (ObjCDictionaryLiteral *DictLit 6962 = dyn_cast<ObjCDictionaryLiteral>(E)) { 6963 // Don't do reclaims if we're using the zero-element dictionary 6964 // constant. 6965 if (DictLit->getNumElements() == 0 && 6966 Context.getLangOpts().ObjCRuntime.hasEmptyCollections()) 6967 return E; 6968 6969 D = DictLit->getDictWithObjectsMethod(); 6970 } 6971 6972 ReturnsRetained = (D && D->hasAttr<NSReturnsRetainedAttr>()); 6973 6974 // Don't do reclaims on performSelector calls; despite their 6975 // return type, the invoked method doesn't necessarily actually 6976 // return an object. 6977 if (!ReturnsRetained && 6978 D && D->getMethodFamily() == OMF_performSelector) 6979 return E; 6980 } 6981 6982 // Don't reclaim an object of Class type. 6983 if (!ReturnsRetained && E->getType()->isObjCARCImplicitlyUnretainedType()) 6984 return E; 6985 6986 Cleanup.setExprNeedsCleanups(true); 6987 6988 CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject 6989 : CK_ARCReclaimReturnedObject); 6990 return ImplicitCastExpr::Create(Context, E->getType(), ck, E, nullptr, 6991 VK_PRValue, FPOptionsOverride()); 6992 } 6993 6994 if (E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct) 6995 Cleanup.setExprNeedsCleanups(true); 6996 6997 if (!getLangOpts().CPlusPlus) 6998 return E; 6999 7000 // Search for the base element type (cf. ASTContext::getBaseElementType) with 7001 // a fast path for the common case that the type is directly a RecordType. 7002 const Type *T = Context.getCanonicalType(E->getType().getTypePtr()); 7003 const RecordType *RT = nullptr; 7004 while (!RT) { 7005 switch (T->getTypeClass()) { 7006 case Type::Record: 7007 RT = cast<RecordType>(T); 7008 break; 7009 case Type::ConstantArray: 7010 case Type::IncompleteArray: 7011 case Type::VariableArray: 7012 case Type::DependentSizedArray: 7013 T = cast<ArrayType>(T)->getElementType().getTypePtr(); 7014 break; 7015 default: 7016 return E; 7017 } 7018 } 7019 7020 // That should be enough to guarantee that this type is complete, if we're 7021 // not processing a decltype expression. 7022 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 7023 if (RD->isInvalidDecl() || RD->isDependentContext()) 7024 return E; 7025 7026 bool IsDecltype = ExprEvalContexts.back().ExprContext == 7027 ExpressionEvaluationContextRecord::EK_Decltype; 7028 CXXDestructorDecl *Destructor = IsDecltype ? nullptr : LookupDestructor(RD); 7029 7030 if (Destructor) { 7031 MarkFunctionReferenced(E->getExprLoc(), Destructor); 7032 CheckDestructorAccess(E->getExprLoc(), Destructor, 7033 PDiag(diag::err_access_dtor_temp) 7034 << E->getType()); 7035 if (DiagnoseUseOfDecl(Destructor, E->getExprLoc())) 7036 return ExprError(); 7037 7038 // If destructor is trivial, we can avoid the extra copy. 7039 if (Destructor->isTrivial()) 7040 return E; 7041 7042 // We need a cleanup, but we don't need to remember the temporary. 7043 Cleanup.setExprNeedsCleanups(true); 7044 } 7045 7046 CXXTemporary *Temp = CXXTemporary::Create(Context, Destructor); 7047 CXXBindTemporaryExpr *Bind = CXXBindTemporaryExpr::Create(Context, Temp, E); 7048 7049 if (IsDecltype) 7050 ExprEvalContexts.back().DelayedDecltypeBinds.push_back(Bind); 7051 7052 return Bind; 7053} 7054 7055ExprResult 7056Sema::MaybeCreateExprWithCleanups(ExprResult SubExpr) { 7057 if (SubExpr.isInvalid()) 7058 return ExprError(); 7059 7060 return MaybeCreateExprWithCleanups(SubExpr.get()); 7061} 7062 7063Expr *Sema::MaybeCreateExprWithCleanups(Expr *SubExpr) { 7064 assert(SubExpr && "subexpression can't be null!")((void)0); 7065 7066 CleanupVarDeclMarking(); 7067 7068 unsigned FirstCleanup = ExprEvalContexts.back().NumCleanupObjects; 7069 assert(ExprCleanupObjects.size() >= FirstCleanup)((void)0); 7070 assert(Cleanup.exprNeedsCleanups() ||((void)0) 7071 ExprCleanupObjects.size() == FirstCleanup)((void)0); 7072 if (!Cleanup.exprNeedsCleanups()) 7073 return SubExpr; 7074 7075 auto Cleanups = llvm::makeArrayRef(ExprCleanupObjects.begin() + FirstCleanup, 7076 ExprCleanupObjects.size() - FirstCleanup); 7077 7078 auto *E = ExprWithCleanups::Create( 7079 Context, SubExpr, Cleanup.cleanupsHaveSideEffects(), Cleanups); 7080 DiscardCleanupsInEvaluationContext(); 7081 7082 return E; 7083} 7084 7085Stmt *Sema::MaybeCreateStmtWithCleanups(Stmt *SubStmt) { 7086 assert(SubStmt && "sub-statement can't be null!")((void)0); 7087 7088 CleanupVarDeclMarking(); 7089 7090 if (!Cleanup.exprNeedsCleanups()) 7091 return SubStmt; 7092 7093 // FIXME: In order to attach the temporaries, wrap the statement into 7094 // a StmtExpr; currently this is only used for asm statements. 7095 // This is hacky, either create a new CXXStmtWithTemporaries statement or 7096 // a new AsmStmtWithTemporaries. 7097 CompoundStmt *CompStmt = CompoundStmt::Create( 7098 Context, SubStmt, SourceLocation(), SourceLocation()); 7099 Expr *E = new (Context) 7100 StmtExpr(CompStmt, Context.VoidTy, SourceLocation(), SourceLocation(), 7101 /*FIXME TemplateDepth=*/0); 7102 return MaybeCreateExprWithCleanups(E); 7103} 7104 7105/// Process the expression contained within a decltype. For such expressions, 7106/// certain semantic checks on temporaries are delayed until this point, and 7107/// are omitted for the 'topmost' call in the decltype expression. If the 7108/// topmost call bound a temporary, strip that temporary off the expression. 7109ExprResult Sema::ActOnDecltypeExpression(Expr *E) { 7110 assert(ExprEvalContexts.back().ExprContext ==((void)0) 7111 ExpressionEvaluationContextRecord::EK_Decltype &&((void)0) 7112 "not in a decltype expression")((void)0); 7113 7114 ExprResult Result = CheckPlaceholderExpr(E); 7115 if (Result.isInvalid()) 7116 return ExprError(); 7117 E = Result.get(); 7118 7119 // C++11 [expr.call]p11: 7120 // If a function call is a prvalue of object type, 7121 // -- if the function call is either 7122 // -- the operand of a decltype-specifier, or 7123 // -- the right operand of a comma operator that is the operand of a 7124 // decltype-specifier, 7125 // a temporary object is not introduced for the prvalue. 7126 7127 // Recursively rebuild ParenExprs and comma expressions to strip out the 7128 // outermost CXXBindTemporaryExpr, if any. 7129 if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) { 7130 ExprResult SubExpr = ActOnDecltypeExpression(PE->getSubExpr()); 7131 if (SubExpr.isInvalid()) 7132 return ExprError(); 7133 if (SubExpr.get() == PE->getSubExpr()) 7134 return E; 7135 return ActOnParenExpr(PE->getLParen(), PE->getRParen(), SubExpr.get()); 7136 } 7137 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 7138 if (BO->getOpcode() == BO_Comma) { 7139 ExprResult RHS = ActOnDecltypeExpression(BO->getRHS()); 7140 if (RHS.isInvalid()) 7141 return ExprError(); 7142 if (RHS.get() == BO->getRHS()) 7143 return E; 7144 return BinaryOperator::Create(Context, BO->getLHS(), RHS.get(), BO_Comma, 7145 BO->getType(), BO->getValueKind(), 7146 BO->getObjectKind(), BO->getOperatorLoc(), 7147 BO->getFPFeatures(getLangOpts())); 7148 } 7149 } 7150 7151 CXXBindTemporaryExpr *TopBind = dyn_cast<CXXBindTemporaryExpr>(E); 7152 CallExpr *TopCall = TopBind ? dyn_cast<CallExpr>(TopBind->getSubExpr()) 7153 : nullptr; 7154 if (TopCall) 7155 E = TopCall; 7156 else 7157 TopBind = nullptr; 7158 7159 // Disable the special decltype handling now. 7160 ExprEvalContexts.back().ExprContext = 7161 ExpressionEvaluationContextRecord::EK_Other; 7162 7163 Result = CheckUnevaluatedOperand(E); 7164 if (Result.isInvalid()) 7165 return ExprError(); 7166 E = Result.get(); 7167 7168 // In MS mode, don't perform any extra checking of call return types within a 7169 // decltype expression. 7170 if (getLangOpts().MSVCCompat) 7171 return E; 7172 7173 // Perform the semantic checks we delayed until this point. 7174 for (unsigned I = 0, N = ExprEvalContexts.back().DelayedDecltypeCalls.size(); 7175 I != N; ++I) { 7176 CallExpr *Call = ExprEvalContexts.back().DelayedDecltypeCalls[I]; 7177 if (Call == TopCall) 7178 continue; 7179 7180 if (CheckCallReturnType(Call->getCallReturnType(Context), 7181 Call->getBeginLoc(), Call, Call->getDirectCallee())) 7182 return ExprError(); 7183 } 7184 7185 // Now all relevant types are complete, check the destructors are accessible 7186 // and non-deleted, and annotate them on the temporaries. 7187 for (unsigned I = 0, N = ExprEvalContexts.back().DelayedDecltypeBinds.size(); 7188 I != N; ++I) { 7189 CXXBindTemporaryExpr *Bind = 7190 ExprEvalContexts.back().DelayedDecltypeBinds[I]; 7191 if (Bind == TopBind) 7192 continue; 7193 7194 CXXTemporary *Temp = Bind->getTemporary(); 7195 7196 CXXRecordDecl *RD = 7197 Bind->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl(); 7198 CXXDestructorDecl *Destructor = LookupDestructor(RD); 7199 Temp->setDestructor(Destructor); 7200 7201 MarkFunctionReferenced(Bind->getExprLoc(), Destructor); 7202 CheckDestructorAccess(Bind->getExprLoc(), Destructor, 7203 PDiag(diag::err_access_dtor_temp) 7204 << Bind->getType()); 7205 if (DiagnoseUseOfDecl(Destructor, Bind->getExprLoc())) 7206 return ExprError(); 7207 7208 // We need a cleanup, but we don't need to remember the temporary. 7209 Cleanup.setExprNeedsCleanups(true); 7210 } 7211 7212 // Possibly strip off the top CXXBindTemporaryExpr. 7213 return E; 7214} 7215 7216/// Note a set of 'operator->' functions that were used for a member access. 7217static void noteOperatorArrows(Sema &S, 7218 ArrayRef<FunctionDecl *> OperatorArrows) { 7219 unsigned SkipStart = OperatorArrows.size(), SkipCount = 0; 7220 // FIXME: Make this configurable? 7221 unsigned Limit = 9; 7222 if (OperatorArrows.size() > Limit) { 7223 // Produce Limit-1 normal notes and one 'skipping' note. 7224 SkipStart = (Limit - 1) / 2 + (Limit - 1) % 2; 7225 SkipCount = OperatorArrows.size() - (Limit - 1); 7226 } 7227 7228 for (unsigned I = 0; I < OperatorArrows.size(); /**/) { 7229 if (I == SkipStart) { 7230 S.Diag(OperatorArrows[I]->getLocation(), 7231 diag::note_operator_arrows_suppressed) 7232 << SkipCount; 7233 I += SkipCount; 7234 } else { 7235 S.Diag(OperatorArrows[I]->getLocation(), diag::note_operator_arrow_here) 7236 << OperatorArrows[I]->getCallResultType(); 7237 ++I; 7238 } 7239 } 7240} 7241 7242ExprResult Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base, 7243 SourceLocation OpLoc, 7244 tok::TokenKind OpKind, 7245 ParsedType &ObjectType, 7246 bool &MayBePseudoDestructor) { 7247 // Since this might be a postfix expression, get rid of ParenListExprs. 7248 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base); 7249 if (Result.isInvalid()) return ExprError(); 7250 Base = Result.get(); 7251 7252 Result = CheckPlaceholderExpr(Base); 7253 if (Result.isInvalid()) return ExprError(); 7254 Base = Result.get(); 7255 7256 QualType BaseType = Base->getType(); 7257 MayBePseudoDestructor = false; 7258 if (BaseType->isDependentType()) { 7259 // If we have a pointer to a dependent type and are using the -> operator, 7260 // the object type is the type that the pointer points to. We might still 7261 // have enough information about that type to do something useful. 7262 if (OpKind == tok::arrow) 7263 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) 7264 BaseType = Ptr->getPointeeType(); 7265 7266 ObjectType = ParsedType::make(BaseType); 7267 MayBePseudoDestructor = true; 7268 return Base; 7269 } 7270 7271 // C++ [over.match.oper]p8: 7272 // [...] When operator->returns, the operator-> is applied to the value 7273 // returned, with the original second operand. 7274 if (OpKind == tok::arrow) { 7275 QualType StartingType = BaseType; 7276 bool NoArrowOperatorFound = false; 7277 bool FirstIteration = true; 7278 FunctionDecl *CurFD = dyn_cast<FunctionDecl>(CurContext); 7279 // The set of types we've considered so far. 7280 llvm::SmallPtrSet<CanQualType,8> CTypes; 7281 SmallVector<FunctionDecl*, 8> OperatorArrows; 7282 CTypes.insert(Context.getCanonicalType(BaseType)); 7283 7284 while (BaseType->isRecordType()) { 7285 if (OperatorArrows.size() >= getLangOpts().ArrowDepth) { 7286 Diag(OpLoc, diag::err_operator_arrow_depth_exceeded) 7287 << StartingType << getLangOpts().ArrowDepth << Base->getSourceRange(); 7288 noteOperatorArrows(*this, OperatorArrows); 7289 Diag(OpLoc, diag::note_operator_arrow_depth) 7290 << getLangOpts().ArrowDepth; 7291 return ExprError(); 7292 } 7293 7294 Result = BuildOverloadedArrowExpr( 7295 S, Base, OpLoc, 7296 // When in a template specialization and on the first loop iteration, 7297 // potentially give the default diagnostic (with the fixit in a 7298 // separate note) instead of having the error reported back to here 7299 // and giving a diagnostic with a fixit attached to the error itself. 7300 (FirstIteration && CurFD && CurFD->isFunctionTemplateSpecialization()) 7301 ? nullptr 7302 : &NoArrowOperatorFound); 7303 if (Result.isInvalid()) { 7304 if (NoArrowOperatorFound) { 7305 if (FirstIteration) { 7306 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 7307 << BaseType << 1 << Base->getSourceRange() 7308 << FixItHint::CreateReplacement(OpLoc, "."); 7309 OpKind = tok::period; 7310 break; 7311 } 7312 Diag(OpLoc, diag::err_typecheck_member_reference_arrow) 7313 << BaseType << Base->getSourceRange(); 7314 CallExpr *CE = dyn_cast<CallExpr>(Base); 7315 if (Decl *CD = (CE ? CE->getCalleeDecl() : nullptr)) { 7316 Diag(CD->getBeginLoc(), 7317 diag::note_member_reference_arrow_from_operator_arrow); 7318 } 7319 } 7320 return ExprError(); 7321 } 7322 Base = Result.get(); 7323 if (CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(Base)) 7324 OperatorArrows.push_back(OpCall->getDirectCallee()); 7325 BaseType = Base->getType(); 7326 CanQualType CBaseType = Context.getCanonicalType(BaseType); 7327 if (!CTypes.insert(CBaseType).second) { 7328 Diag(OpLoc, diag::err_operator_arrow_circular) << StartingType; 7329 noteOperatorArrows(*this, OperatorArrows); 7330 return ExprError(); 7331 } 7332 FirstIteration = false; 7333 } 7334 7335 if (OpKind == tok::arrow) { 7336 if (BaseType->isPointerType()) 7337 BaseType = BaseType->getPointeeType(); 7338 else if (auto *AT = Context.getAsArrayType(BaseType)) 7339 BaseType = AT->getElementType(); 7340 } 7341 } 7342 7343 // Objective-C properties allow "." access on Objective-C pointer types, 7344 // so adjust the base type to the object type itself. 7345 if (BaseType->isObjCObjectPointerType()) 7346 BaseType = BaseType->getPointeeType(); 7347 7348 // C++ [basic.lookup.classref]p2: 7349 // [...] If the type of the object expression is of pointer to scalar 7350 // type, the unqualified-id is looked up in the context of the complete 7351 // postfix-expression. 7352 // 7353 // This also indicates that we could be parsing a pseudo-destructor-name. 7354 // Note that Objective-C class and object types can be pseudo-destructor 7355 // expressions or normal member (ivar or property) access expressions, and 7356 // it's legal for the type to be incomplete if this is a pseudo-destructor 7357 // call. We'll do more incomplete-type checks later in the lookup process, 7358 // so just skip this check for ObjC types. 7359 if (!BaseType->isRecordType()) { 7360 ObjectType = ParsedType::make(BaseType); 7361 MayBePseudoDestructor = true; 7362 return Base; 7363 } 7364 7365 // The object type must be complete (or dependent), or 7366 // C++11 [expr.prim.general]p3: 7367 // Unlike the object expression in other contexts, *this is not required to 7368 // be of complete type for purposes of class member access (5.2.5) outside 7369 // the member function body. 7370 if (!BaseType->isDependentType() && 7371 !isThisOutsideMemberFunctionBody(BaseType) && 7372 RequireCompleteType(OpLoc, BaseType, diag::err_incomplete_member_access)) 7373 return ExprError(); 7374 7375 // C++ [basic.lookup.classref]p2: 7376 // If the id-expression in a class member access (5.2.5) is an 7377 // unqualified-id, and the type of the object expression is of a class 7378 // type C (or of pointer to a class type C), the unqualified-id is looked 7379 // up in the scope of class C. [...] 7380 ObjectType = ParsedType::make(BaseType); 7381 return Base; 7382} 7383 7384static bool CheckArrow(Sema &S, QualType &ObjectType, Expr *&Base, 7385 tok::TokenKind &OpKind, SourceLocation OpLoc) { 7386 if (Base->hasPlaceholderType()) { 7387 ExprResult result = S.CheckPlaceholderExpr(Base); 7388 if (result.isInvalid()) return true; 7389 Base = result.get(); 7390 } 7391 ObjectType = Base->getType(); 7392 7393 // C++ [expr.pseudo]p2: 7394 // The left-hand side of the dot operator shall be of scalar type. The 7395 // left-hand side of the arrow operator shall be of pointer to scalar type. 7396 // This scalar type is the object type. 7397 // Note that this is rather different from the normal handling for the 7398 // arrow operator. 7399 if (OpKind == tok::arrow) { 7400 // The operator requires a prvalue, so perform lvalue conversions. 7401 // Only do this if we might plausibly end with a pointer, as otherwise 7402 // this was likely to be intended to be a '.'. 7403 if (ObjectType->isPointerType() || ObjectType->isArrayType() || 7404 ObjectType->isFunctionType()) { 7405 ExprResult BaseResult = S.DefaultFunctionArrayLvalueConversion(Base); 7406 if (BaseResult.isInvalid()) 7407 return true; 7408 Base = BaseResult.get(); 7409 ObjectType = Base->getType(); 7410 } 7411 7412 if (const PointerType *Ptr = ObjectType->getAs<PointerType>()) { 7413 ObjectType = Ptr->getPointeeType(); 7414 } else if (!Base->isTypeDependent()) { 7415 // The user wrote "p->" when they probably meant "p."; fix it. 7416 S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 7417 << ObjectType << true 7418 << FixItHint::CreateReplacement(OpLoc, "."); 7419 if (S.isSFINAEContext()) 7420 return true; 7421 7422 OpKind = tok::period; 7423 } 7424 } 7425 7426 return false; 7427} 7428 7429/// Check if it's ok to try and recover dot pseudo destructor calls on 7430/// pointer objects. 7431static bool 7432canRecoverDotPseudoDestructorCallsOnPointerObjects(Sema &SemaRef, 7433 QualType DestructedType) { 7434 // If this is a record type, check if its destructor is callable. 7435 if (auto *RD = DestructedType->getAsCXXRecordDecl()) { 7436 if (RD->hasDefinition()) 7437 if (CXXDestructorDecl *D = SemaRef.LookupDestructor(RD)) 7438 return SemaRef.CanUseDecl(D, /*TreatUnavailableAsInvalid=*/false); 7439 return false; 7440 } 7441 7442 // Otherwise, check if it's a type for which it's valid to use a pseudo-dtor. 7443 return DestructedType->isDependentType() || DestructedType->isScalarType() || 7444 DestructedType->isVectorType(); 7445} 7446 7447ExprResult Sema::BuildPseudoDestructorExpr(Expr *Base, 7448 SourceLocation OpLoc, 7449 tok::TokenKind OpKind, 7450 const CXXScopeSpec &SS, 7451 TypeSourceInfo *ScopeTypeInfo, 7452 SourceLocation CCLoc, 7453 SourceLocation TildeLoc, 7454 PseudoDestructorTypeStorage Destructed) { 7455 TypeSourceInfo *DestructedTypeInfo = Destructed.getTypeSourceInfo(); 7456 7457 QualType ObjectType; 7458 if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc)) 7459 return ExprError(); 7460 7461 if (!ObjectType->isDependentType() && !ObjectType->isScalarType() && 7462 !ObjectType->isVectorType()) { 7463 if (getLangOpts().MSVCCompat && ObjectType->isVoidType()) 7464 Diag(OpLoc, diag::ext_pseudo_dtor_on_void) << Base->getSourceRange(); 7465 else { 7466 Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar) 7467 << ObjectType << Base->getSourceRange(); 7468 return ExprError(); 7469 } 7470 } 7471 7472 // C++ [expr.pseudo]p2: 7473 // [...] The cv-unqualified versions of the object type and of the type 7474 // designated by the pseudo-destructor-name shall be the same type. 7475 if (DestructedTypeInfo) { 7476 QualType DestructedType = DestructedTypeInfo->getType(); 7477 SourceLocation DestructedTypeStart 7478 = DestructedTypeInfo->getTypeLoc().getLocalSourceRange().getBegin(); 7479 if (!DestructedType->isDependentType() && !ObjectType->isDependentType()) { 7480 if (!Context.hasSameUnqualifiedType(DestructedType, ObjectType)) { 7481 // Detect dot pseudo destructor calls on pointer objects, e.g.: 7482 // Foo *foo; 7483 // foo.~Foo(); 7484 if (OpKind == tok::period && ObjectType->isPointerType() && 7485 Context.hasSameUnqualifiedType(DestructedType, 7486 ObjectType->getPointeeType())) { 7487 auto Diagnostic = 7488 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) 7489 << ObjectType << /*IsArrow=*/0 << Base->getSourceRange(); 7490 7491 // Issue a fixit only when the destructor is valid. 7492 if (canRecoverDotPseudoDestructorCallsOnPointerObjects( 7493 *this, DestructedType)) 7494 Diagnostic << FixItHint::CreateReplacement(OpLoc, "->"); 7495 7496 // Recover by setting the object type to the destructed type and the 7497 // operator to '->'. 7498 ObjectType = DestructedType; 7499 OpKind = tok::arrow; 7500 } else { 7501 Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch) 7502 << ObjectType << DestructedType << Base->getSourceRange() 7503 << DestructedTypeInfo->getTypeLoc().getLocalSourceRange(); 7504 7505 // Recover by setting the destructed type to the object type. 7506 DestructedType = ObjectType; 7507 DestructedTypeInfo = 7508 Context.getTrivialTypeSourceInfo(ObjectType, DestructedTypeStart); 7509 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 7510 } 7511 } else if (DestructedType.getObjCLifetime() != 7512 ObjectType.getObjCLifetime()) { 7513 7514 if (DestructedType.getObjCLifetime() == Qualifiers::OCL_None) { 7515 // Okay: just pretend that the user provided the correctly-qualified 7516 // type. 7517 } else { 7518 Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals) 7519 << ObjectType << DestructedType << Base->getSourceRange() 7520 << DestructedTypeInfo->getTypeLoc().getLocalSourceRange(); 7521 } 7522 7523 // Recover by setting the destructed type to the object type. 7524 DestructedType = ObjectType; 7525 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(ObjectType, 7526 DestructedTypeStart); 7527 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 7528 } 7529 } 7530 } 7531 7532 // C++ [expr.pseudo]p2: 7533 // [...] Furthermore, the two type-names in a pseudo-destructor-name of the 7534 // form 7535 // 7536 // ::[opt] nested-name-specifier[opt] type-name :: ~ type-name 7537 // 7538 // shall designate the same scalar type. 7539 if (ScopeTypeInfo) { 7540 QualType ScopeType = ScopeTypeInfo->getType(); 7541 if (!ScopeType->isDependentType() && !ObjectType->isDependentType() && 7542 !Context.hasSameUnqualifiedType(ScopeType, ObjectType)) { 7543 7544 Diag(ScopeTypeInfo->getTypeLoc().getLocalSourceRange().getBegin(), 7545 diag::err_pseudo_dtor_type_mismatch) 7546 << ObjectType << ScopeType << Base->getSourceRange() 7547 << ScopeTypeInfo->getTypeLoc().getLocalSourceRange(); 7548 7549 ScopeType = QualType(); 7550 ScopeTypeInfo = nullptr; 7551 } 7552 } 7553 7554 Expr *Result 7555 = new (Context) CXXPseudoDestructorExpr(Context, Base, 7556 OpKind == tok::arrow, OpLoc, 7557 SS.getWithLocInContext(Context), 7558 ScopeTypeInfo, 7559 CCLoc, 7560 TildeLoc, 7561 Destructed); 7562 7563 return Result; 7564} 7565 7566ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base, 7567 SourceLocation OpLoc, 7568 tok::TokenKind OpKind, 7569 CXXScopeSpec &SS, 7570 UnqualifiedId &FirstTypeName, 7571 SourceLocation CCLoc, 7572 SourceLocation TildeLoc, 7573 UnqualifiedId &SecondTypeName) { 7574 assert((FirstTypeName.getKind() == UnqualifiedIdKind::IK_TemplateId ||((void)0) 7575 FirstTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) &&((void)0) 7576 "Invalid first type name in pseudo-destructor")((void)0); 7577 assert((SecondTypeName.getKind() == UnqualifiedIdKind::IK_TemplateId ||((void)0) 7578 SecondTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) &&((void)0) 7579 "Invalid second type name in pseudo-destructor")((void)0); 7580 7581 QualType ObjectType; 7582 if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc)) 7583 return ExprError(); 7584 7585 // Compute the object type that we should use for name lookup purposes. Only 7586 // record types and dependent types matter. 7587 ParsedType ObjectTypePtrForLookup; 7588 if (!SS.isSet()) { 7589 if (ObjectType->isRecordType()) 7590 ObjectTypePtrForLookup = ParsedType::make(ObjectType); 7591 else if (ObjectType->isDependentType()) 7592 ObjectTypePtrForLookup = ParsedType::make(Context.DependentTy); 7593 } 7594 7595 // Convert the name of the type being destructed (following the ~) into a 7596 // type (with source-location information). 7597 QualType DestructedType; 7598 TypeSourceInfo *DestructedTypeInfo = nullptr; 7599 PseudoDestructorTypeStorage Destructed; 7600 if (SecondTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) { 7601 ParsedType T = getTypeName(*SecondTypeName.Identifier, 7602 SecondTypeName.StartLocation, 7603 S, &SS, true, false, ObjectTypePtrForLookup, 7604 /*IsCtorOrDtorName*/true); 7605 if (!T && 7606 ((SS.isSet() && !computeDeclContext(SS, false)) || 7607 (!SS.isSet() && ObjectType->isDependentType()))) { 7608 // The name of the type being destroyed is a dependent name, and we 7609 // couldn't find anything useful in scope. Just store the identifier and 7610 // it's location, and we'll perform (qualified) name lookup again at 7611 // template instantiation time. 7612 Destructed = PseudoDestructorTypeStorage(SecondTypeName.Identifier, 7613 SecondTypeName.StartLocation); 7614 } else if (!T) { 7615 Diag(SecondTypeName.StartLocation, 7616 diag::err_pseudo_dtor_destructor_non_type) 7617 << SecondTypeName.Identifier << ObjectType; 7618 if (isSFINAEContext()) 7619 return ExprError(); 7620 7621 // Recover by assuming we had the right type all along. 7622 DestructedType = ObjectType; 7623 } else 7624 DestructedType = GetTypeFromParser(T, &DestructedTypeInfo); 7625 } else { 7626 // Resolve the template-id to a type. 7627 TemplateIdAnnotation *TemplateId = SecondTypeName.TemplateId; 7628 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(), 7629 TemplateId->NumArgs); 7630 TypeResult T = ActOnTemplateIdType(S, 7631 SS, 7632 TemplateId->TemplateKWLoc, 7633 TemplateId->Template, 7634 TemplateId->Name, 7635 TemplateId->TemplateNameLoc, 7636 TemplateId->LAngleLoc, 7637 TemplateArgsPtr, 7638 TemplateId->RAngleLoc, 7639 /*IsCtorOrDtorName*/true); 7640 if (T.isInvalid() || !T.get()) { 7641 // Recover by assuming we had the right type all along. 7642 DestructedType = ObjectType; 7643 } else 7644 DestructedType = GetTypeFromParser(T.get(), &DestructedTypeInfo); 7645 } 7646 7647 // If we've performed some kind of recovery, (re-)build the type source 7648 // information. 7649 if (!DestructedType.isNull()) { 7650 if (!DestructedTypeInfo) 7651 DestructedTypeInfo = Context.getTrivialTypeSourceInfo(DestructedType, 7652 SecondTypeName.StartLocation); 7653 Destructed = PseudoDestructorTypeStorage(DestructedTypeInfo); 7654 } 7655 7656 // Convert the name of the scope type (the type prior to '::') into a type. 7657 TypeSourceInfo *ScopeTypeInfo = nullptr; 7658 QualType ScopeType; 7659 if (FirstTypeName.getKind() == UnqualifiedIdKind::IK_TemplateId || 7660 FirstTypeName.Identifier) { 7661 if (FirstTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) { 7662 ParsedType T = getTypeName(*FirstTypeName.Identifier, 7663 FirstTypeName.StartLocation, 7664 S, &SS, true, false, ObjectTypePtrForLookup, 7665 /*IsCtorOrDtorName*/true); 7666 if (!T) { 7667 Diag(FirstTypeName.StartLocation, 7668 diag::err_pseudo_dtor_destructor_non_type) 7669 << FirstTypeName.Identifier << ObjectType; 7670 7671 if (isSFINAEContext()) 7672 return ExprError(); 7673 7674 // Just drop this type. It's unnecessary anyway. 7675 ScopeType = QualType(); 7676 } else 7677 ScopeType = GetTypeFromParser(T, &ScopeTypeInfo); 7678 } else { 7679 // Resolve the template-id to a type. 7680 TemplateIdAnnotation *TemplateId = FirstTypeName.TemplateId; 7681 ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(), 7682 TemplateId->NumArgs); 7683 TypeResult T = ActOnTemplateIdType(S, 7684 SS, 7685 TemplateId->TemplateKWLoc, 7686 TemplateId->Template, 7687 TemplateId->Name, 7688 TemplateId->TemplateNameLoc, 7689 TemplateId->LAngleLoc, 7690 TemplateArgsPtr, 7691 TemplateId->RAngleLoc, 7692 /*IsCtorOrDtorName*/true); 7693 if (T.isInvalid() || !T.get()) { 7694 // Recover by dropping this type. 7695 ScopeType = QualType(); 7696 } else 7697 ScopeType = GetTypeFromParser(T.get(), &ScopeTypeInfo); 7698 } 7699 } 7700 7701 if (!ScopeType.isNull() && !ScopeTypeInfo) 7702 ScopeTypeInfo = Context.getTrivialTypeSourceInfo(ScopeType, 7703 FirstTypeName.StartLocation); 7704 7705 7706 return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, SS, 7707 ScopeTypeInfo, CCLoc, TildeLoc, 7708 Destructed); 7709} 7710 7711ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base, 7712 SourceLocation OpLoc, 7713 tok::TokenKind OpKind, 7714 SourceLocation TildeLoc, 7715 const DeclSpec& DS) { 7716 QualType ObjectType; 7717 if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc)) 7718 return ExprError(); 7719 7720 if (DS.getTypeSpecType() == DeclSpec::TST_decltype_auto) { 7721 Diag(DS.getTypeSpecTypeLoc(), diag::err_decltype_auto_invalid); 7722 return true; 7723 } 7724 7725 QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc(), 7726 false); 7727 7728 TypeLocBuilder TLB; 7729 DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T); 7730 DecltypeTL.setNameLoc(DS.getTypeSpecTypeLoc()); 7731 TypeSourceInfo *DestructedTypeInfo = TLB.getTypeSourceInfo(Context, T); 7732 PseudoDestructorTypeStorage Destructed(DestructedTypeInfo); 7733 7734 return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, CXXScopeSpec(), 7735 nullptr, SourceLocation(), TildeLoc, 7736 Destructed); 7737} 7738 7739ExprResult Sema::BuildCXXMemberCallExpr(Expr *E, NamedDecl *FoundDecl, 7740 CXXConversionDecl *Method, 7741 bool HadMultipleCandidates) { 7742 // Convert the expression to match the conversion function's implicit object 7743 // parameter. 7744 ExprResult Exp = PerformObjectArgumentInitialization(E, /*Qualifier=*/nullptr, 7745 FoundDecl, Method); 7746 if (Exp.isInvalid()) 7747 return true; 7748 7749 if (Method->getParent()->isLambda() && 7750 Method->getConversionType()->isBlockPointerType()) { 7751 // This is a lambda conversion to block pointer; check if the argument 7752 // was a LambdaExpr. 7753 Expr *SubE = E; 7754 CastExpr *CE = dyn_cast<CastExpr>(SubE); 7755 if (CE && CE->getCastKind() == CK_NoOp) 7756 SubE = CE->getSubExpr(); 7757 SubE = SubE->IgnoreParens(); 7758 if (CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(SubE)) 7759 SubE = BE->getSubExpr(); 7760 if (isa<LambdaExpr>(SubE)) { 7761 // For the conversion to block pointer on a lambda expression, we 7762 // construct a special BlockLiteral instead; this doesn't really make 7763 // a difference in ARC, but outside of ARC the resulting block literal 7764 // follows the normal lifetime rules for block literals instead of being 7765 // autoreleased. 7766 PushExpressionEvaluationContext( 7767 ExpressionEvaluationContext::PotentiallyEvaluated); 7768 ExprResult BlockExp = BuildBlockForLambdaConversion( 7769 Exp.get()->getExprLoc(), Exp.get()->getExprLoc(), Method, Exp.get()); 7770 PopExpressionEvaluationContext(); 7771 7772 // FIXME: This note should be produced by a CodeSynthesisContext. 7773 if (BlockExp.isInvalid()) 7774 Diag(Exp.get()->getExprLoc(), diag::note_lambda_to_block_conv); 7775 return BlockExp; 7776 } 7777 } 7778 7779 MemberExpr *ME = 7780 BuildMemberExpr(Exp.get(), /*IsArrow=*/false, SourceLocation(), 7781 NestedNameSpecifierLoc(), SourceLocation(), Method, 7782 DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()), 7783 HadMultipleCandidates, DeclarationNameInfo(), 7784 Context.BoundMemberTy, VK_PRValue, OK_Ordinary); 7785 7786 QualType ResultType = Method->getReturnType(); 7787 ExprValueKind VK = Expr::getValueKindForType(ResultType); 7788 ResultType = ResultType.getNonLValueExprType(Context); 7789 7790 CXXMemberCallExpr *CE = CXXMemberCallExpr::Create( 7791 Context, ME, /*Args=*/{}, ResultType, VK, Exp.get()->getEndLoc(), 7792 CurFPFeatureOverrides()); 7793 7794 if (CheckFunctionCall(Method, CE, 7795 Method->getType()->castAs<FunctionProtoType>())) 7796 return ExprError(); 7797 7798 return CheckForImmediateInvocation(CE, CE->getMethodDecl()); 7799} 7800 7801ExprResult Sema::BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand, 7802 SourceLocation RParen) { 7803 // If the operand is an unresolved lookup expression, the expression is ill- 7804 // formed per [over.over]p1, because overloaded function names cannot be used 7805 // without arguments except in explicit contexts. 7806 ExprResult R = CheckPlaceholderExpr(Operand); 7807 if (R.isInvalid()) 7808 return R; 7809 7810 R = CheckUnevaluatedOperand(R.get()); 7811 if (R.isInvalid()) 7812 return ExprError(); 7813 7814 Operand = R.get(); 7815 7816 if (!inTemplateInstantiation() && !Operand->isInstantiationDependent() && 7817 Operand->HasSideEffects(Context, false)) { 7818 // The expression operand for noexcept is in an unevaluated expression 7819 // context, so side effects could result in unintended consequences. 7820 Diag(Operand->getExprLoc(), diag::warn_side_effects_unevaluated_context); 7821 } 7822 7823 CanThrowResult CanThrow = canThrow(Operand); 7824 return new (Context) 7825 CXXNoexceptExpr(Context.BoolTy, Operand, CanThrow, KeyLoc, RParen); 7826} 7827 7828ExprResult Sema::ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation, 7829 Expr *Operand, SourceLocation RParen) { 7830 return BuildCXXNoexceptExpr(KeyLoc, Operand, RParen); 7831} 7832 7833static void MaybeDecrementCount( 7834 Expr *E, llvm::DenseMap<const VarDecl *, int> &RefsMinusAssignments) { 7835 DeclRefExpr *LHS = nullptr; 7836 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 7837 if (BO->getLHS()->getType()->isDependentType() || 7838 BO->getRHS()->getType()->isDependentType()) { 7839 if (BO->getOpcode() != BO_Assign) 7840 return; 7841 } else if (!BO->isAssignmentOp()) 7842 return; 7843 LHS = dyn_cast<DeclRefExpr>(BO->getLHS()); 7844 } else if (CXXOperatorCallExpr *COCE = dyn_cast<CXXOperatorCallExpr>(E)) { 7845 if (COCE->getOperator() != OO_Equal) 7846 return; 7847 LHS = dyn_cast<DeclRefExpr>(COCE->getArg(0)); 7848 } 7849 if (!LHS) 7850 return; 7851 VarDecl *VD = dyn_cast<VarDecl>(LHS->getDecl()); 7852 if (!VD) 7853 return; 7854 auto iter = RefsMinusAssignments.find(VD); 7855 if (iter == RefsMinusAssignments.end()) 7856 return; 7857 iter->getSecond()--; 7858} 7859 7860/// Perform the conversions required for an expression used in a 7861/// context that ignores the result. 7862ExprResult Sema::IgnoredValueConversions(Expr *E) { 7863 MaybeDecrementCount(E, RefsMinusAssignments); 7864 7865 if (E->hasPlaceholderType()) { 7866 ExprResult result = CheckPlaceholderExpr(E); 7867 if (result.isInvalid()) return E; 7868 E = result.get(); 7869 } 7870 7871 // C99 6.3.2.1: 7872 // [Except in specific positions,] an lvalue that does not have 7873 // array type is converted to the value stored in the 7874 // designated object (and is no longer an lvalue). 7875 if (E->isPRValue()) { 7876 // In C, function designators (i.e. expressions of function type) 7877 // are r-values, but we still want to do function-to-pointer decay 7878 // on them. This is both technically correct and convenient for 7879 // some clients. 7880 if (!getLangOpts().CPlusPlus && E->getType()->isFunctionType()) 7881 return DefaultFunctionArrayConversion(E); 7882 7883 return E; 7884 } 7885 7886 if (getLangOpts().CPlusPlus) { 7887 // The C++11 standard defines the notion of a discarded-value expression; 7888 // normally, we don't need to do anything to handle it, but if it is a 7889 // volatile lvalue with a special form, we perform an lvalue-to-rvalue 7890 // conversion. 7891 if (getLangOpts().CPlusPlus11 && E->isReadIfDiscardedInCPlusPlus11()) { 7892 ExprResult Res = DefaultLvalueConversion(E); 7893 if (Res.isInvalid()) 7894 return E; 7895 E = Res.get(); 7896 } else { 7897 // Per C++2a [expr.ass]p5, a volatile assignment is not deprecated if 7898 // it occurs as a discarded-value expression. 7899 CheckUnusedVolatileAssignment(E); 7900 } 7901 7902 // C++1z: 7903 // If the expression is a prvalue after this optional conversion, the 7904 // temporary materialization conversion is applied. 7905 // 7906 // We skip this step: IR generation is able to synthesize the storage for 7907 // itself in the aggregate case, and adding the extra node to the AST is 7908 // just clutter. 7909 // FIXME: We don't emit lifetime markers for the temporaries due to this. 7910 // FIXME: Do any other AST consumers care about this? 7911 return E; 7912 } 7913 7914 // GCC seems to also exclude expressions of incomplete enum type. 7915 if (const EnumType *T = E->getType()->getAs<EnumType>()) { 7916 if (!T->getDecl()->isComplete()) { 7917 // FIXME: stupid workaround for a codegen bug! 7918 E = ImpCastExprToType(E, Context.VoidTy, CK_ToVoid).get(); 7919 return E; 7920 } 7921 } 7922 7923 ExprResult Res = DefaultFunctionArrayLvalueConversion(E); 7924 if (Res.isInvalid()) 7925 return E; 7926 E = Res.get(); 7927 7928 if (!E->getType()->isVoidType()) 7929 RequireCompleteType(E->getExprLoc(), E->getType(), 7930 diag::err_incomplete_type); 7931 return E; 7932} 7933 7934ExprResult Sema::CheckUnevaluatedOperand(Expr *E) { 7935 // Per C++2a [expr.ass]p5, a volatile assignment is not deprecated if 7936 // it occurs as an unevaluated operand. 7937 CheckUnusedVolatileAssignment(E); 7938 7939 return E; 7940} 7941 7942// If we can unambiguously determine whether Var can never be used 7943// in a constant expression, return true. 7944// - if the variable and its initializer are non-dependent, then 7945// we can unambiguously check if the variable is a constant expression. 7946// - if the initializer is not value dependent - we can determine whether 7947// it can be used to initialize a constant expression. If Init can not 7948// be used to initialize a constant expression we conclude that Var can 7949// never be a constant expression. 7950// - FXIME: if the initializer is dependent, we can still do some analysis and 7951// identify certain cases unambiguously as non-const by using a Visitor: 7952// - such as those that involve odr-use of a ParmVarDecl, involve a new 7953// delete, lambda-expr, dynamic-cast, reinterpret-cast etc... 7954static inline bool VariableCanNeverBeAConstantExpression(VarDecl *Var, 7955 ASTContext &Context) { 7956 if (isa<ParmVarDecl>(Var)) return true; 7957 const VarDecl *DefVD = nullptr; 7958 7959 // If there is no initializer - this can not be a constant expression. 7960 if (!Var->getAnyInitializer(DefVD)) return true; 7961 assert(DefVD)((void)0); 7962 if (DefVD->isWeak()) return false; 7963 EvaluatedStmt *Eval = DefVD->ensureEvaluatedStmt(); 7964 7965 Expr *Init = cast<Expr>(Eval->Value); 7966 7967 if (Var->getType()->isDependentType() || Init->isValueDependent()) { 7968 // FIXME: Teach the constant evaluator to deal with the non-dependent parts 7969 // of value-dependent expressions, and use it here to determine whether the 7970 // initializer is a potential constant expression. 7971 return false; 7972 } 7973 7974 return !Var->isUsableInConstantExpressions(Context); 7975} 7976 7977/// Check if the current lambda has any potential captures 7978/// that must be captured by any of its enclosing lambdas that are ready to 7979/// capture. If there is a lambda that can capture a nested 7980/// potential-capture, go ahead and do so. Also, check to see if any 7981/// variables are uncaptureable or do not involve an odr-use so do not 7982/// need to be captured. 7983 7984static void CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures( 7985 Expr *const FE, LambdaScopeInfo *const CurrentLSI, Sema &S) { 7986 7987 assert(!S.isUnevaluatedContext())((void)0); 7988 assert(S.CurContext->isDependentContext())((void)0); 7989#ifndef NDEBUG1 7990 DeclContext *DC = S.CurContext; 7991 while (DC && isa<CapturedDecl>(DC)) 7992 DC = DC->getParent(); 7993 assert(((void)0) 7994 CurrentLSI->CallOperator == DC &&((void)0) 7995 "The current call operator must be synchronized with Sema's CurContext")((void)0); 7996#endif // NDEBUG 7997 7998 const bool IsFullExprInstantiationDependent = FE->isInstantiationDependent(); 7999 8000 // All the potentially captureable variables in the current nested 8001 // lambda (within a generic outer lambda), must be captured by an 8002 // outer lambda that is enclosed within a non-dependent context. 8003 CurrentLSI->visitPotentialCaptures([&] (VarDecl *Var, Expr *VarExpr) { 8004 // If the variable is clearly identified as non-odr-used and the full 8005 // expression is not instantiation dependent, only then do we not 8006 // need to check enclosing lambda's for speculative captures. 8007 // For e.g.: 8008 // Even though 'x' is not odr-used, it should be captured. 8009 // int test() { 8010 // const int x = 10; 8011 // auto L = [=](auto a) { 8012 // (void) +x + a; 8013 // }; 8014 // } 8015 if (CurrentLSI->isVariableExprMarkedAsNonODRUsed(VarExpr) && 8016 !IsFullExprInstantiationDependent) 8017 return; 8018 8019 // If we have a capture-capable lambda for the variable, go ahead and 8020 // capture the variable in that lambda (and all its enclosing lambdas). 8021 if (const Optional<unsigned> Index = 8022 getStackIndexOfNearestEnclosingCaptureCapableLambda( 8023 S.FunctionScopes, Var, S)) 8024 S.MarkCaptureUsedInEnclosingContext(Var, VarExpr->getExprLoc(), 8025 Index.getValue()); 8026 const bool IsVarNeverAConstantExpression = 8027 VariableCanNeverBeAConstantExpression(Var, S.Context); 8028 if (!IsFullExprInstantiationDependent || IsVarNeverAConstantExpression) { 8029 // This full expression is not instantiation dependent or the variable 8030 // can not be used in a constant expression - which means 8031 // this variable must be odr-used here, so diagnose a 8032 // capture violation early, if the variable is un-captureable. 8033 // This is purely for diagnosing errors early. Otherwise, this 8034 // error would get diagnosed when the lambda becomes capture ready. 8035 QualType CaptureType, DeclRefType; 8036 SourceLocation ExprLoc = VarExpr->getExprLoc(); 8037 if (S.tryCaptureVariable(Var, ExprLoc, S.TryCapture_Implicit, 8038 /*EllipsisLoc*/ SourceLocation(), 8039 /*BuildAndDiagnose*/false, CaptureType, 8040 DeclRefType, nullptr)) { 8041 // We will never be able to capture this variable, and we need 8042 // to be able to in any and all instantiations, so diagnose it. 8043 S.tryCaptureVariable(Var, ExprLoc, S.TryCapture_Implicit, 8044 /*EllipsisLoc*/ SourceLocation(), 8045 /*BuildAndDiagnose*/true, CaptureType, 8046 DeclRefType, nullptr); 8047 } 8048 } 8049 }); 8050 8051 // Check if 'this' needs to be captured. 8052 if (CurrentLSI->hasPotentialThisCapture()) { 8053 // If we have a capture-capable lambda for 'this', go ahead and capture 8054 // 'this' in that lambda (and all its enclosing lambdas). 8055 if (const Optional<unsigned> Index = 8056 getStackIndexOfNearestEnclosingCaptureCapableLambda( 8057 S.FunctionScopes, /*0 is 'this'*/ nullptr, S)) { 8058 const unsigned FunctionScopeIndexOfCapturableLambda = Index.getValue(); 8059 S.CheckCXXThisCapture(CurrentLSI->PotentialThisCaptureLocation, 8060 /*Explicit*/ false, /*BuildAndDiagnose*/ true, 8061 &FunctionScopeIndexOfCapturableLambda); 8062 } 8063 } 8064 8065 // Reset all the potential captures at the end of each full-expression. 8066 CurrentLSI->clearPotentialCaptures(); 8067} 8068 8069static ExprResult attemptRecovery(Sema &SemaRef, 8070 const TypoCorrectionConsumer &Consumer, 8071 const TypoCorrection &TC) { 8072 LookupResult R(SemaRef, Consumer.getLookupResult().getLookupNameInfo(), 8073 Consumer.getLookupResult().getLookupKind()); 8074 const CXXScopeSpec *SS = Consumer.getSS(); 8075 CXXScopeSpec NewSS; 8076 8077 // Use an approprate CXXScopeSpec for building the expr. 8078 if (auto *NNS = TC.getCorrectionSpecifier()) 8079 NewSS.MakeTrivial(SemaRef.Context, NNS, TC.getCorrectionRange()); 8080 else if (SS && !TC.WillReplaceSpecifier()) 8081 NewSS = *SS; 8082 8083 if (auto *ND = TC.getFoundDecl()) { 8084 R.setLookupName(ND->getDeclName()); 8085 R.addDecl(ND); 8086 if (ND->isCXXClassMember()) { 8087 // Figure out the correct naming class to add to the LookupResult. 8088 CXXRecordDecl *Record = nullptr; 8089 if (auto *NNS = TC.getCorrectionSpecifier()) 8090 Record = NNS->getAsType()->getAsCXXRecordDecl(); 8091 if (!Record) 8092 Record = 8093 dyn_cast<CXXRecordDecl>(ND->getDeclContext()->getRedeclContext()); 8094 if (Record) 8095 R.setNamingClass(Record); 8096 8097 // Detect and handle the case where the decl might be an implicit 8098 // member. 8099 bool MightBeImplicitMember; 8100 if (!Consumer.isAddressOfOperand()) 8101 MightBeImplicitMember = true; 8102 else if (!NewSS.isEmpty()) 8103 MightBeImplicitMember = false; 8104 else if (R.isOverloadedResult()) 8105 MightBeImplicitMember = false; 8106 else if (R.isUnresolvableResult()) 8107 MightBeImplicitMember = true; 8108 else 8109 MightBeImplicitMember = isa<FieldDecl>(ND) || 8110 isa<IndirectFieldDecl>(ND) || 8111 isa<MSPropertyDecl>(ND); 8112 8113 if (MightBeImplicitMember) 8114 return SemaRef.BuildPossibleImplicitMemberExpr( 8115 NewSS, /*TemplateKWLoc*/ SourceLocation(), R, 8116 /*TemplateArgs*/ nullptr, /*S*/ nullptr); 8117 } else if (auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) { 8118 return SemaRef.LookupInObjCMethod(R, Consumer.getScope(), 8119 Ivar->getIdentifier()); 8120 } 8121 } 8122 8123 return SemaRef.BuildDeclarationNameExpr(NewSS, R, /*NeedsADL*/ false, 8124 /*AcceptInvalidDecl*/ true); 8125} 8126 8127namespace { 8128class FindTypoExprs : public RecursiveASTVisitor<FindTypoExprs> { 8129 llvm::SmallSetVector<TypoExpr *, 2> &TypoExprs; 8130 8131public: 8132 explicit FindTypoExprs(llvm::SmallSetVector<TypoExpr *, 2> &TypoExprs) 8133 : TypoExprs(TypoExprs) {} 8134 bool VisitTypoExpr(TypoExpr *TE) { 8135 TypoExprs.insert(TE); 8136 return true; 8137 } 8138}; 8139 8140class TransformTypos : public TreeTransform<TransformTypos> { 8141 typedef TreeTransform<TransformTypos> BaseTransform; 8142 8143 VarDecl *InitDecl; // A decl to avoid as a correction because it is in the 8144 // process of being initialized. 8145 llvm::function_ref<ExprResult(Expr *)> ExprFilter; 8146 llvm::SmallSetVector<TypoExpr *, 2> TypoExprs, AmbiguousTypoExprs; 8147 llvm::SmallDenseMap<TypoExpr *, ExprResult, 2> TransformCache; 8148 llvm::SmallDenseMap<OverloadExpr *, Expr *, 4> OverloadResolution; 8149 8150 /// Emit diagnostics for all of the TypoExprs encountered. 8151 /// 8152 /// If the TypoExprs were successfully corrected, then the diagnostics should 8153 /// suggest the corrections. Otherwise the diagnostics will not suggest 8154 /// anything (having been passed an empty TypoCorrection). 8155 /// 8156 /// If we've failed to correct due to ambiguous corrections, we need to 8157 /// be sure to pass empty corrections and replacements. Otherwise it's 8158 /// possible that the Consumer has a TypoCorrection that failed to ambiguity 8159 /// and we don't want to report those diagnostics. 8160 void EmitAllDiagnostics(bool IsAmbiguous) { 8161 for (TypoExpr *TE : TypoExprs) { 8162 auto &State = SemaRef.getTypoExprState(TE); 8163 if (State.DiagHandler) { 8164 TypoCorrection TC = IsAmbiguous 8165 ? TypoCorrection() : State.Consumer->getCurrentCorrection(); 8166 ExprResult Replacement = IsAmbiguous ? ExprError() : TransformCache[TE]; 8167 8168 // Extract the NamedDecl from the transformed TypoExpr and add it to the 8169 // TypoCorrection, replacing the existing decls. This ensures the right 8170 // NamedDecl is used in diagnostics e.g. in the case where overload 8171 // resolution was used to select one from several possible decls that 8172 // had been stored in the TypoCorrection. 8173 if (auto *ND = getDeclFromExpr( 8174 Replacement.isInvalid() ? nullptr : Replacement.get())) 8175 TC.setCorrectionDecl(ND); 8176 8177 State.DiagHandler(TC); 8178 } 8179 SemaRef.clearDelayedTypo(TE); 8180 } 8181 } 8182 8183 /// Try to advance the typo correction state of the first unfinished TypoExpr. 8184 /// We allow advancement of the correction stream by removing it from the 8185 /// TransformCache which allows `TransformTypoExpr` to advance during the 8186 /// next transformation attempt. 8187 /// 8188 /// Any substitution attempts for the previous TypoExprs (which must have been 8189 /// finished) will need to be retried since it's possible that they will now 8190 /// be invalid given the latest advancement. 8191 /// 8192 /// We need to be sure that we're making progress - it's possible that the 8193 /// tree is so malformed that the transform never makes it to the 8194 /// `TransformTypoExpr`. 8195 /// 8196 /// Returns true if there are any untried correction combinations. 8197 bool CheckAndAdvanceTypoExprCorrectionStreams() { 8198 for (auto TE : TypoExprs) { 8199 auto &State = SemaRef.getTypoExprState(TE); 8200 TransformCache.erase(TE); 8201 if (!State.Consumer->hasMadeAnyCorrectionProgress()) 8202 return false; 8203 if (!State.Consumer->finished()) 8204 return true; 8205 State.Consumer->resetCorrectionStream(); 8206 } 8207 return false; 8208 } 8209 8210 NamedDecl *getDeclFromExpr(Expr *E) { 8211 if (auto *OE = dyn_cast_or_null<OverloadExpr>(E)) 8212 E = OverloadResolution[OE]; 8213 8214 if (!E) 8215 return nullptr; 8216 if (auto *DRE = dyn_cast<DeclRefExpr>(E)) 8217 return DRE->getFoundDecl(); 8218 if (auto *ME = dyn_cast<MemberExpr>(E)) 8219 return ME->getFoundDecl(); 8220 // FIXME: Add any other expr types that could be be seen by the delayed typo 8221 // correction TreeTransform for which the corresponding TypoCorrection could 8222 // contain multiple decls. 8223 return nullptr; 8224 } 8225 8226 ExprResult TryTransform(Expr *E) { 8227 Sema::SFINAETrap Trap(SemaRef); 8228 ExprResult Res = TransformExpr(E); 8229 if (Trap.hasErrorOccurred() || Res.isInvalid()) 8230 return ExprError(); 8231 8232 return ExprFilter(Res.get()); 8233 } 8234 8235 // Since correcting typos may intoduce new TypoExprs, this function 8236 // checks for new TypoExprs and recurses if it finds any. Note that it will 8237 // only succeed if it is able to correct all typos in the given expression. 8238 ExprResult CheckForRecursiveTypos(ExprResult Res, bool &IsAmbiguous) { 8239 if (Res.isInvalid()) { 8240 return Res; 8241 } 8242 // Check to see if any new TypoExprs were created. If so, we need to recurse 8243 // to check their validity. 8244 Expr *FixedExpr = Res.get(); 8245 8246 auto SavedTypoExprs = std::move(TypoExprs); 8247 auto SavedAmbiguousTypoExprs = std::move(AmbiguousTypoExprs); 8248 TypoExprs.clear(); 8249 AmbiguousTypoExprs.clear(); 8250 8251 FindTypoExprs(TypoExprs).TraverseStmt(FixedExpr); 8252 if (!TypoExprs.empty()) { 8253 // Recurse to handle newly created TypoExprs. If we're not able to 8254 // handle them, discard these TypoExprs. 8255 ExprResult RecurResult = 8256 RecursiveTransformLoop(FixedExpr, IsAmbiguous); 8257 if (RecurResult.isInvalid()) { 8258 Res = ExprError(); 8259 // Recursive corrections didn't work, wipe them away and don't add 8260 // them to the TypoExprs set. Remove them from Sema's TypoExpr list 8261 // since we don't want to clear them twice. Note: it's possible the 8262 // TypoExprs were created recursively and thus won't be in our 8263 // Sema's TypoExprs - they were created in our `RecursiveTransformLoop`. 8264 auto &SemaTypoExprs = SemaRef.TypoExprs; 8265 for (auto TE : TypoExprs) { 8266 TransformCache.erase(TE); 8267 SemaRef.clearDelayedTypo(TE); 8268 8269 auto SI = find(SemaTypoExprs, TE); 8270 if (SI != SemaTypoExprs.end()) { 8271 SemaTypoExprs.erase(SI); 8272 } 8273 } 8274 } else { 8275 // TypoExpr is valid: add newly created TypoExprs since we were 8276 // able to correct them. 8277 Res = RecurResult; 8278 SavedTypoExprs.set_union(TypoExprs); 8279 } 8280 } 8281 8282 TypoExprs = std::move(SavedTypoExprs); 8283 AmbiguousTypoExprs = std::move(SavedAmbiguousTypoExprs); 8284 8285 return Res; 8286 } 8287 8288 // Try to transform the given expression, looping through the correction 8289 // candidates with `CheckAndAdvanceTypoExprCorrectionStreams`. 8290 // 8291 // If valid ambiguous typo corrections are seen, `IsAmbiguous` is set to 8292 // true and this method immediately will return an `ExprError`. 8293 ExprResult RecursiveTransformLoop(Expr *E, bool &IsAmbiguous) { 8294 ExprResult Res; 8295 auto SavedTypoExprs = std::move(SemaRef.TypoExprs); 8296 SemaRef.TypoExprs.clear(); 8297 8298 while (true) { 8299 Res = CheckForRecursiveTypos(TryTransform(E), IsAmbiguous); 8300 8301 // Recursion encountered an ambiguous correction. This means that our 8302 // correction itself is ambiguous, so stop now. 8303 if (IsAmbiguous) 8304 break; 8305 8306 // If the transform is still valid after checking for any new typos, 8307 // it's good to go. 8308 if (!Res.isInvalid()) 8309 break; 8310 8311 // The transform was invalid, see if we have any TypoExprs with untried 8312 // correction candidates. 8313 if (!CheckAndAdvanceTypoExprCorrectionStreams()) 8314 break; 8315 } 8316 8317 // If we found a valid result, double check to make sure it's not ambiguous. 8318 if (!IsAmbiguous && !Res.isInvalid() && !AmbiguousTypoExprs.empty()) { 8319 auto SavedTransformCache = 8320 llvm::SmallDenseMap<TypoExpr *, ExprResult, 2>(TransformCache); 8321 8322 // Ensure none of the TypoExprs have multiple typo correction candidates 8323 // with the same edit length that pass all the checks and filters. 8324 while (!AmbiguousTypoExprs.empty()) { 8325 auto TE = AmbiguousTypoExprs.back(); 8326 8327 // TryTransform itself can create new Typos, adding them to the TypoExpr map 8328 // and invalidating our TypoExprState, so always fetch it instead of storing. 8329 SemaRef.getTypoExprState(TE).Consumer->saveCurrentPosition(); 8330 8331 TypoCorrection TC = SemaRef.getTypoExprState(TE).Consumer->peekNextCorrection(); 8332 TypoCorrection Next; 8333 do { 8334 // Fetch the next correction by erasing the typo from the cache and calling 8335 // `TryTransform` which will iterate through corrections in 8336 // `TransformTypoExpr`. 8337 TransformCache.erase(TE); 8338 ExprResult AmbigRes = CheckForRecursiveTypos(TryTransform(E), IsAmbiguous); 8339 8340 if (!AmbigRes.isInvalid() || IsAmbiguous) { 8341 SemaRef.getTypoExprState(TE).Consumer->resetCorrectionStream(); 8342 SavedTransformCache.erase(TE); 8343 Res = ExprError(); 8344 IsAmbiguous = true; 8345 break; 8346 } 8347 } while ((Next = SemaRef.getTypoExprState(TE).Consumer->peekNextCorrection()) && 8348 Next.getEditDistance(false) == TC.getEditDistance(false)); 8349 8350 if (IsAmbiguous) 8351 break; 8352 8353 AmbiguousTypoExprs.remove(TE); 8354 SemaRef.getTypoExprState(TE).Consumer->restoreSavedPosition(); 8355 TransformCache[TE] = SavedTransformCache[TE]; 8356 } 8357 TransformCache = std::move(SavedTransformCache); 8358 } 8359 8360 // Wipe away any newly created TypoExprs that we don't know about. Since we 8361 // clear any invalid TypoExprs in `CheckForRecursiveTypos`, this is only 8362 // possible if a `TypoExpr` is created during a transformation but then 8363 // fails before we can discover it. 8364 auto &SemaTypoExprs = SemaRef.TypoExprs; 8365 for (auto Iterator = SemaTypoExprs.begin(); Iterator != SemaTypoExprs.end();) { 8366 auto TE = *Iterator; 8367 auto FI = find(TypoExprs, TE); 8368 if (FI != TypoExprs.end()) { 8369 Iterator++; 8370 continue; 8371 } 8372 SemaRef.clearDelayedTypo(TE); 8373 Iterator = SemaTypoExprs.erase(Iterator); 8374 } 8375 SemaRef.TypoExprs = std::move(SavedTypoExprs); 8376 8377 return Res; 8378 } 8379 8380public: 8381 TransformTypos(Sema &SemaRef, VarDecl *InitDecl, llvm::function_ref<ExprResult(Expr *)> Filter) 8382 : BaseTransform(SemaRef), InitDecl(InitDecl), ExprFilter(Filter) {} 8383 8384 ExprResult RebuildCallExpr(Expr *Callee, SourceLocation LParenLoc, 8385 MultiExprArg Args, 8386 SourceLocation RParenLoc, 8387 Expr *ExecConfig = nullptr) { 8388 auto Result = BaseTransform::RebuildCallExpr(Callee, LParenLoc, Args, 8389 RParenLoc, ExecConfig); 8390 if (auto *OE = dyn_cast<OverloadExpr>(Callee)) { 8391 if (Result.isUsable()) { 8392 Expr *ResultCall = Result.get(); 8393 if (auto *BE = dyn_cast<CXXBindTemporaryExpr>(ResultCall)) 8394 ResultCall = BE->getSubExpr(); 8395 if (auto *CE = dyn_cast<CallExpr>(ResultCall)) 8396 OverloadResolution[OE] = CE->getCallee(); 8397 } 8398 } 8399 return Result; 8400 } 8401 8402 ExprResult TransformLambdaExpr(LambdaExpr *E) { return Owned(E); } 8403 8404 ExprResult TransformBlockExpr(BlockExpr *E) { return Owned(E); } 8405 8406 ExprResult Transform(Expr *E) { 8407 bool IsAmbiguous = false; 8408 ExprResult Res = RecursiveTransformLoop(E, IsAmbiguous); 8409 8410 if (!Res.isUsable()) 8411 FindTypoExprs(TypoExprs).TraverseStmt(E); 8412 8413 EmitAllDiagnostics(IsAmbiguous); 8414 8415 return Res; 8416 } 8417 8418 ExprResult TransformTypoExpr(TypoExpr *E) { 8419 // If the TypoExpr hasn't been seen before, record it. Otherwise, return the 8420 // cached transformation result if there is one and the TypoExpr isn't the 8421 // first one that was encountered. 8422 auto &CacheEntry = TransformCache[E]; 8423 if (!TypoExprs.insert(E) && !CacheEntry.isUnset()) { 8424 return CacheEntry; 8425 } 8426 8427 auto &State = SemaRef.getTypoExprState(E); 8428 assert(State.Consumer && "Cannot transform a cleared TypoExpr")((void)0); 8429 8430 // For the first TypoExpr and an uncached TypoExpr, find the next likely 8431 // typo correction and return it. 8432 while (TypoCorrection TC = State.Consumer->getNextCorrection()) { 8433 if (InitDecl && TC.getFoundDecl() == InitDecl) 8434 continue; 8435 // FIXME: If we would typo-correct to an invalid declaration, it's 8436 // probably best to just suppress all errors from this typo correction. 8437 ExprResult NE = State.RecoveryHandler ? 8438 State.RecoveryHandler(SemaRef, E, TC) : 8439 attemptRecovery(SemaRef, *State.Consumer, TC); 8440 if (!NE.isInvalid()) { 8441 // Check whether there may be a second viable correction with the same 8442 // edit distance; if so, remember this TypoExpr may have an ambiguous 8443 // correction so it can be more thoroughly vetted later. 8444 TypoCorrection Next; 8445 if ((Next = State.Consumer->peekNextCorrection()) && 8446 Next.getEditDistance(false) == TC.getEditDistance(false)) { 8447 AmbiguousTypoExprs.insert(E); 8448 } else { 8449 AmbiguousTypoExprs.remove(E); 8450 } 8451 assert(!NE.isUnset() &&((void)0) 8452 "Typo was transformed into a valid-but-null ExprResult")((void)0); 8453 return CacheEntry = NE; 8454 } 8455 } 8456 return CacheEntry = ExprError(); 8457 } 8458}; 8459} 8460 8461ExprResult 8462Sema::CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl, 8463 bool RecoverUncorrectedTypos, 8464 llvm::function_ref<ExprResult(Expr *)> Filter) { 8465 // If the current evaluation context indicates there are uncorrected typos 8466 // and the current expression isn't guaranteed to not have typos, try to 8467 // resolve any TypoExpr nodes that might be in the expression. 8468 if (E && !ExprEvalContexts.empty() && ExprEvalContexts.back().NumTypos && 8469 (E->isTypeDependent() || E->isValueDependent() || 8470 E->isInstantiationDependent())) { 8471 auto TyposResolved = DelayedTypos.size(); 8472 auto Result = TransformTypos(*this, InitDecl, Filter).Transform(E); 8473 TyposResolved -= DelayedTypos.size(); 8474 if (Result.isInvalid() || Result.get() != E) { 8475 ExprEvalContexts.back().NumTypos -= TyposResolved; 8476 if (Result.isInvalid() && RecoverUncorrectedTypos) { 8477 struct TyposReplace : TreeTransform<TyposReplace> { 8478 TyposReplace(Sema &SemaRef) : TreeTransform(SemaRef) {} 8479 ExprResult TransformTypoExpr(clang::TypoExpr *E) { 8480 return this->SemaRef.CreateRecoveryExpr(E->getBeginLoc(), 8481 E->getEndLoc(), {}); 8482 } 8483 } TT(*this); 8484 return TT.TransformExpr(E); 8485 } 8486 return Result; 8487 } 8488 assert(TyposResolved == 0 && "Corrected typo but got same Expr back?")((void)0); 8489 } 8490 return E; 8491} 8492 8493ExprResult Sema::ActOnFinishFullExpr(Expr *FE, SourceLocation CC, 8494 bool DiscardedValue, 8495 bool IsConstexpr) { 8496 ExprResult FullExpr = FE; 8497 8498 if (!FullExpr.get()) 8499 return ExprError(); 8500 8501 if (DiagnoseUnexpandedParameterPack(FullExpr.get())) 8502 return ExprError(); 8503 8504 if (DiscardedValue) { 8505 // Top-level expressions default to 'id' when we're in a debugger. 8506 if (getLangOpts().DebuggerCastResultToId && 8507 FullExpr.get()->getType() == Context.UnknownAnyTy) { 8508 FullExpr = forceUnknownAnyToType(FullExpr.get(), Context.getObjCIdType()); 8509 if (FullExpr.isInvalid()) 8510 return ExprError(); 8511 } 8512 8513 FullExpr = CheckPlaceholderExpr(FullExpr.get()); 8514 if (FullExpr.isInvalid()) 8515 return ExprError(); 8516 8517 FullExpr = IgnoredValueConversions(FullExpr.get()); 8518 if (FullExpr.isInvalid()) 8519 return ExprError(); 8520 8521 DiagnoseUnusedExprResult(FullExpr.get()); 8522 } 8523 8524 FullExpr = CorrectDelayedTyposInExpr(FullExpr.get(), /*InitDecl=*/nullptr, 8525 /*RecoverUncorrectedTypos=*/true); 8526 if (FullExpr.isInvalid()) 8527 return ExprError(); 8528 8529 CheckCompletedExpr(FullExpr.get(), CC, IsConstexpr); 8530 8531 // At the end of this full expression (which could be a deeply nested 8532 // lambda), if there is a potential capture within the nested lambda, 8533 // have the outer capture-able lambda try and capture it. 8534 // Consider the following code: 8535 // void f(int, int); 8536 // void f(const int&, double); 8537 // void foo() { 8538 // const int x = 10, y = 20; 8539 // auto L = [=](auto a) { 8540 // auto M = [=](auto b) { 8541 // f(x, b); <-- requires x to be captured by L and M 8542 // f(y, a); <-- requires y to be captured by L, but not all Ms 8543 // }; 8544 // }; 8545 // } 8546 8547 // FIXME: Also consider what happens for something like this that involves 8548 // the gnu-extension statement-expressions or even lambda-init-captures: 8549 // void f() { 8550 // const int n = 0; 8551 // auto L = [&](auto a) { 8552 // +n + ({ 0; a; }); 8553 // }; 8554 // } 8555 // 8556 // Here, we see +n, and then the full-expression 0; ends, so we don't 8557 // capture n (and instead remove it from our list of potential captures), 8558 // and then the full-expression +n + ({ 0; }); ends, but it's too late 8559 // for us to see that we need to capture n after all. 8560 8561 LambdaScopeInfo *const CurrentLSI = 8562 getCurLambda(/*IgnoreCapturedRegions=*/true); 8563 // FIXME: PR 17877 showed that getCurLambda() can return a valid pointer 8564 // even if CurContext is not a lambda call operator. Refer to that Bug Report 8565 // for an example of the code that might cause this asynchrony. 8566 // By ensuring we are in the context of a lambda's call operator 8567 // we can fix the bug (we only need to check whether we need to capture 8568 // if we are within a lambda's body); but per the comments in that 8569 // PR, a proper fix would entail : 8570 // "Alternative suggestion: 8571 // - Add to Sema an integer holding the smallest (outermost) scope 8572 // index that we are *lexically* within, and save/restore/set to 8573 // FunctionScopes.size() in InstantiatingTemplate's 8574 // constructor/destructor. 8575 // - Teach the handful of places that iterate over FunctionScopes to 8576 // stop at the outermost enclosing lexical scope." 8577 DeclContext *DC = CurContext; 8578 while (DC && isa<CapturedDecl>(DC)) 8579 DC = DC->getParent(); 8580 const bool IsInLambdaDeclContext = isLambdaCallOperator(DC); 8581 if (IsInLambdaDeclContext && CurrentLSI && 8582 CurrentLSI->hasPotentialCaptures() && !FullExpr.isInvalid()) 8583 CheckIfAnyEnclosingLambdasMustCaptureAnyPotentialCaptures(FE, CurrentLSI, 8584 *this); 8585 return MaybeCreateExprWithCleanups(FullExpr); 8586} 8587 8588StmtResult Sema::ActOnFinishFullStmt(Stmt *FullStmt) { 8589 if (!FullStmt) return StmtError(); 8590 8591 return MaybeCreateStmtWithCleanups(FullStmt); 8592} 8593 8594Sema::IfExistsResult 8595Sema::CheckMicrosoftIfExistsSymbol(Scope *S, 8596 CXXScopeSpec &SS, 8597 const DeclarationNameInfo &TargetNameInfo) { 8598 DeclarationName TargetName = TargetNameInfo.getName(); 8599 if (!TargetName) 8600 return IER_DoesNotExist; 8601 8602 // If the name itself is dependent, then the result is dependent. 8603 if (TargetName.isDependentName()) 8604 return IER_Dependent; 8605 8606 // Do the redeclaration lookup in the current scope. 8607 LookupResult R(*this, TargetNameInfo, Sema::LookupAnyName, 8608 Sema::NotForRedeclaration); 8609 LookupParsedName(R, S, &SS); 8610 R.suppressDiagnostics(); 8611 8612 switch (R.getResultKind()) { 8613 case LookupResult::Found: 8614 case LookupResult::FoundOverloaded: 8615 case LookupResult::FoundUnresolvedValue: 8616 case LookupResult::Ambiguous: 8617 return IER_Exists; 8618 8619 case LookupResult::NotFound: 8620 return IER_DoesNotExist; 8621 8622 case LookupResult::NotFoundInCurrentInstantiation: 8623 return IER_Dependent; 8624 } 8625 8626 llvm_unreachable("Invalid LookupResult Kind!")__builtin_unreachable(); 8627} 8628 8629Sema::IfExistsResult 8630Sema::CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc, 8631 bool IsIfExists, CXXScopeSpec &SS, 8632 UnqualifiedId &Name) { 8633 DeclarationNameInfo TargetNameInfo = GetNameFromUnqualifiedId(Name); 8634 8635 // Check for an unexpanded parameter pack. 8636 auto UPPC = IsIfExists ? UPPC_IfExists : UPPC_IfNotExists; 8637 if (DiagnoseUnexpandedParameterPack(SS, UPPC) || 8638 DiagnoseUnexpandedParameterPack(TargetNameInfo, UPPC)) 8639 return IER_Error; 8640 8641 return CheckMicrosoftIfExistsSymbol(S, SS, TargetNameInfo); 8642} 8643 8644concepts::Requirement *Sema::ActOnSimpleRequirement(Expr *E) { 8645 return BuildExprRequirement(E, /*IsSimple=*/true, 8646 /*NoexceptLoc=*/SourceLocation(), 8647 /*ReturnTypeRequirement=*/{}); 8648} 8649 8650concepts::Requirement * 8651Sema::ActOnTypeRequirement(SourceLocation TypenameKWLoc, CXXScopeSpec &SS, 8652 SourceLocation NameLoc, IdentifierInfo *TypeName, 8653 TemplateIdAnnotation *TemplateId) { 8654 assert(((!TypeName && TemplateId) || (TypeName && !TemplateId)) &&((void)0) 8655 "Exactly one of TypeName and TemplateId must be specified.")((void)0); 8656 TypeSourceInfo *TSI = nullptr; 8657 if (TypeName) { 8658 QualType T = CheckTypenameType(ETK_Typename, TypenameKWLoc, 8659 SS.getWithLocInContext(Context), *TypeName, 8660 NameLoc, &TSI, /*DeducedTypeContext=*/false); 8661 if (T.isNull()) 8662 return nullptr; 8663 } else { 8664 ASTTemplateArgsPtr ArgsPtr(TemplateId->getTemplateArgs(), 8665 TemplateId->NumArgs); 8666 TypeResult T = ActOnTypenameType(CurScope, TypenameKWLoc, SS, 8667 TemplateId->TemplateKWLoc, 8668 TemplateId->Template, TemplateId->Name, 8669 TemplateId->TemplateNameLoc, 8670 TemplateId->LAngleLoc, ArgsPtr, 8671 TemplateId->RAngleLoc); 8672 if (T.isInvalid()) 8673 return nullptr; 8674 if (GetTypeFromParser(T.get(), &TSI).isNull()) 8675 return nullptr; 8676 } 8677 return BuildTypeRequirement(TSI); 8678} 8679 8680concepts::Requirement * 8681Sema::ActOnCompoundRequirement(Expr *E, SourceLocation NoexceptLoc) { 8682 return BuildExprRequirement(E, /*IsSimple=*/false, NoexceptLoc, 8683 /*ReturnTypeRequirement=*/{}); 8684} 8685 8686concepts::Requirement * 8687Sema::ActOnCompoundRequirement( 8688 Expr *E, SourceLocation NoexceptLoc, CXXScopeSpec &SS, 8689 TemplateIdAnnotation *TypeConstraint, unsigned Depth) { 8690 // C++2a [expr.prim.req.compound] p1.3.3 8691 // [..] the expression is deduced against an invented function template 8692 // F [...] F is a void function template with a single type template 8693 // parameter T declared with the constrained-parameter. Form a new 8694 // cv-qualifier-seq cv by taking the union of const and volatile specifiers 8695 // around the constrained-parameter. F has a single parameter whose 8696 // type-specifier is cv T followed by the abstract-declarator. [...] 8697 // 8698 // The cv part is done in the calling function - we get the concept with 8699 // arguments and the abstract declarator with the correct CV qualification and 8700 // have to synthesize T and the single parameter of F. 8701 auto &II = Context.Idents.get("expr-type"); 8702 auto *TParam = TemplateTypeParmDecl::Create(Context, CurContext, 8703 SourceLocation(), 8704 SourceLocation(), Depth, 8705 /*Index=*/0, &II, 8706 /*Typename=*/true, 8707 /*ParameterPack=*/false, 8708 /*HasTypeConstraint=*/true); 8709 8710 if (BuildTypeConstraint(SS, TypeConstraint, TParam, 8711 /*EllpsisLoc=*/SourceLocation(), 8712 /*AllowUnexpandedPack=*/true)) 8713 // Just produce a requirement with no type requirements. 8714 return BuildExprRequirement(E, /*IsSimple=*/false, NoexceptLoc, {}); 8715 8716 auto *TPL = TemplateParameterList::Create(Context, SourceLocation(), 8717 SourceLocation(), 8718 ArrayRef<NamedDecl *>(TParam), 8719 SourceLocation(), 8720 /*RequiresClause=*/nullptr); 8721 return BuildExprRequirement( 8722 E, /*IsSimple=*/false, NoexceptLoc, 8723 concepts::ExprRequirement::ReturnTypeRequirement(TPL)); 8724} 8725 8726concepts::ExprRequirement * 8727Sema::BuildExprRequirement( 8728 Expr *E, bool IsSimple, SourceLocation NoexceptLoc, 8729 concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement) { 8730 auto Status = concepts::ExprRequirement::SS_Satisfied; 8731 ConceptSpecializationExpr *SubstitutedConstraintExpr = nullptr; 8732 if (E->isInstantiationDependent() || ReturnTypeRequirement.isDependent()) 8733 Status = concepts::ExprRequirement::SS_Dependent; 8734 else if (NoexceptLoc.isValid() && canThrow(E) == CanThrowResult::CT_Can) 8735 Status = concepts::ExprRequirement::SS_NoexceptNotMet; 8736 else if (ReturnTypeRequirement.isSubstitutionFailure()) 8737 Status = concepts::ExprRequirement::SS_TypeRequirementSubstitutionFailure; 8738 else if (ReturnTypeRequirement.isTypeConstraint()) { 8739 // C++2a [expr.prim.req]p1.3.3 8740 // The immediately-declared constraint ([temp]) of decltype((E)) shall 8741 // be satisfied. 8742 TemplateParameterList *TPL = 8743 ReturnTypeRequirement.getTypeConstraintTemplateParameterList(); 8744 QualType MatchedType = 8745 getDecltypeForParenthesizedExpr(E).getCanonicalType(); 8746 llvm::SmallVector<TemplateArgument, 1> Args; 8747 Args.push_back(TemplateArgument(MatchedType)); 8748 TemplateArgumentList TAL(TemplateArgumentList::OnStack, Args); 8749 MultiLevelTemplateArgumentList MLTAL(TAL); 8750 for (unsigned I = 0; I < TPL->getDepth(); ++I) 8751 MLTAL.addOuterRetainedLevel(); 8752 Expr *IDC = 8753 cast<TemplateTypeParmDecl>(TPL->getParam(0))->getTypeConstraint() 8754 ->getImmediatelyDeclaredConstraint(); 8755 ExprResult Constraint = SubstExpr(IDC, MLTAL); 8756 assert(!Constraint.isInvalid() &&((void)0) 8757 "Substitution cannot fail as it is simply putting a type template "((void)0) 8758 "argument into a concept specialization expression's parameter.")((void)0); 8759 8760 SubstitutedConstraintExpr = 8761 cast<ConceptSpecializationExpr>(Constraint.get()); 8762 if (!SubstitutedConstraintExpr->isSatisfied()) 8763 Status = concepts::ExprRequirement::SS_ConstraintsNotSatisfied; 8764 } 8765 return new (Context) concepts::ExprRequirement(E, IsSimple, NoexceptLoc, 8766 ReturnTypeRequirement, Status, 8767 SubstitutedConstraintExpr); 8768} 8769 8770concepts::ExprRequirement * 8771Sema::BuildExprRequirement( 8772 concepts::Requirement::SubstitutionDiagnostic *ExprSubstitutionDiagnostic, 8773 bool IsSimple, SourceLocation NoexceptLoc, 8774 concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement) { 8775 return new (Context) concepts::ExprRequirement(ExprSubstitutionDiagnostic, 8776 IsSimple, NoexceptLoc, 8777 ReturnTypeRequirement); 8778} 8779 8780concepts::TypeRequirement * 8781Sema::BuildTypeRequirement(TypeSourceInfo *Type) { 8782 return new (Context) concepts::TypeRequirement(Type); 8783} 8784 8785concepts::TypeRequirement * 8786Sema::BuildTypeRequirement( 8787 concepts::Requirement::SubstitutionDiagnostic *SubstDiag) { 8788 return new (Context) concepts::TypeRequirement(SubstDiag); 8789} 8790 8791concepts::Requirement *Sema::ActOnNestedRequirement(Expr *Constraint) { 8792 return BuildNestedRequirement(Constraint); 8793} 8794 8795concepts::NestedRequirement * 8796Sema::BuildNestedRequirement(Expr *Constraint) { 8797 ConstraintSatisfaction Satisfaction; 8798 if (!Constraint->isInstantiationDependent() && 8799 CheckConstraintSatisfaction(nullptr, {Constraint}, /*TemplateArgs=*/{}, 8800 Constraint->getSourceRange(), Satisfaction)) 8801 return nullptr; 8802 return new (Context) concepts::NestedRequirement(Context, Constraint, 8803 Satisfaction); 8804} 8805 8806concepts::NestedRequirement * 8807Sema::BuildNestedRequirement( 8808 concepts::Requirement::SubstitutionDiagnostic *SubstDiag) { 8809 return new (Context) concepts::NestedRequirement(SubstDiag); 8810} 8811 8812RequiresExprBodyDecl * 8813Sema::ActOnStartRequiresExpr(SourceLocation RequiresKWLoc, 8814 ArrayRef<ParmVarDecl *> LocalParameters, 8815 Scope *BodyScope) { 8816 assert(BodyScope)((void)0); 8817 8818 RequiresExprBodyDecl *Body = RequiresExprBodyDecl::Create(Context, CurContext, 8819 RequiresKWLoc); 8820 8821 PushDeclContext(BodyScope, Body); 8822 8823 for (ParmVarDecl *Param : LocalParameters) { 8824 if (Param->hasDefaultArg()) 8825 // C++2a [expr.prim.req] p4 8826 // [...] A local parameter of a requires-expression shall not have a 8827 // default argument. [...] 8828 Diag(Param->getDefaultArgRange().getBegin(), 8829 diag::err_requires_expr_local_parameter_default_argument); 8830 // Ignore default argument and move on 8831 8832 Param->setDeclContext(Body); 8833 // If this has an identifier, add it to the scope stack. 8834 if (Param->getIdentifier()) { 8835 CheckShadow(BodyScope, Param); 8836 PushOnScopeChains(Param, BodyScope); 8837 } 8838 } 8839 return Body; 8840} 8841 8842void Sema::ActOnFinishRequiresExpr() { 8843 assert(CurContext && "DeclContext imbalance!")((void)0); 8844 CurContext = CurContext->getLexicalParent(); 8845 assert(CurContext && "Popped translation unit!")((void)0); 8846} 8847 8848ExprResult 8849Sema::ActOnRequiresExpr(SourceLocation RequiresKWLoc, 8850 RequiresExprBodyDecl *Body, 8851 ArrayRef<ParmVarDecl *> LocalParameters, 8852 ArrayRef<concepts::Requirement *> Requirements, 8853 SourceLocation ClosingBraceLoc) { 8854 auto *RE = RequiresExpr::Create(Context, RequiresKWLoc, Body, LocalParameters, 8855 Requirements, ClosingBraceLoc); 8856 if (DiagnoseUnexpandedParameterPackInRequiresExpr(RE)) 8857 return ExprError(); 8858 return RE; 8859}

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include/clang/Sema/Sema.h

1//===--- Sema.h - Semantic Analysis & AST Building --------------*- 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 Sema class, which performs semantic analysis and
10// builds ASTs.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_SEMA_SEMA_H
15#define LLVM_CLANG_SEMA_SEMA_H
16
17#include "clang/AST/ASTConcept.h"
18#include "clang/AST/ASTFwd.h"
19#include "clang/AST/Attr.h"
20#include "clang/AST/Availability.h"
21#include "clang/AST/ComparisonCategories.h"
22#include "clang/AST/DeclTemplate.h"
23#include "clang/AST/DeclarationName.h"
24#include "clang/AST/Expr.h"
25#include "clang/AST/ExprCXX.h"
26#include "clang/AST/ExprConcepts.h"
27#include "clang/AST/ExprObjC.h"
28#include "clang/AST/ExprOpenMP.h"
29#include "clang/AST/ExternalASTSource.h"
30#include "clang/AST/LocInfoType.h"
31#include "clang/AST/MangleNumberingContext.h"
32#include "clang/AST/NSAPI.h"
33#include "clang/AST/PrettyPrinter.h"
34#include "clang/AST/StmtCXX.h"
35#include "clang/AST/StmtOpenMP.h"
36#include "clang/AST/TypeLoc.h"
37#include "clang/AST/TypeOrdering.h"
38#include "clang/Basic/BitmaskEnum.h"
39#include "clang/Basic/Builtins.h"
40#include "clang/Basic/DarwinSDKInfo.h"
41#include "clang/Basic/ExpressionTraits.h"
42#include "clang/Basic/Module.h"
43#include "clang/Basic/OpenCLOptions.h"
44#include "clang/Basic/OpenMPKinds.h"
45#include "clang/Basic/PragmaKinds.h"
46#include "clang/Basic/Specifiers.h"
47#include "clang/Basic/TemplateKinds.h"
48#include "clang/Basic/TypeTraits.h"
49#include "clang/Sema/AnalysisBasedWarnings.h"
50#include "clang/Sema/CleanupInfo.h"
51#include "clang/Sema/DeclSpec.h"
52#include "clang/Sema/ExternalSemaSource.h"
53#include "clang/Sema/IdentifierResolver.h"
54#include "clang/Sema/ObjCMethodList.h"
55#include "clang/Sema/Ownership.h"
56#include "clang/Sema/Scope.h"
57#include "clang/Sema/SemaConcept.h"
58#include "clang/Sema/TypoCorrection.h"
59#include "clang/Sema/Weak.h"
60#include "llvm/ADT/ArrayRef.h"
61#include "llvm/ADT/Optional.h"
62#include "llvm/ADT/SetVector.h"
63#include "llvm/ADT/SmallBitVector.h"
64#include "llvm/ADT/SmallPtrSet.h"
65#include "llvm/ADT/SmallSet.h"
66#include "llvm/ADT/SmallVector.h"
67#include "llvm/ADT/TinyPtrVector.h"
68#include "llvm/Frontend/OpenMP/OMPConstants.h"
69#include <deque>
70#include <memory>
71#include <string>
72#include <tuple>
73#include <vector>
74
75namespace llvm {
76 class APSInt;
77 template <typename ValueT> struct DenseMapInfo;
78 template <typename ValueT, typename ValueInfoT> class DenseSet;
79 class SmallBitVector;
80 struct InlineAsmIdentifierInfo;
81}
82
83namespace clang {
84 class ADLResult;
85 class ASTConsumer;
86 class ASTContext;
87 class ASTMutationListener;
88 class ASTReader;
89 class ASTWriter;
90 class ArrayType;
91 class ParsedAttr;
92 class BindingDecl;
93 class BlockDecl;
94 class CapturedDecl;
95 class CXXBasePath;
96 class CXXBasePaths;
97 class CXXBindTemporaryExpr;
98 typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;
99 class CXXConstructorDecl;
100 class CXXConversionDecl;
101 class CXXDeleteExpr;
102 class CXXDestructorDecl;
103 class CXXFieldCollector;
104 class CXXMemberCallExpr;
105 class CXXMethodDecl;
106 class CXXScopeSpec;
107 class CXXTemporary;
108 class CXXTryStmt;
109 class CallExpr;
110 class ClassTemplateDecl;
111 class ClassTemplatePartialSpecializationDecl;
112 class ClassTemplateSpecializationDecl;
113 class VarTemplatePartialSpecializationDecl;
114 class CodeCompleteConsumer;
115 class CodeCompletionAllocator;
116 class CodeCompletionTUInfo;
117 class CodeCompletionResult;
118 class CoroutineBodyStmt;
119 class Decl;
120 class DeclAccessPair;
121 class DeclContext;
122 class DeclRefExpr;
123 class DeclaratorDecl;
124 class DeducedTemplateArgument;
125 class DependentDiagnostic;
126 class DesignatedInitExpr;
127 class Designation;
128 class EnableIfAttr;
129 class EnumConstantDecl;
130 class Expr;
131 class ExtVectorType;
132 class FormatAttr;
133 class FriendDecl;
134 class FunctionDecl;
135 class FunctionProtoType;
136 class FunctionTemplateDecl;
137 class ImplicitConversionSequence;
138 typedef MutableArrayRef<ImplicitConversionSequence> ConversionSequenceList;
139 class InitListExpr;
140 class InitializationKind;
141 class InitializationSequence;
142 class InitializedEntity;
143 class IntegerLiteral;
144 class LabelStmt;
145 class LambdaExpr;
146 class LangOptions;
147 class LocalInstantiationScope;
148 class LookupResult;
149 class MacroInfo;
150 typedef ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> ModuleIdPath;
151 class ModuleLoader;
152 class MultiLevelTemplateArgumentList;
153 class NamedDecl;
154 class ObjCCategoryDecl;
155 class ObjCCategoryImplDecl;
156 class ObjCCompatibleAliasDecl;
157 class ObjCContainerDecl;
158 class ObjCImplDecl;
159 class ObjCImplementationDecl;
160 class ObjCInterfaceDecl;
161 class ObjCIvarDecl;
162 template <class T> class ObjCList;
163 class ObjCMessageExpr;
164 class ObjCMethodDecl;
165 class ObjCPropertyDecl;
166 class ObjCProtocolDecl;
167 class OMPThreadPrivateDecl;
168 class OMPRequiresDecl;
169 class OMPDeclareReductionDecl;
170 class OMPDeclareSimdDecl;
171 class OMPClause;
172 struct OMPVarListLocTy;
173 struct OverloadCandidate;
174 enum class OverloadCandidateParamOrder : char;
175 enum OverloadCandidateRewriteKind : unsigned;
176 class OverloadCandidateSet;
177 class OverloadExpr;
178 class ParenListExpr;
179 class ParmVarDecl;
180 class Preprocessor;
181 class PseudoDestructorTypeStorage;
182 class PseudoObjectExpr;
183 class QualType;
184 class StandardConversionSequence;
185 class Stmt;
186 class StringLiteral;
187 class SwitchStmt;
188 class TemplateArgument;
189 class TemplateArgumentList;
190 class TemplateArgumentLoc;
191 class TemplateDecl;
192 class TemplateInstantiationCallback;
193 class TemplateParameterList;
194 class TemplatePartialOrderingContext;
195 class TemplateTemplateParmDecl;
196 class Token;
197 class TypeAliasDecl;
198 class TypedefDecl;
199 class TypedefNameDecl;
200 class TypeLoc;
201 class TypoCorrectionConsumer;
202 class UnqualifiedId;
203 class UnresolvedLookupExpr;
204 class UnresolvedMemberExpr;
205 class UnresolvedSetImpl;
206 class UnresolvedSetIterator;
207 class UsingDecl;
208 class UsingShadowDecl;
209 class ValueDecl;
210 class VarDecl;
211 class VarTemplateSpecializationDecl;
212 class VisibilityAttr;
213 class VisibleDeclConsumer;
214 class IndirectFieldDecl;
215 struct DeductionFailureInfo;
216 class TemplateSpecCandidateSet;
217
218namespace sema {
219 class AccessedEntity;
220 class BlockScopeInfo;
221 class Capture;
222 class CapturedRegionScopeInfo;
223 class CapturingScopeInfo;
224 class CompoundScopeInfo;
225 class DelayedDiagnostic;
226 class DelayedDiagnosticPool;
227 class FunctionScopeInfo;
228 class LambdaScopeInfo;
229 class PossiblyUnreachableDiag;
230 class SemaPPCallbacks;
231 class TemplateDeductionInfo;
232}
233
234namespace threadSafety {
235 class BeforeSet;
236 void threadSafetyCleanup(BeforeSet* Cache);
237}
238
239// FIXME: No way to easily map from TemplateTypeParmTypes to
240// TemplateTypeParmDecls, so we have this horrible PointerUnion.
241typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType*, NamedDecl*>,
242 SourceLocation> UnexpandedParameterPack;
243
244/// Describes whether we've seen any nullability information for the given
245/// file.
246struct FileNullability {
247 /// The first pointer declarator (of any pointer kind) in the file that does
248 /// not have a corresponding nullability annotation.
249 SourceLocation PointerLoc;
250
251 /// The end location for the first pointer declarator in the file. Used for
252 /// placing fix-its.
253 SourceLocation PointerEndLoc;
254
255 /// Which kind of pointer declarator we saw.
256 uint8_t PointerKind;
257
258 /// Whether we saw any type nullability annotations in the given file.
259 bool SawTypeNullability = false;
260};
261
262/// A mapping from file IDs to a record of whether we've seen nullability
263/// information in that file.
264class FileNullabilityMap {
265 /// A mapping from file IDs to the nullability information for each file ID.
266 llvm::DenseMap<FileID, FileNullability> Map;
267
268 /// A single-element cache based on the file ID.
269 struct {
270 FileID File;
271 FileNullability Nullability;
272 } Cache;
273
274public:
275 FileNullability &operator[](FileID file) {
276 // Check the single-element cache.
277 if (file == Cache.File)
278 return Cache.Nullability;
279
280 // It's not in the single-element cache; flush the cache if we have one.
281 if (!Cache.File.isInvalid()) {
282 Map[Cache.File] = Cache.Nullability;
283 }
284
285 // Pull this entry into the cache.
286 Cache.File = file;
287 Cache.Nullability = Map[file];
288 return Cache.Nullability;
289 }
290};
291
292/// Tracks expected type during expression parsing, for use in code completion.
293/// The type is tied to a particular token, all functions that update or consume
294/// the type take a start location of the token they are looking at as a
295/// parameter. This avoids updating the type on hot paths in the parser.
296class PreferredTypeBuilder {
297public:
298 PreferredTypeBuilder(bool Enabled) : Enabled(Enabled) {}
299
300 void enterCondition(Sema &S, SourceLocation Tok);
301 void enterReturn(Sema &S, SourceLocation Tok);
302 void enterVariableInit(SourceLocation Tok, Decl *D);
303 /// Handles e.g. BaseType{ .D = Tok...
304 void enterDesignatedInitializer(SourceLocation Tok, QualType BaseType,
305 const Designation &D);
306 /// Computing a type for the function argument may require running
307 /// overloading, so we postpone its computation until it is actually needed.
308 ///
309 /// Clients should be very careful when using this funciton, as it stores a
310 /// function_ref, clients should make sure all calls to get() with the same
311 /// location happen while function_ref is alive.
312 ///
313 /// The callback should also emit signature help as a side-effect, but only
314 /// if the completion point has been reached.
315 void enterFunctionArgument(SourceLocation Tok,
316 llvm::function_ref<QualType()> ComputeType);
317
318 void enterParenExpr(SourceLocation Tok, SourceLocation LParLoc);
319 void enterUnary(Sema &S, SourceLocation Tok, tok::TokenKind OpKind,
320 SourceLocation OpLoc);
321 void enterBinary(Sema &S, SourceLocation Tok, Expr *LHS, tok::TokenKind Op);
322 void enterMemAccess(Sema &S, SourceLocation Tok, Expr *Base);
323 void enterSubscript(Sema &S, SourceLocation Tok, Expr *LHS);
324 /// Handles all type casts, including C-style cast, C++ casts, etc.
325 void enterTypeCast(SourceLocation Tok, QualType CastType);
326
327 /// Get the expected type associated with this location, if any.
328 ///
329 /// If the location is a function argument, determining the expected type
330 /// involves considering all function overloads and the arguments so far.
331 /// In this case, signature help for these function overloads will be reported
332 /// as a side-effect (only if the completion point has been reached).
333 QualType get(SourceLocation Tok) const {
334 if (!Enabled || Tok != ExpectedLoc)
335 return QualType();
336 if (!Type.isNull())
337 return Type;
338 if (ComputeType)
339 return ComputeType();
340 return QualType();
341 }
342
343private:
344 bool Enabled;
345 /// Start position of a token for which we store expected type.
346 SourceLocation ExpectedLoc;
347 /// Expected type for a token starting at ExpectedLoc.
348 QualType Type;
349 /// A function to compute expected type at ExpectedLoc. It is only considered
350 /// if Type is null.
351 llvm::function_ref<QualType()> ComputeType;
352};
353
354/// Sema - This implements semantic analysis and AST building for C.
355class Sema final {
356 Sema(const Sema &) = delete;
357 void operator=(const Sema &) = delete;
358
359 ///Source of additional semantic information.
360 ExternalSemaSource *ExternalSource;
361
362 ///Whether Sema has generated a multiplexer and has to delete it.
363 bool isMultiplexExternalSource;
364
365 static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD);
366
367 bool isVisibleSlow(const NamedDecl *D);
368
369 /// Determine whether two declarations should be linked together, given that
370 /// the old declaration might not be visible and the new declaration might
371 /// not have external linkage.
372 bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old,
373 const NamedDecl *New) {
374 if (isVisible(Old))
375 return true;
376 // See comment in below overload for why it's safe to compute the linkage
377 // of the new declaration here.
378 if (New->isExternallyDeclarable()) {
379 assert(Old->isExternallyDeclarable() &&((void)0)
380 "should not have found a non-externally-declarable previous decl")((void)0);
381 return true;
382 }
383 return false;
384 }
385 bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New);
386
387 void setupImplicitSpecialMemberType(CXXMethodDecl *SpecialMem,
388 QualType ResultTy,
389 ArrayRef<QualType> Args);
390
391public:
392 /// The maximum alignment, same as in llvm::Value. We duplicate them here
393 /// because that allows us not to duplicate the constants in clang code,
394 /// which we must to since we can't directly use the llvm constants.
395 /// The value is verified against llvm here: lib/CodeGen/CGDecl.cpp
396 ///
397 /// This is the greatest alignment value supported by load, store, and alloca
398 /// instructions, and global values.
399 static const unsigned MaxAlignmentExponent = 29;
400 static const unsigned MaximumAlignment = 1u << MaxAlignmentExponent;
401
402 typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
403 typedef OpaquePtr<TemplateName> TemplateTy;
404 typedef OpaquePtr<QualType> TypeTy;
405
406 OpenCLOptions OpenCLFeatures;
407 FPOptions CurFPFeatures;
408
409 const LangOptions &LangOpts;
410 Preprocessor &PP;
411 ASTContext &Context;
412 ASTConsumer &Consumer;
413 DiagnosticsEngine &Diags;
414 SourceManager &SourceMgr;
415
416 /// Flag indicating whether or not to collect detailed statistics.
417 bool CollectStats;
418
419 /// Code-completion consumer.
420 CodeCompleteConsumer *CodeCompleter;
421
422 /// CurContext - This is the current declaration context of parsing.
423 DeclContext *CurContext;
424
425 /// Generally null except when we temporarily switch decl contexts,
426 /// like in \see ActOnObjCTemporaryExitContainerContext.
427 DeclContext *OriginalLexicalContext;
428
429 /// VAListTagName - The declaration name corresponding to __va_list_tag.
430 /// This is used as part of a hack to omit that class from ADL results.
431 DeclarationName VAListTagName;
432
433 bool MSStructPragmaOn; // True when \#pragma ms_struct on
434
435 /// Controls member pointer representation format under the MS ABI.
436 LangOptions::PragmaMSPointersToMembersKind
437 MSPointerToMemberRepresentationMethod;
438
439 /// Stack of active SEH __finally scopes. Can be empty.
440 SmallVector<Scope*, 2> CurrentSEHFinally;
441
442 /// Source location for newly created implicit MSInheritanceAttrs
443 SourceLocation ImplicitMSInheritanceAttrLoc;
444
445 /// Holds TypoExprs that are created from `createDelayedTypo`. This is used by
446 /// `TransformTypos` in order to keep track of any TypoExprs that are created
447 /// recursively during typo correction and wipe them away if the correction
448 /// fails.
449 llvm::SmallVector<TypoExpr *, 2> TypoExprs;
450
451 /// pragma clang section kind
452 enum PragmaClangSectionKind {
453 PCSK_Invalid = 0,
454 PCSK_BSS = 1,
455 PCSK_Data = 2,
456 PCSK_Rodata = 3,
457 PCSK_Text = 4,
458 PCSK_Relro = 5
459 };
460
461 enum PragmaClangSectionAction {
462 PCSA_Set = 0,
463 PCSA_Clear = 1
464 };
465
466 struct PragmaClangSection {
467 std::string SectionName;
468 bool Valid = false;
469 SourceLocation PragmaLocation;
470 };
471
472 PragmaClangSection PragmaClangBSSSection;
473 PragmaClangSection PragmaClangDataSection;
474 PragmaClangSection PragmaClangRodataSection;
475 PragmaClangSection PragmaClangRelroSection;
476 PragmaClangSection PragmaClangTextSection;
477
478 enum PragmaMsStackAction {
479 PSK_Reset = 0x0, // #pragma ()
480 PSK_Set = 0x1, // #pragma (value)
481 PSK_Push = 0x2, // #pragma (push[, id])
482 PSK_Pop = 0x4, // #pragma (pop[, id])
483 PSK_Show = 0x8, // #pragma (show) -- only for "pack"!
484 PSK_Push_Set = PSK_Push | PSK_Set, // #pragma (push[, id], value)
485 PSK_Pop_Set = PSK_Pop | PSK_Set, // #pragma (pop[, id], value)
486 };
487
488 // #pragma pack and align.
489 class AlignPackInfo {
490 public:
491 // `Native` represents default align mode, which may vary based on the
492 // platform.
493 enum Mode : unsigned char { Native, Natural, Packed, Mac68k };
494
495 // #pragma pack info constructor
496 AlignPackInfo(AlignPackInfo::Mode M, unsigned Num, bool IsXL)
497 : PackAttr(true), AlignMode(M), PackNumber(Num), XLStack(IsXL) {
498 assert(Num == PackNumber && "The pack number has been truncated.")((void)0);
499 }
500
501 // #pragma align info constructor
502 AlignPackInfo(AlignPackInfo::Mode M, bool IsXL)
503 : PackAttr(false), AlignMode(M),
504 PackNumber(M == Packed ? 1 : UninitPackVal), XLStack(IsXL) {}
505
506 explicit AlignPackInfo(bool IsXL) : AlignPackInfo(Native, IsXL) {}
507
508 AlignPackInfo() : AlignPackInfo(Native, false) {}
509
510 // When a AlignPackInfo itself cannot be used, this returns an 32-bit
511 // integer encoding for it. This should only be passed to
512 // AlignPackInfo::getFromRawEncoding, it should not be inspected directly.
513 static uint32_t getRawEncoding(const AlignPackInfo &Info) {
514 std::uint32_t Encoding{};
515 if (Info.IsXLStack())
516 Encoding |= IsXLMask;
517
518 Encoding |= static_cast<uint32_t>(Info.getAlignMode()) << 1;
519
520 if (Info.IsPackAttr())
521 Encoding |= PackAttrMask;
522
523 Encoding |= static_cast<uint32_t>(Info.getPackNumber()) << 4;
524
525 return Encoding;
526 }
527
528 static AlignPackInfo getFromRawEncoding(unsigned Encoding) {
529 bool IsXL = static_cast<bool>(Encoding & IsXLMask);
530 AlignPackInfo::Mode M =
531 static_cast<AlignPackInfo::Mode>((Encoding & AlignModeMask) >> 1);
532 int PackNumber = (Encoding & PackNumMask) >> 4;
533
534 if (Encoding & PackAttrMask)
535 return AlignPackInfo(M, PackNumber, IsXL);
536
537 return AlignPackInfo(M, IsXL);
538 }
539
540 bool IsPackAttr() const { return PackAttr; }
541
542 bool IsAlignAttr() const { return !PackAttr; }
543
544 Mode getAlignMode() const { return AlignMode; }
545
546 unsigned getPackNumber() const { return PackNumber; }
547
548 bool IsPackSet() const {
549 // #pragma align, #pragma pack(), and #pragma pack(0) do not set the pack
550 // attriute on a decl.
551 return PackNumber != UninitPackVal && PackNumber != 0;
552 }
553
554 bool IsXLStack() const { return XLStack; }
555
556 bool operator==(const AlignPackInfo &Info) const {
557 return std::tie(AlignMode, PackNumber, PackAttr, XLStack) ==
558 std::tie(Info.AlignMode, Info.PackNumber, Info.PackAttr,
559 Info.XLStack);
560 }
561
562 bool operator!=(const AlignPackInfo &Info) const {
563 return !(*this == Info);
564 }
565
566 private:
567 /// \brief True if this is a pragma pack attribute,
568 /// not a pragma align attribute.
569 bool PackAttr;
570
571 /// \brief The alignment mode that is in effect.
572 Mode AlignMode;
573
574 /// \brief The pack number of the stack.
575 unsigned char PackNumber;
576
577 /// \brief True if it is a XL #pragma align/pack stack.
578 bool XLStack;
579
580 /// \brief Uninitialized pack value.
581 static constexpr unsigned char UninitPackVal = -1;
582
583 // Masks to encode and decode an AlignPackInfo.
584 static constexpr uint32_t IsXLMask{0x0000'0001};
585 static constexpr uint32_t AlignModeMask{0x0000'0006};
586 static constexpr uint32_t PackAttrMask{0x00000'0008};
587 static constexpr uint32_t PackNumMask{0x0000'01F0};
588 };
589
590 template<typename ValueType>
591 struct PragmaStack {
592 struct Slot {
593 llvm::StringRef StackSlotLabel;
594 ValueType Value;
595 SourceLocation PragmaLocation;
596 SourceLocation PragmaPushLocation;
597 Slot(llvm::StringRef StackSlotLabel, ValueType Value,
598 SourceLocation PragmaLocation, SourceLocation PragmaPushLocation)
599 : StackSlotLabel(StackSlotLabel), Value(Value),
600 PragmaLocation(PragmaLocation),
601 PragmaPushLocation(PragmaPushLocation) {}
602 };
603
604 void Act(SourceLocation PragmaLocation, PragmaMsStackAction Action,
605 llvm::StringRef StackSlotLabel, ValueType Value) {
606 if (Action == PSK_Reset) {
607 CurrentValue = DefaultValue;
608 CurrentPragmaLocation = PragmaLocation;
609 return;
610 }
611 if (Action & PSK_Push)
612 Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation,
613 PragmaLocation);
614 else if (Action & PSK_Pop) {
615 if (!StackSlotLabel.empty()) {
616 // If we've got a label, try to find it and jump there.
617 auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
618 return x.StackSlotLabel == StackSlotLabel;
619 });
620 // If we found the label so pop from there.
621 if (I != Stack.rend()) {
622 CurrentValue = I->Value;
623 CurrentPragmaLocation = I->PragmaLocation;
624 Stack.erase(std::prev(I.base()), Stack.end());
625 }
626 } else if (!Stack.empty()) {
627 // We do not have a label, just pop the last entry.
628 CurrentValue = Stack.back().Value;
629 CurrentPragmaLocation = Stack.back().PragmaLocation;
630 Stack.pop_back();
631 }
632 }
633 if (Action & PSK_Set) {
634 CurrentValue = Value;
635 CurrentPragmaLocation = PragmaLocation;
636 }
637 }
638
639 // MSVC seems to add artificial slots to #pragma stacks on entering a C++
640 // method body to restore the stacks on exit, so it works like this:
641 //
642 // struct S {
643 // #pragma <name>(push, InternalPragmaSlot, <current_pragma_value>)
644 // void Method {}
645 // #pragma <name>(pop, InternalPragmaSlot)
646 // };
647 //
648 // It works even with #pragma vtordisp, although MSVC doesn't support
649 // #pragma vtordisp(push [, id], n)
650 // syntax.
651 //
652 // Push / pop a named sentinel slot.
653 void SentinelAction(PragmaMsStackAction Action, StringRef Label) {
654 assert((Action == PSK_Push || Action == PSK_Pop) &&((void)0)
655 "Can only push / pop #pragma stack sentinels!")((void)0);
656 Act(CurrentPragmaLocation, Action, Label, CurrentValue);
657 }
658
659 // Constructors.
660 explicit PragmaStack(const ValueType &Default)
661 : DefaultValue(Default), CurrentValue(Default) {}
662
663 bool hasValue() const { return CurrentValue != DefaultValue; }
664
665 SmallVector<Slot, 2> Stack;
666 ValueType DefaultValue; // Value used for PSK_Reset action.
667 ValueType CurrentValue;
668 SourceLocation CurrentPragmaLocation;
669 };
670 // FIXME: We should serialize / deserialize these if they occur in a PCH (but
671 // we shouldn't do so if they're in a module).
672
673 /// Whether to insert vtordisps prior to virtual bases in the Microsoft
674 /// C++ ABI. Possible values are 0, 1, and 2, which mean:
675 ///
676 /// 0: Suppress all vtordisps
677 /// 1: Insert vtordisps in the presence of vbase overrides and non-trivial
678 /// structors
679 /// 2: Always insert vtordisps to support RTTI on partially constructed
680 /// objects
681 PragmaStack<MSVtorDispMode> VtorDispStack;
682 PragmaStack<AlignPackInfo> AlignPackStack;
683 // The current #pragma align/pack values and locations at each #include.
684 struct AlignPackIncludeState {
685 AlignPackInfo CurrentValue;
686 SourceLocation CurrentPragmaLocation;
687 bool HasNonDefaultValue, ShouldWarnOnInclude;
688 };
689 SmallVector<AlignPackIncludeState, 8> AlignPackIncludeStack;
690 // Segment #pragmas.
691 PragmaStack<StringLiteral *> DataSegStack;
692 PragmaStack<StringLiteral *> BSSSegStack;
693 PragmaStack<StringLiteral *> ConstSegStack;
694 PragmaStack<StringLiteral *> CodeSegStack;
695
696 // This stack tracks the current state of Sema.CurFPFeatures.
697 PragmaStack<FPOptionsOverride> FpPragmaStack;
698 FPOptionsOverride CurFPFeatureOverrides() {
699 FPOptionsOverride result;
700 if (!FpPragmaStack.hasValue()) {
701 result = FPOptionsOverride();
702 } else {
703 result = FpPragmaStack.CurrentValue;
704 }
705 return result;
706 }
707
708 // RAII object to push / pop sentinel slots for all MS #pragma stacks.
709 // Actions should be performed only if we enter / exit a C++ method body.
710 class PragmaStackSentinelRAII {
711 public:
712 PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct);
713 ~PragmaStackSentinelRAII();
714
715 private:
716 Sema &S;
717 StringRef SlotLabel;
718 bool ShouldAct;
719 };
720
721 /// A mapping that describes the nullability we've seen in each header file.
722 FileNullabilityMap NullabilityMap;
723
724 /// Last section used with #pragma init_seg.
725 StringLiteral *CurInitSeg;
726 SourceLocation CurInitSegLoc;
727
728 /// VisContext - Manages the stack for \#pragma GCC visibility.
729 void *VisContext; // Really a "PragmaVisStack*"
730
731 /// This an attribute introduced by \#pragma clang attribute.
732 struct PragmaAttributeEntry {
733 SourceLocation Loc;
734 ParsedAttr *Attribute;
735 SmallVector<attr::SubjectMatchRule, 4> MatchRules;
736 bool IsUsed;
737 };
738
739 /// A push'd group of PragmaAttributeEntries.
740 struct PragmaAttributeGroup {
741 /// The location of the push attribute.
742 SourceLocation Loc;
743 /// The namespace of this push group.
744 const IdentifierInfo *Namespace;
745 SmallVector<PragmaAttributeEntry, 2> Entries;
746 };
747
748 SmallVector<PragmaAttributeGroup, 2> PragmaAttributeStack;
749
750 /// The declaration that is currently receiving an attribute from the
751 /// #pragma attribute stack.
752 const Decl *PragmaAttributeCurrentTargetDecl;
753
754 /// This represents the last location of a "#pragma clang optimize off"
755 /// directive if such a directive has not been closed by an "on" yet. If
756 /// optimizations are currently "on", this is set to an invalid location.
757 SourceLocation OptimizeOffPragmaLocation;
758
759 /// Flag indicating if Sema is building a recovery call expression.
760 ///
761 /// This flag is used to avoid building recovery call expressions
762 /// if Sema is already doing so, which would cause infinite recursions.
763 bool IsBuildingRecoveryCallExpr;
764
765 /// Used to control the generation of ExprWithCleanups.
766 CleanupInfo Cleanup;
767
768 /// ExprCleanupObjects - This is the stack of objects requiring
769 /// cleanup that are created by the current full expression.
770 SmallVector<ExprWithCleanups::CleanupObject, 8> ExprCleanupObjects;
771
772 /// Store a set of either DeclRefExprs or MemberExprs that contain a reference
773 /// to a variable (constant) that may or may not be odr-used in this Expr, and
774 /// we won't know until all lvalue-to-rvalue and discarded value conversions
775 /// have been applied to all subexpressions of the enclosing full expression.
776 /// This is cleared at the end of each full expression.
777 using MaybeODRUseExprSet = llvm::SetVector<Expr *, SmallVector<Expr *, 4>,
778 llvm::SmallPtrSet<Expr *, 4>>;
779 MaybeODRUseExprSet MaybeODRUseExprs;
780
781 std::unique_ptr<sema::FunctionScopeInfo> CachedFunctionScope;
782
783 /// Stack containing information about each of the nested
784 /// function, block, and method scopes that are currently active.
785 SmallVector<sema::FunctionScopeInfo *, 4> FunctionScopes;
786
787 /// The index of the first FunctionScope that corresponds to the current
788 /// context.
789 unsigned FunctionScopesStart = 0;
790
791 ArrayRef<sema::FunctionScopeInfo*> getFunctionScopes() const {
792 return llvm::makeArrayRef(FunctionScopes.begin() + FunctionScopesStart,
793 FunctionScopes.end());
794 }
795
796 /// Stack containing information needed when in C++2a an 'auto' is encountered
797 /// in a function declaration parameter type specifier in order to invent a
798 /// corresponding template parameter in the enclosing abbreviated function
799 /// template. This information is also present in LambdaScopeInfo, stored in
800 /// the FunctionScopes stack.
801 SmallVector<InventedTemplateParameterInfo, 4> InventedParameterInfos;
802
803 /// The index of the first InventedParameterInfo that refers to the current
804 /// context.
805 unsigned InventedParameterInfosStart = 0;
806
807 ArrayRef<InventedTemplateParameterInfo> getInventedParameterInfos() const {
808 return llvm::makeArrayRef(InventedParameterInfos.begin() +
809 InventedParameterInfosStart,
810 InventedParameterInfos.end());
811 }
812
813 typedef LazyVector<TypedefNameDecl *, ExternalSemaSource,
814 &ExternalSemaSource::ReadExtVectorDecls, 2, 2>
815 ExtVectorDeclsType;
816
817 /// ExtVectorDecls - This is a list all the extended vector types. This allows
818 /// us to associate a raw vector type with one of the ext_vector type names.
819 /// This is only necessary for issuing pretty diagnostics.
820 ExtVectorDeclsType ExtVectorDecls;
821
822 /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
823 std::unique_ptr<CXXFieldCollector> FieldCollector;
824
825 typedef llvm::SmallSetVector<NamedDecl *, 16> NamedDeclSetType;
826
827 /// Set containing all declared private fields that are not used.
828 NamedDeclSetType UnusedPrivateFields;
829
830 /// Set containing all typedefs that are likely unused.
831 llvm::SmallSetVector<const TypedefNameDecl *, 4>
832 UnusedLocalTypedefNameCandidates;
833
834 /// Delete-expressions to be analyzed at the end of translation unit
835 ///
836 /// This list contains class members, and locations of delete-expressions
837 /// that could not be proven as to whether they mismatch with new-expression
838 /// used in initializer of the field.
839 typedef std::pair<SourceLocation, bool> DeleteExprLoc;
840 typedef llvm::SmallVector<DeleteExprLoc, 4> DeleteLocs;
841 llvm::MapVector<FieldDecl *, DeleteLocs> DeleteExprs;
842
843 typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;
844
845 /// PureVirtualClassDiagSet - a set of class declarations which we have
846 /// emitted a list of pure virtual functions. Used to prevent emitting the
847 /// same list more than once.
848 std::unique_ptr<RecordDeclSetTy> PureVirtualClassDiagSet;
849
850 /// ParsingInitForAutoVars - a set of declarations with auto types for which
851 /// we are currently parsing the initializer.
852 llvm::SmallPtrSet<const Decl*, 4> ParsingInitForAutoVars;
853
854 /// Look for a locally scoped extern "C" declaration by the given name.
855 NamedDecl *findLocallyScopedExternCDecl(DeclarationName Name);
856
857 typedef LazyVector<VarDecl *, ExternalSemaSource,
858 &ExternalSemaSource::ReadTentativeDefinitions, 2, 2>
859 TentativeDefinitionsType;
860
861 /// All the tentative definitions encountered in the TU.
862 TentativeDefinitionsType TentativeDefinitions;
863
864 /// All the external declarations encoutered and used in the TU.
865 SmallVector<VarDecl *, 4> ExternalDeclarations;
866
867 typedef LazyVector<const DeclaratorDecl *, ExternalSemaSource,
868 &ExternalSemaSource::ReadUnusedFileScopedDecls, 2, 2>
869 UnusedFileScopedDeclsType;
870
871 /// The set of file scoped decls seen so far that have not been used
872 /// and must warn if not used. Only contains the first declaration.
873 UnusedFileScopedDeclsType UnusedFileScopedDecls;
874
875 typedef LazyVector<CXXConstructorDecl *, ExternalSemaSource,
876 &ExternalSemaSource::ReadDelegatingConstructors, 2, 2>
877 DelegatingCtorDeclsType;
878
879 /// All the delegating constructors seen so far in the file, used for
880 /// cycle detection at the end of the TU.
881 DelegatingCtorDeclsType DelegatingCtorDecls;
882
883 /// All the overriding functions seen during a class definition
884 /// that had their exception spec checks delayed, plus the overridden
885 /// function.
886 SmallVector<std::pair<const CXXMethodDecl*, const CXXMethodDecl*>, 2>
887 DelayedOverridingExceptionSpecChecks;
888
889 /// All the function redeclarations seen during a class definition that had
890 /// their exception spec checks delayed, plus the prior declaration they
891 /// should be checked against. Except during error recovery, the new decl
892 /// should always be a friend declaration, as that's the only valid way to
893 /// redeclare a special member before its class is complete.
894 SmallVector<std::pair<FunctionDecl*, FunctionDecl*>, 2>
895 DelayedEquivalentExceptionSpecChecks;
896
897 typedef llvm::MapVector<const FunctionDecl *,
898 std::unique_ptr<LateParsedTemplate>>
899 LateParsedTemplateMapT;
900 LateParsedTemplateMapT LateParsedTemplateMap;
901
902 /// Callback to the parser to parse templated functions when needed.
903 typedef void LateTemplateParserCB(void *P, LateParsedTemplate &LPT);
904 typedef void LateTemplateParserCleanupCB(void *P);
905 LateTemplateParserCB *LateTemplateParser;
906 LateTemplateParserCleanupCB *LateTemplateParserCleanup;
907 void *OpaqueParser;
908
909 void SetLateTemplateParser(LateTemplateParserCB *LTP,
910 LateTemplateParserCleanupCB *LTPCleanup,
911 void *P) {
912 LateTemplateParser = LTP;
913 LateTemplateParserCleanup = LTPCleanup;
914 OpaqueParser = P;
915 }
916
917 // Does the work necessary to deal with a SYCL kernel lambda. At the moment,
918 // this just marks the list of lambdas required to name the kernel.
919 void AddSYCLKernelLambda(const FunctionDecl *FD);
920
921 class DelayedDiagnostics;
922
923 class DelayedDiagnosticsState {
924 sema::DelayedDiagnosticPool *SavedPool;
925 friend class Sema::DelayedDiagnostics;
926 };
927 typedef DelayedDiagnosticsState ParsingDeclState;
928 typedef DelayedDiagnosticsState ProcessingContextState;
929
930 /// A class which encapsulates the logic for delaying diagnostics
931 /// during parsing and other processing.
932 class DelayedDiagnostics {
933 /// The current pool of diagnostics into which delayed
934 /// diagnostics should go.
935 sema::DelayedDiagnosticPool *CurPool;
936
937 public:
938 DelayedDiagnostics() : CurPool(nullptr) {}
939
940 /// Adds a delayed diagnostic.
941 void add(const sema::DelayedDiagnostic &diag); // in DelayedDiagnostic.h
942
943 /// Determines whether diagnostics should be delayed.
944 bool shouldDelayDiagnostics() { return CurPool != nullptr; }
945
946 /// Returns the current delayed-diagnostics pool.
947 sema::DelayedDiagnosticPool *getCurrentPool() const {
948 return CurPool;
949 }
950
951 /// Enter a new scope. Access and deprecation diagnostics will be
952 /// collected in this pool.
953 DelayedDiagnosticsState push(sema::DelayedDiagnosticPool &pool) {
954 DelayedDiagnosticsState state;
955 state.SavedPool = CurPool;
956 CurPool = &pool;
957 return state;
958 }
959
960 /// Leave a delayed-diagnostic state that was previously pushed.
961 /// Do not emit any of the diagnostics. This is performed as part
962 /// of the bookkeeping of popping a pool "properly".
963 void popWithoutEmitting(DelayedDiagnosticsState state) {
964 CurPool = state.SavedPool;
965 }
966
967 /// Enter a new scope where access and deprecation diagnostics are
968 /// not delayed.
969 DelayedDiagnosticsState pushUndelayed() {
970 DelayedDiagnosticsState state;
971 state.SavedPool = CurPool;
972 CurPool = nullptr;
973 return state;
974 }
975
976 /// Undo a previous pushUndelayed().
977 void popUndelayed(DelayedDiagnosticsState state) {
978 assert(CurPool == nullptr)((void)0);
979 CurPool = state.SavedPool;
980 }
981 } DelayedDiagnostics;
982
983 /// A RAII object to temporarily push a declaration context.
984 class ContextRAII {
985 private:
986 Sema &S;
987 DeclContext *SavedContext;
988 ProcessingContextState SavedContextState;
989 QualType SavedCXXThisTypeOverride;
990 unsigned SavedFunctionScopesStart;
991 unsigned SavedInventedParameterInfosStart;
992
993 public:
994 ContextRAII(Sema &S, DeclContext *ContextToPush, bool NewThisContext = true)
995 : S(S), SavedContext(S.CurContext),
996 SavedContextState(S.DelayedDiagnostics.pushUndelayed()),
997 SavedCXXThisTypeOverride(S.CXXThisTypeOverride),
998 SavedFunctionScopesStart(S.FunctionScopesStart),
999 SavedInventedParameterInfosStart(S.InventedParameterInfosStart)
1000 {
1001 assert(ContextToPush && "pushing null context")((void)0);
1002 S.CurContext = ContextToPush;
1003 if (NewThisContext)
1004 S.CXXThisTypeOverride = QualType();
1005 // Any saved FunctionScopes do not refer to this context.
1006 S.FunctionScopesStart = S.FunctionScopes.size();
1007 S.InventedParameterInfosStart = S.InventedParameterInfos.size();
1008 }
1009
1010 void pop() {
1011 if (!SavedContext) return;
1012 S.CurContext = SavedContext;
1013 S.DelayedDiagnostics.popUndelayed(SavedContextState);
1014 S.CXXThisTypeOverride = SavedCXXThisTypeOverride;
1015 S.FunctionScopesStart = SavedFunctionScopesStart;
1016 S.InventedParameterInfosStart = SavedInventedParameterInfosStart;
1017 SavedContext = nullptr;
1018 }
1019
1020 ~ContextRAII() {
1021 pop();
1022 }
1023 };
1024
1025 /// Whether the AST is currently being rebuilt to correct immediate
1026 /// invocations. Immediate invocation candidates and references to consteval
1027 /// functions aren't tracked when this is set.
1028 bool RebuildingImmediateInvocation = false;
1029
1030 /// Used to change context to isConstantEvaluated without pushing a heavy
1031 /// ExpressionEvaluationContextRecord object.
1032 bool isConstantEvaluatedOverride;
1033
1034 bool isConstantEvaluated() {
1035 return ExprEvalContexts.back().isConstantEvaluated() ||
1036 isConstantEvaluatedOverride;
1037 }
1038
1039 /// RAII object to handle the state changes required to synthesize
1040 /// a function body.
1041 class SynthesizedFunctionScope {
1042 Sema &S;
1043 Sema::ContextRAII SavedContext;
1044 bool PushedCodeSynthesisContext = false;
1045
1046 public:
1047 SynthesizedFunctionScope(Sema &S, DeclContext *DC)
1048 : S(S), SavedContext(S, DC) {
1049 S.PushFunctionScope();
1050 S.PushExpressionEvaluationContext(
1051 Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1052 if (auto *FD = dyn_cast<FunctionDecl>(DC))
1053 FD->setWillHaveBody(true);
1054 else
1055 assert(isa<ObjCMethodDecl>(DC))((void)0);
1056 }
1057
1058 void addContextNote(SourceLocation UseLoc) {
1059 assert(!PushedCodeSynthesisContext)((void)0);
1060
1061 Sema::CodeSynthesisContext Ctx;
1062 Ctx.Kind = Sema::CodeSynthesisContext::DefiningSynthesizedFunction;
1063 Ctx.PointOfInstantiation = UseLoc;
1064 Ctx.Entity = cast<Decl>(S.CurContext);
1065 S.pushCodeSynthesisContext(Ctx);
1066
1067 PushedCodeSynthesisContext = true;
1068 }
1069
1070 ~SynthesizedFunctionScope() {
1071 if (PushedCodeSynthesisContext)
1072 S.popCodeSynthesisContext();
1073 if (auto *FD = dyn_cast<FunctionDecl>(S.CurContext))
1074 FD->setWillHaveBody(false);
1075 S.PopExpressionEvaluationContext();
1076 S.PopFunctionScopeInfo();
1077 }
1078 };
1079
1080 /// WeakUndeclaredIdentifiers - Identifiers contained in
1081 /// \#pragma weak before declared. rare. may alias another
1082 /// identifier, declared or undeclared
1083 llvm::MapVector<IdentifierInfo *, WeakInfo> WeakUndeclaredIdentifiers;
1084
1085 /// ExtnameUndeclaredIdentifiers - Identifiers contained in
1086 /// \#pragma redefine_extname before declared. Used in Solaris system headers
1087 /// to define functions that occur in multiple standards to call the version
1088 /// in the currently selected standard.
1089 llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*> ExtnameUndeclaredIdentifiers;
1090
1091
1092 /// Load weak undeclared identifiers from the external source.
1093 void LoadExternalWeakUndeclaredIdentifiers();
1094
1095 /// WeakTopLevelDecl - Translation-unit scoped declarations generated by
1096 /// \#pragma weak during processing of other Decls.
1097 /// I couldn't figure out a clean way to generate these in-line, so
1098 /// we store them here and handle separately -- which is a hack.
1099 /// It would be best to refactor this.
1100 SmallVector<Decl*,2> WeakTopLevelDecl;
1101
1102 IdentifierResolver IdResolver;
1103
1104 /// Translation Unit Scope - useful to Objective-C actions that need
1105 /// to lookup file scope declarations in the "ordinary" C decl namespace.
1106 /// For example, user-defined classes, built-in "id" type, etc.
1107 Scope *TUScope;
1108
1109 /// The C++ "std" namespace, where the standard library resides.
1110 LazyDeclPtr StdNamespace;
1111
1112 /// The C++ "std::bad_alloc" class, which is defined by the C++
1113 /// standard library.
1114 LazyDeclPtr StdBadAlloc;
1115
1116 /// The C++ "std::align_val_t" enum class, which is defined by the C++
1117 /// standard library.
1118 LazyDeclPtr StdAlignValT;
1119
1120 /// The C++ "std::experimental" namespace, where the experimental parts
1121 /// of the standard library resides.
1122 NamespaceDecl *StdExperimentalNamespaceCache;
1123
1124 /// The C++ "std::initializer_list" template, which is defined in
1125 /// \<initializer_list>.
1126 ClassTemplateDecl *StdInitializerList;
1127
1128 /// The C++ "std::coroutine_traits" template, which is defined in
1129 /// \<coroutine_traits>
1130 ClassTemplateDecl *StdCoroutineTraitsCache;
1131
1132 /// The C++ "type_info" declaration, which is defined in \<typeinfo>.
1133 RecordDecl *CXXTypeInfoDecl;
1134
1135 /// The MSVC "_GUID" struct, which is defined in MSVC header files.
1136 RecordDecl *MSVCGuidDecl;
1137
1138 /// Caches identifiers/selectors for NSFoundation APIs.
1139 std::unique_ptr<NSAPI> NSAPIObj;
1140
1141 /// The declaration of the Objective-C NSNumber class.
1142 ObjCInterfaceDecl *NSNumberDecl;
1143
1144 /// The declaration of the Objective-C NSValue class.
1145 ObjCInterfaceDecl *NSValueDecl;
1146
1147 /// Pointer to NSNumber type (NSNumber *).
1148 QualType NSNumberPointer;
1149
1150 /// Pointer to NSValue type (NSValue *).
1151 QualType NSValuePointer;
1152
1153 /// The Objective-C NSNumber methods used to create NSNumber literals.
1154 ObjCMethodDecl *NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods];
1155
1156 /// The declaration of the Objective-C NSString class.
1157 ObjCInterfaceDecl *NSStringDecl;
1158
1159 /// Pointer to NSString type (NSString *).
1160 QualType NSStringPointer;
1161
1162 /// The declaration of the stringWithUTF8String: method.
1163 ObjCMethodDecl *StringWithUTF8StringMethod;
1164
1165 /// The declaration of the valueWithBytes:objCType: method.
1166 ObjCMethodDecl *ValueWithBytesObjCTypeMethod;
1167
1168 /// The declaration of the Objective-C NSArray class.
1169 ObjCInterfaceDecl *NSArrayDecl;
1170
1171 /// The declaration of the arrayWithObjects:count: method.
1172 ObjCMethodDecl *ArrayWithObjectsMethod;
1173
1174 /// The declaration of the Objective-C NSDictionary class.
1175 ObjCInterfaceDecl *NSDictionaryDecl;
1176
1177 /// The declaration of the dictionaryWithObjects:forKeys:count: method.
1178 ObjCMethodDecl *DictionaryWithObjectsMethod;
1179
1180 /// id<NSCopying> type.
1181 QualType QIDNSCopying;
1182
1183 /// will hold 'respondsToSelector:'
1184 Selector RespondsToSelectorSel;
1185
1186 /// A flag to remember whether the implicit forms of operator new and delete
1187 /// have been declared.
1188 bool GlobalNewDeleteDeclared;
1189
1190 /// Describes how the expressions currently being parsed are
1191 /// evaluated at run-time, if at all.
1192 enum class ExpressionEvaluationContext {
1193 /// The current expression and its subexpressions occur within an
1194 /// unevaluated operand (C++11 [expr]p7), such as the subexpression of
1195 /// \c sizeof, where the type of the expression may be significant but
1196 /// no code will be generated to evaluate the value of the expression at
1197 /// run time.
1198 Unevaluated,
1199
1200 /// The current expression occurs within a braced-init-list within
1201 /// an unevaluated operand. This is mostly like a regular unevaluated
1202 /// context, except that we still instantiate constexpr functions that are
1203 /// referenced here so that we can perform narrowing checks correctly.
1204 UnevaluatedList,
1205
1206 /// The current expression occurs within a discarded statement.
1207 /// This behaves largely similarly to an unevaluated operand in preventing
1208 /// definitions from being required, but not in other ways.
1209 DiscardedStatement,
1210
1211 /// The current expression occurs within an unevaluated
1212 /// operand that unconditionally permits abstract references to
1213 /// fields, such as a SIZE operator in MS-style inline assembly.
1214 UnevaluatedAbstract,
1215
1216 /// The current context is "potentially evaluated" in C++11 terms,
1217 /// but the expression is evaluated at compile-time (like the values of
1218 /// cases in a switch statement).
1219 ConstantEvaluated,
1220
1221 /// The current expression is potentially evaluated at run time,
1222 /// which means that code may be generated to evaluate the value of the
1223 /// expression at run time.
1224 PotentiallyEvaluated,
1225
1226 /// The current expression is potentially evaluated, but any
1227 /// declarations referenced inside that expression are only used if
1228 /// in fact the current expression is used.
1229 ///
1230 /// This value is used when parsing default function arguments, for which
1231 /// we would like to provide diagnostics (e.g., passing non-POD arguments
1232 /// through varargs) but do not want to mark declarations as "referenced"
1233 /// until the default argument is used.
1234 PotentiallyEvaluatedIfUsed
1235 };
1236
1237 using ImmediateInvocationCandidate = llvm::PointerIntPair<ConstantExpr *, 1>;
1238
1239 /// Data structure used to record current or nested
1240 /// expression evaluation contexts.
1241 struct ExpressionEvaluationContextRecord {
1242 /// The expression evaluation context.
1243 ExpressionEvaluationContext Context;
1244
1245 /// Whether the enclosing context needed a cleanup.
1246 CleanupInfo ParentCleanup;
1247
1248 /// The number of active cleanup objects when we entered
1249 /// this expression evaluation context.
1250 unsigned NumCleanupObjects;
1251
1252 /// The number of typos encountered during this expression evaluation
1253 /// context (i.e. the number of TypoExprs created).
1254 unsigned NumTypos;
1255
1256 MaybeODRUseExprSet SavedMaybeODRUseExprs;
1257
1258 /// The lambdas that are present within this context, if it
1259 /// is indeed an unevaluated context.
1260 SmallVector<LambdaExpr *, 2> Lambdas;
1261
1262 /// The declaration that provides context for lambda expressions
1263 /// and block literals if the normal declaration context does not
1264 /// suffice, e.g., in a default function argument.
1265 Decl *ManglingContextDecl;
1266
1267 /// If we are processing a decltype type, a set of call expressions
1268 /// for which we have deferred checking the completeness of the return type.
1269 SmallVector<CallExpr *, 8> DelayedDecltypeCalls;
1270
1271 /// If we are processing a decltype type, a set of temporary binding
1272 /// expressions for which we have deferred checking the destructor.
1273 SmallVector<CXXBindTemporaryExpr *, 8> DelayedDecltypeBinds;
1274
1275 llvm::SmallPtrSet<const Expr *, 8> PossibleDerefs;
1276
1277 /// Expressions appearing as the LHS of a volatile assignment in this
1278 /// context. We produce a warning for these when popping the context if
1279 /// they are not discarded-value expressions nor unevaluated operands.
1280 SmallVector<Expr*, 2> VolatileAssignmentLHSs;
1281
1282 /// Set of candidates for starting an immediate invocation.
1283 llvm::SmallVector<ImmediateInvocationCandidate, 4> ImmediateInvocationCandidates;
1284
1285 /// Set of DeclRefExprs referencing a consteval function when used in a
1286 /// context not already known to be immediately invoked.
1287 llvm::SmallPtrSet<DeclRefExpr *, 4> ReferenceToConsteval;
1288
1289 /// \brief Describes whether we are in an expression constext which we have
1290 /// to handle differently.
1291 enum ExpressionKind {
1292 EK_Decltype, EK_TemplateArgument, EK_Other
1293 } ExprContext;
1294
1295 ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
1296 unsigned NumCleanupObjects,
1297 CleanupInfo ParentCleanup,
1298 Decl *ManglingContextDecl,
1299 ExpressionKind ExprContext)
1300 : Context(Context), ParentCleanup(ParentCleanup),
1301 NumCleanupObjects(NumCleanupObjects), NumTypos(0),
1302 ManglingContextDecl(ManglingContextDecl), ExprContext(ExprContext) {}
1303
1304 bool isUnevaluated() const {
1305 return Context == ExpressionEvaluationContext::Unevaluated ||
7
Assuming field 'Context' is not equal to Unevaluated
10
Returning zero, which participates in a condition later
1306 Context == ExpressionEvaluationContext::UnevaluatedAbstract ||
8
Assuming field 'Context' is not equal to UnevaluatedAbstract
1307 Context == ExpressionEvaluationContext::UnevaluatedList;
9
Assuming field 'Context' is not equal to UnevaluatedList
1308 }
1309 bool isConstantEvaluated() const {
1310 return Context == ExpressionEvaluationContext::ConstantEvaluated;
1311 }
1312 };
1313
1314 /// A stack of expression evaluation contexts.
1315 SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts;
1316
1317 /// Emit a warning for all pending noderef expressions that we recorded.
1318 void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec);
1319
1320 /// Compute the mangling number context for a lambda expression or
1321 /// block literal. Also return the extra mangling decl if any.
1322 ///
1323 /// \param DC - The DeclContext containing the lambda expression or
1324 /// block literal.
1325 std::tuple<MangleNumberingContext *, Decl *>
1326 getCurrentMangleNumberContext(const DeclContext *DC);
1327
1328
1329 /// SpecialMemberOverloadResult - The overloading result for a special member
1330 /// function.
1331 ///
1332 /// This is basically a wrapper around PointerIntPair. The lowest bits of the
1333 /// integer are used to determine whether overload resolution succeeded.
1334 class SpecialMemberOverloadResult {
1335 public:
1336 enum Kind {
1337 NoMemberOrDeleted,
1338 Ambiguous,
1339 Success
1340 };
1341
1342 private:
1343 llvm::PointerIntPair<CXXMethodDecl*, 2> Pair;
1344
1345 public:
1346 SpecialMemberOverloadResult() : Pair() {}
1347 SpecialMemberOverloadResult(CXXMethodDecl *MD)
1348 : Pair(MD, MD->isDeleted() ? NoMemberOrDeleted : Success) {}
1349
1350 CXXMethodDecl *getMethod() const { return Pair.getPointer(); }
1351 void setMethod(CXXMethodDecl *MD) { Pair.setPointer(MD); }
1352
1353 Kind getKind() const { return static_cast<Kind>(Pair.getInt()); }
1354 void setKind(Kind K) { Pair.setInt(K); }
1355 };
1356
1357 class SpecialMemberOverloadResultEntry
1358 : public llvm::FastFoldingSetNode,
1359 public SpecialMemberOverloadResult {
1360 public:
1361 SpecialMemberOverloadResultEntry(const llvm::FoldingSetNodeID &ID)
1362 : FastFoldingSetNode(ID)
1363 {}
1364 };
1365
1366 /// A cache of special member function overload resolution results
1367 /// for C++ records.
1368 llvm::FoldingSet<SpecialMemberOverloadResultEntry> SpecialMemberCache;
1369
1370 /// A cache of the flags available in enumerations with the flag_bits
1371 /// attribute.
1372 mutable llvm::DenseMap<const EnumDecl*, llvm::APInt> FlagBitsCache;
1373
1374 /// The kind of translation unit we are processing.
1375 ///
1376 /// When we're processing a complete translation unit, Sema will perform
1377 /// end-of-translation-unit semantic tasks (such as creating
1378 /// initializers for tentative definitions in C) once parsing has
1379 /// completed. Modules and precompiled headers perform different kinds of
1380 /// checks.
1381 const TranslationUnitKind TUKind;
1382
1383 llvm::BumpPtrAllocator BumpAlloc;
1384
1385 /// The number of SFINAE diagnostics that have been trapped.
1386 unsigned NumSFINAEErrors;
1387
1388 typedef llvm::DenseMap<ParmVarDecl *, llvm::TinyPtrVector<ParmVarDecl *>>
1389 UnparsedDefaultArgInstantiationsMap;
1390
1391 /// A mapping from parameters with unparsed default arguments to the
1392 /// set of instantiations of each parameter.
1393 ///
1394 /// This mapping is a temporary data structure used when parsing
1395 /// nested class templates or nested classes of class templates,
1396 /// where we might end up instantiating an inner class before the
1397 /// default arguments of its methods have been parsed.
1398 UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations;
1399
1400 // Contains the locations of the beginning of unparsed default
1401 // argument locations.
1402 llvm::DenseMap<ParmVarDecl *, SourceLocation> UnparsedDefaultArgLocs;
1403
1404 /// UndefinedInternals - all the used, undefined objects which require a
1405 /// definition in this translation unit.
1406 llvm::MapVector<NamedDecl *, SourceLocation> UndefinedButUsed;
1407
1408 /// Determine if VD, which must be a variable or function, is an external
1409 /// symbol that nonetheless can't be referenced from outside this translation
1410 /// unit because its type has no linkage and it's not extern "C".
1411 bool isExternalWithNoLinkageType(ValueDecl *VD);
1412
1413 /// Obtain a sorted list of functions that are undefined but ODR-used.
1414 void getUndefinedButUsed(
1415 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined);
1416
1417 /// Retrieves list of suspicious delete-expressions that will be checked at
1418 /// the end of translation unit.
1419 const llvm::MapVector<FieldDecl *, DeleteLocs> &
1420 getMismatchingDeleteExpressions() const;
1421
1422 typedef std::pair<ObjCMethodList, ObjCMethodList> GlobalMethods;
1423 typedef llvm::DenseMap<Selector, GlobalMethods> GlobalMethodPool;
1424
1425 /// Method Pool - allows efficient lookup when typechecking messages to "id".
1426 /// We need to maintain a list, since selectors can have differing signatures
1427 /// across classes. In Cocoa, this happens to be extremely uncommon (only 1%
1428 /// of selectors are "overloaded").
1429 /// At the head of the list it is recorded whether there were 0, 1, or >= 2
1430 /// methods inside categories with a particular selector.
1431 GlobalMethodPool MethodPool;
1432
1433 /// Method selectors used in a \@selector expression. Used for implementation
1434 /// of -Wselector.
1435 llvm::MapVector<Selector, SourceLocation> ReferencedSelectors;
1436
1437 /// List of SourceLocations where 'self' is implicitly retained inside a
1438 /// block.
1439 llvm::SmallVector<std::pair<SourceLocation, const BlockDecl *>, 1>
1440 ImplicitlyRetainedSelfLocs;
1441
1442 /// Kinds of C++ special members.
1443 enum CXXSpecialMember {
1444 CXXDefaultConstructor,
1445 CXXCopyConstructor,
1446 CXXMoveConstructor,
1447 CXXCopyAssignment,
1448 CXXMoveAssignment,
1449 CXXDestructor,
1450 CXXInvalid
1451 };
1452
1453 typedef llvm::PointerIntPair<CXXRecordDecl *, 3, CXXSpecialMember>
1454 SpecialMemberDecl;
1455
1456 /// The C++ special members which we are currently in the process of
1457 /// declaring. If this process recursively triggers the declaration of the
1458 /// same special member, we should act as if it is not yet declared.
1459 llvm::SmallPtrSet<SpecialMemberDecl, 4> SpecialMembersBeingDeclared;
1460
1461 /// Kinds of defaulted comparison operator functions.
1462 enum class DefaultedComparisonKind : unsigned char {
1463 /// This is not a defaultable comparison operator.
1464 None,
1465 /// This is an operator== that should be implemented as a series of
1466 /// subobject comparisons.
1467 Equal,
1468 /// This is an operator<=> that should be implemented as a series of
1469 /// subobject comparisons.
1470 ThreeWay,
1471 /// This is an operator!= that should be implemented as a rewrite in terms
1472 /// of a == comparison.
1473 NotEqual,
1474 /// This is an <, <=, >, or >= that should be implemented as a rewrite in
1475 /// terms of a <=> comparison.
1476 Relational,
1477 };
1478
1479 /// The function definitions which were renamed as part of typo-correction
1480 /// to match their respective declarations. We want to keep track of them
1481 /// to ensure that we don't emit a "redefinition" error if we encounter a
1482 /// correctly named definition after the renamed definition.
1483 llvm::SmallPtrSet<const NamedDecl *, 4> TypoCorrectedFunctionDefinitions;
1484
1485 /// Stack of types that correspond to the parameter entities that are
1486 /// currently being copy-initialized. Can be empty.
1487 llvm::SmallVector<QualType, 4> CurrentParameterCopyTypes;
1488
1489 void ReadMethodPool(Selector Sel);
1490 void updateOutOfDateSelector(Selector Sel);
1491
1492 /// Private Helper predicate to check for 'self'.
1493 bool isSelfExpr(Expr *RExpr);
1494 bool isSelfExpr(Expr *RExpr, const ObjCMethodDecl *Method);
1495
1496 /// Cause the active diagnostic on the DiagosticsEngine to be
1497 /// emitted. This is closely coupled to the SemaDiagnosticBuilder class and
1498 /// should not be used elsewhere.
1499 void EmitCurrentDiagnostic(unsigned DiagID);
1500
1501 /// Records and restores the CurFPFeatures state on entry/exit of compound
1502 /// statements.
1503 class FPFeaturesStateRAII {
1504 public:
1505 FPFeaturesStateRAII(Sema &S) : S(S), OldFPFeaturesState(S.CurFPFeatures) {
1506 OldOverrides = S.FpPragmaStack.CurrentValue;
1507 }
1508 ~FPFeaturesStateRAII() {
1509 S.CurFPFeatures = OldFPFeaturesState;
1510 S.FpPragmaStack.CurrentValue = OldOverrides;
1511 }
1512 FPOptionsOverride getOverrides() { return OldOverrides; }
1513
1514 private:
1515 Sema& S;
1516 FPOptions OldFPFeaturesState;
1517 FPOptionsOverride OldOverrides;
1518 };
1519
1520 void addImplicitTypedef(StringRef Name, QualType T);
1521
1522 bool WarnedStackExhausted = false;
1523
1524 /// Increment when we find a reference; decrement when we find an ignored
1525 /// assignment. Ultimately the value is 0 if every reference is an ignored
1526 /// assignment.
1527 llvm::DenseMap<const VarDecl *, int> RefsMinusAssignments;
1528
1529 Optional<std::unique_ptr<DarwinSDKInfo>> CachedDarwinSDKInfo;
1530
1531public:
1532 Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
1533 TranslationUnitKind TUKind = TU_Complete,
1534 CodeCompleteConsumer *CompletionConsumer = nullptr);
1535 ~Sema();
1536
1537 /// Perform initialization that occurs after the parser has been
1538 /// initialized but before it parses anything.
1539 void Initialize();
1540
1541 /// This virtual key function only exists to limit the emission of debug info
1542 /// describing the Sema class. GCC and Clang only emit debug info for a class
1543 /// with a vtable when the vtable is emitted. Sema is final and not
1544 /// polymorphic, but the debug info size savings are so significant that it is
1545 /// worth adding a vtable just to take advantage of this optimization.
1546 virtual void anchor();
1547
1548 const LangOptions &getLangOpts() const { return LangOpts; }
1549 OpenCLOptions &getOpenCLOptions() { return OpenCLFeatures; }
1550 FPOptions &getCurFPFeatures() { return CurFPFeatures; }
1551
1552 DiagnosticsEngine &getDiagnostics() const { return Diags; }
1553 SourceManager &getSourceManager() const { return SourceMgr; }
1554 Preprocessor &getPreprocessor() const { return PP; }
1555 ASTContext &getASTContext() const { return Context; }
1556 ASTConsumer &getASTConsumer() const { return Consumer; }
1557 ASTMutationListener *getASTMutationListener() const;
1558 ExternalSemaSource* getExternalSource() const { return ExternalSource; }
1559 DarwinSDKInfo *getDarwinSDKInfoForAvailabilityChecking(SourceLocation Loc,
1560 StringRef Platform);
1561
1562 ///Registers an external source. If an external source already exists,
1563 /// creates a multiplex external source and appends to it.
1564 ///
1565 ///\param[in] E - A non-null external sema source.
1566 ///
1567 void addExternalSource(ExternalSemaSource *E);
1568
1569 void PrintStats() const;
1570
1571 /// Warn that the stack is nearly exhausted.
1572 void warnStackExhausted(SourceLocation Loc);
1573
1574 /// Run some code with "sufficient" stack space. (Currently, at least 256K is
1575 /// guaranteed). Produces a warning if we're low on stack space and allocates
1576 /// more in that case. Use this in code that may recurse deeply (for example,
1577 /// in template instantiation) to avoid stack overflow.
1578 void runWithSufficientStackSpace(SourceLocation Loc,
1579 llvm::function_ref<void()> Fn);
1580
1581 /// Helper class that creates diagnostics with optional
1582 /// template instantiation stacks.
1583 ///
1584 /// This class provides a wrapper around the basic DiagnosticBuilder
1585 /// class that emits diagnostics. ImmediateDiagBuilder is
1586 /// responsible for emitting the diagnostic (as DiagnosticBuilder
1587 /// does) and, if the diagnostic comes from inside a template
1588 /// instantiation, printing the template instantiation stack as
1589 /// well.
1590 class ImmediateDiagBuilder : public DiagnosticBuilder {
1591 Sema &SemaRef;
1592 unsigned DiagID;
1593
1594 public:
1595 ImmediateDiagBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
1596 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {}
1597 ImmediateDiagBuilder(DiagnosticBuilder &&DB, Sema &SemaRef, unsigned DiagID)
1598 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {}
1599
1600 // This is a cunning lie. DiagnosticBuilder actually performs move
1601 // construction in its copy constructor (but due to varied uses, it's not
1602 // possible to conveniently express this as actual move construction). So
1603 // the default copy ctor here is fine, because the base class disables the
1604 // source anyway, so the user-defined ~ImmediateDiagBuilder is a safe no-op
1605 // in that case anwyay.
1606 ImmediateDiagBuilder(const ImmediateDiagBuilder &) = default;
1607
1608 ~ImmediateDiagBuilder() {
1609 // If we aren't active, there is nothing to do.
1610 if (!isActive()) return;
1611
1612 // Otherwise, we need to emit the diagnostic. First clear the diagnostic
1613 // builder itself so it won't emit the diagnostic in its own destructor.
1614 //
1615 // This seems wasteful, in that as written the DiagnosticBuilder dtor will
1616 // do its own needless checks to see if the diagnostic needs to be
1617 // emitted. However, because we take care to ensure that the builder
1618 // objects never escape, a sufficiently smart compiler will be able to
1619 // eliminate that code.
1620 Clear();
1621
1622 // Dispatch to Sema to emit the diagnostic.
1623 SemaRef.EmitCurrentDiagnostic(DiagID);
1624 }
1625
1626 /// Teach operator<< to produce an object of the correct type.
1627 template <typename T>
1628 friend const ImmediateDiagBuilder &
1629 operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {
1630 const DiagnosticBuilder &BaseDiag = Diag;
1631 BaseDiag << Value;
1632 return Diag;
1633 }
1634
1635 // It is necessary to limit this to rvalue reference to avoid calling this
1636 // function with a bitfield lvalue argument since non-const reference to
1637 // bitfield is not allowed.
1638 template <typename T, typename = typename std::enable_if<
1639 !std::is_lvalue_reference<T>::value>::type>
1640 const ImmediateDiagBuilder &operator<<(T &&V) const {
1641 const DiagnosticBuilder &BaseDiag = *this;
1642 BaseDiag << std::move(V);
1643 return *this;
1644 }
1645 };
1646
1647 /// A generic diagnostic builder for errors which may or may not be deferred.
1648 ///
1649 /// In CUDA, there exist constructs (e.g. variable-length arrays, try/catch)
1650 /// which are not allowed to appear inside __device__ functions and are
1651 /// allowed to appear in __host__ __device__ functions only if the host+device
1652 /// function is never codegen'ed.
1653 ///
1654 /// To handle this, we use the notion of "deferred diagnostics", where we
1655 /// attach a diagnostic to a FunctionDecl that's emitted iff it's codegen'ed.
1656 ///
1657 /// This class lets you emit either a regular diagnostic, a deferred
1658 /// diagnostic, or no diagnostic at all, according to an argument you pass to
1659 /// its constructor, thus simplifying the process of creating these "maybe
1660 /// deferred" diagnostics.
1661 class SemaDiagnosticBuilder {
1662 public:
1663 enum Kind {
1664 /// Emit no diagnostics.
1665 K_Nop,
1666 /// Emit the diagnostic immediately (i.e., behave like Sema::Diag()).
1667 K_Immediate,
1668 /// Emit the diagnostic immediately, and, if it's a warning or error, also
1669 /// emit a call stack showing how this function can be reached by an a
1670 /// priori known-emitted function.
1671 K_ImmediateWithCallStack,
1672 /// Create a deferred diagnostic, which is emitted only if the function
1673 /// it's attached to is codegen'ed. Also emit a call stack as with
1674 /// K_ImmediateWithCallStack.
1675 K_Deferred
1676 };
1677
1678 SemaDiagnosticBuilder(Kind K, SourceLocation Loc, unsigned DiagID,
1679 FunctionDecl *Fn, Sema &S);
1680 SemaDiagnosticBuilder(SemaDiagnosticBuilder &&D);
1681 SemaDiagnosticBuilder(const SemaDiagnosticBuilder &) = default;
1682 ~SemaDiagnosticBuilder();
1683
1684 bool isImmediate() const { return ImmediateDiag.hasValue(); }
1685
1686 /// Convertible to bool: True if we immediately emitted an error, false if
1687 /// we didn't emit an error or we created a deferred error.
1688 ///
1689 /// Example usage:
1690 ///
1691 /// if (SemaDiagnosticBuilder(...) << foo << bar)
1692 /// return ExprError();
1693 ///
1694 /// But see CUDADiagIfDeviceCode() and CUDADiagIfHostCode() -- you probably
1695 /// want to use these instead of creating a SemaDiagnosticBuilder yourself.
1696 operator bool() const { return isImmediate(); }
1697
1698 template <typename T>
1699 friend const SemaDiagnosticBuilder &
1700 operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {
1701 if (Diag.ImmediateDiag.hasValue())
1702 *Diag.ImmediateDiag << Value;
1703 else if (Diag.PartialDiagId.hasValue())
1704 Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second
1705 << Value;
1706 return Diag;
1707 }
1708
1709 // It is necessary to limit this to rvalue reference to avoid calling this
1710 // function with a bitfield lvalue argument since non-const reference to
1711 // bitfield is not allowed.
1712 template <typename T, typename = typename std::enable_if<
1713 !std::is_lvalue_reference<T>::value>::type>
1714 const SemaDiagnosticBuilder &operator<<(T &&V) const {
1715 if (ImmediateDiag.hasValue())
1716 *ImmediateDiag << std::move(V);
1717 else if (PartialDiagId.hasValue())
1718 S.DeviceDeferredDiags[Fn][*PartialDiagId].second << std::move(V);
1719 return *this;
1720 }
1721
1722 friend const SemaDiagnosticBuilder &
1723 operator<<(const SemaDiagnosticBuilder &Diag, const PartialDiagnostic &PD) {
1724 if (Diag.ImmediateDiag.hasValue())
1725 PD.Emit(*Diag.ImmediateDiag);
1726 else if (Diag.PartialDiagId.hasValue())
1727 Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second = PD;
1728 return Diag;
1729 }
1730
1731 void AddFixItHint(const FixItHint &Hint) const {
1732 if (ImmediateDiag.hasValue())
1733 ImmediateDiag->AddFixItHint(Hint);
1734 else if (PartialDiagId.hasValue())
1735 S.DeviceDeferredDiags[Fn][*PartialDiagId].second.AddFixItHint(Hint);
1736 }
1737
1738 friend ExprResult ExprError(const SemaDiagnosticBuilder &) {
1739 return ExprError();
1740 }
1741 friend StmtResult StmtError(const SemaDiagnosticBuilder &) {
1742 return StmtError();
1743 }
1744 operator ExprResult() const { return ExprError(); }
1745 operator StmtResult() const { return StmtError(); }
1746 operator TypeResult() const { return TypeError(); }
1747 operator DeclResult() const { return DeclResult(true); }
1748 operator MemInitResult() const { return MemInitResult(true); }
1749
1750 private:
1751 Sema &S;
1752 SourceLocation Loc;
1753 unsigned DiagID;
1754 FunctionDecl *Fn;
1755 bool ShowCallStack;
1756
1757 // Invariant: At most one of these Optionals has a value.
1758 // FIXME: Switch these to a Variant once that exists.
1759 llvm::Optional<ImmediateDiagBuilder> ImmediateDiag;
1760 llvm::Optional<unsigned> PartialDiagId;
1761 };
1762
1763 /// Is the last error level diagnostic immediate. This is used to determined
1764 /// whether the next info diagnostic should be immediate.
1765 bool IsLastErrorImmediate = true;
1766
1767 /// Emit a diagnostic.
1768 SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID,
1769 bool DeferHint = false);
1770
1771 /// Emit a partial diagnostic.
1772 SemaDiagnosticBuilder Diag(SourceLocation Loc, const PartialDiagnostic &PD,
1773 bool DeferHint = false);
1774
1775 /// Build a partial diagnostic.
1776 PartialDiagnostic PDiag(unsigned DiagID = 0); // in SemaInternal.h
1777
1778 /// Whether deferrable diagnostics should be deferred.
1779 bool DeferDiags = false;
1780
1781 /// RAII class to control scope of DeferDiags.
1782 class DeferDiagsRAII {
1783 Sema &S;
1784 bool SavedDeferDiags = false;
1785
1786 public:
1787 DeferDiagsRAII(Sema &S, bool DeferDiags)
1788 : S(S), SavedDeferDiags(S.DeferDiags) {
1789 S.DeferDiags = DeferDiags;
1790 }
1791 ~DeferDiagsRAII() { S.DeferDiags = SavedDeferDiags; }
1792 };
1793
1794 /// Whether uncompilable error has occurred. This includes error happens
1795 /// in deferred diagnostics.
1796 bool hasUncompilableErrorOccurred() const;
1797
1798 bool findMacroSpelling(SourceLocation &loc, StringRef name);
1799
1800 /// Get a string to suggest for zero-initialization of a type.
1801 std::string
1802 getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const;
1803 std::string getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const;
1804
1805 /// Calls \c Lexer::getLocForEndOfToken()
1806 SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset = 0);
1807
1808 /// Retrieve the module loader associated with the preprocessor.
1809 ModuleLoader &getModuleLoader() const;
1810
1811 /// Invent a new identifier for parameters of abbreviated templates.
1812 IdentifierInfo *
1813 InventAbbreviatedTemplateParameterTypeName(IdentifierInfo *ParamName,
1814 unsigned Index);
1815
1816 void emitAndClearUnusedLocalTypedefWarnings();
1817
1818 private:
1819 /// Function or variable declarations to be checked for whether the deferred
1820 /// diagnostics should be emitted.
1821 llvm::SmallSetVector<Decl *, 4> DeclsToCheckForDeferredDiags;
1822
1823 public:
1824 // Emit all deferred diagnostics.
1825 void emitDeferredDiags();
1826
1827 enum TUFragmentKind {
1828 /// The global module fragment, between 'module;' and a module-declaration.
1829 Global,
1830 /// A normal translation unit fragment. For a non-module unit, this is the
1831 /// entire translation unit. Otherwise, it runs from the module-declaration
1832 /// to the private-module-fragment (if any) or the end of the TU (if not).
1833 Normal,
1834 /// The private module fragment, between 'module :private;' and the end of
1835 /// the translation unit.
1836 Private
1837 };
1838
1839 void ActOnStartOfTranslationUnit();
1840 void ActOnEndOfTranslationUnit();
1841 void ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind);
1842
1843 void CheckDelegatingCtorCycles();
1844
1845 Scope *getScopeForContext(DeclContext *Ctx);
1846
1847 void PushFunctionScope();
1848 void PushBlockScope(Scope *BlockScope, BlockDecl *Block);
1849 sema::LambdaScopeInfo *PushLambdaScope();
1850
1851 /// This is used to inform Sema what the current TemplateParameterDepth
1852 /// is during Parsing. Currently it is used to pass on the depth
1853 /// when parsing generic lambda 'auto' parameters.
1854 void RecordParsingTemplateParameterDepth(unsigned Depth);
1855
1856 void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD,
1857 RecordDecl *RD, CapturedRegionKind K,
1858 unsigned OpenMPCaptureLevel = 0);
1859
1860 /// Custom deleter to allow FunctionScopeInfos to be kept alive for a short
1861 /// time after they've been popped.
1862 class PoppedFunctionScopeDeleter {
1863 Sema *Self;
1864
1865 public:
1866 explicit PoppedFunctionScopeDeleter(Sema *Self) : Self(Self) {}
1867 void operator()(sema::FunctionScopeInfo *Scope) const;
1868 };
1869
1870 using PoppedFunctionScopePtr =
1871 std::unique_ptr<sema::FunctionScopeInfo, PoppedFunctionScopeDeleter>;
1872
1873 PoppedFunctionScopePtr
1874 PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP = nullptr,
1875 const Decl *D = nullptr,
1876 QualType BlockType = QualType());
1877
1878 sema::FunctionScopeInfo *getCurFunction() const {
1879 return FunctionScopes.empty() ? nullptr : FunctionScopes.back();
1880 }
1881
1882 sema::FunctionScopeInfo *getEnclosingFunction() const;
1883
1884 void setFunctionHasBranchIntoScope();
1885 void setFunctionHasBranchProtectedScope();
1886 void setFunctionHasIndirectGoto();
1887 void setFunctionHasMustTail();
1888
1889 void PushCompoundScope(bool IsStmtExpr);
1890 void PopCompoundScope();
1891
1892 sema::CompoundScopeInfo &getCurCompoundScope() const;
1893
1894 bool hasAnyUnrecoverableErrorsInThisFunction() const;
1895
1896 /// Retrieve the current block, if any.
1897 sema::BlockScopeInfo *getCurBlock();
1898
1899 /// Get the innermost lambda enclosing the current location, if any. This
1900 /// looks through intervening non-lambda scopes such as local functions and
1901 /// blocks.
1902 sema::LambdaScopeInfo *getEnclosingLambda() const;
1903
1904 /// Retrieve the current lambda scope info, if any.
1905 /// \param IgnoreNonLambdaCapturingScope true if should find the top-most
1906 /// lambda scope info ignoring all inner capturing scopes that are not
1907 /// lambda scopes.
1908 sema::LambdaScopeInfo *
1909 getCurLambda(bool IgnoreNonLambdaCapturingScope = false);
1910
1911 /// Retrieve the current generic lambda info, if any.
1912 sema::LambdaScopeInfo *getCurGenericLambda();
1913
1914 /// Retrieve the current captured region, if any.
1915 sema::CapturedRegionScopeInfo *getCurCapturedRegion();
1916
1917 /// Retrieve the current function, if any, that should be analyzed for
1918 /// potential availability violations.
1919 sema::FunctionScopeInfo *getCurFunctionAvailabilityContext();
1920
1921 /// WeakTopLevelDeclDecls - access to \#pragma weak-generated Decls
1922 SmallVectorImpl<Decl *> &WeakTopLevelDecls() { return WeakTopLevelDecl; }
1923
1924 /// Called before parsing a function declarator belonging to a function
1925 /// declaration.
1926 void ActOnStartFunctionDeclarationDeclarator(Declarator &D,
1927 unsigned TemplateParameterDepth);
1928
1929 /// Called after parsing a function declarator belonging to a function
1930 /// declaration.
1931 void ActOnFinishFunctionDeclarationDeclarator(Declarator &D);
1932
1933 void ActOnComment(SourceRange Comment);
1934
1935 //===--------------------------------------------------------------------===//
1936 // Type Analysis / Processing: SemaType.cpp.
1937 //
1938
1939 QualType BuildQualifiedType(QualType T, SourceLocation Loc, Qualifiers Qs,
1940 const DeclSpec *DS = nullptr);
1941 QualType BuildQualifiedType(QualType T, SourceLocation Loc, unsigned CVRA,
1942 const DeclSpec *DS = nullptr);
1943 QualType BuildPointerType(QualType T,
1944 SourceLocation Loc, DeclarationName Entity);
1945 QualType BuildReferenceType(QualType T, bool LValueRef,
1946 SourceLocation Loc, DeclarationName Entity);
1947 QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
1948 Expr *ArraySize, unsigned Quals,
1949 SourceRange Brackets, DeclarationName Entity);
1950 QualType BuildVectorType(QualType T, Expr *VecSize, SourceLocation AttrLoc);
1951 QualType BuildExtVectorType(QualType T, Expr *ArraySize,
1952 SourceLocation AttrLoc);
1953 QualType BuildMatrixType(QualType T, Expr *NumRows, Expr *NumColumns,
1954 SourceLocation AttrLoc);
1955
1956 QualType BuildAddressSpaceAttr(QualType &T, LangAS ASIdx, Expr *AddrSpace,
1957 SourceLocation AttrLoc);
1958
1959 /// Same as above, but constructs the AddressSpace index if not provided.
1960 QualType BuildAddressSpaceAttr(QualType &T, Expr *AddrSpace,
1961 SourceLocation AttrLoc);
1962
1963 bool CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc);
1964
1965 bool CheckFunctionReturnType(QualType T, SourceLocation Loc);
1966
1967 /// Build a function type.
1968 ///
1969 /// This routine checks the function type according to C++ rules and
1970 /// under the assumption that the result type and parameter types have
1971 /// just been instantiated from a template. It therefore duplicates
1972 /// some of the behavior of GetTypeForDeclarator, but in a much
1973 /// simpler form that is only suitable for this narrow use case.
1974 ///
1975 /// \param T The return type of the function.
1976 ///
1977 /// \param ParamTypes The parameter types of the function. This array
1978 /// will be modified to account for adjustments to the types of the
1979 /// function parameters.
1980 ///
1981 /// \param Loc The location of the entity whose type involves this
1982 /// function type or, if there is no such entity, the location of the
1983 /// type that will have function type.
1984 ///
1985 /// \param Entity The name of the entity that involves the function
1986 /// type, if known.
1987 ///
1988 /// \param EPI Extra information about the function type. Usually this will
1989 /// be taken from an existing function with the same prototype.
1990 ///
1991 /// \returns A suitable function type, if there are no errors. The
1992 /// unqualified type will always be a FunctionProtoType.
1993 /// Otherwise, returns a NULL type.
1994 QualType BuildFunctionType(QualType T,
1995 MutableArrayRef<QualType> ParamTypes,
1996 SourceLocation Loc, DeclarationName Entity,
1997 const FunctionProtoType::ExtProtoInfo &EPI);
1998
1999 QualType BuildMemberPointerType(QualType T, QualType Class,
2000 SourceLocation Loc,
2001 DeclarationName Entity);
2002 QualType BuildBlockPointerType(QualType T,
2003 SourceLocation Loc, DeclarationName Entity);
2004 QualType BuildParenType(QualType T);
2005 QualType BuildAtomicType(QualType T, SourceLocation Loc);
2006 QualType BuildReadPipeType(QualType T,
2007 SourceLocation Loc);
2008 QualType BuildWritePipeType(QualType T,
2009 SourceLocation Loc);
2010 QualType BuildExtIntType(bool IsUnsigned, Expr *BitWidth, SourceLocation Loc);
2011
2012 TypeSourceInfo *GetTypeForDeclarator(Declarator &D, Scope *S);
2013 TypeSourceInfo *GetTypeForDeclaratorCast(Declarator &D, QualType FromTy);
2014
2015 /// Package the given type and TSI into a ParsedType.
2016 ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo);
2017 DeclarationNameInfo GetNameForDeclarator(Declarator &D);
2018 DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name);
2019 static QualType GetTypeFromParser(ParsedType Ty,
2020 TypeSourceInfo **TInfo = nullptr);
2021 CanThrowResult canThrow(const Stmt *E);
2022 /// Determine whether the callee of a particular function call can throw.
2023 /// E, D and Loc are all optional.
2024 static CanThrowResult canCalleeThrow(Sema &S, const Expr *E, const Decl *D,
2025 SourceLocation Loc = SourceLocation());
2026 const FunctionProtoType *ResolveExceptionSpec(SourceLocation Loc,
2027 const FunctionProtoType *FPT);
2028 void UpdateExceptionSpec(FunctionDecl *FD,
2029 const FunctionProtoType::ExceptionSpecInfo &ESI);
2030 bool CheckSpecifiedExceptionType(QualType &T, SourceRange Range);
2031 bool CheckDistantExceptionSpec(QualType T);
2032 bool CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New);
2033 bool CheckEquivalentExceptionSpec(
2034 const FunctionProtoType *Old, SourceLocation OldLoc,
2035 const FunctionProtoType *New, SourceLocation NewLoc);
2036 bool CheckEquivalentExceptionSpec(
2037 const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
2038 const FunctionProtoType *Old, SourceLocation OldLoc,
2039 const FunctionProtoType *New, SourceLocation NewLoc);
2040 bool handlerCanCatch(QualType HandlerType, QualType ExceptionType);
2041 bool CheckExceptionSpecSubset(const PartialDiagnostic &DiagID,
2042 const PartialDiagnostic &NestedDiagID,
2043 const PartialDiagnostic &NoteID,
2044 const PartialDiagnostic &NoThrowDiagID,
2045 const FunctionProtoType *Superset,
2046 SourceLocation SuperLoc,
2047 const FunctionProtoType *Subset,
2048 SourceLocation SubLoc);
2049 bool CheckParamExceptionSpec(const PartialDiagnostic &NestedDiagID,
2050 const PartialDiagnostic &NoteID,
2051 const FunctionProtoType *Target,
2052 SourceLocation TargetLoc,
2053 const FunctionProtoType *Source,
2054 SourceLocation SourceLoc);
2055
2056 TypeResult ActOnTypeName(Scope *S, Declarator &D);
2057
2058 /// The parser has parsed the context-sensitive type 'instancetype'
2059 /// in an Objective-C message declaration. Return the appropriate type.
2060 ParsedType ActOnObjCInstanceType(SourceLocation Loc);
2061
2062 /// Abstract class used to diagnose incomplete types.
2063 struct TypeDiagnoser {
2064 TypeDiagnoser() {}
2065
2066 virtual void diagnose(Sema &S, SourceLocation Loc, QualType T) = 0;
2067 virtual ~TypeDiagnoser() {}
2068 };
2069
2070 static int getPrintable(int I) { return I; }
2071 static unsigned getPrintable(unsigned I) { return I; }
2072 static bool getPrintable(bool B) { return B; }
2073 static const char * getPrintable(const char *S) { return S; }
2074 static StringRef getPrintable(StringRef S) { return S; }
2075 static const std::string &getPrintable(const std::string &S) { return S; }
2076 static const IdentifierInfo *getPrintable(const IdentifierInfo *II) {
2077 return II;
2078 }
2079 static DeclarationName getPrintable(DeclarationName N) { return N; }
2080 static QualType getPrintable(QualType T) { return T; }
2081 static SourceRange getPrintable(SourceRange R) { return R; }
2082 static SourceRange getPrintable(SourceLocation L) { return L; }
2083 static SourceRange getPrintable(const Expr *E) { return E->getSourceRange(); }
2084 static SourceRange getPrintable(TypeLoc TL) { return TL.getSourceRange();}
2085
2086 template <typename... Ts> class BoundTypeDiagnoser : public TypeDiagnoser {
2087 protected:
2088 unsigned DiagID;
2089 std::tuple<const Ts &...> Args;
2090
2091 template <std::size_t... Is>
2092 void emit(const SemaDiagnosticBuilder &DB,
2093 std::index_sequence<Is...>) const {
2094 // Apply all tuple elements to the builder in order.
2095 bool Dummy[] = {false, (DB << getPrintable(std::get<Is>(Args)))...};
2096 (void)Dummy;
2097 }
2098
2099 public:
2100 BoundTypeDiagnoser(unsigned DiagID, const Ts &...Args)
2101 : TypeDiagnoser(), DiagID(DiagID), Args(Args...) {
2102 assert(DiagID != 0 && "no diagnostic for type diagnoser")((void)0);
2103 }
2104
2105 void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
2106 const SemaDiagnosticBuilder &DB = S.Diag(Loc, DiagID);
2107 emit(DB, std::index_sequence_for<Ts...>());
2108 DB << T;
2109 }
2110 };
2111
2112 /// Do a check to make sure \p Name looks like a legal argument for the
2113 /// swift_name attribute applied to decl \p D. Raise a diagnostic if the name
2114 /// is invalid for the given declaration.
2115 ///
2116 /// \p AL is used to provide caret diagnostics in case of a malformed name.
2117 ///
2118 /// \returns true if the name is a valid swift name for \p D, false otherwise.
2119 bool DiagnoseSwiftName(Decl *D, StringRef Name, SourceLocation Loc,
2120 const ParsedAttr &AL, bool IsAsync);
2121
2122 /// A derivative of BoundTypeDiagnoser for which the diagnostic's type
2123 /// parameter is preceded by a 0/1 enum that is 1 if the type is sizeless.
2124 /// For example, a diagnostic with no other parameters would generally have
2125 /// the form "...%select{incomplete|sizeless}0 type %1...".
2126 template <typename... Ts>
2127 class SizelessTypeDiagnoser : public BoundTypeDiagnoser<Ts...> {
2128 public:
2129 SizelessTypeDiagnoser(unsigned DiagID, const Ts &... Args)
2130 : BoundTypeDiagnoser<Ts...>(DiagID, Args...) {}
2131
2132 void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
2133 const SemaDiagnosticBuilder &DB = S.Diag(Loc, this->DiagID);
2134 this->emit(DB, std::index_sequence_for<Ts...>());
2135 DB << T->isSizelessType() << T;
2136 }
2137 };
2138
2139 enum class CompleteTypeKind {
2140 /// Apply the normal rules for complete types. In particular,
2141 /// treat all sizeless types as incomplete.
2142 Normal,
2143
2144 /// Relax the normal rules for complete types so that they include
2145 /// sizeless built-in types.
2146 AcceptSizeless,
2147
2148 // FIXME: Eventually we should flip the default to Normal and opt in
2149 // to AcceptSizeless rather than opt out of it.
2150 Default = AcceptSizeless
2151 };
2152
2153private:
2154 /// Methods for marking which expressions involve dereferencing a pointer
2155 /// marked with the 'noderef' attribute. Expressions are checked bottom up as
2156 /// they are parsed, meaning that a noderef pointer may not be accessed. For
2157 /// example, in `&*p` where `p` is a noderef pointer, we will first parse the
2158 /// `*p`, but need to check that `address of` is called on it. This requires
2159 /// keeping a container of all pending expressions and checking if the address
2160 /// of them are eventually taken.
2161 void CheckSubscriptAccessOfNoDeref(const ArraySubscriptExpr *E);
2162 void CheckAddressOfNoDeref(const Expr *E);
2163 void CheckMemberAccessOfNoDeref(const MemberExpr *E);
2164
2165 bool RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
2166 CompleteTypeKind Kind, TypeDiagnoser *Diagnoser);
2167
2168 struct ModuleScope {
2169 SourceLocation BeginLoc;
2170 clang::Module *Module = nullptr;
2171 bool ModuleInterface = false;
2172 bool ImplicitGlobalModuleFragment = false;
2173 VisibleModuleSet OuterVisibleModules;
2174 };
2175 /// The modules we're currently parsing.
2176 llvm::SmallVector<ModuleScope, 16> ModuleScopes;
2177
2178 /// Namespace definitions that we will export when they finish.
2179 llvm::SmallPtrSet<const NamespaceDecl*, 8> DeferredExportedNamespaces;
2180
2181 /// Get the module whose scope we are currently within.
2182 Module *getCurrentModule() const {
2183 return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module;
2184 }
2185
2186 VisibleModuleSet VisibleModules;
2187
2188public:
2189 /// Get the module owning an entity.
2190 Module *getOwningModule(const Decl *Entity) {
2191 return Entity->getOwningModule();
2192 }
2193
2194 /// Make a merged definition of an existing hidden definition \p ND
2195 /// visible at the specified location.
2196 void makeMergedDefinitionVisible(NamedDecl *ND);
2197
2198 bool isModuleVisible(const Module *M, bool ModulePrivate = false);
2199
2200 // When loading a non-modular PCH files, this is used to restore module
2201 // visibility.
2202 void makeModuleVisible(Module *Mod, SourceLocation ImportLoc) {
2203 VisibleModules.setVisible(Mod, ImportLoc);
2204 }
2205
2206 /// Determine whether a declaration is visible to name lookup.
2207 bool isVisible(const NamedDecl *D) {
2208 return D->isUnconditionallyVisible() || isVisibleSlow(D);
2209 }
2210
2211 /// Determine whether any declaration of an entity is visible.
2212 bool
2213 hasVisibleDeclaration(const NamedDecl *D,
2214 llvm::SmallVectorImpl<Module *> *Modules = nullptr) {
2215 return isVisible(D) || hasVisibleDeclarationSlow(D, Modules);
2216 }
2217 bool hasVisibleDeclarationSlow(const NamedDecl *D,
2218 llvm::SmallVectorImpl<Module *> *Modules);
2219
2220 bool hasVisibleMergedDefinition(NamedDecl *Def);
2221 bool hasMergedDefinitionInCurrentModule(NamedDecl *Def);
2222
2223 /// Determine if \p D and \p Suggested have a structurally compatible
2224 /// layout as described in C11 6.2.7/1.
2225 bool hasStructuralCompatLayout(Decl *D, Decl *Suggested);
2226
2227 /// Determine if \p D has a visible definition. If not, suggest a declaration
2228 /// that should be made visible to expose the definition.
2229 bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested,
2230 bool OnlyNeedComplete = false);
2231 bool hasVisibleDefinition(const NamedDecl *D) {
2232 NamedDecl *Hidden;
2233 return hasVisibleDefinition(const_cast<NamedDecl*>(D), &Hidden);
2234 }
2235
2236 /// Determine if the template parameter \p D has a visible default argument.
2237 bool
2238 hasVisibleDefaultArgument(const NamedDecl *D,
2239 llvm::SmallVectorImpl<Module *> *Modules = nullptr);
2240
2241 /// Determine if there is a visible declaration of \p D that is an explicit
2242 /// specialization declaration for a specialization of a template. (For a
2243 /// member specialization, use hasVisibleMemberSpecialization.)
2244 bool hasVisibleExplicitSpecialization(
2245 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
2246
2247 /// Determine if there is a visible declaration of \p D that is a member
2248 /// specialization declaration (as opposed to an instantiated declaration).
2249 bool hasVisibleMemberSpecialization(
2250 const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
2251
2252 /// Determine if \p A and \p B are equivalent internal linkage declarations
2253 /// from different modules, and thus an ambiguity error can be downgraded to
2254 /// an extension warning.
2255 bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A,
2256 const NamedDecl *B);
2257 void diagnoseEquivalentInternalLinkageDeclarations(
2258 SourceLocation Loc, const NamedDecl *D,
2259 ArrayRef<const NamedDecl *> Equiv);
2260
2261 bool isUsualDeallocationFunction(const CXXMethodDecl *FD);
2262
2263 bool isCompleteType(SourceLocation Loc, QualType T,
2264 CompleteTypeKind Kind = CompleteTypeKind::Default) {
2265 return !RequireCompleteTypeImpl(Loc, T, Kind, nullptr);
2266 }
2267 bool RequireCompleteType(SourceLocation Loc, QualType T,
2268 CompleteTypeKind Kind, TypeDiagnoser &Diagnoser);
2269 bool RequireCompleteType(SourceLocation Loc, QualType T,
2270 CompleteTypeKind Kind, unsigned DiagID);
2271
2272 bool RequireCompleteType(SourceLocation Loc, QualType T,
2273 TypeDiagnoser &Diagnoser) {
2274 return RequireCompleteType(Loc, T, CompleteTypeKind::Default, Diagnoser);
2275 }
2276 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID) {
2277 return RequireCompleteType(Loc, T, CompleteTypeKind::Default, DiagID);
2278 }
2279
2280 template <typename... Ts>
2281 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned DiagID,
2282 const Ts &...Args) {
2283 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2284 return RequireCompleteType(Loc, T, Diagnoser);
2285 }
2286
2287 template <typename... Ts>
2288 bool RequireCompleteSizedType(SourceLocation Loc, QualType T, unsigned DiagID,
2289 const Ts &... Args) {
2290 SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2291 return RequireCompleteType(Loc, T, CompleteTypeKind::Normal, Diagnoser);
2292 }
2293
2294 /// Get the type of expression E, triggering instantiation to complete the
2295 /// type if necessary -- that is, if the expression refers to a templated
2296 /// static data member of incomplete array type.
2297 ///
2298 /// May still return an incomplete type if instantiation was not possible or
2299 /// if the type is incomplete for a different reason. Use
2300 /// RequireCompleteExprType instead if a diagnostic is expected for an
2301 /// incomplete expression type.
2302 QualType getCompletedType(Expr *E);
2303
2304 void completeExprArrayBound(Expr *E);
2305 bool RequireCompleteExprType(Expr *E, CompleteTypeKind Kind,
2306 TypeDiagnoser &Diagnoser);
2307 bool RequireCompleteExprType(Expr *E, unsigned DiagID);
2308
2309 template <typename... Ts>
2310 bool RequireCompleteExprType(Expr *E, unsigned DiagID, const Ts &...Args) {
2311 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2312 return RequireCompleteExprType(E, CompleteTypeKind::Default, Diagnoser);
2313 }
2314
2315 template <typename... Ts>
2316 bool RequireCompleteSizedExprType(Expr *E, unsigned DiagID,
2317 const Ts &... Args) {
2318 SizelessTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2319 return RequireCompleteExprType(E, CompleteTypeKind::Normal, Diagnoser);
2320 }
2321
2322 bool RequireLiteralType(SourceLocation Loc, QualType T,
2323 TypeDiagnoser &Diagnoser);
2324 bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID);
2325
2326 template <typename... Ts>
2327 bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID,
2328 const Ts &...Args) {
2329 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
2330 return RequireLiteralType(Loc, T, Diagnoser);
2331 }
2332
2333 QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
2334 const CXXScopeSpec &SS, QualType T,
2335 TagDecl *OwnedTagDecl = nullptr);
2336
2337 QualType getDecltypeForParenthesizedExpr(Expr *E);
2338 QualType BuildTypeofExprType(Expr *E, SourceLocation Loc);
2339 /// If AsUnevaluated is false, E is treated as though it were an evaluated
2340 /// context, such as when building a type for decltype(auto).
2341 QualType BuildDecltypeType(Expr *E, SourceLocation Loc,
2342 bool AsUnevaluated = true);
2343 QualType BuildUnaryTransformType(QualType BaseType,
2344 UnaryTransformType::UTTKind UKind,
2345 SourceLocation Loc);
2346
2347 //===--------------------------------------------------------------------===//
2348 // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
2349 //
2350
2351 struct SkipBodyInfo {
2352 SkipBodyInfo()
2353 : ShouldSkip(false), CheckSameAsPrevious(false), Previous(nullptr),
2354 New(nullptr) {}
2355 bool ShouldSkip;
2356 bool CheckSameAsPrevious;
2357 NamedDecl *Previous;
2358 NamedDecl *New;
2359 };
2360
2361 DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType = nullptr);
2362
2363 void DiagnoseUseOfUnimplementedSelectors();
2364
2365 bool isSimpleTypeSpecifier(tok::TokenKind Kind) const;
2366
2367 ParsedType getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
2368 Scope *S, CXXScopeSpec *SS = nullptr,
2369 bool isClassName = false, bool HasTrailingDot = false,
2370 ParsedType ObjectType = nullptr,
2371 bool IsCtorOrDtorName = false,
2372 bool WantNontrivialTypeSourceInfo = false,
2373 bool IsClassTemplateDeductionContext = true,
2374 IdentifierInfo **CorrectedII = nullptr);
2375 TypeSpecifierType isTagName(IdentifierInfo &II, Scope *S);
2376 bool isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S);
2377 void DiagnoseUnknownTypeName(IdentifierInfo *&II,
2378 SourceLocation IILoc,
2379 Scope *S,
2380 CXXScopeSpec *SS,
2381 ParsedType &SuggestedType,
2382 bool IsTemplateName = false);
2383
2384 /// Attempt to behave like MSVC in situations where lookup of an unqualified
2385 /// type name has failed in a dependent context. In these situations, we
2386 /// automatically form a DependentTypeName that will retry lookup in a related
2387 /// scope during instantiation.
2388 ParsedType ActOnMSVCUnknownTypeName(const IdentifierInfo &II,
2389 SourceLocation NameLoc,
2390 bool IsTemplateTypeArg);
2391
2392 /// Describes the result of the name lookup and resolution performed
2393 /// by \c ClassifyName().
2394 enum NameClassificationKind {
2395 /// This name is not a type or template in this context, but might be
2396 /// something else.
2397 NC_Unknown,
2398 /// Classification failed; an error has been produced.
2399 NC_Error,
2400 /// The name has been typo-corrected to a keyword.
2401 NC_Keyword,
2402 /// The name was classified as a type.
2403 NC_Type,
2404 /// The name was classified as a specific non-type, non-template
2405 /// declaration. ActOnNameClassifiedAsNonType should be called to
2406 /// convert the declaration to an expression.
2407 NC_NonType,
2408 /// The name was classified as an ADL-only function name.
2409 /// ActOnNameClassifiedAsUndeclaredNonType should be called to convert the
2410 /// result to an expression.
2411 NC_UndeclaredNonType,
2412 /// The name denotes a member of a dependent type that could not be
2413 /// resolved. ActOnNameClassifiedAsDependentNonType should be called to
2414 /// convert the result to an expression.
2415 NC_DependentNonType,
2416 /// The name was classified as an overload set, and an expression
2417 /// representing that overload set has been formed.
2418 /// ActOnNameClassifiedAsOverloadSet should be called to form a suitable
2419 /// expression referencing the overload set.
2420 NC_OverloadSet,
2421 /// The name was classified as a template whose specializations are types.
2422 NC_TypeTemplate,
2423 /// The name was classified as a variable template name.
2424 NC_VarTemplate,
2425 /// The name was classified as a function template name.
2426 NC_FunctionTemplate,
2427 /// The name was classified as an ADL-only function template name.
2428 NC_UndeclaredTemplate,
2429 /// The name was classified as a concept name.
2430 NC_Concept,
2431 };
2432
2433 class NameClassification {
2434 NameClassificationKind Kind;
2435 union {
2436 ExprResult Expr;
2437 NamedDecl *NonTypeDecl;
2438 TemplateName Template;
2439 ParsedType Type;
2440 };
2441
2442 explicit NameClassification(NameClassificationKind Kind) : Kind(Kind) {}
2443
2444 public:
2445 NameClassification(ParsedType Type) : Kind(NC_Type), Type(Type) {}
2446
2447 NameClassification(const IdentifierInfo *Keyword) : Kind(NC_Keyword) {}
2448
2449 static NameClassification Error() {
2450 return NameClassification(NC_Error);
2451 }
2452
2453 static NameClassification Unknown() {
2454 return NameClassification(NC_Unknown);
2455 }
2456
2457 static NameClassification OverloadSet(ExprResult E) {
2458 NameClassification Result(NC_OverloadSet);
2459 Result.Expr = E;
2460 return Result;
2461 }
2462
2463 static NameClassification NonType(NamedDecl *D) {
2464 NameClassification Result(NC_NonType);
2465 Result.NonTypeDecl = D;
2466 return Result;
2467 }
2468
2469 static NameClassification UndeclaredNonType() {
2470 return NameClassification(NC_UndeclaredNonType);
2471 }
2472
2473 static NameClassification DependentNonType() {
2474 return NameClassification(NC_DependentNonType);
2475 }
2476
2477 static NameClassification TypeTemplate(TemplateName Name) {
2478 NameClassification Result(NC_TypeTemplate);
2479 Result.Template = Name;
2480 return Result;
2481 }
2482
2483 static NameClassification VarTemplate(TemplateName Name) {
2484 NameClassification Result(NC_VarTemplate);
2485 Result.Template = Name;
2486 return Result;
2487 }
2488
2489 static NameClassification FunctionTemplate(TemplateName Name) {
2490 NameClassification Result(NC_FunctionTemplate);
2491 Result.Template = Name;
2492 return Result;
2493 }
2494
2495 static NameClassification Concept(TemplateName Name) {
2496 NameClassification Result(NC_Concept);
2497 Result.Template = Name;
2498 return Result;
2499 }
2500
2501 static NameClassification UndeclaredTemplate(TemplateName Name) {
2502 NameClassification Result(NC_UndeclaredTemplate);
2503 Result.Template = Name;
2504 return Result;
2505 }
2506
2507 NameClassificationKind getKind() const { return Kind; }
2508
2509 ExprResult getExpression() const {
2510 assert(Kind == NC_OverloadSet)((void)0);
2511 return Expr;
2512 }
2513
2514 ParsedType getType() const {
2515 assert(Kind == NC_Type)((void)0);
2516 return Type;
2517 }
2518
2519 NamedDecl *getNonTypeDecl() const {
2520 assert(Kind == NC_NonType)((void)0);
2521 return NonTypeDecl;
2522 }
2523
2524 TemplateName getTemplateName() const {
2525 assert(Kind == NC_TypeTemplate || Kind == NC_FunctionTemplate ||((void)0)
2526 Kind == NC_VarTemplate || Kind == NC_Concept ||((void)0)
2527 Kind == NC_UndeclaredTemplate)((void)0);
2528 return Template;
2529 }
2530
2531 TemplateNameKind getTemplateNameKind() const {
2532 switch (Kind) {
2533 case NC_TypeTemplate:
2534 return TNK_Type_template;
2535 case NC_FunctionTemplate:
2536 return TNK_Function_template;
2537 case NC_VarTemplate:
2538 return TNK_Var_template;
2539 case NC_Concept:
2540 return TNK_Concept_template;
2541 case NC_UndeclaredTemplate:
2542 return TNK_Undeclared_template;
2543 default:
2544 llvm_unreachable("unsupported name classification.")__builtin_unreachable();
2545 }
2546 }
2547 };
2548
2549 /// Perform name lookup on the given name, classifying it based on
2550 /// the results of name lookup and the following token.
2551 ///
2552 /// This routine is used by the parser to resolve identifiers and help direct
2553 /// parsing. When the identifier cannot be found, this routine will attempt
2554 /// to correct the typo and classify based on the resulting name.
2555 ///
2556 /// \param S The scope in which we're performing name lookup.
2557 ///
2558 /// \param SS The nested-name-specifier that precedes the name.
2559 ///
2560 /// \param Name The identifier. If typo correction finds an alternative name,
2561 /// this pointer parameter will be updated accordingly.
2562 ///
2563 /// \param NameLoc The location of the identifier.
2564 ///
2565 /// \param NextToken The token following the identifier. Used to help
2566 /// disambiguate the name.
2567 ///
2568 /// \param CCC The correction callback, if typo correction is desired.
2569 NameClassification ClassifyName(Scope *S, CXXScopeSpec &SS,
2570 IdentifierInfo *&Name, SourceLocation NameLoc,
2571 const Token &NextToken,
2572 CorrectionCandidateCallback *CCC = nullptr);
2573
2574 /// Act on the result of classifying a name as an undeclared (ADL-only)
2575 /// non-type declaration.
2576 ExprResult ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name,
2577 SourceLocation NameLoc);
2578 /// Act on the result of classifying a name as an undeclared member of a
2579 /// dependent base class.
2580 ExprResult ActOnNameClassifiedAsDependentNonType(const CXXScopeSpec &SS,
2581 IdentifierInfo *Name,
2582 SourceLocation NameLoc,
2583 bool IsAddressOfOperand);
2584 /// Act on the result of classifying a name as a specific non-type
2585 /// declaration.
2586 ExprResult ActOnNameClassifiedAsNonType(Scope *S, const CXXScopeSpec &SS,
2587 NamedDecl *Found,
2588 SourceLocation NameLoc,
2589 const Token &NextToken);
2590 /// Act on the result of classifying a name as an overload set.
2591 ExprResult ActOnNameClassifiedAsOverloadSet(Scope *S, Expr *OverloadSet);
2592
2593 /// Describes the detailed kind of a template name. Used in diagnostics.
2594 enum class TemplateNameKindForDiagnostics {
2595 ClassTemplate,
2596 FunctionTemplate,
2597 VarTemplate,
2598 AliasTemplate,
2599 TemplateTemplateParam,
2600 Concept,
2601 DependentTemplate
2602 };
2603 TemplateNameKindForDiagnostics
2604 getTemplateNameKindForDiagnostics(TemplateName Name);
2605
2606 /// Determine whether it's plausible that E was intended to be a
2607 /// template-name.
2608 bool mightBeIntendedToBeTemplateName(ExprResult E, bool &Dependent) {
2609 if (!getLangOpts().CPlusPlus || E.isInvalid())
2610 return false;
2611 Dependent = false;
2612 if (auto *DRE = dyn_cast<DeclRefExpr>(E.get()))
2613 return !DRE->hasExplicitTemplateArgs();
2614 if (auto *ME = dyn_cast<MemberExpr>(E.get()))
2615 return !ME->hasExplicitTemplateArgs();
2616 Dependent = true;
2617 if (auto *DSDRE = dyn_cast<DependentScopeDeclRefExpr>(E.get()))
2618 return !DSDRE->hasExplicitTemplateArgs();
2619 if (auto *DSME = dyn_cast<CXXDependentScopeMemberExpr>(E.get()))
2620 return !DSME->hasExplicitTemplateArgs();
2621 // Any additional cases recognized here should also be handled by
2622 // diagnoseExprIntendedAsTemplateName.
2623 return false;
2624 }
2625 void diagnoseExprIntendedAsTemplateName(Scope *S, ExprResult TemplateName,
2626 SourceLocation Less,
2627 SourceLocation Greater);
2628
2629 void warnOnReservedIdentifier(const NamedDecl *D);
2630
2631 Decl *ActOnDeclarator(Scope *S, Declarator &D);
2632
2633 NamedDecl *HandleDeclarator(Scope *S, Declarator &D,
2634 MultiTemplateParamsArg TemplateParameterLists);
2635 bool tryToFixVariablyModifiedVarType(TypeSourceInfo *&TInfo,
2636 QualType &T, SourceLocation Loc,
2637 unsigned FailedFoldDiagID);
2638 void RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S);
2639 bool DiagnoseClassNameShadow(DeclContext *DC, DeclarationNameInfo Info);
2640 bool diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
2641 DeclarationName Name, SourceLocation Loc,
2642 bool IsTemplateId);
2643 void
2644 diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals,
2645 SourceLocation FallbackLoc,
2646 SourceLocation ConstQualLoc = SourceLocation(),
2647 SourceLocation VolatileQualLoc = SourceLocation(),
2648 SourceLocation RestrictQualLoc = SourceLocation(),
2649 SourceLocation AtomicQualLoc = SourceLocation(),
2650 SourceLocation UnalignedQualLoc = SourceLocation());
2651
2652 static bool adjustContextForLocalExternDecl(DeclContext *&DC);
2653 void DiagnoseFunctionSpecifiers(const DeclSpec &DS);
2654 NamedDecl *getShadowedDeclaration(const TypedefNameDecl *D,
2655 const LookupResult &R);
2656 NamedDecl *getShadowedDeclaration(const VarDecl *D, const LookupResult &R);
2657 NamedDecl *getShadowedDeclaration(const BindingDecl *D,
2658 const LookupResult &R);
2659 void CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl,
2660 const LookupResult &R);
2661 void CheckShadow(Scope *S, VarDecl *D);
2662
2663 /// Warn if 'E', which is an expression that is about to be modified, refers
2664 /// to a shadowing declaration.
2665 void CheckShadowingDeclModification(Expr *E, SourceLocation Loc);
2666
2667 void DiagnoseShadowingLambdaDecls(const sema::LambdaScopeInfo *LSI);
2668
2669private:
2670 /// Map of current shadowing declarations to shadowed declarations. Warn if
2671 /// it looks like the user is trying to modify the shadowing declaration.
2672 llvm::DenseMap<const NamedDecl *, const NamedDecl *> ShadowingDecls;
2673
2674public:
2675 void CheckCastAlign(Expr *Op, QualType T, SourceRange TRange);
2676 void handleTagNumbering(const TagDecl *Tag, Scope *TagScope);
2677 void setTagNameForLinkagePurposes(TagDecl *TagFromDeclSpec,
2678 TypedefNameDecl *NewTD);
2679 void CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *D);
2680 NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2681 TypeSourceInfo *TInfo,
2682 LookupResult &Previous);
2683 NamedDecl* ActOnTypedefNameDecl(Scope* S, DeclContext* DC, TypedefNameDecl *D,
2684 LookupResult &Previous, bool &Redeclaration);
2685 NamedDecl *ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
2686 TypeSourceInfo *TInfo,
2687 LookupResult &Previous,
2688 MultiTemplateParamsArg TemplateParamLists,
2689 bool &AddToScope,
2690 ArrayRef<BindingDecl *> Bindings = None);
2691 NamedDecl *
2692 ActOnDecompositionDeclarator(Scope *S, Declarator &D,
2693 MultiTemplateParamsArg TemplateParamLists);
2694 // Returns true if the variable declaration is a redeclaration
2695 bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);
2696 void CheckVariableDeclarationType(VarDecl *NewVD);
2697 bool DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,
2698 Expr *Init);
2699 void CheckCompleteVariableDeclaration(VarDecl *VD);
2700 void CheckCompleteDecompositionDeclaration(DecompositionDecl *DD);
2701 void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D);
2702
2703 NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2704 TypeSourceInfo *TInfo,
2705 LookupResult &Previous,
2706 MultiTemplateParamsArg TemplateParamLists,
2707 bool &AddToScope);
2708 bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);
2709
2710 enum class CheckConstexprKind {
2711 /// Diagnose issues that are non-constant or that are extensions.
2712 Diagnose,
2713 /// Identify whether this function satisfies the formal rules for constexpr
2714 /// functions in the current lanugage mode (with no extensions).
2715 CheckValid
2716 };
2717
2718 bool CheckConstexprFunctionDefinition(const FunctionDecl *FD,
2719 CheckConstexprKind Kind);
2720
2721 void DiagnoseHiddenVirtualMethods(CXXMethodDecl *MD);
2722 void FindHiddenVirtualMethods(CXXMethodDecl *MD,
2723 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
2724 void NoteHiddenVirtualMethods(CXXMethodDecl *MD,
2725 SmallVectorImpl<CXXMethodDecl*> &OverloadedMethods);
2726 // Returns true if the function declaration is a redeclaration
2727 bool CheckFunctionDeclaration(Scope *S,
2728 FunctionDecl *NewFD, LookupResult &Previous,
2729 bool IsMemberSpecialization);
2730 bool shouldLinkDependentDeclWithPrevious(Decl *D, Decl *OldDecl);
2731 bool canFullyTypeCheckRedeclaration(ValueDecl *NewD, ValueDecl *OldD,
2732 QualType NewT, QualType OldT);
2733 void CheckMain(FunctionDecl *FD, const DeclSpec &D);
2734 void CheckMSVCRTEntryPoint(FunctionDecl *FD);
2735 Attr *getImplicitCodeSegOrSectionAttrForFunction(const FunctionDecl *FD,
2736 bool IsDefinition);
2737 void CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D);
2738 Decl *ActOnParamDeclarator(Scope *S, Declarator &D);
2739 ParmVarDecl *BuildParmVarDeclForTypedef(DeclContext *DC,
2740 SourceLocation Loc,
2741 QualType T);
2742 ParmVarDecl *CheckParameter(DeclContext *DC, SourceLocation StartLoc,
2743 SourceLocation NameLoc, IdentifierInfo *Name,
2744 QualType T, TypeSourceInfo *TSInfo,
2745 StorageClass SC);
2746 void ActOnParamDefaultArgument(Decl *param,
2747 SourceLocation EqualLoc,
2748 Expr *defarg);
2749 void ActOnParamUnparsedDefaultArgument(Decl *param, SourceLocation EqualLoc,
2750 SourceLocation ArgLoc);
2751 void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc);
2752 ExprResult ConvertParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
2753 SourceLocation EqualLoc);
2754 void SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
2755 SourceLocation EqualLoc);
2756
2757 // Contexts where using non-trivial C union types can be disallowed. This is
2758 // passed to err_non_trivial_c_union_in_invalid_context.
2759 enum NonTrivialCUnionContext {
2760 // Function parameter.
2761 NTCUC_FunctionParam,
2762 // Function return.
2763 NTCUC_FunctionReturn,
2764 // Default-initialized object.
2765 NTCUC_DefaultInitializedObject,
2766 // Variable with automatic storage duration.
2767 NTCUC_AutoVar,
2768 // Initializer expression that might copy from another object.
2769 NTCUC_CopyInit,
2770 // Assignment.
2771 NTCUC_Assignment,
2772 // Compound literal.
2773 NTCUC_CompoundLiteral,
2774 // Block capture.
2775 NTCUC_BlockCapture,
2776 // lvalue-to-rvalue conversion of volatile type.
2777 NTCUC_LValueToRValueVolatile,
2778 };
2779
2780 /// Emit diagnostics if the initializer or any of its explicit or
2781 /// implicitly-generated subexpressions require copying or
2782 /// default-initializing a type that is or contains a C union type that is
2783 /// non-trivial to copy or default-initialize.
2784 void checkNonTrivialCUnionInInitializer(const Expr *Init, SourceLocation Loc);
2785
2786 // These flags are passed to checkNonTrivialCUnion.
2787 enum NonTrivialCUnionKind {
2788 NTCUK_Init = 0x1,
2789 NTCUK_Destruct = 0x2,
2790 NTCUK_Copy = 0x4,
2791 };
2792
2793 /// Emit diagnostics if a non-trivial C union type or a struct that contains
2794 /// a non-trivial C union is used in an invalid context.
2795 void checkNonTrivialCUnion(QualType QT, SourceLocation Loc,
2796 NonTrivialCUnionContext UseContext,
2797 unsigned NonTrivialKind);
2798
2799 void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit);
2800 void ActOnUninitializedDecl(Decl *dcl);
2801 void ActOnInitializerError(Decl *Dcl);
2802
2803 void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc);
2804 void ActOnCXXForRangeDecl(Decl *D);
2805 StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
2806 IdentifierInfo *Ident,
2807 ParsedAttributes &Attrs,
2808 SourceLocation AttrEnd);
2809 void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc);
2810 void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc);
2811 void CheckStaticLocalForDllExport(VarDecl *VD);
2812 void FinalizeDeclaration(Decl *D);
2813 DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
2814 ArrayRef<Decl *> Group);
2815 DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef<Decl *> Group);
2816
2817 /// Should be called on all declarations that might have attached
2818 /// documentation comments.
2819 void ActOnDocumentableDecl(Decl *D);
2820 void ActOnDocumentableDecls(ArrayRef<Decl *> Group);
2821
2822 void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
2823 SourceLocation LocAfterDecls);
2824 void CheckForFunctionRedefinition(
2825 FunctionDecl *FD, const FunctionDecl *EffectiveDefinition = nullptr,
2826 SkipBodyInfo *SkipBody = nullptr);
2827 Decl *ActOnStartOfFunctionDef(Scope *S, Declarator &D,
2828 MultiTemplateParamsArg TemplateParamLists,
2829 SkipBodyInfo *SkipBody = nullptr);
2830 Decl *ActOnStartOfFunctionDef(Scope *S, Decl *D,
2831 SkipBodyInfo *SkipBody = nullptr);
2832 void ActOnStartTrailingRequiresClause(Scope *S, Declarator &D);
2833 ExprResult ActOnFinishTrailingRequiresClause(ExprResult ConstraintExpr);
2834 ExprResult ActOnRequiresClause(ExprResult ConstraintExpr);
2835 void ActOnStartOfObjCMethodDef(Scope *S, Decl *D);
2836 bool isObjCMethodDecl(Decl *D) {
2837 return D && isa<ObjCMethodDecl>(D);
2838 }
2839
2840 /// Determine whether we can delay parsing the body of a function or
2841 /// function template until it is used, assuming we don't care about emitting
2842 /// code for that function.
2843 ///
2844 /// This will be \c false if we may need the body of the function in the
2845 /// middle of parsing an expression (where it's impractical to switch to
2846 /// parsing a different function), for instance, if it's constexpr in C++11
2847 /// or has an 'auto' return type in C++14. These cases are essentially bugs.
2848 bool canDelayFunctionBody(const Declarator &D);
2849
2850 /// Determine whether we can skip parsing the body of a function
2851 /// definition, assuming we don't care about analyzing its body or emitting
2852 /// code for that function.
2853 ///
2854 /// This will be \c false only if we may need the body of the function in
2855 /// order to parse the rest of the program (for instance, if it is
2856 /// \c constexpr in C++11 or has an 'auto' return type in C++14).
2857 bool canSkipFunctionBody(Decl *D);
2858
2859 void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope);
2860 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body);
2861 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body, bool IsInstantiation);
2862 Decl *ActOnSkippedFunctionBody(Decl *Decl);
2863 void ActOnFinishInlineFunctionDef(FunctionDecl *D);
2864
2865 /// ActOnFinishDelayedAttribute - Invoked when we have finished parsing an
2866 /// attribute for which parsing is delayed.
2867 void ActOnFinishDelayedAttribute(Scope *S, Decl *D, ParsedAttributes &Attrs);
2868
2869 /// Diagnose any unused parameters in the given sequence of
2870 /// ParmVarDecl pointers.
2871 void DiagnoseUnusedParameters(ArrayRef<ParmVarDecl *> Parameters);
2872
2873 /// Diagnose whether the size of parameters or return value of a
2874 /// function or obj-c method definition is pass-by-value and larger than a
2875 /// specified threshold.
2876 void
2877 DiagnoseSizeOfParametersAndReturnValue(ArrayRef<ParmVarDecl *> Parameters,
2878 QualType ReturnTy, NamedDecl *D);
2879
2880 void DiagnoseInvalidJumps(Stmt *Body);
2881 Decl *ActOnFileScopeAsmDecl(Expr *expr,
2882 SourceLocation AsmLoc,
2883 SourceLocation RParenLoc);
2884
2885 /// Handle a C++11 empty-declaration and attribute-declaration.
2886 Decl *ActOnEmptyDeclaration(Scope *S, const ParsedAttributesView &AttrList,
2887 SourceLocation SemiLoc);
2888
2889 enum class ModuleDeclKind {
2890 Interface, ///< 'export module X;'
2891 Implementation, ///< 'module X;'
2892 };
2893
2894 /// The parser has processed a module-declaration that begins the definition
2895 /// of a module interface or implementation.
2896 DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc,
2897 SourceLocation ModuleLoc, ModuleDeclKind MDK,
2898 ModuleIdPath Path, bool IsFirstDecl);
2899
2900 /// The parser has processed a global-module-fragment declaration that begins
2901 /// the definition of the global module fragment of the current module unit.
2902 /// \param ModuleLoc The location of the 'module' keyword.
2903 DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc);
2904
2905 /// The parser has processed a private-module-fragment declaration that begins
2906 /// the definition of the private module fragment of the current module unit.
2907 /// \param ModuleLoc The location of the 'module' keyword.
2908 /// \param PrivateLoc The location of the 'private' keyword.
2909 DeclGroupPtrTy ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,
2910 SourceLocation PrivateLoc);
2911
2912 /// The parser has processed a module import declaration.
2913 ///
2914 /// \param StartLoc The location of the first token in the declaration. This
2915 /// could be the location of an '@', 'export', or 'import'.
2916 /// \param ExportLoc The location of the 'export' keyword, if any.
2917 /// \param ImportLoc The location of the 'import' keyword.
2918 /// \param Path The module access path.
2919 DeclResult ActOnModuleImport(SourceLocation StartLoc,
2920 SourceLocation ExportLoc,
2921 SourceLocation ImportLoc, ModuleIdPath Path);
2922 DeclResult ActOnModuleImport(SourceLocation StartLoc,
2923 SourceLocation ExportLoc,
2924 SourceLocation ImportLoc, Module *M,
2925 ModuleIdPath Path = {});
2926
2927 /// The parser has processed a module import translated from a
2928 /// #include or similar preprocessing directive.
2929 void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2930 void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
2931
2932 /// The parsed has entered a submodule.
2933 void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod);
2934 /// The parser has left a submodule.
2935 void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod);
2936
2937 /// Create an implicit import of the given module at the given
2938 /// source location, for error recovery, if possible.
2939 ///
2940 /// This routine is typically used when an entity found by name lookup
2941 /// is actually hidden within a module that we know about but the user
2942 /// has forgotten to import.
2943 void createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
2944 Module *Mod);
2945
2946 /// Kinds of missing import. Note, the values of these enumerators correspond
2947 /// to %select values in diagnostics.
2948 enum class MissingImportKind {
2949 Declaration,
2950 Definition,
2951 DefaultArgument,
2952 ExplicitSpecialization,
2953 PartialSpecialization
2954 };
2955
2956 /// Diagnose that the specified declaration needs to be visible but
2957 /// isn't, and suggest a module import that would resolve the problem.
2958 void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2959 MissingImportKind MIK, bool Recover = true);
2960 void diagnoseMissingImport(SourceLocation Loc, NamedDecl *Decl,
2961 SourceLocation DeclLoc, ArrayRef<Module *> Modules,
2962 MissingImportKind MIK, bool Recover);
2963
2964 Decl *ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc,
2965 SourceLocation LBraceLoc);
2966 Decl *ActOnFinishExportDecl(Scope *S, Decl *ExportDecl,
2967 SourceLocation RBraceLoc);
2968
2969 /// We've found a use of a templated declaration that would trigger an
2970 /// implicit instantiation. Check that any relevant explicit specializations
2971 /// and partial specializations are visible, and diagnose if not.
2972 void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec);
2973
2974 /// Retrieve a suitable printing policy for diagnostics.
2975 PrintingPolicy getPrintingPolicy() const {
2976 return getPrintingPolicy(Context, PP);
2977 }
2978
2979 /// Retrieve a suitable printing policy for diagnostics.
2980 static PrintingPolicy getPrintingPolicy(const ASTContext &Ctx,
2981 const Preprocessor &PP);
2982
2983 /// Scope actions.
2984 void ActOnPopScope(SourceLocation Loc, Scope *S);
2985 void ActOnTranslationUnitScope(Scope *S);
2986
2987 Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
2988 RecordDecl *&AnonRecord);
2989 Decl *ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS, DeclSpec &DS,
2990 MultiTemplateParamsArg TemplateParams,
2991 bool IsExplicitInstantiation,
2992 RecordDecl *&AnonRecord);
2993
2994 Decl *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
2995 AccessSpecifier AS,
2996 RecordDecl *Record,
2997 const PrintingPolicy &Policy);
2998
2999 Decl *BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
3000 RecordDecl *Record);
3001
3002 /// Common ways to introduce type names without a tag for use in diagnostics.
3003 /// Keep in sync with err_tag_reference_non_tag.
3004 enum NonTagKind {
3005 NTK_NonStruct,
3006 NTK_NonClass,
3007 NTK_NonUnion,
3008 NTK_NonEnum,
3009 NTK_Typedef,
3010 NTK_TypeAlias,
3011 NTK_Template,
3012 NTK_TypeAliasTemplate,
3013 NTK_TemplateTemplateArgument,
3014 };
3015
3016 /// Given a non-tag type declaration, returns an enum useful for indicating
3017 /// what kind of non-tag type this is.
3018 NonTagKind getNonTagTypeDeclKind(const Decl *D, TagTypeKind TTK);
3019
3020 bool isAcceptableTagRedeclaration(const TagDecl *Previous,
3021 TagTypeKind NewTag, bool isDefinition,
3022 SourceLocation NewTagLoc,
3023 const IdentifierInfo *Name);
3024
3025 enum TagUseKind {
3026 TUK_Reference, // Reference to a tag: 'struct foo *X;'
3027 TUK_Declaration, // Fwd decl of a tag: 'struct foo;'
3028 TUK_Definition, // Definition of a tag: 'struct foo { int X; } Y;'
3029 TUK_Friend // Friend declaration: 'friend struct foo;'
3030 };
3031
3032 Decl *ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
3033 SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name,
3034 SourceLocation NameLoc, const ParsedAttributesView &Attr,
3035 AccessSpecifier AS, SourceLocation ModulePrivateLoc,
3036 MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl,
3037 bool &IsDependent, SourceLocation ScopedEnumKWLoc,
3038 bool ScopedEnumUsesClassTag, TypeResult UnderlyingType,
3039 bool IsTypeSpecifier, bool IsTemplateParamOrArg,
3040 SkipBodyInfo *SkipBody = nullptr);
3041
3042 Decl *ActOnTemplatedFriendTag(Scope *S, SourceLocation FriendLoc,
3043 unsigned TagSpec, SourceLocation TagLoc,
3044 CXXScopeSpec &SS, IdentifierInfo *Name,
3045 SourceLocation NameLoc,
3046 const ParsedAttributesView &Attr,
3047 MultiTemplateParamsArg TempParamLists);
3048
3049 TypeResult ActOnDependentTag(Scope *S,
3050 unsigned TagSpec,
3051 TagUseKind TUK,
3052 const CXXScopeSpec &SS,
3053 IdentifierInfo *Name,
3054 SourceLocation TagLoc,
3055 SourceLocation NameLoc);
3056
3057 void ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart,
3058 IdentifierInfo *ClassName,
3059 SmallVectorImpl<Decl *> &Decls);
3060 Decl *ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart,
3061 Declarator &D, Expr *BitfieldWidth);
3062
3063 FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,
3064 Declarator &D, Expr *BitfieldWidth,
3065 InClassInitStyle InitStyle,
3066 AccessSpecifier AS);
3067 MSPropertyDecl *HandleMSProperty(Scope *S, RecordDecl *TagD,
3068 SourceLocation DeclStart, Declarator &D,
3069 Expr *BitfieldWidth,
3070 InClassInitStyle InitStyle,
3071 AccessSpecifier AS,
3072 const ParsedAttr &MSPropertyAttr);
3073
3074 FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,
3075 TypeSourceInfo *TInfo,
3076 RecordDecl *Record, SourceLocation Loc,
3077 bool Mutable, Expr *BitfieldWidth,
3078 InClassInitStyle InitStyle,
3079 SourceLocation TSSL,
3080 AccessSpecifier AS, NamedDecl *PrevDecl,
3081 Declarator *D = nullptr);
3082
3083 bool CheckNontrivialField(FieldDecl *FD);
3084 void DiagnoseNontrivial(const CXXRecordDecl *Record, CXXSpecialMember CSM);
3085
3086 enum TrivialABIHandling {
3087 /// The triviality of a method unaffected by "trivial_abi".
3088 TAH_IgnoreTrivialABI,
3089
3090 /// The triviality of a method affected by "trivial_abi".
3091 TAH_ConsiderTrivialABI
3092 };
3093
3094 bool SpecialMemberIsTrivial(CXXMethodDecl *MD, CXXSpecialMember CSM,
3095 TrivialABIHandling TAH = TAH_IgnoreTrivialABI,
3096 bool Diagnose = false);
3097
3098 /// For a defaulted function, the kind of defaulted function that it is.
3099 class DefaultedFunctionKind {
3100 CXXSpecialMember SpecialMember : 8;
3101 DefaultedComparisonKind Comparison : 8;
3102
3103 public:
3104 DefaultedFunctionKind()
3105 : SpecialMember(CXXInvalid), Comparison(DefaultedComparisonKind::None) {
3106 }
3107 DefaultedFunctionKind(CXXSpecialMember CSM)
3108 : SpecialMember(CSM), Comparison(DefaultedComparisonKind::None) {}
3109 DefaultedFunctionKind(DefaultedComparisonKind Comp)
3110 : SpecialMember(CXXInvalid), Comparison(Comp) {}
3111
3112 bool isSpecialMember() const { return SpecialMember != CXXInvalid; }
3113 bool isComparison() const {
3114 return Comparison != DefaultedComparisonKind::None;
3115 }
3116
3117 explicit operator bool() const {
3118 return isSpecialMember() || isComparison();
3119 }
3120
3121 CXXSpecialMember asSpecialMember() const { return SpecialMember; }
3122 DefaultedComparisonKind asComparison() const { return Comparison; }
3123
3124 /// Get the index of this function kind for use in diagnostics.
3125 unsigned getDiagnosticIndex() const {
3126 static_assert(CXXInvalid > CXXDestructor,
3127 "invalid should have highest index");
3128 static_assert((unsigned)DefaultedComparisonKind::None == 0,
3129 "none should be equal to zero");
3130 return SpecialMember + (unsigned)Comparison;
3131 }
3132 };
3133
3134 DefaultedFunctionKind getDefaultedFunctionKind(const FunctionDecl *FD);
3135
3136 CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD) {
3137 return getDefaultedFunctionKind(MD).asSpecialMember();
3138 }
3139 DefaultedComparisonKind getDefaultedComparisonKind(const FunctionDecl *FD) {
3140 return getDefaultedFunctionKind(FD).asComparison();
3141 }
3142
3143 void ActOnLastBitfield(SourceLocation DeclStart,
3144 SmallVectorImpl<Decl *> &AllIvarDecls);
3145 Decl *ActOnIvar(Scope *S, SourceLocation DeclStart,
3146 Declarator &D, Expr *BitfieldWidth,
3147 tok::ObjCKeywordKind visibility);
3148
3149 // This is used for both record definitions and ObjC interface declarations.
3150 void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl,
3151 ArrayRef<Decl *> Fields, SourceLocation LBrac,
3152 SourceLocation RBrac, const ParsedAttributesView &AttrList);
3153
3154 /// ActOnTagStartDefinition - Invoked when we have entered the
3155 /// scope of a tag's definition (e.g., for an enumeration, class,
3156 /// struct, or union).
3157 void ActOnTagStartDefinition(Scope *S, Decl *TagDecl);
3158
3159 /// Perform ODR-like check for C/ObjC when merging tag types from modules.
3160 /// Differently from C++, actually parse the body and reject / error out
3161 /// in case of a structural mismatch.
3162 bool ActOnDuplicateDefinition(DeclSpec &DS, Decl *Prev,
3163 SkipBodyInfo &SkipBody);
3164
3165 typedef void *SkippedDefinitionContext;
3166
3167 /// Invoked when we enter a tag definition that we're skipping.
3168 SkippedDefinitionContext ActOnTagStartSkippedDefinition(Scope *S, Decl *TD);
3169
3170 Decl *ActOnObjCContainerStartDefinition(Decl *IDecl);
3171
3172 /// ActOnStartCXXMemberDeclarations - Invoked when we have parsed a
3173 /// C++ record definition's base-specifiers clause and are starting its
3174 /// member declarations.
3175 void ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagDecl,
3176 SourceLocation FinalLoc,
3177 bool IsFinalSpelledSealed,
3178 bool IsAbstract,
3179 SourceLocation LBraceLoc);
3180
3181 /// ActOnTagFinishDefinition - Invoked once we have finished parsing
3182 /// the definition of a tag (enumeration, class, struct, or union).
3183 void ActOnTagFinishDefinition(Scope *S, Decl *TagDecl,
3184 SourceRange BraceRange);
3185
3186 void ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context);
3187
3188 void ActOnObjCContainerFinishDefinition();
3189
3190 /// Invoked when we must temporarily exit the objective-c container
3191 /// scope for parsing/looking-up C constructs.
3192 ///
3193 /// Must be followed by a call to \see ActOnObjCReenterContainerContext
3194 void ActOnObjCTemporaryExitContainerContext(DeclContext *DC);
3195 void ActOnObjCReenterContainerContext(DeclContext *DC);
3196
3197 /// ActOnTagDefinitionError - Invoked when there was an unrecoverable
3198 /// error parsing the definition of a tag.
3199 void ActOnTagDefinitionError(Scope *S, Decl *TagDecl);
3200
3201 EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,
3202 EnumConstantDecl *LastEnumConst,
3203 SourceLocation IdLoc,
3204 IdentifierInfo *Id,
3205 Expr *val);
3206 bool CheckEnumUnderlyingType(TypeSourceInfo *TI);
3207 bool CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,
3208 QualType EnumUnderlyingTy, bool IsFixed,
3209 const EnumDecl *Prev);
3210
3211 /// Determine whether the body of an anonymous enumeration should be skipped.
3212 /// \param II The name of the first enumerator.
3213 SkipBodyInfo shouldSkipAnonEnumBody(Scope *S, IdentifierInfo *II,
3214 SourceLocation IILoc);
3215
3216 Decl *ActOnEnumConstant(Scope *S, Decl *EnumDecl, Decl *LastEnumConstant,
3217 SourceLocation IdLoc, IdentifierInfo *Id,
3218 const ParsedAttributesView &Attrs,
3219 SourceLocation EqualLoc, Expr *Val);
3220 void ActOnEnumBody(SourceLocation EnumLoc, SourceRange BraceRange,
3221 Decl *EnumDecl, ArrayRef<Decl *> Elements, Scope *S,
3222 const ParsedAttributesView &Attr);
3223
3224 /// Set the current declaration context until it gets popped.
3225 void PushDeclContext(Scope *S, DeclContext *DC);
3226 void PopDeclContext();
3227
3228 /// EnterDeclaratorContext - Used when we must lookup names in the context
3229 /// of a declarator's nested name specifier.
3230 void EnterDeclaratorContext(Scope *S, DeclContext *DC);
3231 void ExitDeclaratorContext(Scope *S);
3232
3233 /// Enter a template parameter scope, after it's been associated with a particular
3234 /// DeclContext. Causes lookup within the scope to chain through enclosing contexts
3235 /// in the correct order.
3236 void EnterTemplatedContext(Scope *S, DeclContext *DC);
3237
3238 /// Push the parameters of D, which must be a function, into scope.
3239 void ActOnReenterFunctionContext(Scope* S, Decl* D);
3240 void ActOnExitFunctionContext();
3241
3242 DeclContext *getFunctionLevelDeclContext();
3243
3244 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
3245 /// to the function decl for the function being parsed. If we're currently
3246 /// in a 'block', this returns the containing context.
3247 FunctionDecl *getCurFunctionDecl();
3248
3249 /// getCurMethodDecl - If inside of a method body, this returns a pointer to
3250 /// the method decl for the method being parsed. If we're currently
3251 /// in a 'block', this returns the containing context.
3252 ObjCMethodDecl *getCurMethodDecl();
3253
3254 /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
3255 /// or C function we're in, otherwise return null. If we're currently
3256 /// in a 'block', this returns the containing context.
3257 NamedDecl *getCurFunctionOrMethodDecl();
3258
3259 /// Add this decl to the scope shadowed decl chains.
3260 void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext = true);
3261
3262 /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
3263 /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
3264 /// true if 'D' belongs to the given declaration context.
3265 ///
3266 /// \param AllowInlineNamespace If \c true, allow the declaration to be in the
3267 /// enclosing namespace set of the context, rather than contained
3268 /// directly within it.
3269 bool isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S = nullptr,
3270 bool AllowInlineNamespace = false);
3271
3272 /// Finds the scope corresponding to the given decl context, if it
3273 /// happens to be an enclosing scope. Otherwise return NULL.
3274 static Scope *getScopeForDeclContext(Scope *S, DeclContext *DC);
3275
3276 /// Subroutines of ActOnDeclarator().
3277 TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
3278 TypeSourceInfo *TInfo);
3279 bool isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New);
3280
3281 /// Describes the kind of merge to perform for availability
3282 /// attributes (including "deprecated", "unavailable", and "availability").
3283 enum AvailabilityMergeKind {
3284 /// Don't merge availability attributes at all.
3285 AMK_None,
3286 /// Merge availability attributes for a redeclaration, which requires
3287 /// an exact match.
3288 AMK_Redeclaration,
3289 /// Merge availability attributes for an override, which requires
3290 /// an exact match or a weakening of constraints.
3291 AMK_Override,
3292 /// Merge availability attributes for an implementation of
3293 /// a protocol requirement.
3294 AMK_ProtocolImplementation,
3295 /// Merge availability attributes for an implementation of
3296 /// an optional protocol requirement.
3297 AMK_OptionalProtocolImplementation
3298 };
3299
3300 /// Describes the kind of priority given to an availability attribute.
3301 ///
3302 /// The sum of priorities deteremines the final priority of the attribute.
3303 /// The final priority determines how the attribute will be merged.
3304 /// An attribute with a lower priority will always remove higher priority
3305 /// attributes for the specified platform when it is being applied. An
3306 /// attribute with a higher priority will not be applied if the declaration
3307 /// already has an availability attribute with a lower priority for the
3308 /// specified platform. The final prirority values are not expected to match
3309 /// the values in this enumeration, but instead should be treated as a plain
3310 /// integer value. This enumeration just names the priority weights that are
3311 /// used to calculate that final vaue.
3312 enum AvailabilityPriority : int {
3313 /// The availability attribute was specified explicitly next to the
3314 /// declaration.
3315 AP_Explicit = 0,
3316
3317 /// The availability attribute was applied using '#pragma clang attribute'.
3318 AP_PragmaClangAttribute = 1,
3319
3320 /// The availability attribute for a specific platform was inferred from
3321 /// an availability attribute for another platform.
3322 AP_InferredFromOtherPlatform = 2
3323 };
3324
3325 /// Attribute merging methods. Return true if a new attribute was added.
3326 AvailabilityAttr *
3327 mergeAvailabilityAttr(NamedDecl *D, const AttributeCommonInfo &CI,
3328 IdentifierInfo *Platform, bool Implicit,
3329 VersionTuple Introduced, VersionTuple Deprecated,
3330 VersionTuple Obsoleted, bool IsUnavailable,
3331 StringRef Message, bool IsStrict, StringRef Replacement,
3332 AvailabilityMergeKind AMK, int Priority);
3333 TypeVisibilityAttr *
3334 mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI,
3335 TypeVisibilityAttr::VisibilityType Vis);
3336 VisibilityAttr *mergeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI,
3337 VisibilityAttr::VisibilityType Vis);
3338 UuidAttr *mergeUuidAttr(Decl *D, const AttributeCommonInfo &CI,
3339 StringRef UuidAsWritten, MSGuidDecl *GuidDecl);
3340 DLLImportAttr *mergeDLLImportAttr(Decl *D, const AttributeCommonInfo &CI);
3341 DLLExportAttr *mergeDLLExportAttr(Decl *D, const AttributeCommonInfo &CI);
3342 MSInheritanceAttr *mergeMSInheritanceAttr(Decl *D,
3343 const AttributeCommonInfo &CI,
3344 bool BestCase,
3345 MSInheritanceModel Model);
3346 FormatAttr *mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI,
3347 IdentifierInfo *Format, int FormatIdx,
3348 int FirstArg);
3349 SectionAttr *mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI,
3350 StringRef Name);
3351 CodeSegAttr *mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI,
3352 StringRef Name);
3353 AlwaysInlineAttr *mergeAlwaysInlineAttr(Decl *D,
3354 const AttributeCommonInfo &CI,
3355 const IdentifierInfo *Ident);
3356 MinSizeAttr *mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI);
3357 SwiftNameAttr *mergeSwiftNameAttr(Decl *D, const SwiftNameAttr &SNA,
3358 StringRef Name);
3359 OptimizeNoneAttr *mergeOptimizeNoneAttr(Decl *D,
3360 const AttributeCommonInfo &CI);
3361 InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D, const ParsedAttr &AL);
3362 InternalLinkageAttr *mergeInternalLinkageAttr(Decl *D,
3363 const InternalLinkageAttr &AL);
3364 WebAssemblyImportNameAttr *mergeImportNameAttr(
3365 Decl *D, const WebAssemblyImportNameAttr &AL);
3366 WebAssemblyImportModuleAttr *mergeImportModuleAttr(
3367 Decl *D, const WebAssemblyImportModuleAttr &AL);
3368 EnforceTCBAttr *mergeEnforceTCBAttr(Decl *D, const EnforceTCBAttr &AL);
3369 EnforceTCBLeafAttr *mergeEnforceTCBLeafAttr(Decl *D,
3370 const EnforceTCBLeafAttr &AL);
3371
3372 void mergeDeclAttributes(NamedDecl *New, Decl *Old,
3373 AvailabilityMergeKind AMK = AMK_Redeclaration);
3374 void MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New,
3375 LookupResult &OldDecls);
3376 bool MergeFunctionDecl(FunctionDecl *New, NamedDecl *&Old, Scope *S,
3377 bool MergeTypeWithOld);
3378 bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,
3379 Scope *S, bool MergeTypeWithOld);
3380 void mergeObjCMethodDecls(ObjCMethodDecl *New, ObjCMethodDecl *Old);
3381 void MergeVarDecl(VarDecl *New, LookupResult &Previous);
3382 void MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool MergeTypeWithOld);
3383 void MergeVarDeclExceptionSpecs(VarDecl *New, VarDecl *Old);
3384 bool checkVarDeclRedefinition(VarDecl *OldDefn, VarDecl *NewDefn);
3385 void notePreviousDefinition(const NamedDecl *Old, SourceLocation New);
3386 bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old, Scope *S);
3387
3388 // AssignmentAction - This is used by all the assignment diagnostic functions
3389 // to represent what is actually causing the operation
3390 enum AssignmentAction {
3391 AA_Assigning,
3392 AA_Passing,
3393 AA_Returning,
3394 AA_Converting,
3395 AA_Initializing,
3396 AA_Sending,
3397 AA_Casting,
3398 AA_Passing_CFAudited
3399 };
3400
3401 /// C++ Overloading.
3402 enum OverloadKind {
3403 /// This is a legitimate overload: the existing declarations are
3404 /// functions or function templates with different signatures.
3405 Ovl_Overload,
3406
3407 /// This is not an overload because the signature exactly matches
3408 /// an existing declaration.
3409 Ovl_Match,
3410
3411 /// This is not an overload because the lookup results contain a
3412 /// non-function.
3413 Ovl_NonFunction
3414 };
3415 OverloadKind CheckOverload(Scope *S,
3416 FunctionDecl *New,
3417 const LookupResult &OldDecls,
3418 NamedDecl *&OldDecl,
3419 bool IsForUsingDecl);
3420 bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl,
3421 bool ConsiderCudaAttrs = true,
3422 bool ConsiderRequiresClauses = true);
3423
3424 enum class AllowedExplicit {
3425 /// Allow no explicit functions to be used.
3426 None,
3427 /// Allow explicit conversion functions but not explicit constructors.
3428 Conversions,
3429 /// Allow both explicit conversion functions and explicit constructors.
3430 All
3431 };
3432
3433 ImplicitConversionSequence
3434 TryImplicitConversion(Expr *From, QualType ToType,
3435 bool SuppressUserConversions,
3436 AllowedExplicit AllowExplicit,
3437 bool InOverloadResolution,
3438 bool CStyle,
3439 bool AllowObjCWritebackConversion);
3440
3441 bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
3442 bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
3443 bool IsComplexPromotion(QualType FromType, QualType ToType);
3444 bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
3445 bool InOverloadResolution,
3446 QualType& ConvertedType, bool &IncompatibleObjC);
3447 bool isObjCPointerConversion(QualType FromType, QualType ToType,
3448 QualType& ConvertedType, bool &IncompatibleObjC);
3449 bool isObjCWritebackConversion(QualType FromType, QualType ToType,
3450 QualType &ConvertedType);
3451 bool IsBlockPointerConversion(QualType FromType, QualType ToType,
3452 QualType& ConvertedType);
3453 bool FunctionParamTypesAreEqual(const FunctionProtoType *OldType,
3454 const FunctionProtoType *NewType,
3455 unsigned *ArgPos = nullptr);
3456 void HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,
3457 QualType FromType, QualType ToType);
3458
3459 void maybeExtendBlockObject(ExprResult &E);
3460 CastKind PrepareCastToObjCObjectPointer(ExprResult &E);
3461 bool CheckPointerConversion(Expr *From, QualType ToType,
3462 CastKind &Kind,
3463 CXXCastPath& BasePath,
3464 bool IgnoreBaseAccess,
3465 bool Diagnose = true);
3466 bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
3467 bool InOverloadResolution,
3468 QualType &ConvertedType);
3469 bool CheckMemberPointerConversion(Expr *From, QualType ToType,
3470 CastKind &Kind,
3471 CXXCastPath &BasePath,
3472 bool IgnoreBaseAccess);
3473 bool IsQualificationConversion(QualType FromType, QualType ToType,
3474 bool CStyle, bool &ObjCLifetimeConversion);
3475 bool IsFunctionConversion(QualType FromType, QualType ToType,
3476 QualType &ResultTy);
3477 bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);
3478 bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg);
3479
3480 bool CanPerformAggregateInitializationForOverloadResolution(
3481 const InitializedEntity &Entity, InitListExpr *From);
3482
3483 bool IsStringInit(Expr *Init, const ArrayType *AT);
3484
3485 bool CanPerformCopyInitialization(const InitializedEntity &Entity,
3486 ExprResult Init);
3487 ExprResult PerformCopyInitialization(const InitializedEntity &Entity,
3488 SourceLocation EqualLoc,
3489 ExprResult Init,
3490 bool TopLevelOfInitList = false,
3491 bool AllowExplicit = false);
3492 ExprResult PerformObjectArgumentInitialization(Expr *From,
3493 NestedNameSpecifier *Qualifier,
3494 NamedDecl *FoundDecl,
3495 CXXMethodDecl *Method);
3496
3497 /// Check that the lifetime of the initializer (and its subobjects) is
3498 /// sufficient for initializing the entity, and perform lifetime extension
3499 /// (when permitted) if not.
3500 void checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init);
3501
3502 ExprResult PerformContextuallyConvertToBool(Expr *From);
3503 ExprResult PerformContextuallyConvertToObjCPointer(Expr *From);
3504
3505 /// Contexts in which a converted constant expression is required.
3506 enum CCEKind {
3507 CCEK_CaseValue, ///< Expression in a case label.
3508 CCEK_Enumerator, ///< Enumerator value with fixed underlying type.
3509 CCEK_TemplateArg, ///< Value of a non-type template parameter.
3510 CCEK_ArrayBound, ///< Array bound in array declarator or new-expression.
3511 CCEK_ExplicitBool ///< Condition in an explicit(bool) specifier.
3512 };
3513 ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
3514 llvm::APSInt &Value, CCEKind CCE);
3515 ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
3516 APValue &Value, CCEKind CCE,
3517 NamedDecl *Dest = nullptr);
3518
3519 /// Abstract base class used to perform a contextual implicit
3520 /// conversion from an expression to any type passing a filter.
3521 class ContextualImplicitConverter {
3522 public:
3523 bool Suppress;
3524 bool SuppressConversion;
3525
3526 ContextualImplicitConverter(bool Suppress = false,
3527 bool SuppressConversion = false)
3528 : Suppress(Suppress), SuppressConversion(SuppressConversion) {}
3529
3530 /// Determine whether the specified type is a valid destination type
3531 /// for this conversion.
3532 virtual bool match(QualType T) = 0;
3533
3534 /// Emits a diagnostic complaining that the expression does not have
3535 /// integral or enumeration type.
3536 virtual SemaDiagnosticBuilder
3537 diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) = 0;
3538
3539 /// Emits a diagnostic when the expression has incomplete class type.
3540 virtual SemaDiagnosticBuilder
3541 diagnoseIncomplete(Sema &S, SourceLocation Loc, QualType T) = 0;
3542
3543 /// Emits a diagnostic when the only matching conversion function
3544 /// is explicit.
3545 virtual SemaDiagnosticBuilder diagnoseExplicitConv(
3546 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;
3547
3548 /// Emits a note for the explicit conversion function.
3549 virtual SemaDiagnosticBuilder
3550 noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;
3551
3552 /// Emits a diagnostic when there are multiple possible conversion
3553 /// functions.
3554 virtual SemaDiagnosticBuilder
3555 diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T) = 0;
3556
3557 /// Emits a note for one of the candidate conversions.
3558 virtual SemaDiagnosticBuilder
3559 noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) = 0;
3560
3561 /// Emits a diagnostic when we picked a conversion function
3562 /// (for cases when we are not allowed to pick a conversion function).
3563 virtual SemaDiagnosticBuilder diagnoseConversion(
3564 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) = 0;
3565
3566 virtual ~ContextualImplicitConverter() {}
3567 };
3568
3569 class ICEConvertDiagnoser : public ContextualImplicitConverter {
3570 bool AllowScopedEnumerations;
3571
3572 public:
3573 ICEConvertDiagnoser(bool AllowScopedEnumerations,
3574 bool Suppress, bool SuppressConversion)
3575 : ContextualImplicitConverter(Suppress, SuppressConversion),
3576 AllowScopedEnumerations(AllowScopedEnumerations) {}
3577
3578 /// Match an integral or (possibly scoped) enumeration type.
3579 bool match(QualType T) override;
3580
3581 SemaDiagnosticBuilder
3582 diagnoseNoMatch(Sema &S, SourceLocation Loc, QualType T) override {
3583 return diagnoseNotInt(S, Loc, T);
3584 }
3585
3586 /// Emits a diagnostic complaining that the expression does not have
3587 /// integral or enumeration type.
3588 virtual SemaDiagnosticBuilder
3589 diagnoseNotInt(Sema &S, SourceLocation Loc, QualType T) = 0;
3590 };
3591
3592 /// Perform a contextual implicit conversion.
3593 ExprResult PerformContextualImplicitConversion(
3594 SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter);
3595
3596
3597 enum ObjCSubscriptKind {
3598 OS_Array,
3599 OS_Dictionary,
3600 OS_Error
3601 };
3602 ObjCSubscriptKind CheckSubscriptingKind(Expr *FromE);
3603
3604 // Note that LK_String is intentionally after the other literals, as
3605 // this is used for diagnostics logic.
3606 enum ObjCLiteralKind {
3607 LK_Array,
3608 LK_Dictionary,
3609 LK_Numeric,
3610 LK_Boxed,
3611 LK_String,
3612 LK_Block,
3613 LK_None
3614 };
3615 ObjCLiteralKind CheckLiteralKind(Expr *FromE);
3616
3617 ExprResult PerformObjectMemberConversion(Expr *From,
3618 NestedNameSpecifier *Qualifier,
3619 NamedDecl *FoundDecl,
3620 NamedDecl *Member);
3621
3622 // Members have to be NamespaceDecl* or TranslationUnitDecl*.
3623 // TODO: make this is a typesafe union.
3624 typedef llvm::SmallSetVector<DeclContext *, 16> AssociatedNamespaceSet;
3625 typedef llvm::SmallSetVector<CXXRecordDecl *, 16> AssociatedClassSet;
3626
3627 using ADLCallKind = CallExpr::ADLCallKind;
3628
3629 void AddOverloadCandidate(FunctionDecl *Function, DeclAccessPair FoundDecl,
3630 ArrayRef<Expr *> Args,
3631 OverloadCandidateSet &CandidateSet,
3632 bool SuppressUserConversions = false,
3633 bool PartialOverloading = false,
3634 bool AllowExplicit = true,
3635 bool AllowExplicitConversion = false,
3636 ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
3637 ConversionSequenceList EarlyConversions = None,
3638 OverloadCandidateParamOrder PO = {});
3639 void AddFunctionCandidates(const UnresolvedSetImpl &Functions,
3640 ArrayRef<Expr *> Args,
3641 OverloadCandidateSet &CandidateSet,
3642 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,
3643 bool SuppressUserConversions = false,
3644 bool PartialOverloading = false,
3645 bool FirstArgumentIsBase = false);
3646 void AddMethodCandidate(DeclAccessPair FoundDecl,
3647 QualType ObjectType,
3648 Expr::Classification ObjectClassification,
3649 ArrayRef<Expr *> Args,
3650 OverloadCandidateSet& CandidateSet,
3651 bool SuppressUserConversion = false,
3652 OverloadCandidateParamOrder PO = {});
3653 void AddMethodCandidate(CXXMethodDecl *Method,
3654 DeclAccessPair FoundDecl,
3655 CXXRecordDecl *ActingContext, QualType ObjectType,
3656 Expr::Classification ObjectClassification,
3657 ArrayRef<Expr *> Args,
3658 OverloadCandidateSet& CandidateSet,
3659 bool SuppressUserConversions = false,
3660 bool PartialOverloading = false,
3661 ConversionSequenceList EarlyConversions = None,
3662 OverloadCandidateParamOrder PO = {});
3663 void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
3664 DeclAccessPair FoundDecl,
3665 CXXRecordDecl *ActingContext,
3666 TemplateArgumentListInfo *ExplicitTemplateArgs,
3667 QualType ObjectType,
3668 Expr::Classification ObjectClassification,
3669 ArrayRef<Expr *> Args,
3670 OverloadCandidateSet& CandidateSet,
3671 bool SuppressUserConversions = false,
3672 bool PartialOverloading = false,
3673 OverloadCandidateParamOrder PO = {});
3674 void AddTemplateOverloadCandidate(
3675 FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
3676 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
3677 OverloadCandidateSet &CandidateSet, bool SuppressUserConversions = false,
3678 bool PartialOverloading = false, bool AllowExplicit = true,
3679 ADLCallKind IsADLCandidate = ADLCallKind::NotADL,
3680 OverloadCandidateParamOrder PO = {});
3681 bool CheckNonDependentConversions(
3682 FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,
3683 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
3684 ConversionSequenceList &Conversions, bool SuppressUserConversions,
3685 CXXRecordDecl *ActingContext = nullptr, QualType ObjectType = QualType(),
3686 Expr::Classification ObjectClassification = {},
3687 OverloadCandidateParamOrder PO = {});
3688 void AddConversionCandidate(
3689 CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
3690 CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
3691 OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
3692 bool AllowExplicit, bool AllowResultConversion = true);
3693 void AddTemplateConversionCandidate(
3694 FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
3695 CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
3696 OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
3697 bool AllowExplicit, bool AllowResultConversion = true);
3698 void AddSurrogateCandidate(CXXConversionDecl *Conversion,
3699 DeclAccessPair FoundDecl,
3700 CXXRecordDecl *ActingContext,
3701 const FunctionProtoType *Proto,
3702 Expr *Object, ArrayRef<Expr *> Args,
3703 OverloadCandidateSet& CandidateSet);
3704 void AddNonMemberOperatorCandidates(
3705 const UnresolvedSetImpl &Functions, ArrayRef<Expr *> Args,
3706 OverloadCandidateSet &CandidateSet,
3707 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr);
3708 void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
3709 SourceLocation OpLoc, ArrayRef<Expr *> Args,
3710 OverloadCandidateSet &CandidateSet,
3711 OverloadCandidateParamOrder PO = {});
3712 void AddBuiltinCandidate(QualType *ParamTys, ArrayRef<Expr *> Args,
3713 OverloadCandidateSet& CandidateSet,
3714 bool IsAssignmentOperator = false,
3715 unsigned NumContextualBoolArguments = 0);
3716 void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
3717 SourceLocation OpLoc, ArrayRef<Expr *> Args,
3718 OverloadCandidateSet& CandidateSet);
3719 void AddArgumentDependentLookupCandidates(DeclarationName Name,
3720 SourceLocation Loc,
3721 ArrayRef<Expr *> Args,
3722 TemplateArgumentListInfo *ExplicitTemplateArgs,
3723 OverloadCandidateSet& CandidateSet,
3724 bool PartialOverloading = false);
3725
3726 // Emit as a 'note' the specific overload candidate
3727 void NoteOverloadCandidate(
3728 NamedDecl *Found, FunctionDecl *Fn,
3729 OverloadCandidateRewriteKind RewriteKind = OverloadCandidateRewriteKind(),
3730 QualType DestType = QualType(), bool TakingAddress = false);
3731
3732 // Emit as a series of 'note's all template and non-templates identified by
3733 // the expression Expr
3734 void NoteAllOverloadCandidates(Expr *E, QualType DestType = QualType(),
3735 bool TakingAddress = false);
3736
3737 /// Check the enable_if expressions on the given function. Returns the first
3738 /// failing attribute, or NULL if they were all successful.
3739 EnableIfAttr *CheckEnableIf(FunctionDecl *Function, SourceLocation CallLoc,
3740 ArrayRef<Expr *> Args,
3741 bool MissingImplicitThis = false);
3742
3743 /// Find the failed Boolean condition within a given Boolean
3744 /// constant expression, and describe it with a string.
3745 std::pair<Expr *, std::string> findFailedBooleanCondition(Expr *Cond);
3746
3747 /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any
3748 /// non-ArgDependent DiagnoseIfAttrs.
3749 ///
3750 /// Argument-dependent diagnose_if attributes should be checked each time a
3751 /// function is used as a direct callee of a function call.
3752 ///
3753 /// Returns true if any errors were emitted.
3754 bool diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function,
3755 const Expr *ThisArg,
3756 ArrayRef<const Expr *> Args,
3757 SourceLocation Loc);
3758
3759 /// Emit diagnostics for the diagnose_if attributes on Function, ignoring any
3760 /// ArgDependent DiagnoseIfAttrs.
3761 ///
3762 /// Argument-independent diagnose_if attributes should be checked on every use
3763 /// of a function.
3764 ///
3765 /// Returns true if any errors were emitted.
3766 bool diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND,
3767 SourceLocation Loc);
3768
3769 /// Returns whether the given function's address can be taken or not,
3770 /// optionally emitting a diagnostic if the address can't be taken.
3771 ///
3772 /// Returns false if taking the address of the function is illegal.
3773 bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function,
3774 bool Complain = false,
3775 SourceLocation Loc = SourceLocation());
3776
3777 // [PossiblyAFunctionType] --> [Return]
3778 // NonFunctionType --> NonFunctionType
3779 // R (A) --> R(A)
3780 // R (*)(A) --> R (A)
3781 // R (&)(A) --> R (A)
3782 // R (S::*)(A) --> R (A)
3783 QualType ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType);
3784
3785 FunctionDecl *
3786 ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
3787 QualType TargetType,
3788 bool Complain,
3789 DeclAccessPair &Found,
3790 bool *pHadMultipleCandidates = nullptr);
3791
3792 FunctionDecl *
3793 resolveAddressOfSingleOverloadCandidate(Expr *E, DeclAccessPair &FoundResult);
3794
3795 bool resolveAndFixAddressOfSingleOverloadCandidate(
3796 ExprResult &SrcExpr, bool DoFunctionPointerConversion = false);
3797
3798 FunctionDecl *
3799 ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
3800 bool Complain = false,
3801 DeclAccessPair *Found = nullptr);
3802
3803 bool ResolveAndFixSingleFunctionTemplateSpecialization(
3804 ExprResult &SrcExpr,
3805 bool DoFunctionPointerConverion = false,
3806 bool Complain = false,
3807 SourceRange OpRangeForComplaining = SourceRange(),
3808 QualType DestTypeForComplaining = QualType(),
3809 unsigned DiagIDForComplaining = 0);
3810
3811
3812 Expr *FixOverloadedFunctionReference(Expr *E,
3813 DeclAccessPair FoundDecl,
3814 FunctionDecl *Fn);
3815 ExprResult FixOverloadedFunctionReference(ExprResult,
3816 DeclAccessPair FoundDecl,
3817 FunctionDecl *Fn);
3818
3819 void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
3820 ArrayRef<Expr *> Args,
3821 OverloadCandidateSet &CandidateSet,
3822 bool PartialOverloading = false);
3823 void AddOverloadedCallCandidates(
3824 LookupResult &R, TemplateArgumentListInfo *ExplicitTemplateArgs,
3825 ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet);
3826
3827 // An enum used to represent the different possible results of building a
3828 // range-based for loop.
3829 enum ForRangeStatus {
3830 FRS_Success,
3831 FRS_NoViableFunction,
3832 FRS_DiagnosticIssued
3833 };
3834
3835 ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc,
3836 SourceLocation RangeLoc,
3837 const DeclarationNameInfo &NameInfo,
3838 LookupResult &MemberLookup,
3839 OverloadCandidateSet *CandidateSet,
3840 Expr *Range, ExprResult *CallExpr);
3841
3842 ExprResult BuildOverloadedCallExpr(Scope *S, Expr *Fn,
3843 UnresolvedLookupExpr *ULE,
3844 SourceLocation LParenLoc,
3845 MultiExprArg Args,
3846 SourceLocation RParenLoc,
3847 Expr *ExecConfig,
3848 bool AllowTypoCorrection=true,
3849 bool CalleesAddressIsTaken=false);
3850
3851 bool buildOverloadedCallSet(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE,
3852 MultiExprArg Args, SourceLocation RParenLoc,
3853 OverloadCandidateSet *CandidateSet,
3854 ExprResult *Result);
3855
3856 ExprResult CreateUnresolvedLookupExpr(CXXRecordDecl *NamingClass,
3857 NestedNameSpecifierLoc NNSLoc,
3858 DeclarationNameInfo DNI,
3859 const UnresolvedSetImpl &Fns,
3860 bool PerformADL = true);
3861
3862 ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
3863 UnaryOperatorKind Opc,
3864 const UnresolvedSetImpl &Fns,
3865 Expr *input, bool RequiresADL = true);
3866
3867 void LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet,
3868 OverloadedOperatorKind Op,
3869 const UnresolvedSetImpl &Fns,
3870 ArrayRef<Expr *> Args, bool RequiresADL = true);
3871 ExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
3872 BinaryOperatorKind Opc,
3873 const UnresolvedSetImpl &Fns,
3874 Expr *LHS, Expr *RHS,
3875 bool RequiresADL = true,
3876 bool AllowRewrittenCandidates = true,
3877 FunctionDecl *DefaultedFn = nullptr);
3878 ExprResult BuildSynthesizedThreeWayComparison(SourceLocation OpLoc,
3879 const UnresolvedSetImpl &Fns,
3880 Expr *LHS, Expr *RHS,
3881 FunctionDecl *DefaultedFn);
3882
3883 ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
3884 SourceLocation RLoc,
3885 Expr *Base,Expr *Idx);
3886
3887 ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
3888 SourceLocation LParenLoc,
3889 MultiExprArg Args,
3890 SourceLocation RParenLoc,
3891 bool AllowRecovery = false);
3892 ExprResult
3893 BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
3894 MultiExprArg Args,
3895 SourceLocation RParenLoc);
3896
3897 ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base,
3898 SourceLocation OpLoc,
3899 bool *NoArrowOperatorFound = nullptr);
3900
3901 /// CheckCallReturnType - Checks that a call expression's return type is
3902 /// complete. Returns true on failure. The location passed in is the location
3903 /// that best represents the call.
3904 bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
3905 CallExpr *CE, FunctionDecl *FD);
3906
3907 /// Helpers for dealing with blocks and functions.
3908 bool CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters,
3909 bool CheckParameterNames);
3910 void CheckCXXDefaultArguments(FunctionDecl *FD);
3911 void CheckExtraCXXDefaultArguments(Declarator &D);
3912 Scope *getNonFieldDeclScope(Scope *S);
3913
3914 /// \name Name lookup
3915 ///
3916 /// These routines provide name lookup that is used during semantic
3917 /// analysis to resolve the various kinds of names (identifiers,
3918 /// overloaded operator names, constructor names, etc.) into zero or
3919 /// more declarations within a particular scope. The major entry
3920 /// points are LookupName, which performs unqualified name lookup,
3921 /// and LookupQualifiedName, which performs qualified name lookup.
3922 ///
3923 /// All name lookup is performed based on some specific criteria,
3924 /// which specify what names will be visible to name lookup and how
3925 /// far name lookup should work. These criteria are important both
3926 /// for capturing language semantics (certain lookups will ignore
3927 /// certain names, for example) and for performance, since name
3928 /// lookup is often a bottleneck in the compilation of C++. Name
3929 /// lookup criteria is specified via the LookupCriteria enumeration.
3930 ///
3931 /// The results of name lookup can vary based on the kind of name
3932 /// lookup performed, the current language, and the translation
3933 /// unit. In C, for example, name lookup will either return nothing
3934 /// (no entity found) or a single declaration. In C++, name lookup
3935 /// can additionally refer to a set of overloaded functions or
3936 /// result in an ambiguity. All of the possible results of name
3937 /// lookup are captured by the LookupResult class, which provides
3938 /// the ability to distinguish among them.
3939 //@{
3940
3941 /// Describes the kind of name lookup to perform.
3942 enum LookupNameKind {
3943 /// Ordinary name lookup, which finds ordinary names (functions,
3944 /// variables, typedefs, etc.) in C and most kinds of names
3945 /// (functions, variables, members, types, etc.) in C++.
3946 LookupOrdinaryName = 0,
3947 /// Tag name lookup, which finds the names of enums, classes,
3948 /// structs, and unions.
3949 LookupTagName,
3950 /// Label name lookup.
3951 LookupLabel,
3952 /// Member name lookup, which finds the names of
3953 /// class/struct/union members.
3954 LookupMemberName,
3955 /// Look up of an operator name (e.g., operator+) for use with
3956 /// operator overloading. This lookup is similar to ordinary name
3957 /// lookup, but will ignore any declarations that are class members.
3958 LookupOperatorName,
3959 /// Look up a name following ~ in a destructor name. This is an ordinary
3960 /// lookup, but prefers tags to typedefs.
3961 LookupDestructorName,
3962 /// Look up of a name that precedes the '::' scope resolution
3963 /// operator in C++. This lookup completely ignores operator, object,
3964 /// function, and enumerator names (C++ [basic.lookup.qual]p1).
3965 LookupNestedNameSpecifierName,
3966 /// Look up a namespace name within a C++ using directive or
3967 /// namespace alias definition, ignoring non-namespace names (C++
3968 /// [basic.lookup.udir]p1).
3969 LookupNamespaceName,
3970 /// Look up all declarations in a scope with the given name,
3971 /// including resolved using declarations. This is appropriate
3972 /// for checking redeclarations for a using declaration.
3973 LookupUsingDeclName,
3974 /// Look up an ordinary name that is going to be redeclared as a
3975 /// name with linkage. This lookup ignores any declarations that
3976 /// are outside of the current scope unless they have linkage. See
3977 /// C99 6.2.2p4-5 and C++ [basic.link]p6.
3978 LookupRedeclarationWithLinkage,
3979 /// Look up a friend of a local class. This lookup does not look
3980 /// outside the innermost non-class scope. See C++11 [class.friend]p11.
3981 LookupLocalFriendName,
3982 /// Look up the name of an Objective-C protocol.
3983 LookupObjCProtocolName,
3984 /// Look up implicit 'self' parameter of an objective-c method.
3985 LookupObjCImplicitSelfParam,
3986 /// Look up the name of an OpenMP user-defined reduction operation.
3987 LookupOMPReductionName,
3988 /// Look up the name of an OpenMP user-defined mapper.
3989 LookupOMPMapperName,
3990 /// Look up any declaration with any name.
3991 LookupAnyName
3992 };
3993
3994 /// Specifies whether (or how) name lookup is being performed for a
3995 /// redeclaration (vs. a reference).
3996 enum RedeclarationKind {
3997 /// The lookup is a reference to this name that is not for the
3998 /// purpose of redeclaring the name.
3999 NotForRedeclaration = 0,
4000 /// The lookup results will be used for redeclaration of a name,
4001 /// if an entity by that name already exists and is visible.
4002 ForVisibleRedeclaration,
4003 /// The lookup results will be used for redeclaration of a name
4004 /// with external linkage; non-visible lookup results with external linkage
4005 /// may also be found.
4006 ForExternalRedeclaration
4007 };
4008
4009 RedeclarationKind forRedeclarationInCurContext() {
4010 // A declaration with an owning module for linkage can never link against
4011 // anything that is not visible. We don't need to check linkage here; if
4012 // the context has internal linkage, redeclaration lookup won't find things
4013 // from other TUs, and we can't safely compute linkage yet in general.
4014 if (cast<Decl>(CurContext)
4015 ->getOwningModuleForLinkage(/*IgnoreLinkage*/true))
4016 return ForVisibleRedeclaration;
4017 return ForExternalRedeclaration;
4018 }
4019
4020 /// The possible outcomes of name lookup for a literal operator.
4021 enum LiteralOperatorLookupResult {
4022 /// The lookup resulted in an error.
4023 LOLR_Error,
4024 /// The lookup found no match but no diagnostic was issued.
4025 LOLR_ErrorNoDiagnostic,
4026 /// The lookup found a single 'cooked' literal operator, which
4027 /// expects a normal literal to be built and passed to it.
4028 LOLR_Cooked,
4029 /// The lookup found a single 'raw' literal operator, which expects
4030 /// a string literal containing the spelling of the literal token.
4031 LOLR_Raw,
4032 /// The lookup found an overload set of literal operator templates,
4033 /// which expect the characters of the spelling of the literal token to be
4034 /// passed as a non-type template argument pack.
4035 LOLR_Template,
4036 /// The lookup found an overload set of literal operator templates,
4037 /// which expect the character type and characters of the spelling of the
4038 /// string literal token to be passed as template arguments.
4039 LOLR_StringTemplatePack,
4040 };
4041
4042 SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D,
4043 CXXSpecialMember SM,
4044 bool ConstArg,
4045 bool VolatileArg,
4046 bool RValueThis,
4047 bool ConstThis,
4048 bool VolatileThis);
4049
4050 typedef std::function<void(const TypoCorrection &)> TypoDiagnosticGenerator;
4051 typedef std::function<ExprResult(Sema &, TypoExpr *, TypoCorrection)>
4052 TypoRecoveryCallback;
4053
4054private:
4055 bool CppLookupName(LookupResult &R, Scope *S);
4056
4057 struct TypoExprState {
4058 std::unique_ptr<TypoCorrectionConsumer> Consumer;
4059 TypoDiagnosticGenerator DiagHandler;
4060 TypoRecoveryCallback RecoveryHandler;
4061 TypoExprState();
4062 TypoExprState(TypoExprState &&other) noexcept;
4063 TypoExprState &operator=(TypoExprState &&other) noexcept;
4064 };
4065
4066 /// The set of unhandled TypoExprs and their associated state.
4067 llvm::MapVector<TypoExpr *, TypoExprState> DelayedTypos;
4068
4069 /// Creates a new TypoExpr AST node.
4070 TypoExpr *createDelayedTypo(std::unique_ptr<TypoCorrectionConsumer> TCC,
4071 TypoDiagnosticGenerator TDG,
4072 TypoRecoveryCallback TRC, SourceLocation TypoLoc);
4073
4074 // The set of known/encountered (unique, canonicalized) NamespaceDecls.
4075 //
4076 // The boolean value will be true to indicate that the namespace was loaded
4077 // from an AST/PCH file, or false otherwise.
4078 llvm::MapVector<NamespaceDecl*, bool> KnownNamespaces;
4079
4080 /// Whether we have already loaded known namespaces from an extenal
4081 /// source.
4082 bool LoadedExternalKnownNamespaces;
4083
4084 /// Helper for CorrectTypo and CorrectTypoDelayed used to create and
4085 /// populate a new TypoCorrectionConsumer. Returns nullptr if typo correction
4086 /// should be skipped entirely.
4087 std::unique_ptr<TypoCorrectionConsumer>
4088 makeTypoCorrectionConsumer(const DeclarationNameInfo &Typo,
4089 Sema::LookupNameKind LookupKind, Scope *S,
4090 CXXScopeSpec *SS,
4091 CorrectionCandidateCallback &CCC,
4092 DeclContext *MemberContext, bool EnteringContext,
4093 const ObjCObjectPointerType *OPT,
4094 bool ErrorRecovery);
4095
4096public:
4097 const TypoExprState &getTypoExprState(TypoExpr *TE) const;
4098
4099 /// Clears the state of the given TypoExpr.
4100 void clearDelayedTypo(TypoExpr *TE);
4101
4102 /// Look up a name, looking for a single declaration. Return
4103 /// null if the results were absent, ambiguous, or overloaded.
4104 ///
4105 /// It is preferable to use the elaborated form and explicitly handle
4106 /// ambiguity and overloaded.
4107 NamedDecl *LookupSingleName(Scope *S, DeclarationName Name,
4108 SourceLocation Loc,
4109 LookupNameKind NameKind,
4110 RedeclarationKind Redecl
4111 = NotForRedeclaration);
4112 bool LookupBuiltin(LookupResult &R);
4113 void LookupNecessaryTypesForBuiltin(Scope *S, unsigned ID);
4114 bool LookupName(LookupResult &R, Scope *S,
4115 bool AllowBuiltinCreation = false);
4116 bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
4117 bool InUnqualifiedLookup = false);
4118 bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx,
4119 CXXScopeSpec &SS);
4120 bool LookupParsedName(LookupResult &R, Scope *S, CXXScopeSpec *SS,
4121 bool AllowBuiltinCreation = false,
4122 bool EnteringContext = false);
4123 ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II, SourceLocation IdLoc,
4124 RedeclarationKind Redecl
4125 = NotForRedeclaration);
4126 bool LookupInSuper(LookupResult &R, CXXRecordDecl *Class);
4127
4128 void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
4129 UnresolvedSetImpl &Functions);
4130
4131 LabelDecl *LookupOrCreateLabel(IdentifierInfo *II, SourceLocation IdentLoc,
4132 SourceLocation GnuLabelLoc = SourceLocation());
4133
4134 DeclContextLookupResult LookupConstructors(CXXRecordDecl *Class);
4135 CXXConstructorDecl *LookupDefaultConstructor(CXXRecordDecl *Class);
4136 CXXConstructorDecl *LookupCopyingConstructor(CXXRecordDecl *Class,
4137 unsigned Quals);
4138 CXXMethodDecl *LookupCopyingAssignment(CXXRecordDecl *Class, unsigned Quals,
4139 bool RValueThis, unsigned ThisQuals);
4140 CXXConstructorDecl *LookupMovingConstructor(CXXRecordDecl *Class,
4141 unsigned Quals);
4142 CXXMethodDecl *LookupMovingAssignment(CXXRecordDecl *Class, unsigned Quals,
4143 bool RValueThis, unsigned ThisQuals);
4144 CXXDestructorDecl *LookupDestructor(CXXRecordDecl *Class);
4145
4146 bool checkLiteralOperatorId(const CXXScopeSpec &SS, const UnqualifiedId &Id,
4147 bool IsUDSuffix);
4148 LiteralOperatorLookupResult
4149 LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef<QualType> ArgTys,
4150 bool AllowRaw, bool AllowTemplate,
4151 bool AllowStringTemplate, bool DiagnoseMissing,
4152 StringLiteral *StringLit = nullptr);
4153 bool isKnownName(StringRef name);
4154
4155 /// Status of the function emission on the CUDA/HIP/OpenMP host/device attrs.
4156 enum class FunctionEmissionStatus {
4157 Emitted,
4158 CUDADiscarded, // Discarded due to CUDA/HIP hostness
4159 OMPDiscarded, // Discarded due to OpenMP hostness
4160 TemplateDiscarded, // Discarded due to uninstantiated templates
4161 Unknown,
4162 };
4163 FunctionEmissionStatus getEmissionStatus(FunctionDecl *Decl,
4164 bool Final = false);
4165
4166 // Whether the callee should be ignored in CUDA/HIP/OpenMP host/device check.
4167 bool shouldIgnoreInHostDeviceCheck(FunctionDecl *Callee);
4168
4169 void ArgumentDependentLookup(DeclarationName Name, SourceLocation Loc,
4170 ArrayRef<Expr *> Args, ADLResult &Functions);
4171
4172 void LookupVisibleDecls(Scope *S, LookupNameKind Kind,
4173 VisibleDeclConsumer &Consumer,
4174 bool IncludeGlobalScope = true,
4175 bool LoadExternal = true);
4176 void LookupVisibleDecls(DeclContext *Ctx, LookupNameKind Kind,
4177 VisibleDeclConsumer &Consumer,
4178 bool IncludeGlobalScope = true,
4179 bool IncludeDependentBases = false,
4180 bool LoadExternal = true);
4181
4182 enum CorrectTypoKind {
4183 CTK_NonError, // CorrectTypo used in a non error recovery situation.
4184 CTK_ErrorRecovery // CorrectTypo used in normal error recovery.
4185 };
4186
4187 TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
4188 Sema::LookupNameKind LookupKind,
4189 Scope *S, CXXScopeSpec *SS,
4190 CorrectionCandidateCallback &CCC,
4191 CorrectTypoKind Mode,
4192 DeclContext *MemberContext = nullptr,
4193 bool EnteringContext = false,
4194 const ObjCObjectPointerType *OPT = nullptr,
4195 bool RecordFailure = true);
4196
4197 TypoExpr *CorrectTypoDelayed(const DeclarationNameInfo &Typo,
4198 Sema::LookupNameKind LookupKind, Scope *S,
4199 CXXScopeSpec *SS,
4200 CorrectionCandidateCallback &CCC,
4201 TypoDiagnosticGenerator TDG,
4202 TypoRecoveryCallback TRC, CorrectTypoKind Mode,
4203 DeclContext *MemberContext = nullptr,
4204 bool EnteringContext = false,
4205 const ObjCObjectPointerType *OPT = nullptr);
4206
4207 /// Process any TypoExprs in the given Expr and its children,
4208 /// generating diagnostics as appropriate and returning a new Expr if there
4209 /// were typos that were all successfully corrected and ExprError if one or
4210 /// more typos could not be corrected.
4211 ///
4212 /// \param E The Expr to check for TypoExprs.
4213 ///
4214 /// \param InitDecl A VarDecl to avoid because the Expr being corrected is its
4215 /// initializer.
4216 ///
4217 /// \param RecoverUncorrectedTypos If true, when typo correction fails, it
4218 /// will rebuild the given Expr with all TypoExprs degraded to RecoveryExprs.
4219 ///
4220 /// \param Filter A function applied to a newly rebuilt Expr to determine if
4221 /// it is an acceptable/usable result from a single combination of typo
4222 /// corrections. As long as the filter returns ExprError, different
4223 /// combinations of corrections will be tried until all are exhausted.
4224 ExprResult CorrectDelayedTyposInExpr(
4225 Expr *E, VarDecl *InitDecl = nullptr,
4226 bool RecoverUncorrectedTypos = false,
4227 llvm::function_ref<ExprResult(Expr *)> Filter =
4228 [](Expr *E) -> ExprResult { return E; });
4229
4230 ExprResult CorrectDelayedTyposInExpr(
4231 ExprResult ER, VarDecl *InitDecl = nullptr,
4232 bool RecoverUncorrectedTypos = false,
4233 llvm::function_ref<ExprResult(Expr *)> Filter =
4234 [](Expr *E) -> ExprResult { return E; }) {
4235 return ER.isInvalid()
4236 ? ER
4237 : CorrectDelayedTyposInExpr(ER.get(), InitDecl,
4238 RecoverUncorrectedTypos, Filter);
4239 }
4240
4241 void diagnoseTypo(const TypoCorrection &Correction,
4242 const PartialDiagnostic &TypoDiag,
4243 bool ErrorRecovery = true);
4244
4245 void diagnoseTypo(const TypoCorrection &Correction,
4246 const PartialDiagnostic &TypoDiag,
4247 const PartialDiagnostic &PrevNote,
4248 bool ErrorRecovery = true);
4249
4250 void MarkTypoCorrectedFunctionDefinition(const NamedDecl *F);
4251
4252 void FindAssociatedClassesAndNamespaces(SourceLocation InstantiationLoc,
4253 ArrayRef<Expr *> Args,
4254 AssociatedNamespaceSet &AssociatedNamespaces,
4255 AssociatedClassSet &AssociatedClasses);
4256
4257 void FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S,
4258 bool ConsiderLinkage, bool AllowInlineNamespace);
4259
4260 bool CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old);
4261
4262 void DiagnoseAmbiguousLookup(LookupResult &Result);
4263 //@}
4264
4265 /// Attempts to produce a RecoveryExpr after some AST node cannot be created.
4266 ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End,
4267 ArrayRef<Expr *> SubExprs,
4268 QualType T = QualType());
4269
4270 ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *&Id,
4271 SourceLocation IdLoc,
4272 bool TypoCorrection = false);
4273 FunctionDecl *CreateBuiltin(IdentifierInfo *II, QualType Type, unsigned ID,
4274 SourceLocation Loc);
4275 NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
4276 Scope *S, bool ForRedeclaration,
4277 SourceLocation Loc);
4278 NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
4279 Scope *S);
4280 void AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction(
4281 FunctionDecl *FD);
4282 void AddKnownFunctionAttributes(FunctionDecl *FD);
4283
4284 // More parsing and symbol table subroutines.
4285
4286 void ProcessPragmaWeak(Scope *S, Decl *D);
4287 // Decl attributes - this routine is the top level dispatcher.
4288 void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);
4289 // Helper for delayed processing of attributes.
4290 void ProcessDeclAttributeDelayed(Decl *D,
4291 const ParsedAttributesView &AttrList);
4292 void ProcessDeclAttributeList(Scope *S, Decl *D, const ParsedAttributesView &AL,
4293 bool IncludeCXX11Attributes = true);
4294 bool ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
4295 const ParsedAttributesView &AttrList);
4296
4297 void checkUnusedDeclAttributes(Declarator &D);
4298
4299 /// Handles semantic checking for features that are common to all attributes,
4300 /// such as checking whether a parameter was properly specified, or the
4301 /// correct number of arguments were passed, etc. Returns true if the
4302 /// attribute has been diagnosed.
4303 bool checkCommonAttributeFeatures(const Decl *D, const ParsedAttr &A);
4304 bool checkCommonAttributeFeatures(const Stmt *S, const ParsedAttr &A);
4305
4306 /// Determine if type T is a valid subject for a nonnull and similar
4307 /// attributes. By default, we look through references (the behavior used by
4308 /// nonnull), but if the second parameter is true, then we treat a reference
4309 /// type as valid.
4310 bool isValidPointerAttrType(QualType T, bool RefOkay = false);
4311
4312 bool CheckRegparmAttr(const ParsedAttr &attr, unsigned &value);
4313 bool CheckCallingConvAttr(const ParsedAttr &attr, CallingConv &CC,
4314 const FunctionDecl *FD = nullptr);
4315 bool CheckAttrTarget(const ParsedAttr &CurrAttr);
4316 bool CheckAttrNoArgs(const ParsedAttr &CurrAttr);
4317 bool checkStringLiteralArgumentAttr(const ParsedAttr &Attr, unsigned ArgNum,
4318 StringRef &Str,
4319 SourceLocation *ArgLocation = nullptr);
4320 llvm::Error isValidSectionSpecifier(StringRef Str);
4321 bool checkSectionName(SourceLocation LiteralLoc, StringRef Str);
4322 bool checkTargetAttr(SourceLocation LiteralLoc, StringRef Str);
4323 bool checkMSInheritanceAttrOnDefinition(
4324 CXXRecordDecl *RD, SourceRange Range, bool BestCase,
4325 MSInheritanceModel SemanticSpelling);
4326
4327 void CheckAlignasUnderalignment(Decl *D);
4328
4329 /// Adjust the calling convention of a method to be the ABI default if it
4330 /// wasn't specified explicitly. This handles method types formed from
4331 /// function type typedefs and typename template arguments.
4332 void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor,
4333 SourceLocation Loc);
4334
4335 // Check if there is an explicit attribute, but only look through parens.
4336 // The intent is to look for an attribute on the current declarator, but not
4337 // one that came from a typedef.
4338 bool hasExplicitCallingConv(QualType T);
4339
4340 /// Get the outermost AttributedType node that sets a calling convention.
4341 /// Valid types should not have multiple attributes with different CCs.
4342 const AttributedType *getCallingConvAttributedType(QualType T) const;
4343
4344 /// Process the attributes before creating an attributed statement. Returns
4345 /// the semantic attributes that have been processed.
4346 void ProcessStmtAttributes(Stmt *Stmt,
4347 const ParsedAttributesWithRange &InAttrs,
4348 SmallVectorImpl<const Attr *> &OutAttrs);
4349
4350 void WarnConflictingTypedMethods(ObjCMethodDecl *Method,
4351 ObjCMethodDecl *MethodDecl,
4352 bool IsProtocolMethodDecl);
4353
4354 void CheckConflictingOverridingMethod(ObjCMethodDecl *Method,
4355 ObjCMethodDecl *Overridden,
4356 bool IsProtocolMethodDecl);
4357
4358 /// WarnExactTypedMethods - This routine issues a warning if method
4359 /// implementation declaration matches exactly that of its declaration.
4360 void WarnExactTypedMethods(ObjCMethodDecl *Method,
4361 ObjCMethodDecl *MethodDecl,
4362 bool IsProtocolMethodDecl);
4363
4364 typedef llvm::SmallPtrSet<Selector, 8> SelectorSet;
4365
4366 /// CheckImplementationIvars - This routine checks if the instance variables
4367 /// listed in the implelementation match those listed in the interface.
4368 void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
4369 ObjCIvarDecl **Fields, unsigned nIvars,
4370 SourceLocation Loc);
4371
4372 /// ImplMethodsVsClassMethods - This is main routine to warn if any method
4373 /// remains unimplemented in the class or category \@implementation.
4374 void ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl* IMPDecl,
4375 ObjCContainerDecl* IDecl,
4376 bool IncompleteImpl = false);
4377
4378 /// DiagnoseUnimplementedProperties - This routine warns on those properties
4379 /// which must be implemented by this implementation.
4380 void DiagnoseUnimplementedProperties(Scope *S, ObjCImplDecl* IMPDecl,
4381 ObjCContainerDecl *CDecl,
4382 bool SynthesizeProperties);
4383
4384 /// Diagnose any null-resettable synthesized setters.
4385 void diagnoseNullResettableSynthesizedSetters(const ObjCImplDecl *impDecl);
4386
4387 /// DefaultSynthesizeProperties - This routine default synthesizes all
4388 /// properties which must be synthesized in the class's \@implementation.
4389 void DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl,
4390 ObjCInterfaceDecl *IDecl,
4391 SourceLocation AtEnd);
4392 void DefaultSynthesizeProperties(Scope *S, Decl *D, SourceLocation AtEnd);
4393
4394 /// IvarBacksCurrentMethodAccessor - This routine returns 'true' if 'IV' is
4395 /// an ivar synthesized for 'Method' and 'Method' is a property accessor
4396 /// declared in class 'IFace'.
4397 bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace,
4398 ObjCMethodDecl *Method, ObjCIvarDecl *IV);
4399
4400 /// DiagnoseUnusedBackingIvarInAccessor - Issue an 'unused' warning if ivar which
4401 /// backs the property is not used in the property's accessor.
4402 void DiagnoseUnusedBackingIvarInAccessor(Scope *S,
4403 const ObjCImplementationDecl *ImplD);
4404
4405 /// GetIvarBackingPropertyAccessor - If method is a property setter/getter and
4406 /// it property has a backing ivar, returns this ivar; otherwise, returns NULL.
4407 /// It also returns ivar's property on success.
4408 ObjCIvarDecl *GetIvarBackingPropertyAccessor(const ObjCMethodDecl *Method,
4409 const ObjCPropertyDecl *&PDecl) const;
4410
4411 /// Called by ActOnProperty to handle \@property declarations in
4412 /// class extensions.
4413 ObjCPropertyDecl *HandlePropertyInClassExtension(Scope *S,
4414 SourceLocation AtLoc,
4415 SourceLocation LParenLoc,
4416 FieldDeclarator &FD,
4417 Selector GetterSel,
4418 SourceLocation GetterNameLoc,
4419 Selector SetterSel,
4420 SourceLocation SetterNameLoc,
4421 const bool isReadWrite,
4422 unsigned &Attributes,
4423 const unsigned AttributesAsWritten,
4424 QualType T,
4425 TypeSourceInfo *TSI,
4426 tok::ObjCKeywordKind MethodImplKind);
4427
4428 /// Called by ActOnProperty and HandlePropertyInClassExtension to
4429 /// handle creating the ObjcPropertyDecl for a category or \@interface.
4430 ObjCPropertyDecl *CreatePropertyDecl(Scope *S,
4431 ObjCContainerDecl *CDecl,
4432 SourceLocation AtLoc,
4433 SourceLocation LParenLoc,
4434 FieldDeclarator &FD,
4435 Selector GetterSel,
4436 SourceLocation GetterNameLoc,
4437 Selector SetterSel,
4438 SourceLocation SetterNameLoc,
4439 const bool isReadWrite,
4440 const unsigned Attributes,
4441 const unsigned AttributesAsWritten,
4442 QualType T,
4443 TypeSourceInfo *TSI,
4444 tok::ObjCKeywordKind MethodImplKind,
4445 DeclContext *lexicalDC = nullptr);
4446
4447 /// AtomicPropertySetterGetterRules - This routine enforces the rule (via
4448 /// warning) when atomic property has one but not the other user-declared
4449 /// setter or getter.
4450 void AtomicPropertySetterGetterRules(ObjCImplDecl* IMPDecl,
4451 ObjCInterfaceDecl* IDecl);
4452
4453 void DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D);
4454
4455 void DiagnoseMissingDesignatedInitOverrides(
4456 const ObjCImplementationDecl *ImplD,
4457 const ObjCInterfaceDecl *IFD);
4458
4459 void DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, ObjCInterfaceDecl *SID);
4460
4461 enum MethodMatchStrategy {
4462 MMS_loose,
4463 MMS_strict
4464 };
4465
4466 /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns
4467 /// true, or false, accordingly.
4468 bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
4469 const ObjCMethodDecl *PrevMethod,
4470 MethodMatchStrategy strategy = MMS_strict);
4471
4472 /// MatchAllMethodDeclarations - Check methods declaraed in interface or
4473 /// or protocol against those declared in their implementations.
4474 void MatchAllMethodDeclarations(const SelectorSet &InsMap,
4475 const SelectorSet &ClsMap,
4476 SelectorSet &InsMapSeen,
4477 SelectorSet &ClsMapSeen,
4478 ObjCImplDecl* IMPDecl,
4479 ObjCContainerDecl* IDecl,
4480 bool &IncompleteImpl,
4481 bool ImmediateClass,
4482 bool WarnCategoryMethodImpl=false);
4483
4484 /// CheckCategoryVsClassMethodMatches - Checks that methods implemented in
4485 /// category matches with those implemented in its primary class and
4486 /// warns each time an exact match is found.
4487 void CheckCategoryVsClassMethodMatches(ObjCCategoryImplDecl *CatIMP);
4488
4489 /// Add the given method to the list of globally-known methods.
4490 void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method);
4491
4492 /// Returns default addr space for method qualifiers.
4493 LangAS getDefaultCXXMethodAddrSpace() const;
4494
4495private:
4496 /// AddMethodToGlobalPool - Add an instance or factory method to the global
4497 /// pool. See descriptoin of AddInstanceMethodToGlobalPool.
4498 void AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl, bool instance);
4499
4500 /// LookupMethodInGlobalPool - Returns the instance or factory method and
4501 /// optionally warns if there are multiple signatures.
4502 ObjCMethodDecl *LookupMethodInGlobalPool(Selector Sel, SourceRange R,
4503 bool receiverIdOrClass,
4504 bool instance);
4505
4506public:
4507 /// - Returns instance or factory methods in global method pool for
4508 /// given selector. It checks the desired kind first, if none is found, and
4509 /// parameter checkTheOther is set, it then checks the other kind. If no such
4510 /// method or only one method is found, function returns false; otherwise, it
4511 /// returns true.
4512 bool
4513 CollectMultipleMethodsInGlobalPool(Selector Sel,
4514 SmallVectorImpl<ObjCMethodDecl*>& Methods,
4515 bool InstanceFirst, bool CheckTheOther,
4516 const ObjCObjectType *TypeBound = nullptr);
4517
4518 bool
4519 AreMultipleMethodsInGlobalPool(Selector Sel, ObjCMethodDecl *BestMethod,
4520 SourceRange R, bool receiverIdOrClass,
4521 SmallVectorImpl<ObjCMethodDecl*>& Methods);
4522
4523 void
4524 DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl<ObjCMethodDecl*> &Methods,
4525 Selector Sel, SourceRange R,
4526 bool receiverIdOrClass);
4527
4528private:
4529 /// - Returns a selector which best matches given argument list or
4530 /// nullptr if none could be found
4531 ObjCMethodDecl *SelectBestMethod(Selector Sel, MultiExprArg Args,
4532 bool IsInstance,
4533 SmallVectorImpl<ObjCMethodDecl*>& Methods);
4534
4535
4536 /// Record the typo correction failure and return an empty correction.
4537 TypoCorrection FailedCorrection(IdentifierInfo *Typo, SourceLocation TypoLoc,
4538 bool RecordFailure = true) {
4539 if (RecordFailure)
4540 TypoCorrectionFailures[Typo].insert(TypoLoc);
4541 return TypoCorrection();
4542 }
4543
4544public:
4545 /// AddInstanceMethodToGlobalPool - All instance methods in a translation
4546 /// unit are added to a global pool. This allows us to efficiently associate
4547 /// a selector with a method declaraation for purposes of typechecking
4548 /// messages sent to "id" (where the class of the object is unknown).
4549 void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {
4550 AddMethodToGlobalPool(Method, impl, /*instance*/true);
4551 }
4552
4553 /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
4554 void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method, bool impl=false) {
4555 AddMethodToGlobalPool(Method, impl, /*instance*/false);
4556 }
4557
4558 /// AddAnyMethodToGlobalPool - Add any method, instance or factory to global
4559 /// pool.
4560 void AddAnyMethodToGlobalPool(Decl *D);
4561
4562 /// LookupInstanceMethodInGlobalPool - Returns the method and warns if
4563 /// there are multiple signatures.
4564 ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R,
4565 bool receiverIdOrClass=false) {
4566 return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,
4567 /*instance*/true);
4568 }
4569
4570 /// LookupFactoryMethodInGlobalPool - Returns the method and warns if
4571 /// there are multiple signatures.
4572 ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R,
4573 bool receiverIdOrClass=false) {
4574 return LookupMethodInGlobalPool(Sel, R, receiverIdOrClass,
4575 /*instance*/false);
4576 }
4577
4578 const ObjCMethodDecl *SelectorsForTypoCorrection(Selector Sel,
4579 QualType ObjectType=QualType());
4580 /// LookupImplementedMethodInGlobalPool - Returns the method which has an
4581 /// implementation.
4582 ObjCMethodDecl *LookupImplementedMethodInGlobalPool(Selector Sel);
4583
4584 /// CollectIvarsToConstructOrDestruct - Collect those ivars which require
4585 /// initialization.
4586 void CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI,
4587 SmallVectorImpl<ObjCIvarDecl*> &Ivars);
4588
4589 //===--------------------------------------------------------------------===//
4590 // Statement Parsing Callbacks: SemaStmt.cpp.
4591public:
4592 class FullExprArg {
4593 public:
4594 FullExprArg() : E(nullptr) { }
4595 FullExprArg(Sema &actions) : E(nullptr) { }
4596
4597 ExprResult release() {
4598 return E;
4599 }
4600
4601 Expr *get() const { return E; }
4602
4603 Expr *operator->() {
4604 return E;
4605 }
4606
4607 private:
4608 // FIXME: No need to make the entire Sema class a friend when it's just
4609 // Sema::MakeFullExpr that needs access to the constructor below.
4610 friend class Sema;
4611
4612 explicit FullExprArg(Expr *expr) : E(expr) {}
4613
4614 Expr *E;
4615 };
4616
4617 FullExprArg MakeFullExpr(Expr *Arg) {
4618 return MakeFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation());
4619 }
4620 FullExprArg MakeFullExpr(Expr *Arg, SourceLocation CC) {
4621 return FullExprArg(
4622 ActOnFinishFullExpr(Arg, CC, /*DiscardedValue*/ false).get());
4623 }
4624 FullExprArg MakeFullDiscardedValueExpr(Expr *Arg) {
4625 ExprResult FE =
4626 ActOnFinishFullExpr(Arg, Arg ? Arg->getExprLoc() : SourceLocation(),
4627 /*DiscardedValue*/ true);
4628 return FullExprArg(FE.get());
4629 }
4630
4631 StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue = true);
4632 StmtResult ActOnExprStmtError();
4633
4634 StmtResult ActOnNullStmt(SourceLocation SemiLoc,
4635 bool HasLeadingEmptyMacro = false);
4636
4637 void ActOnStartOfCompoundStmt(bool IsStmtExpr);
4638 void ActOnAfterCompoundStatementLeadingPragmas();
4639 void ActOnFinishOfCompoundStmt();
4640 StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
4641 ArrayRef<Stmt *> Elts, bool isStmtExpr);
4642
4643 /// A RAII object to enter scope of a compound statement.
4644 class CompoundScopeRAII {
4645 public:
4646 CompoundScopeRAII(Sema &S, bool IsStmtExpr = false) : S(S) {
4647 S.ActOnStartOfCompoundStmt(IsStmtExpr);
4648 }
4649
4650 ~CompoundScopeRAII() {
4651 S.ActOnFinishOfCompoundStmt();
4652 }
4653
4654 private:
4655 Sema &S;
4656 };
4657
4658 /// An RAII helper that pops function a function scope on exit.
4659 struct FunctionScopeRAII {
4660 Sema &S;
4661 bool Active;
4662 FunctionScopeRAII(Sema &S) : S(S), Active(true) {}
4663 ~FunctionScopeRAII() {
4664 if (Active)
4665 S.PopFunctionScopeInfo();
4666 }
4667 void disable() { Active = false; }
4668 };
4669
4670 StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
4671 SourceLocation StartLoc,
4672 SourceLocation EndLoc);
4673 void ActOnForEachDeclStmt(DeclGroupPtrTy Decl);
4674 StmtResult ActOnForEachLValueExpr(Expr *E);
4675 ExprResult ActOnCaseExpr(SourceLocation CaseLoc, ExprResult Val);
4676 StmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprResult LHS,
4677 SourceLocation DotDotDotLoc, ExprResult RHS,
4678 SourceLocation ColonLoc);
4679 void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt);
4680
4681 StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
4682 SourceLocation ColonLoc,
4683 Stmt *SubStmt, Scope *CurScope);
4684 StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
4685 SourceLocation ColonLoc, Stmt *SubStmt);
4686
4687 StmtResult BuildAttributedStmt(SourceLocation AttrsLoc,
4688 ArrayRef<const Attr *> Attrs, Stmt *SubStmt);
4689 StmtResult ActOnAttributedStmt(const ParsedAttributesWithRange &AttrList,
4690 Stmt *SubStmt);
4691
4692 class ConditionResult;
4693 StmtResult ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr,
4694 SourceLocation LParenLoc, Stmt *InitStmt,
4695 ConditionResult Cond, SourceLocation RParenLoc,
4696 Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal);
4697 StmtResult BuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
4698 SourceLocation LParenLoc, Stmt *InitStmt,
4699 ConditionResult Cond, SourceLocation RParenLoc,
4700 Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal);
4701 StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
4702 SourceLocation LParenLoc, Stmt *InitStmt,
4703 ConditionResult Cond,
4704 SourceLocation RParenLoc);
4705 StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
4706 Stmt *Switch, Stmt *Body);
4707 StmtResult ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc,
4708 ConditionResult Cond, SourceLocation RParenLoc,
4709 Stmt *Body);
4710 StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
4711 SourceLocation WhileLoc, SourceLocation CondLParen,
4712 Expr *Cond, SourceLocation CondRParen);
4713
4714 StmtResult ActOnForStmt(SourceLocation ForLoc,
4715 SourceLocation LParenLoc,
4716 Stmt *First,
4717 ConditionResult Second,
4718 FullExprArg Third,
4719 SourceLocation RParenLoc,
4720 Stmt *Body);
4721 ExprResult CheckObjCForCollectionOperand(SourceLocation forLoc,
4722 Expr *collection);
4723 StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
4724 Stmt *First, Expr *collection,
4725 SourceLocation RParenLoc);
4726 StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body);
4727
4728 enum BuildForRangeKind {
4729 /// Initial building of a for-range statement.
4730 BFRK_Build,
4731 /// Instantiation or recovery rebuild of a for-range statement. Don't
4732 /// attempt any typo-correction.
4733 BFRK_Rebuild,
4734 /// Determining whether a for-range statement could be built. Avoid any
4735 /// unnecessary or irreversible actions.
4736 BFRK_Check
4737 };
4738
4739 StmtResult ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc,
4740 SourceLocation CoawaitLoc,
4741 Stmt *InitStmt,
4742 Stmt *LoopVar,
4743 SourceLocation ColonLoc, Expr *Collection,
4744 SourceLocation RParenLoc,
4745 BuildForRangeKind Kind);
4746 StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc,
4747 SourceLocation CoawaitLoc,
4748 Stmt *InitStmt,
4749 SourceLocation ColonLoc,
4750 Stmt *RangeDecl, Stmt *Begin, Stmt *End,
4751 Expr *Cond, Expr *Inc,
4752 Stmt *LoopVarDecl,
4753 SourceLocation RParenLoc,
4754 BuildForRangeKind Kind);
4755 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body);
4756
4757 StmtResult ActOnGotoStmt(SourceLocation GotoLoc,
4758 SourceLocation LabelLoc,
4759 LabelDecl *TheDecl);
4760 StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
4761 SourceLocation StarLoc,
4762 Expr *DestExp);
4763 StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope);
4764 StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope);
4765
4766 void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
4767 CapturedRegionKind Kind, unsigned NumParams);
4768 typedef std::pair<StringRef, QualType> CapturedParamNameType;
4769 void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope,
4770 CapturedRegionKind Kind,
4771 ArrayRef<CapturedParamNameType> Params,
4772 unsigned OpenMPCaptureLevel = 0);
4773 StmtResult ActOnCapturedRegionEnd(Stmt *S);
4774 void ActOnCapturedRegionError();
4775 RecordDecl *CreateCapturedStmtRecordDecl(CapturedDecl *&CD,
4776 SourceLocation Loc,
4777 unsigned NumParams);
4778
4779 struct NamedReturnInfo {
4780 const VarDecl *Candidate;
4781
4782 enum Status : uint8_t { None, MoveEligible, MoveEligibleAndCopyElidable };
4783 Status S;
4784
4785 bool isMoveEligible() const { return S != None; };
4786 bool isCopyElidable() const { return S == MoveEligibleAndCopyElidable; }
4787 };
4788 enum class SimplerImplicitMoveMode { ForceOff, Normal, ForceOn };
4789 NamedReturnInfo getNamedReturnInfo(
4790 Expr *&E, SimplerImplicitMoveMode Mode = SimplerImplicitMoveMode::Normal);
4791 NamedReturnInfo getNamedReturnInfo(const VarDecl *VD);
4792 const VarDecl *getCopyElisionCandidate(NamedReturnInfo &Info,
4793 QualType ReturnType);
4794
4795 ExprResult
4796 PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
4797 const NamedReturnInfo &NRInfo, Expr *Value,
4798 bool SupressSimplerImplicitMoves = false);
4799
4800 StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
4801 Scope *CurScope);
4802 StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp);
4803 StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
4804 NamedReturnInfo &NRInfo,
4805 bool SupressSimplerImplicitMoves);
4806
4807 StmtResult ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple,
4808 bool IsVolatile, unsigned NumOutputs,
4809 unsigned NumInputs, IdentifierInfo **Names,
4810 MultiExprArg Constraints, MultiExprArg Exprs,
4811 Expr *AsmString, MultiExprArg Clobbers,
4812 unsigned NumLabels,
4813 SourceLocation RParenLoc);
4814
4815 void FillInlineAsmIdentifierInfo(Expr *Res,
4816 llvm::InlineAsmIdentifierInfo &Info);
4817 ExprResult LookupInlineAsmIdentifier(CXXScopeSpec &SS,
4818 SourceLocation TemplateKWLoc,
4819 UnqualifiedId &Id,
4820 bool IsUnevaluatedContext);
4821 bool LookupInlineAsmField(StringRef Base, StringRef Member,
4822 unsigned &Offset, SourceLocation AsmLoc);
4823 ExprResult LookupInlineAsmVarDeclField(Expr *RefExpr, StringRef Member,
4824 SourceLocation AsmLoc);
4825 StmtResult ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc,
4826 ArrayRef<Token> AsmToks,
4827 StringRef AsmString,
4828 unsigned NumOutputs, unsigned NumInputs,
4829 ArrayRef<StringRef> Constraints,
4830 ArrayRef<StringRef> Clobbers,
4831 ArrayRef<Expr*> Exprs,
4832 SourceLocation EndLoc);
4833 LabelDecl *GetOrCreateMSAsmLabel(StringRef ExternalLabelName,
4834 SourceLocation Location,
4835 bool AlwaysCreate);
4836
4837 VarDecl *BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType ExceptionType,
4838 SourceLocation StartLoc,
4839 SourceLocation IdLoc, IdentifierInfo *Id,
4840 bool Invalid = false);
4841
4842 Decl *ActOnObjCExceptionDecl(Scope *S, Declarator &D);
4843
4844 StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc, SourceLocation RParen,
4845 Decl *Parm, Stmt *Body);
4846
4847 StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body);
4848
4849 StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
4850 MultiStmtArg Catch, Stmt *Finally);
4851
4852 StmtResult BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw);
4853 StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
4854 Scope *CurScope);
4855 ExprResult ActOnObjCAtSynchronizedOperand(SourceLocation atLoc,
4856 Expr *operand);
4857 StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
4858 Expr *SynchExpr,
4859 Stmt *SynchBody);
4860
4861 StmtResult ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body);
4862
4863 VarDecl *BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo,
4864 SourceLocation StartLoc,
4865 SourceLocation IdLoc,
4866 IdentifierInfo *Id);
4867
4868 Decl *ActOnExceptionDeclarator(Scope *S, Declarator &D);
4869
4870 StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
4871 Decl *ExDecl, Stmt *HandlerBlock);
4872 StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
4873 ArrayRef<Stmt *> Handlers);
4874
4875 StmtResult ActOnSEHTryBlock(bool IsCXXTry, // try (true) or __try (false) ?
4876 SourceLocation TryLoc, Stmt *TryBlock,
4877 Stmt *Handler);
4878 StmtResult ActOnSEHExceptBlock(SourceLocation Loc,
4879 Expr *FilterExpr,
4880 Stmt *Block);
4881 void ActOnStartSEHFinallyBlock();
4882 void ActOnAbortSEHFinallyBlock();
4883 StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block);
4884 StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope);
4885
4886 void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
4887
4888 bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const;
4889
4890 /// If it's a file scoped decl that must warn if not used, keep track
4891 /// of it.
4892 void MarkUnusedFileScopedDecl(const DeclaratorDecl *D);
4893
4894 /// DiagnoseUnusedExprResult - If the statement passed in is an expression
4895 /// whose result is unused, warn.
4896 void DiagnoseUnusedExprResult(const Stmt *S);
4897 void DiagnoseUnusedNestedTypedefs(const RecordDecl *D);
4898 void DiagnoseUnusedDecl(const NamedDecl *ND);
4899
4900 /// If VD is set but not otherwise used, diagnose, for a parameter or a
4901 /// variable.
4902 void DiagnoseUnusedButSetDecl(const VarDecl *VD);
4903
4904 /// Emit \p DiagID if statement located on \p StmtLoc has a suspicious null
4905 /// statement as a \p Body, and it is located on the same line.
4906 ///
4907 /// This helps prevent bugs due to typos, such as:
4908 /// if (condition);
4909 /// do_stuff();
4910 void DiagnoseEmptyStmtBody(SourceLocation StmtLoc,
4911 const Stmt *Body,
4912 unsigned DiagID);
4913
4914 /// Warn if a for/while loop statement \p S, which is followed by
4915 /// \p PossibleBody, has a suspicious null statement as a body.
4916 void DiagnoseEmptyLoopBody(const Stmt *S,
4917 const Stmt *PossibleBody);
4918
4919 /// Warn if a value is moved to itself.
4920 void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr,
4921 SourceLocation OpLoc);
4922
4923 /// Warn if we're implicitly casting from a _Nullable pointer type to a
4924 /// _Nonnull one.
4925 void diagnoseNullableToNonnullConversion(QualType DstType, QualType SrcType,
4926 SourceLocation Loc);
4927
4928 /// Warn when implicitly casting 0 to nullptr.
4929 void diagnoseZeroToNullptrConversion(CastKind Kind, const Expr *E);
4930
4931 ParsingDeclState PushParsingDeclaration(sema::DelayedDiagnosticPool &pool) {
4932 return DelayedDiagnostics.push(pool);
4933 }
4934 void PopParsingDeclaration(ParsingDeclState state, Decl *decl);
4935
4936 typedef ProcessingContextState ParsingClassState;
4937 ParsingClassState PushParsingClass() {
4938 ParsingClassDepth++;
4939 return DelayedDiagnostics.pushUndelayed();
4940 }
4941 void PopParsingClass(ParsingClassState state) {
4942 ParsingClassDepth--;
4943 DelayedDiagnostics.popUndelayed(state);
4944 }
4945
4946 void redelayDiagnostics(sema::DelayedDiagnosticPool &pool);
4947
4948 void DiagnoseAvailabilityOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
4949 const ObjCInterfaceDecl *UnknownObjCClass,
4950 bool ObjCPropertyAccess,
4951 bool AvoidPartialAvailabilityChecks = false,
4952 ObjCInterfaceDecl *ClassReceiver = nullptr);
4953
4954 bool makeUnavailableInSystemHeader(SourceLocation loc,
4955 UnavailableAttr::ImplicitReason reason);
4956
4957 /// Issue any -Wunguarded-availability warnings in \c FD
4958 void DiagnoseUnguardedAvailabilityViolations(Decl *FD);
4959
4960 void handleDelayedAvailabilityCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);
4961
4962 //===--------------------------------------------------------------------===//
4963 // Expression Parsing Callbacks: SemaExpr.cpp.
4964
4965 bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid);
4966 bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
4967 const ObjCInterfaceDecl *UnknownObjCClass = nullptr,
4968 bool ObjCPropertyAccess = false,
4969 bool AvoidPartialAvailabilityChecks = false,
4970 ObjCInterfaceDecl *ClassReciever = nullptr);
4971 void NoteDeletedFunction(FunctionDecl *FD);
4972 void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD);
4973 bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
4974 ObjCMethodDecl *Getter,
4975 SourceLocation Loc);
4976 void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
4977 ArrayRef<Expr *> Args);
4978
4979 void PushExpressionEvaluationContext(
4980 ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl = nullptr,
4981 ExpressionEvaluationContextRecord::ExpressionKind Type =
4982 ExpressionEvaluationContextRecord::EK_Other);
4983 enum ReuseLambdaContextDecl_t { ReuseLambdaContextDecl };
4984 void PushExpressionEvaluationContext(
4985 ExpressionEvaluationContext NewContext, ReuseLambdaContextDecl_t,
4986 ExpressionEvaluationContextRecord::ExpressionKind Type =
4987 ExpressionEvaluationContextRecord::EK_Other);
4988 void PopExpressionEvaluationContext();
4989
4990 void DiscardCleanupsInEvaluationContext();
4991
4992 ExprResult TransformToPotentiallyEvaluated(Expr *E);
4993 ExprResult HandleExprEvaluationContextForTypeof(Expr *E);
4994
4995 ExprResult CheckUnevaluatedOperand(Expr *E);
4996 void CheckUnusedVolatileAssignment(Expr *E);
4997
4998 ExprResult ActOnConstantExpression(ExprResult Res);
4999
5000 // Functions for marking a declaration referenced. These functions also
5001 // contain the relevant logic for marking if a reference to a function or
5002 // variable is an odr-use (in the C++11 sense). There are separate variants
5003 // for expressions referring to a decl; these exist because odr-use marking
5004 // needs to be delayed for some constant variables when we build one of the
5005 // named expressions.
5006 //
5007 // MightBeOdrUse indicates whether the use could possibly be an odr-use, and
5008 // should usually be true. This only needs to be set to false if the lack of
5009 // odr-use cannot be determined from the current context (for instance,
5010 // because the name denotes a virtual function and was written without an
5011 // explicit nested-name-specifier).
5012 void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse);
5013 void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
5014 bool MightBeOdrUse = true);
5015 void MarkVariableReferenced(SourceLocation Loc, VarDecl *Var);
5016 void MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base = nullptr);
5017 void MarkMemberReferenced(MemberExpr *E);
5018 void MarkFunctionParmPackReferenced(FunctionParmPackExpr *E);
5019 void MarkCaptureUsedInEnclosingContext(VarDecl *Capture, SourceLocation Loc,
5020 unsigned CapturingScopeIndex);
5021
5022 ExprResult CheckLValueToRValueConversionOperand(Expr *E);
5023 void CleanupVarDeclMarking();
5024
5025 enum TryCaptureKind {
5026 TryCapture_Implicit, TryCapture_ExplicitByVal, TryCapture_ExplicitByRef
5027 };
5028
5029 /// Try to capture the given variable.
5030 ///
5031 /// \param Var The variable to capture.
5032 ///
5033 /// \param Loc The location at which the capture occurs.
5034 ///
5035 /// \param Kind The kind of capture, which may be implicit (for either a
5036 /// block or a lambda), or explicit by-value or by-reference (for a lambda).
5037 ///
5038 /// \param EllipsisLoc The location of the ellipsis, if one is provided in
5039 /// an explicit lambda capture.
5040 ///
5041 /// \param BuildAndDiagnose Whether we are actually supposed to add the
5042 /// captures or diagnose errors. If false, this routine merely check whether
5043 /// the capture can occur without performing the capture itself or complaining
5044 /// if the variable cannot be captured.
5045 ///
5046 /// \param CaptureType Will be set to the type of the field used to capture
5047 /// this variable in the innermost block or lambda. Only valid when the
5048 /// variable can be captured.
5049 ///
5050 /// \param DeclRefType Will be set to the type of a reference to the capture
5051 /// from within the current scope. Only valid when the variable can be
5052 /// captured.
5053 ///
5054 /// \param FunctionScopeIndexToStopAt If non-null, it points to the index
5055 /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.
5056 /// This is useful when enclosing lambdas must speculatively capture
5057 /// variables that may or may not be used in certain specializations of
5058 /// a nested generic lambda.
5059 ///
5060 /// \returns true if an error occurred (i.e., the variable cannot be
5061 /// captured) and false if the capture succeeded.
5062 bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc, TryCaptureKind Kind,
5063 SourceLocation EllipsisLoc, bool BuildAndDiagnose,
5064 QualType &CaptureType,
5065 QualType &DeclRefType,
5066 const unsigned *const FunctionScopeIndexToStopAt);
5067
5068 /// Try to capture the given variable.
5069 bool tryCaptureVariable(VarDecl *Var, SourceLocation Loc,
5070 TryCaptureKind Kind = TryCapture_Implicit,
5071 SourceLocation EllipsisLoc = SourceLocation());
5072
5073 /// Checks if the variable must be captured.
5074 bool NeedToCaptureVariable(VarDecl *Var, SourceLocation Loc);
5075
5076 /// Given a variable, determine the type that a reference to that
5077 /// variable will have in the given scope.
5078 QualType getCapturedDeclRefType(VarDecl *Var, SourceLocation Loc);
5079
5080 /// Mark all of the declarations referenced within a particular AST node as
5081 /// referenced. Used when template instantiation instantiates a non-dependent
5082 /// type -- entities referenced by the type are now referenced.
5083 void MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T);
5084 void MarkDeclarationsReferencedInExpr(Expr *E,
5085 bool SkipLocalVariables = false);
5086
5087 /// Try to recover by turning the given expression into a
5088 /// call. Returns true if recovery was attempted or an error was
5089 /// emitted; this may also leave the ExprResult invalid.
5090 bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
5091 bool ForceComplain = false,
5092 bool (*IsPlausibleResult)(QualType) = nullptr);
5093
5094 /// Figure out if an expression could be turned into a call.
5095 bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
5096 UnresolvedSetImpl &NonTemplateOverloads);
5097
5098 /// Try to convert an expression \p E to type \p Ty. Returns the result of the
5099 /// conversion.
5100 ExprResult tryConvertExprToType(Expr *E, QualType Ty);
5101
5102 /// Conditionally issue a diagnostic based on the current
5103 /// evaluation context.
5104 ///
5105 /// \param Statement If Statement is non-null, delay reporting the
5106 /// diagnostic until the function body is parsed, and then do a basic
5107 /// reachability analysis to determine if the statement is reachable.
5108 /// If it is unreachable, the diagnostic will not be emitted.
5109 bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
5110 const PartialDiagnostic &PD);
5111 /// Similar, but diagnostic is only produced if all the specified statements
5112 /// are reachable.
5113 bool DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt*> Stmts,
5114 const PartialDiagnostic &PD);
5115
5116 // Primary Expressions.
5117 SourceRange getExprRange(Expr *E) const;
5118
5119 ExprResult ActOnIdExpression(
5120 Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
5121 UnqualifiedId &Id, bool HasTrailingLParen, bool IsAddressOfOperand,
5122 CorrectionCandidateCallback *CCC = nullptr,
5123 bool IsInlineAsmIdentifier = false, Token *KeywordReplacement = nullptr);
5124
5125 void DecomposeUnqualifiedId(const UnqualifiedId &Id,
5126 TemplateArgumentListInfo &Buffer,
5127 DeclarationNameInfo &NameInfo,
5128 const TemplateArgumentListInfo *&TemplateArgs);
5129
5130 bool DiagnoseDependentMemberLookup(LookupResult &R);
5131
5132 bool
5133 DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
5134 CorrectionCandidateCallback &CCC,
5135 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr,
5136 ArrayRef<Expr *> Args = None, TypoExpr **Out = nullptr);
5137
5138 DeclResult LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S,
5139 IdentifierInfo *II);
5140 ExprResult BuildIvarRefExpr(Scope *S, SourceLocation Loc, ObjCIvarDecl *IV);
5141
5142 ExprResult LookupInObjCMethod(LookupResult &LookUp, Scope *S,
5143 IdentifierInfo *II,
5144 bool AllowBuiltinCreation=false);
5145
5146 ExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS,
5147 SourceLocation TemplateKWLoc,
5148 const DeclarationNameInfo &NameInfo,
5149 bool isAddressOfOperand,
5150 const TemplateArgumentListInfo *TemplateArgs);
5151
5152 /// If \p D cannot be odr-used in the current expression evaluation context,
5153 /// return a reason explaining why. Otherwise, return NOUR_None.
5154 NonOdrUseReason getNonOdrUseReasonInCurrentContext(ValueDecl *D);
5155
5156 DeclRefExpr *BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
5157 SourceLocation Loc,
5158 const CXXScopeSpec *SS = nullptr);
5159 DeclRefExpr *
5160 BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
5161 const DeclarationNameInfo &NameInfo,
5162 const CXXScopeSpec *SS = nullptr,
5163 NamedDecl *FoundD = nullptr,
5164 SourceLocation TemplateKWLoc = SourceLocation(),
5165 const TemplateArgumentListInfo *TemplateArgs = nullptr);
5166 DeclRefExpr *
5167 BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
5168 const DeclarationNameInfo &NameInfo,
5169 NestedNameSpecifierLoc NNS,
5170 NamedDecl *FoundD = nullptr,
5171 SourceLocation TemplateKWLoc = SourceLocation(),
5172 const TemplateArgumentListInfo *TemplateArgs = nullptr);
5173
5174 ExprResult
5175 BuildAnonymousStructUnionMemberReference(
5176 const CXXScopeSpec &SS,
5177 SourceLocation nameLoc,
5178 IndirectFieldDecl *indirectField,
5179 DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_none),
5180 Expr *baseObjectExpr = nullptr,
5181 SourceLocation opLoc = SourceLocation());
5182
5183 ExprResult BuildPossibleImplicitMemberExpr(
5184 const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R,
5185 const TemplateArgumentListInfo *TemplateArgs, const Scope *S,
5186 UnresolvedLookupExpr *AsULE = nullptr);
5187 ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS,
5188 SourceLocation TemplateKWLoc,
5189 LookupResult &R,
5190 const TemplateArgumentListInfo *TemplateArgs,
5191 bool IsDefiniteInstance,
5192 const Scope *S);
5193 bool UseArgumentDependentLookup(const CXXScopeSpec &SS,
5194 const LookupResult &R,
5195 bool HasTrailingLParen);
5196
5197 ExprResult
5198 BuildQualifiedDeclarationNameExpr(CXXScopeSpec &SS,
5199 const DeclarationNameInfo &NameInfo,
5200 bool IsAddressOfOperand, const Scope *S,
5201 TypeSourceInfo **RecoveryTSI = nullptr);
5202
5203 ExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS,
5204 SourceLocation TemplateKWLoc,
5205 const DeclarationNameInfo &NameInfo,
5206 const TemplateArgumentListInfo *TemplateArgs);
5207
5208 ExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS,
5209 LookupResult &R,
5210 bool NeedsADL,
5211 bool AcceptInvalidDecl = false);
5212 ExprResult BuildDeclarationNameExpr(
5213 const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D,
5214 NamedDecl *FoundD = nullptr,
5215 const TemplateArgumentListInfo *TemplateArgs = nullptr,
5216 bool AcceptInvalidDecl = false);
5217
5218 ExprResult BuildLiteralOperatorCall(LookupResult &R,
5219 DeclarationNameInfo &SuffixInfo,
5220 ArrayRef<Expr *> Args,
5221 SourceLocation LitEndLoc,
5222 TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr);
5223
5224 ExprResult BuildPredefinedExpr(SourceLocation Loc,
5225 PredefinedExpr::IdentKind IK);
5226 ExprResult ActOnPredefinedExpr(SourceLocation Loc, tok::TokenKind Kind);
5227 ExprResult ActOnIntegerConstant(SourceLocation Loc, uint64_t Val);
5228
5229 ExprResult BuildSYCLUniqueStableNameExpr(SourceLocation OpLoc,
5230 SourceLocation LParen,
5231 SourceLocation RParen,
5232 TypeSourceInfo *TSI);
5233 ExprResult ActOnSYCLUniqueStableNameExpr(SourceLocation OpLoc,
5234 SourceLocation LParen,
5235 SourceLocation RParen,
5236 ParsedType ParsedTy);
5237
5238 bool CheckLoopHintExpr(Expr *E, SourceLocation Loc);
5239
5240 ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope = nullptr);
5241 ExprResult ActOnCharacterConstant(const Token &Tok,
5242 Scope *UDLScope = nullptr);
5243 ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E);
5244 ExprResult ActOnParenListExpr(SourceLocation L,
5245 SourceLocation R,
5246 MultiExprArg Val);
5247
5248 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
5249 /// fragments (e.g. "foo" "bar" L"baz").
5250 ExprResult ActOnStringLiteral(ArrayRef<Token> StringToks,
5251 Scope *UDLScope = nullptr);
5252
5253 ExprResult ActOnGenericSelectionExpr(SourceLocation KeyLoc,
5254 SourceLocation DefaultLoc,
5255 SourceLocation RParenLoc,
5256 Expr *ControllingExpr,
5257 ArrayRef<ParsedType> ArgTypes,
5258 ArrayRef<Expr *> ArgExprs);
5259 ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc,
5260 SourceLocation DefaultLoc,
5261 SourceLocation RParenLoc,
5262 Expr *ControllingExpr,
5263 ArrayRef<TypeSourceInfo *> Types,
5264 ArrayRef<Expr *> Exprs);
5265
5266 // Binary/Unary Operators. 'Tok' is the token for the operator.
5267 ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc,
5268 Expr *InputExpr);
5269 ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc,
5270 UnaryOperatorKind Opc, Expr *Input);
5271 ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
5272 tok::TokenKind Op, Expr *Input);
5273
5274 bool isQualifiedMemberAccess(Expr *E);
5275 QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc);
5276
5277 ExprResult CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,
5278 SourceLocation OpLoc,
5279 UnaryExprOrTypeTrait ExprKind,
5280 SourceRange R);
5281 ExprResult CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
5282 UnaryExprOrTypeTrait ExprKind);
5283 ExprResult
5284 ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,
5285 UnaryExprOrTypeTrait ExprKind,
5286 bool IsType, void *TyOrEx,
5287 SourceRange ArgRange);
5288
5289 ExprResult CheckPlaceholderExpr(Expr *E);
5290 bool CheckVecStepExpr(Expr *E);
5291
5292 bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind);
5293 bool CheckUnaryExprOrTypeTraitOperand(QualType ExprType, SourceLocation OpLoc,
5294 SourceRange ExprRange,
5295 UnaryExprOrTypeTrait ExprKind);
5296 ExprResult ActOnSizeofParameterPackExpr(Scope *S,
5297 SourceLocation OpLoc,
5298 IdentifierInfo &Name,
5299 SourceLocation NameLoc,
5300 SourceLocation RParenLoc);
5301 ExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
5302 tok::TokenKind Kind, Expr *Input);
5303
5304 ExprResult ActOnArraySubscriptExpr(Scope *S, Expr *Base, SourceLocation LLoc,
5305 Expr *Idx, SourceLocation RLoc);
5306 ExprResult CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
5307 Expr *Idx, SourceLocation RLoc);
5308
5309 ExprResult CreateBuiltinMatrixSubscriptExpr(Expr *Base, Expr *RowIdx,
5310 Expr *ColumnIdx,
5311 SourceLocation RBLoc);
5312
5313 ExprResult ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc,
5314 Expr *LowerBound,
5315 SourceLocation ColonLocFirst,
5316 SourceLocation ColonLocSecond,
5317 Expr *Length, Expr *Stride,
5318 SourceLocation RBLoc);
5319 ExprResult ActOnOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,
5320 SourceLocation RParenLoc,
5321 ArrayRef<Expr *> Dims,
5322 ArrayRef<SourceRange> Brackets);
5323
5324 /// Data structure for iterator expression.
5325 struct OMPIteratorData {
5326 IdentifierInfo *DeclIdent = nullptr;
5327 SourceLocation DeclIdentLoc;
5328 ParsedType Type;
5329 OMPIteratorExpr::IteratorRange Range;
5330 SourceLocation AssignLoc;
5331 SourceLocation ColonLoc;
5332 SourceLocation SecColonLoc;
5333 };
5334
5335 ExprResult ActOnOMPIteratorExpr(Scope *S, SourceLocation IteratorKwLoc,
5336 SourceLocation LLoc, SourceLocation RLoc,
5337 ArrayRef<OMPIteratorData> Data);
5338
5339 // This struct is for use by ActOnMemberAccess to allow
5340 // BuildMemberReferenceExpr to be able to reinvoke ActOnMemberAccess after
5341 // changing the access operator from a '.' to a '->' (to see if that is the
5342 // change needed to fix an error about an unknown member, e.g. when the class
5343 // defines a custom operator->).
5344 struct ActOnMemberAccessExtraArgs {
5345 Scope *S;
5346 UnqualifiedId &Id;
5347 Decl *ObjCImpDecl;
5348 };
5349
5350 ExprResult BuildMemberReferenceExpr(
5351 Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow,
5352 CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
5353 NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo,
5354 const TemplateArgumentListInfo *TemplateArgs,
5355 const Scope *S,
5356 ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);
5357
5358 ExprResult
5359 BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc,
5360 bool IsArrow, const CXXScopeSpec &SS,
5361 SourceLocation TemplateKWLoc,
5362 NamedDecl *FirstQualifierInScope, LookupResult &R,
5363 const TemplateArgumentListInfo *TemplateArgs,
5364 const Scope *S,
5365 bool SuppressQualifierCheck = false,
5366 ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);
5367
5368 ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,
5369 SourceLocation OpLoc,
5370 const CXXScopeSpec &SS, FieldDecl *Field,
5371 DeclAccessPair FoundDecl,
5372 const DeclarationNameInfo &MemberNameInfo);
5373
5374 ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow);
5375
5376 bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType,
5377 const CXXScopeSpec &SS,
5378 const LookupResult &R);
5379
5380 ExprResult ActOnDependentMemberExpr(Expr *Base, QualType BaseType,
5381 bool IsArrow, SourceLocation OpLoc,
5382 const CXXScopeSpec &SS,
5383 SourceLocation TemplateKWLoc,
5384 NamedDecl *FirstQualifierInScope,
5385 const DeclarationNameInfo &NameInfo,
5386 const TemplateArgumentListInfo *TemplateArgs);
5387
5388 ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base,
5389 SourceLocation OpLoc,
5390 tok::TokenKind OpKind,
5391 CXXScopeSpec &SS,
5392 SourceLocation TemplateKWLoc,
5393 UnqualifiedId &Member,
5394 Decl *ObjCImpDecl);
5395
5396 MemberExpr *
5397 BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc,
5398 const CXXScopeSpec *SS, SourceLocation TemplateKWLoc,
5399 ValueDecl *Member, DeclAccessPair FoundDecl,
5400 bool HadMultipleCandidates,
5401 const DeclarationNameInfo &MemberNameInfo, QualType Ty,
5402 ExprValueKind VK, ExprObjectKind OK,
5403 const TemplateArgumentListInfo *TemplateArgs = nullptr);
5404 MemberExpr *
5405 BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc,
5406 NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc,
5407 ValueDecl *Member, DeclAccessPair FoundDecl,
5408 bool HadMultipleCandidates,
5409 const DeclarationNameInfo &MemberNameInfo, QualType Ty,
5410 ExprValueKind VK, ExprObjectKind OK,
5411 const TemplateArgumentListInfo *TemplateArgs = nullptr);
5412
5413 void ActOnDefaultCtorInitializers(Decl *CDtorDecl);
5414 bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
5415 FunctionDecl *FDecl,
5416 const FunctionProtoType *Proto,
5417 ArrayRef<Expr *> Args,
5418 SourceLocation RParenLoc,
5419 bool ExecConfig = false);
5420 void CheckStaticArrayArgument(SourceLocation CallLoc,
5421 ParmVarDecl *Param,
5422 const Expr *ArgExpr);
5423
5424 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
5425 /// This provides the location of the left/right parens and a list of comma
5426 /// locations.
5427 ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
5428 MultiExprArg ArgExprs, SourceLocation RParenLoc,
5429 Expr *ExecConfig = nullptr);
5430 ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
5431 MultiExprArg ArgExprs, SourceLocation RParenLoc,
5432 Expr *ExecConfig = nullptr,
5433 bool IsExecConfig = false,
5434 bool AllowRecovery = false);
5435 Expr *BuildBuiltinCallExpr(SourceLocation Loc, Builtin::ID Id,
5436 MultiExprArg CallArgs);
5437 enum class AtomicArgumentOrder { API, AST };
5438 ExprResult
5439 BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
5440 SourceLocation RParenLoc, MultiExprArg Args,
5441 AtomicExpr::AtomicOp Op,
5442 AtomicArgumentOrder ArgOrder = AtomicArgumentOrder::API);
5443 ExprResult
5444 BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc,
5445 ArrayRef<Expr *> Arg, SourceLocation RParenLoc,
5446 Expr *Config = nullptr, bool IsExecConfig = false,
5447 ADLCallKind UsesADL = ADLCallKind::NotADL);
5448
5449 ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc,
5450 MultiExprArg ExecConfig,
5451 SourceLocation GGGLoc);
5452
5453 ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
5454 Declarator &D, ParsedType &Ty,
5455 SourceLocation RParenLoc, Expr *CastExpr);
5456 ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc,
5457 TypeSourceInfo *Ty,
5458 SourceLocation RParenLoc,
5459 Expr *Op);
5460 CastKind PrepareScalarCast(ExprResult &src, QualType destType);
5461
5462 /// Build an altivec or OpenCL literal.
5463 ExprResult BuildVectorLiteral(SourceLocation LParenLoc,
5464 SourceLocation RParenLoc, Expr *E,
5465 TypeSourceInfo *TInfo);
5466
5467 ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME);
5468
5469 ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,
5470 ParsedType Ty,
5471 SourceLocation RParenLoc,
5472 Expr *InitExpr);
5473
5474 ExprResult BuildCompoundLiteralExpr(SourceLocation LParenLoc,
5475 TypeSourceInfo *TInfo,
5476 SourceLocation RParenLoc,
5477 Expr *LiteralExpr);
5478
5479 ExprResult ActOnInitList(SourceLocation LBraceLoc,
5480 MultiExprArg InitArgList,
5481 SourceLocation RBraceLoc);
5482
5483 ExprResult BuildInitList(SourceLocation LBraceLoc,
5484 MultiExprArg InitArgList,
5485 SourceLocation RBraceLoc);
5486
5487 ExprResult ActOnDesignatedInitializer(Designation &Desig,
5488 SourceLocation EqualOrColonLoc,
5489 bool GNUSyntax,
5490 ExprResult Init);
5491
5492private:
5493 static BinaryOperatorKind ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind);
5494
5495public:
5496 ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
5497 tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr);
5498 ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc,
5499 BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr);
5500 ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc,
5501 Expr *LHSExpr, Expr *RHSExpr);
5502 void LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc,
5503 UnresolvedSetImpl &Functions);
5504
5505 void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc);
5506
5507 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
5508 /// in the case of a the GNU conditional expr extension.
5509 ExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
5510 SourceLocation ColonLoc,
5511 Expr *CondExpr, Expr *LHSExpr, Expr *RHSExpr);
5512
5513 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
5514 ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,
5515 LabelDecl *TheDecl);
5516
5517 void ActOnStartStmtExpr();
5518 ExprResult ActOnStmtExpr(Scope *S, SourceLocation LPLoc, Stmt *SubStmt,
5519 SourceLocation RPLoc);
5520 ExprResult BuildStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
5521 SourceLocation RPLoc, unsigned TemplateDepth);
5522 // Handle the final expression in a statement expression.
5523 ExprResult ActOnStmtExprResult(ExprResult E);
5524 void ActOnStmtExprError();
5525
5526 // __builtin_offsetof(type, identifier(.identifier|[expr])*)
5527 struct OffsetOfComponent {
5528 SourceLocation LocStart, LocEnd;
5529 bool isBrackets; // true if [expr], false if .ident
5530 union {
5531 IdentifierInfo *IdentInfo;
5532 Expr *E;
5533 } U;
5534 };
5535
5536 /// __builtin_offsetof(type, a.b[123][456].c)
5537 ExprResult BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
5538 TypeSourceInfo *TInfo,
5539 ArrayRef<OffsetOfComponent> Components,
5540 SourceLocation RParenLoc);
5541 ExprResult ActOnBuiltinOffsetOf(Scope *S,
5542 SourceLocation BuiltinLoc,
5543 SourceLocation TypeLoc,
5544 ParsedType ParsedArgTy,
5545 ArrayRef<OffsetOfComponent> Components,
5546 SourceLocation RParenLoc);
5547
5548 // __builtin_choose_expr(constExpr, expr1, expr2)
5549 ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
5550 Expr *CondExpr, Expr *LHSExpr,
5551 Expr *RHSExpr, SourceLocation RPLoc);
5552
5553 // __builtin_va_arg(expr, type)
5554 ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,
5555 SourceLocation RPLoc);
5556 ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,
5557 TypeSourceInfo *TInfo, SourceLocation RPLoc);
5558
5559 // __builtin_LINE(), __builtin_FUNCTION(), __builtin_FILE(),
5560 // __builtin_COLUMN()
5561 ExprResult ActOnSourceLocExpr(SourceLocExpr::IdentKind Kind,
5562 SourceLocation BuiltinLoc,
5563 SourceLocation RPLoc);
5564
5565 // Build a potentially resolved SourceLocExpr.
5566 ExprResult BuildSourceLocExpr(SourceLocExpr::IdentKind Kind,
5567 SourceLocation BuiltinLoc, SourceLocation RPLoc,
5568 DeclContext *ParentContext);
5569
5570 // __null
5571 ExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);
5572
5573 bool CheckCaseExpression(Expr *E);
5574
5575 /// Describes the result of an "if-exists" condition check.
5576 enum IfExistsResult {
5577 /// The symbol exists.
5578 IER_Exists,
5579
5580 /// The symbol does not exist.
5581 IER_DoesNotExist,
5582
5583 /// The name is a dependent name, so the results will differ
5584 /// from one instantiation to the next.
5585 IER_Dependent,
5586
5587 /// An error occurred.
5588 IER_Error
5589 };
5590
5591 IfExistsResult
5592 CheckMicrosoftIfExistsSymbol(Scope *S, CXXScopeSpec &SS,
5593 const DeclarationNameInfo &TargetNameInfo);
5594
5595 IfExistsResult
5596 CheckMicrosoftIfExistsSymbol(Scope *S, SourceLocation KeywordLoc,
5597 bool IsIfExists, CXXScopeSpec &SS,
5598 UnqualifiedId &Name);
5599
5600 StmtResult BuildMSDependentExistsStmt(SourceLocation KeywordLoc,
5601 bool IsIfExists,
5602 NestedNameSpecifierLoc QualifierLoc,
5603 DeclarationNameInfo NameInfo,
5604 Stmt *Nested);
5605 StmtResult ActOnMSDependentExistsStmt(SourceLocation KeywordLoc,
5606 bool IsIfExists,
5607 CXXScopeSpec &SS, UnqualifiedId &Name,
5608 Stmt *Nested);
5609
5610 //===------------------------- "Block" Extension ------------------------===//
5611
5612 /// ActOnBlockStart - This callback is invoked when a block literal is
5613 /// started.
5614 void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);
5615
5616 /// ActOnBlockArguments - This callback allows processing of block arguments.
5617 /// If there are no arguments, this is still invoked.
5618 void ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
5619 Scope *CurScope);
5620
5621 /// ActOnBlockError - If there is an error parsing a block, this callback
5622 /// is invoked to pop the information about the block from the action impl.
5623 void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);
5624
5625 /// ActOnBlockStmtExpr - This is called when the body of a block statement
5626 /// literal was successfully completed. ^(int x){...}
5627 ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
5628 Scope *CurScope);
5629
5630 //===---------------------------- Clang Extensions ----------------------===//
5631
5632 /// __builtin_convertvector(...)
5633 ExprResult ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,
5634 SourceLocation BuiltinLoc,
5635 SourceLocation RParenLoc);
5636
5637 //===---------------------------- OpenCL Features -----------------------===//
5638
5639 /// __builtin_astype(...)
5640 ExprResult ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
5641 SourceLocation BuiltinLoc,
5642 SourceLocation RParenLoc);
5643 ExprResult BuildAsTypeExpr(Expr *E, QualType DestTy,
5644 SourceLocation BuiltinLoc,
5645 SourceLocation RParenLoc);
5646
5647 //===---------------------------- C++ Features --------------------------===//
5648
5649 // Act on C++ namespaces
5650 Decl *ActOnStartNamespaceDef(Scope *S, SourceLocation InlineLoc,
5651 SourceLocation NamespaceLoc,
5652 SourceLocation IdentLoc, IdentifierInfo *Ident,
5653 SourceLocation LBrace,
5654 const ParsedAttributesView &AttrList,
5655 UsingDirectiveDecl *&UsingDecl);
5656 void ActOnFinishNamespaceDef(Decl *Dcl, SourceLocation RBrace);
5657
5658 NamespaceDecl *getStdNamespace() const;
5659 NamespaceDecl *getOrCreateStdNamespace();
5660
5661 NamespaceDecl *lookupStdExperimentalNamespace();
5662
5663 CXXRecordDecl *getStdBadAlloc() const;
5664 EnumDecl *getStdAlignValT() const;
5665
5666private:
5667 // A cache representing if we've fully checked the various comparison category
5668 // types stored in ASTContext. The bit-index corresponds to the integer value
5669 // of a ComparisonCategoryType enumerator.
5670 llvm::SmallBitVector FullyCheckedComparisonCategories;
5671
5672 ValueDecl *tryLookupCtorInitMemberDecl(CXXRecordDecl *ClassDecl,
5673 CXXScopeSpec &SS,
5674 ParsedType TemplateTypeTy,
5675 IdentifierInfo *MemberOrBase);
5676
5677public:
5678 enum class ComparisonCategoryUsage {
5679 /// The '<=>' operator was used in an expression and a builtin operator
5680 /// was selected.
5681 OperatorInExpression,
5682 /// A defaulted 'operator<=>' needed the comparison category. This
5683 /// typically only applies to 'std::strong_ordering', due to the implicit
5684 /// fallback return value.
5685 DefaultedOperator,
5686 };
5687
5688 /// Lookup the specified comparison category types in the standard
5689 /// library, an check the VarDecls possibly returned by the operator<=>
5690 /// builtins for that type.
5691 ///
5692 /// \return The type of the comparison category type corresponding to the
5693 /// specified Kind, or a null type if an error occurs
5694 QualType CheckComparisonCategoryType(ComparisonCategoryType Kind,
5695 SourceLocation Loc,
5696 ComparisonCategoryUsage Usage);
5697
5698 /// Tests whether Ty is an instance of std::initializer_list and, if
5699 /// it is and Element is not NULL, assigns the element type to Element.
5700 bool isStdInitializerList(QualType Ty, QualType *Element);
5701
5702 /// Looks for the std::initializer_list template and instantiates it
5703 /// with Element, or emits an error if it's not found.
5704 ///
5705 /// \returns The instantiated template, or null on error.
5706 QualType BuildStdInitializerList(QualType Element, SourceLocation Loc);
5707
5708 /// Determine whether Ctor is an initializer-list constructor, as
5709 /// defined in [dcl.init.list]p2.
5710 bool isInitListConstructor(const FunctionDecl *Ctor);
5711
5712 Decl *ActOnUsingDirective(Scope *CurScope, SourceLocation UsingLoc,
5713 SourceLocation NamespcLoc, CXXScopeSpec &SS,
5714 SourceLocation IdentLoc,
5715 IdentifierInfo *NamespcName,
5716 const ParsedAttributesView &AttrList);
5717
5718 void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir);
5719
5720 Decl *ActOnNamespaceAliasDef(Scope *CurScope,
5721 SourceLocation NamespaceLoc,
5722 SourceLocation AliasLoc,
5723 IdentifierInfo *Alias,
5724 CXXScopeSpec &SS,
5725 SourceLocation IdentLoc,
5726 IdentifierInfo *Ident);
5727
5728 void FilterUsingLookup(Scope *S, LookupResult &lookup);
5729 void HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow);
5730 bool CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Target,
5731 const LookupResult &PreviousDecls,
5732 UsingShadowDecl *&PrevShadow);
5733 UsingShadowDecl *BuildUsingShadowDecl(Scope *S, BaseUsingDecl *BUD,
5734 NamedDecl *Target,
5735 UsingShadowDecl *PrevDecl);
5736
5737 bool CheckUsingDeclRedeclaration(SourceLocation UsingLoc,
5738 bool HasTypenameKeyword,
5739 const CXXScopeSpec &SS,
5740 SourceLocation NameLoc,
5741 const LookupResult &Previous);
5742 bool CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename,
5743 const CXXScopeSpec &SS,
5744 const DeclarationNameInfo &NameInfo,
5745 SourceLocation NameLoc,
5746 const LookupResult *R = nullptr,
5747 const UsingDecl *UD = nullptr);
5748
5749 NamedDecl *BuildUsingDeclaration(
5750 Scope *S, AccessSpecifier AS, SourceLocation UsingLoc,
5751 bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS,
5752 DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc,
5753 const ParsedAttributesView &AttrList, bool IsInstantiation,
5754 bool IsUsingIfExists);
5755 NamedDecl *BuildUsingEnumDeclaration(Scope *S, AccessSpecifier AS,
5756 SourceLocation UsingLoc,
5757 SourceLocation EnumLoc,
5758 SourceLocation NameLoc, EnumDecl *ED);
5759 NamedDecl *BuildUsingPackDecl(NamedDecl *InstantiatedFrom,
5760 ArrayRef<NamedDecl *> Expansions);
5761
5762 bool CheckInheritingConstructorUsingDecl(UsingDecl *UD);
5763
5764 /// Given a derived-class using shadow declaration for a constructor and the
5765 /// correspnding base class constructor, find or create the implicit
5766 /// synthesized derived class constructor to use for this initialization.
5767 CXXConstructorDecl *
5768 findInheritingConstructor(SourceLocation Loc, CXXConstructorDecl *BaseCtor,
5769 ConstructorUsingShadowDecl *DerivedShadow);
5770
5771 Decl *ActOnUsingDeclaration(Scope *CurScope, AccessSpecifier AS,
5772 SourceLocation UsingLoc,
5773 SourceLocation TypenameLoc, CXXScopeSpec &SS,
5774 UnqualifiedId &Name, SourceLocation EllipsisLoc,
5775 const ParsedAttributesView &AttrList);
5776 Decl *ActOnUsingEnumDeclaration(Scope *CurScope, AccessSpecifier AS,
5777 SourceLocation UsingLoc,
5778 SourceLocation EnumLoc, const DeclSpec &);
5779 Decl *ActOnAliasDeclaration(Scope *CurScope, AccessSpecifier AS,
5780 MultiTemplateParamsArg TemplateParams,
5781 SourceLocation UsingLoc, UnqualifiedId &Name,
5782 const ParsedAttributesView &AttrList,
5783 TypeResult Type, Decl *DeclFromDeclSpec);
5784
5785 /// BuildCXXConstructExpr - Creates a complete call to a constructor,
5786 /// including handling of its default argument expressions.
5787 ///
5788 /// \param ConstructKind - a CXXConstructExpr::ConstructionKind
5789 ExprResult
5790 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
5791 NamedDecl *FoundDecl,
5792 CXXConstructorDecl *Constructor, MultiExprArg Exprs,
5793 bool HadMultipleCandidates, bool IsListInitialization,
5794 bool IsStdInitListInitialization,
5795 bool RequiresZeroInit, unsigned ConstructKind,
5796 SourceRange ParenRange);
5797
5798 /// Build a CXXConstructExpr whose constructor has already been resolved if
5799 /// it denotes an inherited constructor.
5800 ExprResult
5801 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
5802 CXXConstructorDecl *Constructor, bool Elidable,
5803 MultiExprArg Exprs,
5804 bool HadMultipleCandidates, bool IsListInitialization,
5805 bool IsStdInitListInitialization,
5806 bool RequiresZeroInit, unsigned ConstructKind,
5807 SourceRange ParenRange);
5808
5809 // FIXME: Can we remove this and have the above BuildCXXConstructExpr check if
5810 // the constructor can be elidable?
5811 ExprResult
5812 BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
5813 NamedDecl *FoundDecl,
5814 CXXConstructorDecl *Constructor, bool Elidable,
5815 MultiExprArg Exprs, bool HadMultipleCandidates,
5816 bool IsListInitialization,
5817 bool IsStdInitListInitialization, bool RequiresZeroInit,
5818 unsigned ConstructKind, SourceRange ParenRange);
5819
5820 ExprResult BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field);
5821
5822
5823 /// Instantiate or parse a C++ default argument expression as necessary.
5824 /// Return true on error.
5825 bool CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
5826 ParmVarDecl *Param);
5827
5828 /// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating
5829 /// the default expr if needed.
5830 ExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc,
5831 FunctionDecl *FD,
5832 ParmVarDecl *Param);
5833
5834 /// FinalizeVarWithDestructor - Prepare for calling destructor on the
5835 /// constructed variable.
5836 void FinalizeVarWithDestructor(VarDecl *VD, const RecordType *DeclInitType);
5837
5838 /// Helper class that collects exception specifications for
5839 /// implicitly-declared special member functions.
5840 class ImplicitExceptionSpecification {
5841 // Pointer to allow copying
5842 Sema *Self;
5843 // We order exception specifications thus:
5844 // noexcept is the most restrictive, but is only used in C++11.
5845 // throw() comes next.
5846 // Then a throw(collected exceptions)
5847 // Finally no specification, which is expressed as noexcept(false).
5848 // throw(...) is used instead if any called function uses it.
5849 ExceptionSpecificationType ComputedEST;
5850 llvm::SmallPtrSet<CanQualType, 4> ExceptionsSeen;
5851 SmallVector<QualType, 4> Exceptions;
5852
5853 void ClearExceptions() {
5854 ExceptionsSeen.clear();
5855 Exceptions.clear();
5856 }
5857
5858 public:
5859 explicit ImplicitExceptionSpecification(Sema &Self)
5860 : Self(&Self), ComputedEST(EST_BasicNoexcept) {
5861 if (!Self.getLangOpts().CPlusPlus11)
5862 ComputedEST = EST_DynamicNone;
5863 }
5864
5865 /// Get the computed exception specification type.
5866 ExceptionSpecificationType getExceptionSpecType() const {
5867 assert(!isComputedNoexcept(ComputedEST) &&((void)0)
5868 "noexcept(expr) should not be a possible result")((void)0);
5869 return ComputedEST;
5870 }
5871
5872 /// The number of exceptions in the exception specification.
5873 unsigned size() const { return Exceptions.size(); }
5874
5875 /// The set of exceptions in the exception specification.
5876 const QualType *data() const { return Exceptions.data(); }
5877
5878 /// Integrate another called method into the collected data.
5879 void CalledDecl(SourceLocation CallLoc, const CXXMethodDecl *Method);
5880
5881 /// Integrate an invoked expression into the collected data.
5882 void CalledExpr(Expr *E) { CalledStmt(E); }
5883
5884 /// Integrate an invoked statement into the collected data.
5885 void CalledStmt(Stmt *S);
5886
5887 /// Overwrite an EPI's exception specification with this
5888 /// computed exception specification.
5889 FunctionProtoType::ExceptionSpecInfo getExceptionSpec() const {
5890 FunctionProtoType::ExceptionSpecInfo ESI;
5891 ESI.Type = getExceptionSpecType();
5892 if (ESI.Type == EST_Dynamic) {
5893 ESI.Exceptions = Exceptions;
5894 } else if (ESI.Type == EST_None) {
5895 /// C++11 [except.spec]p14:
5896 /// The exception-specification is noexcept(false) if the set of
5897 /// potential exceptions of the special member function contains "any"
5898 ESI.Type = EST_NoexceptFalse;
5899 ESI.NoexceptExpr = Self->ActOnCXXBoolLiteral(SourceLocation(),
5900 tok::kw_false).get();
5901 }
5902 return ESI;
5903 }
5904 };
5905
5906 /// Evaluate the implicit exception specification for a defaulted
5907 /// special member function.
5908 void EvaluateImplicitExceptionSpec(SourceLocation Loc, FunctionDecl *FD);
5909
5910 /// Check the given noexcept-specifier, convert its expression, and compute
5911 /// the appropriate ExceptionSpecificationType.
5912 ExprResult ActOnNoexceptSpec(SourceLocation NoexceptLoc, Expr *NoexceptExpr,
5913 ExceptionSpecificationType &EST);
5914
5915 /// Check the given exception-specification and update the
5916 /// exception specification information with the results.
5917 void checkExceptionSpecification(bool IsTopLevel,
5918 ExceptionSpecificationType EST,
5919 ArrayRef<ParsedType> DynamicExceptions,
5920 ArrayRef<SourceRange> DynamicExceptionRanges,
5921 Expr *NoexceptExpr,
5922 SmallVectorImpl<QualType> &Exceptions,
5923 FunctionProtoType::ExceptionSpecInfo &ESI);
5924
5925 /// Determine if we're in a case where we need to (incorrectly) eagerly
5926 /// parse an exception specification to work around a libstdc++ bug.
5927 bool isLibstdcxxEagerExceptionSpecHack(const Declarator &D);
5928
5929 /// Add an exception-specification to the given member function
5930 /// (or member function template). The exception-specification was parsed
5931 /// after the method itself was declared.
5932 void actOnDelayedExceptionSpecification(Decl *Method,
5933 ExceptionSpecificationType EST,
5934 SourceRange SpecificationRange,
5935 ArrayRef<ParsedType> DynamicExceptions,
5936 ArrayRef<SourceRange> DynamicExceptionRanges,
5937 Expr *NoexceptExpr);
5938
5939 class InheritedConstructorInfo;
5940
5941 /// Determine if a special member function should have a deleted
5942 /// definition when it is defaulted.
5943 bool ShouldDeleteSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM,
5944 InheritedConstructorInfo *ICI = nullptr,
5945 bool Diagnose = false);
5946
5947 /// Produce notes explaining why a defaulted function was defined as deleted.
5948 void DiagnoseDeletedDefaultedFunction(FunctionDecl *FD);
5949
5950 /// Declare the implicit default constructor for the given class.
5951 ///
5952 /// \param ClassDecl The class declaration into which the implicit
5953 /// default constructor will be added.
5954 ///
5955 /// \returns The implicitly-declared default constructor.
5956 CXXConstructorDecl *DeclareImplicitDefaultConstructor(
5957 CXXRecordDecl *ClassDecl);
5958
5959 /// DefineImplicitDefaultConstructor - Checks for feasibility of
5960 /// defining this constructor as the default constructor.
5961 void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
5962 CXXConstructorDecl *Constructor);
5963
5964 /// Declare the implicit destructor for the given class.
5965 ///
5966 /// \param ClassDecl The class declaration into which the implicit
5967 /// destructor will be added.
5968 ///
5969 /// \returns The implicitly-declared destructor.
5970 CXXDestructorDecl *DeclareImplicitDestructor(CXXRecordDecl *ClassDecl);
5971
5972 /// DefineImplicitDestructor - Checks for feasibility of
5973 /// defining this destructor as the default destructor.
5974 void DefineImplicitDestructor(SourceLocation CurrentLocation,
5975 CXXDestructorDecl *Destructor);
5976
5977 /// Build an exception spec for destructors that don't have one.
5978 ///
5979 /// C++11 says that user-defined destructors with no exception spec get one
5980 /// that looks as if the destructor was implicitly declared.
5981 void AdjustDestructorExceptionSpec(CXXDestructorDecl *Destructor);
5982
5983 /// Define the specified inheriting constructor.
5984 void DefineInheritingConstructor(SourceLocation UseLoc,
5985 CXXConstructorDecl *Constructor);
5986
5987 /// Declare the implicit copy constructor for the given class.
5988 ///
5989 /// \param ClassDecl The class declaration into which the implicit
5990 /// copy constructor will be added.
5991 ///
5992 /// \returns The implicitly-declared copy constructor.
5993 CXXConstructorDecl *DeclareImplicitCopyConstructor(CXXRecordDecl *ClassDecl);
5994
5995 /// DefineImplicitCopyConstructor - Checks for feasibility of
5996 /// defining this constructor as the copy constructor.
5997 void DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
5998 CXXConstructorDecl *Constructor);
5999
6000 /// Declare the implicit move constructor for the given class.
6001 ///
6002 /// \param ClassDecl The Class declaration into which the implicit
6003 /// move constructor will be added.
6004 ///
6005 /// \returns The implicitly-declared move constructor, or NULL if it wasn't
6006 /// declared.
6007 CXXConstructorDecl *DeclareImplicitMoveConstructor(CXXRecordDecl *ClassDecl);
6008
6009 /// DefineImplicitMoveConstructor - Checks for feasibility of
6010 /// defining this constructor as the move constructor.
6011 void DefineImplicitMoveConstructor(SourceLocation CurrentLocation,
6012 CXXConstructorDecl *Constructor);
6013
6014 /// Declare the implicit copy assignment operator for the given class.
6015 ///
6016 /// \param ClassDecl The class declaration into which the implicit
6017 /// copy assignment operator will be added.
6018 ///
6019 /// \returns The implicitly-declared copy assignment operator.
6020 CXXMethodDecl *DeclareImplicitCopyAssignment(CXXRecordDecl *ClassDecl);
6021
6022 /// Defines an implicitly-declared copy assignment operator.
6023 void DefineImplicitCopyAssignment(SourceLocation CurrentLocation,
6024 CXXMethodDecl *MethodDecl);
6025
6026 /// Declare the implicit move assignment operator for the given class.
6027 ///
6028 /// \param ClassDecl The Class declaration into which the implicit
6029 /// move assignment operator will be added.
6030 ///
6031 /// \returns The implicitly-declared move assignment operator, or NULL if it
6032 /// wasn't declared.
6033 CXXMethodDecl *DeclareImplicitMoveAssignment(CXXRecordDecl *ClassDecl);
6034
6035 /// Defines an implicitly-declared move assignment operator.
6036 void DefineImplicitMoveAssignment(SourceLocation CurrentLocation,
6037 CXXMethodDecl *MethodDecl);
6038
6039 /// Force the declaration of any implicitly-declared members of this
6040 /// class.
6041 void ForceDeclarationOfImplicitMembers(CXXRecordDecl *Class);
6042
6043 /// Check a completed declaration of an implicit special member.
6044 void CheckImplicitSpecialMemberDeclaration(Scope *S, FunctionDecl *FD);
6045
6046 /// Determine whether the given function is an implicitly-deleted
6047 /// special member function.
6048 bool isImplicitlyDeleted(FunctionDecl *FD);
6049
6050 /// Check whether 'this' shows up in the type of a static member
6051 /// function after the (naturally empty) cv-qualifier-seq would be.
6052 ///
6053 /// \returns true if an error occurred.
6054 bool checkThisInStaticMemberFunctionType(CXXMethodDecl *Method);
6055
6056 /// Whether this' shows up in the exception specification of a static
6057 /// member function.
6058 bool checkThisInStaticMemberFunctionExceptionSpec(CXXMethodDecl *Method);
6059
6060 /// Check whether 'this' shows up in the attributes of the given
6061 /// static member function.
6062 ///
6063 /// \returns true if an error occurred.
6064 bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method);
6065
6066 /// MaybeBindToTemporary - If the passed in expression has a record type with
6067 /// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise
6068 /// it simply returns the passed in expression.
6069 ExprResult MaybeBindToTemporary(Expr *E);
6070
6071 /// Wrap the expression in a ConstantExpr if it is a potential immediate
6072 /// invocation.
6073 ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl);
6074
6075 bool CompleteConstructorCall(CXXConstructorDecl *Constructor,
6076 QualType DeclInitType, MultiExprArg ArgsPtr,
6077 SourceLocation Loc,
6078 SmallVectorImpl<Expr *> &ConvertedArgs,
6079 bool AllowExplicit = false,
6080 bool IsListInitialization = false);
6081
6082 ParsedType getInheritingConstructorName(CXXScopeSpec &SS,
6083 SourceLocation NameLoc,
6084 IdentifierInfo &Name);
6085
6086 ParsedType getConstructorName(IdentifierInfo &II, SourceLocation NameLoc,
6087 Scope *S, CXXScopeSpec &SS,
6088 bool EnteringContext);
6089 ParsedType getDestructorName(SourceLocation TildeLoc,
6090 IdentifierInfo &II, SourceLocation NameLoc,
6091 Scope *S, CXXScopeSpec &SS,
6092 ParsedType ObjectType,
6093 bool EnteringContext);
6094
6095 ParsedType getDestructorTypeForDecltype(const DeclSpec &DS,
6096 ParsedType ObjectType);
6097
6098 // Checks that reinterpret casts don't have undefined behavior.
6099 void CheckCompatibleReinterpretCast(QualType SrcType, QualType DestType,
6100 bool IsDereference, SourceRange Range);
6101
6102 // Checks that the vector type should be initialized from a scalar
6103 // by splatting the value rather than populating a single element.
6104 // This is the case for AltiVecVector types as well as with
6105 // AltiVecPixel and AltiVecBool when -faltivec-src-compat=xl is specified.
6106 bool ShouldSplatAltivecScalarInCast(const VectorType *VecTy);
6107
6108 /// ActOnCXXNamedCast - Parse
6109 /// {dynamic,static,reinterpret,const,addrspace}_cast's.
6110 ExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
6111 tok::TokenKind Kind,
6112 SourceLocation LAngleBracketLoc,
6113 Declarator &D,
6114 SourceLocation RAngleBracketLoc,
6115 SourceLocation LParenLoc,
6116 Expr *E,
6117 SourceLocation RParenLoc);
6118
6119 ExprResult BuildCXXNamedCast(SourceLocation OpLoc,
6120 tok::TokenKind Kind,
6121 TypeSourceInfo *Ty,
6122 Expr *E,
6123 SourceRange AngleBrackets,
6124 SourceRange Parens);
6125
6126 ExprResult ActOnBuiltinBitCastExpr(SourceLocation KWLoc, Declarator &Dcl,
6127 ExprResult Operand,
6128 SourceLocation RParenLoc);
6129
6130 ExprResult BuildBuiltinBitCastExpr(SourceLocation KWLoc, TypeSourceInfo *TSI,
6131 Expr *Operand, SourceLocation RParenLoc);
6132
6133 ExprResult BuildCXXTypeId(QualType TypeInfoType,
6134 SourceLocation TypeidLoc,
6135 TypeSourceInfo *Operand,
6136 SourceLocation RParenLoc);
6137 ExprResult BuildCXXTypeId(QualType TypeInfoType,
6138 SourceLocation TypeidLoc,
6139 Expr *Operand,
6140 SourceLocation RParenLoc);
6141
6142 /// ActOnCXXTypeid - Parse typeid( something ).
6143 ExprResult ActOnCXXTypeid(SourceLocation OpLoc,
6144 SourceLocation LParenLoc, bool isType,
6145 void *TyOrExpr,
6146 SourceLocation RParenLoc);
6147
6148 ExprResult BuildCXXUuidof(QualType TypeInfoType,
6149 SourceLocation TypeidLoc,
6150 TypeSourceInfo *Operand,
6151 SourceLocation RParenLoc);
6152 ExprResult BuildCXXUuidof(QualType TypeInfoType,
6153 SourceLocation TypeidLoc,
6154 Expr *Operand,
6155 SourceLocation RParenLoc);
6156
6157 /// ActOnCXXUuidof - Parse __uuidof( something ).
6158 ExprResult ActOnCXXUuidof(SourceLocation OpLoc,
6159 SourceLocation LParenLoc, bool isType,
6160 void *TyOrExpr,
6161 SourceLocation RParenLoc);
6162
6163 /// Handle a C++1z fold-expression: ( expr op ... op expr ).
6164 ExprResult ActOnCXXFoldExpr(Scope *S, SourceLocation LParenLoc, Expr *LHS,
6165 tok::TokenKind Operator,
6166 SourceLocation EllipsisLoc, Expr *RHS,
6167 SourceLocation RParenLoc);
6168 ExprResult BuildCXXFoldExpr(UnresolvedLookupExpr *Callee,
6169 SourceLocation LParenLoc, Expr *LHS,
6170 BinaryOperatorKind Operator,
6171 SourceLocation EllipsisLoc, Expr *RHS,
6172 SourceLocation RParenLoc,
6173 Optional<unsigned> NumExpansions);
6174 ExprResult BuildEmptyCXXFoldExpr(SourceLocation EllipsisLoc,
6175 BinaryOperatorKind Operator);
6176
6177 //// ActOnCXXThis - Parse 'this' pointer.
6178 ExprResult ActOnCXXThis(SourceLocation loc);
6179
6180 /// Build a CXXThisExpr and mark it referenced in the current context.
6181 Expr *BuildCXXThisExpr(SourceLocation Loc, QualType Type, bool IsImplicit);
6182 void MarkThisReferenced(CXXThisExpr *This);
6183
6184 /// Try to retrieve the type of the 'this' pointer.
6185 ///
6186 /// \returns The type of 'this', if possible. Otherwise, returns a NULL type.
6187 QualType getCurrentThisType();
6188
6189 /// When non-NULL, the C++ 'this' expression is allowed despite the
6190 /// current context not being a non-static member function. In such cases,
6191 /// this provides the type used for 'this'.
6192 QualType CXXThisTypeOverride;
6193
6194 /// RAII object used to temporarily allow the C++ 'this' expression
6195 /// to be used, with the given qualifiers on the current class type.
6196 class CXXThisScopeRAII {
6197 Sema &S;
6198 QualType OldCXXThisTypeOverride;
6199 bool Enabled;
6200
6201 public:
6202 /// Introduce a new scope where 'this' may be allowed (when enabled),
6203 /// using the given declaration (which is either a class template or a
6204 /// class) along with the given qualifiers.
6205 /// along with the qualifiers placed on '*this'.
6206 CXXThisScopeRAII(Sema &S, Decl *ContextDecl, Qualifiers CXXThisTypeQuals,
6207 bool Enabled = true);
6208
6209 ~CXXThisScopeRAII();
6210 };
6211
6212 /// Make sure the value of 'this' is actually available in the current
6213 /// context, if it is a potentially evaluated context.
6214 ///
6215 /// \param Loc The location at which the capture of 'this' occurs.
6216 ///
6217 /// \param Explicit Whether 'this' is explicitly captured in a lambda
6218 /// capture list.
6219 ///
6220 /// \param FunctionScopeIndexToStopAt If non-null, it points to the index
6221 /// of the FunctionScopeInfo stack beyond which we do not attempt to capture.
6222 /// This is useful when enclosing lambdas must speculatively capture
6223 /// 'this' that may or may not be used in certain specializations of
6224 /// a nested generic lambda (depending on whether the name resolves to
6225 /// a non-static member function or a static function).
6226 /// \return returns 'true' if failed, 'false' if success.
6227 bool CheckCXXThisCapture(SourceLocation Loc, bool Explicit = false,
6228 bool BuildAndDiagnose = true,
6229 const unsigned *const FunctionScopeIndexToStopAt = nullptr,
6230 bool ByCopy = false);
6231
6232 /// Determine whether the given type is the type of *this that is used
6233 /// outside of the body of a member function for a type that is currently
6234 /// being defined.
6235 bool isThisOutsideMemberFunctionBody(QualType BaseType);
6236
6237 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
6238 ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);
6239
6240
6241 /// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
6242 ExprResult ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind);
6243
6244 ExprResult
6245 ActOnObjCAvailabilityCheckExpr(llvm::ArrayRef<AvailabilitySpec> AvailSpecs,
6246 SourceLocation AtLoc, SourceLocation RParen);
6247
6248 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
6249 ExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc);
6250
6251 //// ActOnCXXThrow - Parse throw expressions.
6252 ExprResult ActOnCXXThrow(Scope *S, SourceLocation OpLoc, Expr *expr);
6253 ExprResult BuildCXXThrow(SourceLocation OpLoc, Expr *Ex,
6254 bool IsThrownVarInScope);
6255 bool CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ThrowTy, Expr *E);
6256
6257 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
6258 /// Can be interpreted either as function-style casting ("int(x)")
6259 /// or class type construction ("ClassType(x,y,z)")
6260 /// or creation of a value-initialized type ("int()").
6261 ExprResult ActOnCXXTypeConstructExpr(ParsedType TypeRep,
6262 SourceLocation LParenOrBraceLoc,
6263 MultiExprArg Exprs,
6264 SourceLocation RParenOrBraceLoc,
6265 bool ListInitialization);
6266
6267 ExprResult BuildCXXTypeConstructExpr(TypeSourceInfo *Type,
6268 SourceLocation LParenLoc,
6269 MultiExprArg Exprs,
6270 SourceLocation RParenLoc,
6271 bool ListInitialization);
6272
6273 /// ActOnCXXNew - Parsed a C++ 'new' expression.
6274 ExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
6275 SourceLocation PlacementLParen,
6276 MultiExprArg PlacementArgs,
6277 SourceLocation PlacementRParen,
6278 SourceRange TypeIdParens, Declarator &D,
6279 Expr *Initializer);
6280 ExprResult BuildCXXNew(SourceRange Range, bool UseGlobal,
6281 SourceLocation PlacementLParen,
6282 MultiExprArg PlacementArgs,
6283 SourceLocation PlacementRParen,
6284 SourceRange TypeIdParens,
6285 QualType AllocType,
6286 TypeSourceInfo *AllocTypeInfo,
6287 Optional<Expr *> ArraySize,
6288 SourceRange DirectInitRange,
6289 Expr *Initializer);
6290
6291 /// Determine whether \p FD is an aligned allocation or deallocation
6292 /// function that is unavailable.
6293 bool isUnavailableAlignedAllocationFunction(const FunctionDecl &FD) const;
6294
6295 /// Produce diagnostics if \p FD is an aligned allocation or deallocation
6296 /// function that is unavailable.
6297 void diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD,
6298 SourceLocation Loc);
6299
6300 bool CheckAllocatedType(QualType AllocType, SourceLocation Loc,
6301 SourceRange R);
6302
6303 /// The scope in which to find allocation functions.
6304 enum AllocationFunctionScope {
6305 /// Only look for allocation functions in the global scope.
6306 AFS_Global,
6307 /// Only look for allocation functions in the scope of the
6308 /// allocated class.
6309 AFS_Class,
6310 /// Look for allocation functions in both the global scope
6311 /// and in the scope of the allocated class.
6312 AFS_Both
6313 };
6314
6315 /// Finds the overloads of operator new and delete that are appropriate
6316 /// for the allocation.
6317 bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
6318 AllocationFunctionScope NewScope,
6319 AllocationFunctionScope DeleteScope,
6320 QualType AllocType, bool IsArray,
6321 bool &PassAlignment, MultiExprArg PlaceArgs,
6322 FunctionDecl *&OperatorNew,
6323 FunctionDecl *&OperatorDelete,
6324 bool Diagnose = true);
6325 void DeclareGlobalNewDelete();
6326 void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,
6327 ArrayRef<QualType> Params);
6328
6329 bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
6330 DeclarationName Name, FunctionDecl* &Operator,
6331 bool Diagnose = true);
6332 FunctionDecl *FindUsualDeallocationFunction(SourceLocation StartLoc,
6333 bool CanProvideSize,
6334 bool Overaligned,
6335 DeclarationName Name);
6336 FunctionDecl *FindDeallocationFunctionForDestructor(SourceLocation StartLoc,
6337 CXXRecordDecl *RD);
6338
6339 /// ActOnCXXDelete - Parsed a C++ 'delete' expression
6340 ExprResult ActOnCXXDelete(SourceLocation StartLoc,
6341 bool UseGlobal, bool ArrayForm,
6342 Expr *Operand);
6343 void CheckVirtualDtorCall(CXXDestructorDecl *dtor, SourceLocation Loc,
6344 bool IsDelete, bool CallCanBeVirtual,
6345 bool WarnOnNonAbstractTypes,
6346 SourceLocation DtorLoc);
6347
6348 ExprResult ActOnNoexceptExpr(SourceLocation KeyLoc, SourceLocation LParen,
6349 Expr *Operand, SourceLocation RParen);
6350 ExprResult BuildCXXNoexceptExpr(SourceLocation KeyLoc, Expr *Operand,
6351 SourceLocation RParen);
6352
6353 /// Parsed one of the type trait support pseudo-functions.
6354 ExprResult ActOnTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
6355 ArrayRef<ParsedType> Args,
6356 SourceLocation RParenLoc);
6357 ExprResult BuildTypeTrait(TypeTrait Kind, SourceLocation KWLoc,
6358 ArrayRef<TypeSourceInfo *> Args,
6359 SourceLocation RParenLoc);
6360
6361 /// ActOnArrayTypeTrait - Parsed one of the binary type trait support
6362 /// pseudo-functions.
6363 ExprResult ActOnArrayTypeTrait(ArrayTypeTrait ATT,
6364 SourceLocation KWLoc,
6365 ParsedType LhsTy,
6366 Expr *DimExpr,
6367 SourceLocation RParen);
6368
6369 ExprResult BuildArrayTypeTrait(ArrayTypeTrait ATT,
6370 SourceLocation KWLoc,
6371 TypeSourceInfo *TSInfo,
6372 Expr *DimExpr,
6373 SourceLocation RParen);
6374
6375 /// ActOnExpressionTrait - Parsed one of the unary type trait support
6376 /// pseudo-functions.
6377 ExprResult ActOnExpressionTrait(ExpressionTrait OET,
6378 SourceLocation KWLoc,
6379 Expr *Queried,
6380 SourceLocation RParen);
6381
6382 ExprResult BuildExpressionTrait(ExpressionTrait OET,
6383 SourceLocation KWLoc,
6384 Expr *Queried,
6385 SourceLocation RParen);
6386
6387 ExprResult ActOnStartCXXMemberReference(Scope *S,
6388 Expr *Base,
6389 SourceLocation OpLoc,
6390 tok::TokenKind OpKind,
6391 ParsedType &ObjectType,
6392 bool &MayBePseudoDestructor);
6393
6394 ExprResult BuildPseudoDestructorExpr(Expr *Base,
6395 SourceLocation OpLoc,
6396 tok::TokenKind OpKind,
6397 const CXXScopeSpec &SS,
6398 TypeSourceInfo *ScopeType,
6399 SourceLocation CCLoc,
6400 SourceLocation TildeLoc,
6401 PseudoDestructorTypeStorage DestroyedType);
6402
6403 ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
6404 SourceLocation OpLoc,
6405 tok::TokenKind OpKind,
6406 CXXScopeSpec &SS,
6407 UnqualifiedId &FirstTypeName,
6408 SourceLocation CCLoc,
6409 SourceLocation TildeLoc,
6410 UnqualifiedId &SecondTypeName);
6411
6412 ExprResult ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
6413 SourceLocation OpLoc,
6414 tok::TokenKind OpKind,
6415 SourceLocation TildeLoc,
6416 const DeclSpec& DS);
6417
6418 /// MaybeCreateExprWithCleanups - If the current full-expression
6419 /// requires any cleanups, surround it with a ExprWithCleanups node.
6420 /// Otherwise, just returns the passed-in expression.
6421 Expr *MaybeCreateExprWithCleanups(Expr *SubExpr);
6422 Stmt *MaybeCreateStmtWithCleanups(Stmt *SubStmt);
6423 ExprResult MaybeCreateExprWithCleanups(ExprResult SubExpr);
6424
6425 MaterializeTemporaryExpr *
6426 CreateMaterializeTemporaryExpr(QualType T, Expr *Temporary,
6427 bool BoundToLvalueReference);
6428
6429 ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue) {
6430 return ActOnFinishFullExpr(
6431 Expr, Expr ? Expr->getExprLoc() : SourceLocation(), DiscardedValue);
6432 }
6433 ExprResult ActOnFinishFullExpr(Expr *Expr, SourceLocation CC,
6434 bool DiscardedValue, bool IsConstexpr = false);
6435 StmtResult ActOnFinishFullStmt(Stmt *Stmt);
6436
6437 // Marks SS invalid if it represents an incomplete type.
6438 bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC);
6439 // Complete an enum decl, maybe without a scope spec.
6440 bool RequireCompleteEnumDecl(EnumDecl *D, SourceLocation L,
6441 CXXScopeSpec *SS = nullptr);
6442
6443 DeclContext *computeDeclContext(QualType T);
6444 DeclContext *computeDeclContext(const CXXScopeSpec &SS,
6445 bool EnteringContext = false);
6446 bool isDependentScopeSpecifier(const CXXScopeSpec &SS);
6447 CXXRecordDecl *getCurrentInstantiationOf(NestedNameSpecifier *NNS);
6448
6449 /// The parser has parsed a global nested-name-specifier '::'.
6450 ///
6451 /// \param CCLoc The location of the '::'.
6452 ///
6453 /// \param SS The nested-name-specifier, which will be updated in-place
6454 /// to reflect the parsed nested-name-specifier.
6455 ///
6456 /// \returns true if an error occurred, false otherwise.
6457 bool ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc, CXXScopeSpec &SS);
6458
6459 /// The parser has parsed a '__super' nested-name-specifier.
6460 ///
6461 /// \param SuperLoc The location of the '__super' keyword.
6462 ///
6463 /// \param ColonColonLoc The location of the '::'.
6464 ///
6465 /// \param SS The nested-name-specifier, which will be updated in-place
6466 /// to reflect the parsed nested-name-specifier.
6467 ///
6468 /// \returns true if an error occurred, false otherwise.
6469 bool ActOnSuperScopeSpecifier(SourceLocation SuperLoc,
6470 SourceLocation ColonColonLoc, CXXScopeSpec &SS);
6471
6472 bool isAcceptableNestedNameSpecifier(const NamedDecl *SD,
6473 bool *CanCorrect = nullptr);
6474 NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS);
6475
6476 /// Keeps information about an identifier in a nested-name-spec.
6477 ///
6478 struct NestedNameSpecInfo {
6479 /// The type of the object, if we're parsing nested-name-specifier in
6480 /// a member access expression.
6481 ParsedType ObjectType;
6482
6483 /// The identifier preceding the '::'.
6484 IdentifierInfo *Identifier;
6485
6486 /// The location of the identifier.
6487 SourceLocation IdentifierLoc;
6488
6489 /// The location of the '::'.
6490 SourceLocation CCLoc;
6491
6492 /// Creates info object for the most typical case.
6493 NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc,
6494 SourceLocation ColonColonLoc, ParsedType ObjectType = ParsedType())
6495 : ObjectType(ObjectType), Identifier(II), IdentifierLoc(IdLoc),
6496 CCLoc(ColonColonLoc) {
6497 }
6498
6499 NestedNameSpecInfo(IdentifierInfo *II, SourceLocation IdLoc,
6500 SourceLocation ColonColonLoc, QualType ObjectType)
6501 : ObjectType(ParsedType::make(ObjectType)), Identifier(II),
6502 IdentifierLoc(IdLoc), CCLoc(ColonColonLoc) {
6503 }
6504 };
6505
6506 bool isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,
6507 NestedNameSpecInfo &IdInfo);
6508
6509 bool BuildCXXNestedNameSpecifier(Scope *S,
6510 NestedNameSpecInfo &IdInfo,
6511 bool EnteringContext,
6512 CXXScopeSpec &SS,
6513 NamedDecl *ScopeLookupResult,
6514 bool ErrorRecoveryLookup,
6515 bool *IsCorrectedToColon = nullptr,
6516 bool OnlyNamespace = false);
6517
6518 /// The parser has parsed a nested-name-specifier 'identifier::'.
6519 ///
6520 /// \param S The scope in which this nested-name-specifier occurs.
6521 ///
6522 /// \param IdInfo Parser information about an identifier in the
6523 /// nested-name-spec.
6524 ///
6525 /// \param EnteringContext Whether we're entering the context nominated by
6526 /// this nested-name-specifier.
6527 ///
6528 /// \param SS The nested-name-specifier, which is both an input
6529 /// parameter (the nested-name-specifier before this type) and an
6530 /// output parameter (containing the full nested-name-specifier,
6531 /// including this new type).
6532 ///
6533 /// \param ErrorRecoveryLookup If true, then this method is called to improve
6534 /// error recovery. In this case do not emit error message.
6535 ///
6536 /// \param IsCorrectedToColon If not null, suggestions to replace '::' -> ':'
6537 /// are allowed. The bool value pointed by this parameter is set to 'true'
6538 /// if the identifier is treated as if it was followed by ':', not '::'.
6539 ///
6540 /// \param OnlyNamespace If true, only considers namespaces in lookup.
6541 ///
6542 /// \returns true if an error occurred, false otherwise.
6543 bool ActOnCXXNestedNameSpecifier(Scope *S,
6544 NestedNameSpecInfo &IdInfo,
6545 bool EnteringContext,
6546 CXXScopeSpec &SS,
6547 bool ErrorRecoveryLookup = false,
6548 bool *IsCorrectedToColon = nullptr,
6549 bool OnlyNamespace = false);
6550
6551 ExprResult ActOnDecltypeExpression(Expr *E);
6552
6553 bool ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,
6554 const DeclSpec &DS,
6555 SourceLocation ColonColonLoc);
6556
6557 bool IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS,
6558 NestedNameSpecInfo &IdInfo,
6559 bool EnteringContext);
6560
6561 /// The parser has parsed a nested-name-specifier
6562 /// 'template[opt] template-name < template-args >::'.
6563 ///
6564 /// \param S The scope in which this nested-name-specifier occurs.
6565 ///
6566 /// \param SS The nested-name-specifier, which is both an input
6567 /// parameter (the nested-name-specifier before this type) and an
6568 /// output parameter (containing the full nested-name-specifier,
6569 /// including this new type).
6570 ///
6571 /// \param TemplateKWLoc the location of the 'template' keyword, if any.
6572 /// \param TemplateName the template name.
6573 /// \param TemplateNameLoc The location of the template name.
6574 /// \param LAngleLoc The location of the opening angle bracket ('<').
6575 /// \param TemplateArgs The template arguments.
6576 /// \param RAngleLoc The location of the closing angle bracket ('>').
6577 /// \param CCLoc The location of the '::'.
6578 ///
6579 /// \param EnteringContext Whether we're entering the context of the
6580 /// nested-name-specifier.
6581 ///
6582 ///
6583 /// \returns true if an error occurred, false otherwise.
6584 bool ActOnCXXNestedNameSpecifier(Scope *S,
6585 CXXScopeSpec &SS,
6586 SourceLocation TemplateKWLoc,
6587 TemplateTy TemplateName,
6588 SourceLocation TemplateNameLoc,
6589 SourceLocation LAngleLoc,
6590 ASTTemplateArgsPtr TemplateArgs,
6591 SourceLocation RAngleLoc,
6592 SourceLocation CCLoc,
6593 bool EnteringContext);
6594
6595 /// Given a C++ nested-name-specifier, produce an annotation value
6596 /// that the parser can use later to reconstruct the given
6597 /// nested-name-specifier.
6598 ///
6599 /// \param SS A nested-name-specifier.
6600 ///
6601 /// \returns A pointer containing all of the information in the
6602 /// nested-name-specifier \p SS.
6603 void *SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS);
6604
6605 /// Given an annotation pointer for a nested-name-specifier, restore
6606 /// the nested-name-specifier structure.
6607 ///
6608 /// \param Annotation The annotation pointer, produced by
6609 /// \c SaveNestedNameSpecifierAnnotation().
6610 ///
6611 /// \param AnnotationRange The source range corresponding to the annotation.
6612 ///
6613 /// \param SS The nested-name-specifier that will be updated with the contents
6614 /// of the annotation pointer.
6615 void RestoreNestedNameSpecifierAnnotation(void *Annotation,
6616 SourceRange AnnotationRange,
6617 CXXScopeSpec &SS);
6618
6619 bool ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
6620
6621 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
6622 /// scope or nested-name-specifier) is parsed, part of a declarator-id.
6623 /// After this method is called, according to [C++ 3.4.3p3], names should be
6624 /// looked up in the declarator-id's scope, until the declarator is parsed and
6625 /// ActOnCXXExitDeclaratorScope is called.
6626 /// The 'SS' should be a non-empty valid CXXScopeSpec.
6627 bool ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS);
6628
6629 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
6630 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
6631 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
6632 /// Used to indicate that names should revert to being looked up in the
6633 /// defining scope.
6634 void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
6635
6636 /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
6637 /// initializer for the declaration 'Dcl'.
6638 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
6639 /// static data member of class X, names should be looked up in the scope of
6640 /// class X.
6641 void ActOnCXXEnterDeclInitializer(Scope *S, Decl *Dcl);
6642
6643 /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
6644 /// initializer for the declaration 'Dcl'.
6645 void ActOnCXXExitDeclInitializer(Scope *S, Decl *Dcl);
6646
6647 /// Create a new lambda closure type.
6648 CXXRecordDecl *createLambdaClosureType(SourceRange IntroducerRange,
6649 TypeSourceInfo *Info,
6650 bool KnownDependent,
6651 LambdaCaptureDefault CaptureDefault);
6652
6653 /// Start the definition of a lambda expression.
6654 CXXMethodDecl *startLambdaDefinition(CXXRecordDecl *Class,
6655 SourceRange IntroducerRange,
6656 TypeSourceInfo *MethodType,
6657 SourceLocation EndLoc,
6658 ArrayRef<ParmVarDecl *> Params,
6659 ConstexprSpecKind ConstexprKind,
6660 Expr *TrailingRequiresClause);
6661
6662 /// Number lambda for linkage purposes if necessary.
6663 void handleLambdaNumbering(
6664 CXXRecordDecl *Class, CXXMethodDecl *Method,
6665 Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling = None);
6666
6667 /// Endow the lambda scope info with the relevant properties.
6668 void buildLambdaScope(sema::LambdaScopeInfo *LSI,
6669 CXXMethodDecl *CallOperator,
6670 SourceRange IntroducerRange,
6671 LambdaCaptureDefault CaptureDefault,
6672 SourceLocation CaptureDefaultLoc,
6673 bool ExplicitParams,
6674 bool ExplicitResultType,
6675 bool Mutable);
6676
6677 /// Perform initialization analysis of the init-capture and perform
6678 /// any implicit conversions such as an lvalue-to-rvalue conversion if
6679 /// not being used to initialize a reference.
6680 ParsedType actOnLambdaInitCaptureInitialization(
6681 SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,
6682 IdentifierInfo *Id, LambdaCaptureInitKind InitKind, Expr *&Init) {
6683 return ParsedType::make(buildLambdaInitCaptureInitialization(
6684 Loc, ByRef, EllipsisLoc, None, Id,
6685 InitKind != LambdaCaptureInitKind::CopyInit, Init));
6686 }
6687 QualType buildLambdaInitCaptureInitialization(
6688 SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc,
6689 Optional<unsigned> NumExpansions, IdentifierInfo *Id, bool DirectInit,
6690 Expr *&Init);
6691
6692 /// Create a dummy variable within the declcontext of the lambda's
6693 /// call operator, for name lookup purposes for a lambda init capture.
6694 ///
6695 /// CodeGen handles emission of lambda captures, ignoring these dummy
6696 /// variables appropriately.
6697 VarDecl *createLambdaInitCaptureVarDecl(SourceLocation Loc,
6698 QualType InitCaptureType,
6699 SourceLocation EllipsisLoc,
6700 IdentifierInfo *Id,
6701 unsigned InitStyle, Expr *Init);
6702
6703 /// Add an init-capture to a lambda scope.
6704 void addInitCapture(sema::LambdaScopeInfo *LSI, VarDecl *Var);
6705
6706 /// Note that we have finished the explicit captures for the
6707 /// given lambda.
6708 void finishLambdaExplicitCaptures(sema::LambdaScopeInfo *LSI);
6709
6710 /// \brief This is called after parsing the explicit template parameter list
6711 /// on a lambda (if it exists) in C++2a.
6712 void ActOnLambdaExplicitTemplateParameterList(SourceLocation LAngleLoc,
6713 ArrayRef<NamedDecl *> TParams,
6714 SourceLocation RAngleLoc,
6715 ExprResult RequiresClause);
6716
6717 /// Introduce the lambda parameters into scope.
6718 void addLambdaParameters(
6719 ArrayRef<LambdaIntroducer::LambdaCapture> Captures,
6720 CXXMethodDecl *CallOperator, Scope *CurScope);
6721
6722 /// Deduce a block or lambda's return type based on the return
6723 /// statements present in the body.
6724 void deduceClosureReturnType(sema::CapturingScopeInfo &CSI);
6725
6726 /// ActOnStartOfLambdaDefinition - This is called just before we start
6727 /// parsing the body of a lambda; it analyzes the explicit captures and
6728 /// arguments, and sets up various data-structures for the body of the
6729 /// lambda.
6730 void ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
6731 Declarator &ParamInfo, Scope *CurScope);
6732
6733 /// ActOnLambdaError - If there is an error parsing a lambda, this callback
6734 /// is invoked to pop the information about the lambda.
6735 void ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,
6736 bool IsInstantiation = false);
6737
6738 /// ActOnLambdaExpr - This is called when the body of a lambda expression
6739 /// was successfully completed.
6740 ExprResult ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body,
6741 Scope *CurScope);
6742
6743 /// Does copying/destroying the captured variable have side effects?
6744 bool CaptureHasSideEffects(const sema::Capture &From);
6745
6746 /// Diagnose if an explicit lambda capture is unused. Returns true if a
6747 /// diagnostic is emitted.
6748 bool DiagnoseUnusedLambdaCapture(SourceRange CaptureRange,
6749 const sema::Capture &From);
6750
6751 /// Build a FieldDecl suitable to hold the given capture.
6752 FieldDecl *BuildCaptureField(RecordDecl *RD, const sema::Capture &Capture);
6753
6754 /// Initialize the given capture with a suitable expression.
6755 ExprResult BuildCaptureInit(const sema::Capture &Capture,
6756 SourceLocation ImplicitCaptureLoc,
6757 bool IsOpenMPMapping = false);
6758
6759 /// Complete a lambda-expression having processed and attached the
6760 /// lambda body.
6761 ExprResult BuildLambdaExpr(SourceLocation StartLoc, SourceLocation EndLoc,
6762 sema::LambdaScopeInfo *LSI);
6763
6764 /// Get the return type to use for a lambda's conversion function(s) to
6765 /// function pointer type, given the type of the call operator.
6766 QualType
6767 getLambdaConversionFunctionResultType(const FunctionProtoType *CallOpType,
6768 CallingConv CC);
6769
6770 /// Define the "body" of the conversion from a lambda object to a
6771 /// function pointer.
6772 ///
6773 /// This routine doesn't actually define a sensible body; rather, it fills
6774 /// in the initialization expression needed to copy the lambda object into
6775 /// the block, and IR generation actually generates the real body of the
6776 /// block pointer conversion.
6777 void DefineImplicitLambdaToFunctionPointerConversion(
6778 SourceLocation CurrentLoc, CXXConversionDecl *Conv);
6779
6780 /// Define the "body" of the conversion from a lambda object to a
6781 /// block pointer.
6782 ///
6783 /// This routine doesn't actually define a sensible body; rather, it fills
6784 /// in the initialization expression needed to copy the lambda object into
6785 /// the block, and IR generation actually generates the real body of the
6786 /// block pointer conversion.
6787 void DefineImplicitLambdaToBlockPointerConversion(SourceLocation CurrentLoc,
6788 CXXConversionDecl *Conv);
6789
6790 ExprResult BuildBlockForLambdaConversion(SourceLocation CurrentLocation,
6791 SourceLocation ConvLocation,
6792 CXXConversionDecl *Conv,
6793 Expr *Src);
6794
6795 /// Check whether the given expression is a valid constraint expression.
6796 /// A diagnostic is emitted if it is not, false is returned, and
6797 /// PossibleNonPrimary will be set to true if the failure might be due to a
6798 /// non-primary expression being used as an atomic constraint.
6799 bool CheckConstraintExpression(const Expr *CE, Token NextToken = Token(),
6800 bool *PossibleNonPrimary = nullptr,
6801 bool IsTrailingRequiresClause = false);
6802
6803private:
6804 /// Caches pairs of template-like decls whose associated constraints were
6805 /// checked for subsumption and whether or not the first's constraints did in
6806 /// fact subsume the second's.
6807 llvm::DenseMap<std::pair<NamedDecl *, NamedDecl *>, bool> SubsumptionCache;
6808 /// Caches the normalized associated constraints of declarations (concepts or
6809 /// constrained declarations). If an error occurred while normalizing the
6810 /// associated constraints of the template or concept, nullptr will be cached
6811 /// here.
6812 llvm::DenseMap<NamedDecl *, NormalizedConstraint *>
6813 NormalizationCache;
6814
6815 llvm::ContextualFoldingSet<ConstraintSatisfaction, const ASTContext &>
6816 SatisfactionCache;
6817
6818public:
6819 const NormalizedConstraint *
6820 getNormalizedAssociatedConstraints(
6821 NamedDecl *ConstrainedDecl, ArrayRef<const Expr *> AssociatedConstraints);
6822
6823 /// \brief Check whether the given declaration's associated constraints are
6824 /// at least as constrained than another declaration's according to the
6825 /// partial ordering of constraints.
6826 ///
6827 /// \param Result If no error occurred, receives the result of true if D1 is
6828 /// at least constrained than D2, and false otherwise.
6829 ///
6830 /// \returns true if an error occurred, false otherwise.
6831 bool IsAtLeastAsConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1,
6832 NamedDecl *D2, ArrayRef<const Expr *> AC2,
6833 bool &Result);
6834
6835 /// If D1 was not at least as constrained as D2, but would've been if a pair
6836 /// of atomic constraints involved had been declared in a concept and not
6837 /// repeated in two separate places in code.
6838 /// \returns true if such a diagnostic was emitted, false otherwise.
6839 bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1,
6840 ArrayRef<const Expr *> AC1, NamedDecl *D2, ArrayRef<const Expr *> AC2);
6841
6842 /// \brief Check whether the given list of constraint expressions are
6843 /// satisfied (as if in a 'conjunction') given template arguments.
6844 /// \param Template the template-like entity that triggered the constraints
6845 /// check (either a concept or a constrained entity).
6846 /// \param ConstraintExprs a list of constraint expressions, treated as if
6847 /// they were 'AND'ed together.
6848 /// \param TemplateArgs the list of template arguments to substitute into the
6849 /// constraint expression.
6850 /// \param TemplateIDRange The source range of the template id that
6851 /// caused the constraints check.
6852 /// \param Satisfaction if true is returned, will contain details of the
6853 /// satisfaction, with enough information to diagnose an unsatisfied
6854 /// expression.
6855 /// \returns true if an error occurred and satisfaction could not be checked,
6856 /// false otherwise.
6857 bool CheckConstraintSatisfaction(
6858 const NamedDecl *Template, ArrayRef<const Expr *> ConstraintExprs,
6859 ArrayRef<TemplateArgument> TemplateArgs,
6860 SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction);
6861
6862 /// \brief Check whether the given non-dependent constraint expression is
6863 /// satisfied. Returns false and updates Satisfaction with the satisfaction
6864 /// verdict if successful, emits a diagnostic and returns true if an error
6865 /// occured and satisfaction could not be determined.
6866 ///
6867 /// \returns true if an error occurred, false otherwise.
6868 bool CheckConstraintSatisfaction(const Expr *ConstraintExpr,
6869 ConstraintSatisfaction &Satisfaction);
6870
6871 /// Check whether the given function decl's trailing requires clause is
6872 /// satisfied, if any. Returns false and updates Satisfaction with the
6873 /// satisfaction verdict if successful, emits a diagnostic and returns true if
6874 /// an error occured and satisfaction could not be determined.
6875 ///
6876 /// \returns true if an error occurred, false otherwise.
6877 bool CheckFunctionConstraints(const FunctionDecl *FD,
6878 ConstraintSatisfaction &Satisfaction,
6879 SourceLocation UsageLoc = SourceLocation());
6880
6881
6882 /// \brief Ensure that the given template arguments satisfy the constraints
6883 /// associated with the given template, emitting a diagnostic if they do not.
6884 ///
6885 /// \param Template The template to which the template arguments are being
6886 /// provided.
6887 ///
6888 /// \param TemplateArgs The converted, canonicalized template arguments.
6889 ///
6890 /// \param TemplateIDRange The source range of the template id that
6891 /// caused the constraints check.
6892 ///
6893 /// \returns true if the constrains are not satisfied or could not be checked
6894 /// for satisfaction, false if the constraints are satisfied.
6895 bool EnsureTemplateArgumentListConstraints(TemplateDecl *Template,
6896 ArrayRef<TemplateArgument> TemplateArgs,
6897 SourceRange TemplateIDRange);
6898
6899 /// \brief Emit diagnostics explaining why a constraint expression was deemed
6900 /// unsatisfied.
6901 /// \param First whether this is the first time an unsatisfied constraint is
6902 /// diagnosed for this error.
6903 void
6904 DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction,
6905 bool First = true);
6906
6907 /// \brief Emit diagnostics explaining why a constraint expression was deemed
6908 /// unsatisfied.
6909 void
6910 DiagnoseUnsatisfiedConstraint(const ASTConstraintSatisfaction &Satisfaction,
6911 bool First = true);
6912
6913 // ParseObjCStringLiteral - Parse Objective-C string literals.
6914 ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
6915 ArrayRef<Expr *> Strings);
6916
6917 ExprResult BuildObjCStringLiteral(SourceLocation AtLoc, StringLiteral *S);
6918
6919 /// BuildObjCNumericLiteral - builds an ObjCBoxedExpr AST node for the
6920 /// numeric literal expression. Type of the expression will be "NSNumber *"
6921 /// or "id" if NSNumber is unavailable.
6922 ExprResult BuildObjCNumericLiteral(SourceLocation AtLoc, Expr *Number);
6923 ExprResult ActOnObjCBoolLiteral(SourceLocation AtLoc, SourceLocation ValueLoc,
6924 bool Value);
6925 ExprResult BuildObjCArrayLiteral(SourceRange SR, MultiExprArg Elements);
6926
6927 /// BuildObjCBoxedExpr - builds an ObjCBoxedExpr AST node for the
6928 /// '@' prefixed parenthesized expression. The type of the expression will
6929 /// either be "NSNumber *", "NSString *" or "NSValue *" depending on the type
6930 /// of ValueType, which is allowed to be a built-in numeric type, "char *",
6931 /// "const char *" or C structure with attribute 'objc_boxable'.
6932 ExprResult BuildObjCBoxedExpr(SourceRange SR, Expr *ValueExpr);
6933
6934 ExprResult BuildObjCSubscriptExpression(SourceLocation RB, Expr *BaseExpr,
6935 Expr *IndexExpr,
6936 ObjCMethodDecl *getterMethod,
6937 ObjCMethodDecl *setterMethod);
6938
6939 ExprResult BuildObjCDictionaryLiteral(SourceRange SR,
6940 MutableArrayRef<ObjCDictionaryElement> Elements);
6941
6942 ExprResult BuildObjCEncodeExpression(SourceLocation AtLoc,
6943 TypeSourceInfo *EncodedTypeInfo,
6944 SourceLocation RParenLoc);
6945 ExprResult BuildCXXMemberCallExpr(Expr *Exp, NamedDecl *FoundDecl,
6946 CXXConversionDecl *Method,
6947 bool HadMultipleCandidates);
6948
6949 ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
6950 SourceLocation EncodeLoc,
6951 SourceLocation LParenLoc,
6952 ParsedType Ty,
6953 SourceLocation RParenLoc);
6954
6955 /// ParseObjCSelectorExpression - Build selector expression for \@selector
6956 ExprResult ParseObjCSelectorExpression(Selector Sel,
6957 SourceLocation AtLoc,
6958 SourceLocation SelLoc,
6959 SourceLocation LParenLoc,
6960 SourceLocation RParenLoc,
6961 bool WarnMultipleSelectors);
6962
6963 /// ParseObjCProtocolExpression - Build protocol expression for \@protocol
6964 ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,
6965 SourceLocation AtLoc,
6966 SourceLocation ProtoLoc,
6967 SourceLocation LParenLoc,
6968 SourceLocation ProtoIdLoc,
6969 SourceLocation RParenLoc);
6970
6971 //===--------------------------------------------------------------------===//
6972 // C++ Declarations
6973 //
6974 Decl *ActOnStartLinkageSpecification(Scope *S,
6975 SourceLocation ExternLoc,
6976 Expr *LangStr,
6977 SourceLocation LBraceLoc);
6978 Decl *ActOnFinishLinkageSpecification(Scope *S,
6979 Decl *LinkageSpec,
6980 SourceLocation RBraceLoc);
6981
6982
6983 //===--------------------------------------------------------------------===//
6984 // C++ Classes
6985 //
6986 CXXRecordDecl *getCurrentClass(Scope *S, const CXXScopeSpec *SS);
6987 bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
6988 const CXXScopeSpec *SS = nullptr);
6989 bool isCurrentClassNameTypo(IdentifierInfo *&II, const CXXScopeSpec *SS);
6990
6991 bool ActOnAccessSpecifier(AccessSpecifier Access, SourceLocation ASLoc,
6992 SourceLocation ColonLoc,
6993 const ParsedAttributesView &Attrs);
6994
6995 NamedDecl *ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,
6996 Declarator &D,
6997 MultiTemplateParamsArg TemplateParameterLists,
6998 Expr *BitfieldWidth, const VirtSpecifiers &VS,
6999 InClassInitStyle InitStyle);
7000
7001 void ActOnStartCXXInClassMemberInitializer();
7002 void ActOnFinishCXXInClassMemberInitializer(Decl *VarDecl,
7003 SourceLocation EqualLoc,
7004 Expr *Init);
7005
7006 MemInitResult ActOnMemInitializer(Decl *ConstructorD,
7007 Scope *S,
7008 CXXScopeSpec &SS,
7009 IdentifierInfo *MemberOrBase,
7010 ParsedType TemplateTypeTy,
7011 const DeclSpec &DS,
7012 SourceLocation IdLoc,
7013 SourceLocation LParenLoc,
7014 ArrayRef<Expr *> Args,
7015 SourceLocation RParenLoc,
7016 SourceLocation EllipsisLoc);
7017
7018 MemInitResult ActOnMemInitializer(Decl *ConstructorD,
7019 Scope *S,
7020 CXXScopeSpec &SS,
7021 IdentifierInfo *MemberOrBase,
7022 ParsedType TemplateTypeTy,
7023 const DeclSpec &DS,
7024 SourceLocation IdLoc,
7025 Expr *InitList,
7026 SourceLocation EllipsisLoc);
7027
7028 MemInitResult BuildMemInitializer(Decl *ConstructorD,
7029 Scope *S,
7030 CXXScopeSpec &SS,
7031 IdentifierInfo *MemberOrBase,
7032 ParsedType TemplateTypeTy,
7033 const DeclSpec &DS,
7034 SourceLocation IdLoc,
7035 Expr *Init,
7036 SourceLocation EllipsisLoc);
7037
7038 MemInitResult BuildMemberInitializer(ValueDecl *Member,
7039 Expr *Init,
7040 SourceLocation IdLoc);
7041
7042 MemInitResult BuildBaseInitializer(QualType BaseType,
7043 TypeSourceInfo *BaseTInfo,
7044 Expr *Init,
7045 CXXRecordDecl *ClassDecl,
7046 SourceLocation EllipsisLoc);
7047
7048 MemInitResult BuildDelegatingInitializer(TypeSourceInfo *TInfo,
7049 Expr *Init,
7050 CXXRecordDecl *ClassDecl);
7051
7052 bool SetDelegatingInitializer(CXXConstructorDecl *Constructor,
7053 CXXCtorInitializer *Initializer);
7054
7055 bool SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors,
7056 ArrayRef<CXXCtorInitializer *> Initializers = None);
7057
7058 void SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation);
7059
7060
7061 /// MarkBaseAndMemberDestructorsReferenced - Given a record decl,
7062 /// mark all the non-trivial destructors of its members and bases as
7063 /// referenced.
7064 void MarkBaseAndMemberDestructorsReferenced(SourceLocation Loc,
7065 CXXRecordDecl *Record);
7066
7067 /// Mark destructors of virtual bases of this class referenced. In the Itanium
7068 /// C++ ABI, this is done when emitting a destructor for any non-abstract
7069 /// class. In the Microsoft C++ ABI, this is done any time a class's
7070 /// destructor is referenced.
7071 void MarkVirtualBaseDestructorsReferenced(
7072 SourceLocation Location, CXXRecordDecl *ClassDecl,
7073 llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases = nullptr);
7074
7075 /// Do semantic checks to allow the complete destructor variant to be emitted
7076 /// when the destructor is defined in another translation unit. In the Itanium
7077 /// C++ ABI, destructor variants are emitted together. In the MS C++ ABI, they
7078 /// can be emitted in separate TUs. To emit the complete variant, run a subset
7079 /// of the checks performed when emitting a regular destructor.
7080 void CheckCompleteDestructorVariant(SourceLocation CurrentLocation,
7081 CXXDestructorDecl *Dtor);
7082
7083 /// The list of classes whose vtables have been used within
7084 /// this translation unit, and the source locations at which the
7085 /// first use occurred.
7086 typedef std::pair<CXXRecordDecl*, SourceLocation> VTableUse;
7087
7088 /// The list of vtables that are required but have not yet been
7089 /// materialized.
7090 SmallVector<VTableUse, 16> VTableUses;
7091
7092 /// The set of classes whose vtables have been used within
7093 /// this translation unit, and a bit that will be true if the vtable is
7094 /// required to be emitted (otherwise, it should be emitted only if needed
7095 /// by code generation).
7096 llvm::DenseMap<CXXRecordDecl *, bool> VTablesUsed;
7097
7098 /// Load any externally-stored vtable uses.
7099 void LoadExternalVTableUses();
7100
7101 /// Note that the vtable for the given class was used at the
7102 /// given location.
7103 void MarkVTableUsed(SourceLocation Loc, CXXRecordDecl *Class,
7104 bool DefinitionRequired = false);
7105
7106 /// Mark the exception specifications of all virtual member functions
7107 /// in the given class as needed.
7108 void MarkVirtualMemberExceptionSpecsNeeded(SourceLocation Loc,
7109 const CXXRecordDecl *RD);
7110
7111 /// MarkVirtualMembersReferenced - Will mark all members of the given
7112 /// CXXRecordDecl referenced.
7113 void MarkVirtualMembersReferenced(SourceLocation Loc, const CXXRecordDecl *RD,
7114 bool ConstexprOnly = false);
7115
7116 /// Define all of the vtables that have been used in this
7117 /// translation unit and reference any virtual members used by those
7118 /// vtables.
7119 ///
7120 /// \returns true if any work was done, false otherwise.
7121 bool DefineUsedVTables();
7122
7123 void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl);
7124
7125 void ActOnMemInitializers(Decl *ConstructorDecl,
7126 SourceLocation ColonLoc,
7127 ArrayRef<CXXCtorInitializer*> MemInits,
7128 bool AnyErrors);
7129
7130 /// Check class-level dllimport/dllexport attribute. The caller must
7131 /// ensure that referenceDLLExportedClassMethods is called some point later
7132 /// when all outer classes of Class are complete.
7133 void checkClassLevelDLLAttribute(CXXRecordDecl *Class);
7134 void checkClassLevelCodeSegAttribute(CXXRecordDecl *Class);
7135
7136 void referenceDLLExportedClassMethods();
7137
7138 void propagateDLLAttrToBaseClassTemplate(
7139 CXXRecordDecl *Class, Attr *ClassAttr,
7140 ClassTemplateSpecializationDecl *BaseTemplateSpec,
7141 SourceLocation BaseLoc);
7142
7143 /// Add gsl::Pointer attribute to std::container::iterator
7144 /// \param ND The declaration that introduces the name
7145 /// std::container::iterator. \param UnderlyingRecord The record named by ND.
7146 void inferGslPointerAttribute(NamedDecl *ND, CXXRecordDecl *UnderlyingRecord);
7147
7148 /// Add [[gsl::Owner]] and [[gsl::Pointer]] attributes for std:: types.
7149 void inferGslOwnerPointerAttribute(CXXRecordDecl *Record);
7150
7151 /// Add [[gsl::Pointer]] attributes for std:: types.
7152 void inferGslPointerAttribute(TypedefNameDecl *TD);
7153
7154 void CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record);
7155
7156 /// Check that the C++ class annoated with "trivial_abi" satisfies all the
7157 /// conditions that are needed for the attribute to have an effect.
7158 void checkIllFormedTrivialABIStruct(CXXRecordDecl &RD);
7159
7160 void ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc,
7161 Decl *TagDecl, SourceLocation LBrac,
7162 SourceLocation RBrac,
7163 const ParsedAttributesView &AttrList);
7164 void ActOnFinishCXXMemberDecls();
7165 void ActOnFinishCXXNonNestedClass();
7166
7167 void ActOnReenterCXXMethodParameter(Scope *S, ParmVarDecl *Param);
7168 unsigned ActOnReenterTemplateScope(Decl *Template,
7169 llvm::function_ref<Scope *()> EnterScope);
7170 void ActOnStartDelayedMemberDeclarations(Scope *S, Decl *Record);
7171 void ActOnStartDelayedCXXMethodDeclaration(Scope *S, Decl *Method);
7172 void ActOnDelayedCXXMethodParameter(Scope *S, Decl *Param);
7173 void ActOnFinishDelayedMemberDeclarations(Scope *S, Decl *Record);
7174 void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, Decl *Method);
7175 void ActOnFinishDelayedMemberInitializers(Decl *Record);
7176 void MarkAsLateParsedTemplate(FunctionDecl *FD, Decl *FnD,
7177 CachedTokens &Toks);
7178 void UnmarkAsLateParsedTemplate(FunctionDecl *FD);
7179 bool IsInsideALocalClassWithinATemplateFunction();
7180
7181 Decl *ActOnStaticAssertDeclaration(SourceLocation StaticAssertLoc,
7182 Expr *AssertExpr,
7183 Expr *AssertMessageExpr,
7184 SourceLocation RParenLoc);
7185 Decl *BuildStaticAssertDeclaration(SourceLocation StaticAssertLoc,
7186 Expr *AssertExpr,
7187 StringLiteral *AssertMessageExpr,
7188 SourceLocation RParenLoc,
7189 bool Failed);
7190
7191 FriendDecl *CheckFriendTypeDecl(SourceLocation LocStart,
7192 SourceLocation FriendLoc,
7193 TypeSourceInfo *TSInfo);
7194 Decl *ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
7195 MultiTemplateParamsArg TemplateParams);
7196 NamedDecl *ActOnFriendFunctionDecl(Scope *S, Declarator &D,
7197 MultiTemplateParamsArg TemplateParams);
7198
7199 QualType CheckConstructorDeclarator(Declarator &D, QualType R,
7200 StorageClass& SC);
7201 void CheckConstructor(CXXConstructorDecl *Constructor);
7202 QualType CheckDestructorDeclarator(Declarator &D, QualType R,
7203 StorageClass& SC);
7204 bool CheckDestructor(CXXDestructorDecl *Destructor);
7205 void CheckConversionDeclarator(Declarator &D, QualType &R,
7206 StorageClass& SC);
7207 Decl *ActOnConversionDeclarator(CXXConversionDecl *Conversion);
7208 void CheckDeductionGuideDeclarator(Declarator &D, QualType &R,
7209 StorageClass &SC);
7210 void CheckDeductionGuideTemplate(FunctionTemplateDecl *TD);
7211
7212 void CheckExplicitlyDefaultedFunction(Scope *S, FunctionDecl *MD);
7213
7214 bool CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD,
7215 CXXSpecialMember CSM);
7216 void CheckDelayedMemberExceptionSpecs();
7217
7218 bool CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *MD,
7219 DefaultedComparisonKind DCK);
7220 void DeclareImplicitEqualityComparison(CXXRecordDecl *RD,
7221 FunctionDecl *Spaceship);
7222 void DefineDefaultedComparison(SourceLocation Loc, FunctionDecl *FD,
7223 DefaultedComparisonKind DCK);
7224
7225 //===--------------------------------------------------------------------===//
7226 // C++ Derived Classes
7227 //
7228
7229 /// ActOnBaseSpecifier - Parsed a base specifier
7230 CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class,
7231 SourceRange SpecifierRange,
7232 bool Virtual, AccessSpecifier Access,
7233 TypeSourceInfo *TInfo,
7234 SourceLocation EllipsisLoc);
7235
7236 BaseResult ActOnBaseSpecifier(Decl *classdecl,
7237 SourceRange SpecifierRange,
7238 ParsedAttributes &Attrs,
7239 bool Virtual, AccessSpecifier Access,
7240 ParsedType basetype,
7241 SourceLocation BaseLoc,
7242 SourceLocation EllipsisLoc);
7243
7244 bool AttachBaseSpecifiers(CXXRecordDecl *Class,
7245 MutableArrayRef<CXXBaseSpecifier *> Bases);
7246 void ActOnBaseSpecifiers(Decl *ClassDecl,
7247 MutableArrayRef<CXXBaseSpecifier *> Bases);
7248
7249 bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base);
7250 bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,
7251 CXXBasePaths &Paths);
7252
7253 // FIXME: I don't like this name.
7254 void BuildBasePathArray(const CXXBasePaths &Paths, CXXCastPath &BasePath);
7255
7256 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
7257 SourceLocation Loc, SourceRange Range,
7258 CXXCastPath *BasePath = nullptr,
7259 bool IgnoreAccess = false);
7260 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
7261 unsigned InaccessibleBaseID,
7262 unsigned AmbiguousBaseConvID,
7263 SourceLocation Loc, SourceRange Range,
7264 DeclarationName Name,
7265 CXXCastPath *BasePath,
7266 bool IgnoreAccess = false);
7267
7268 std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths);
7269
7270 bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
7271 const CXXMethodDecl *Old);
7272
7273 /// CheckOverridingFunctionReturnType - Checks whether the return types are
7274 /// covariant, according to C++ [class.virtual]p5.
7275 bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
7276 const CXXMethodDecl *Old);
7277
7278 /// CheckOverridingFunctionExceptionSpec - Checks whether the exception
7279 /// spec is a subset of base spec.
7280 bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,
7281 const CXXMethodDecl *Old);
7282
7283 bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange);
7284
7285 /// CheckOverrideControl - Check C++11 override control semantics.
7286 void CheckOverrideControl(NamedDecl *D);
7287
7288 /// DiagnoseAbsenceOfOverrideControl - Diagnose if 'override' keyword was
7289 /// not used in the declaration of an overriding method.
7290 void DiagnoseAbsenceOfOverrideControl(NamedDecl *D, bool Inconsistent);
7291
7292 /// CheckForFunctionMarkedFinal - Checks whether a virtual member function
7293 /// overrides a virtual member function marked 'final', according to
7294 /// C++11 [class.virtual]p4.
7295 bool CheckIfOverriddenFunctionIsMarkedFinal(const CXXMethodDecl *New,
7296 const CXXMethodDecl *Old);
7297
7298
7299 //===--------------------------------------------------------------------===//
7300 // C++ Access Control
7301 //
7302
7303 enum AccessResult {
7304 AR_accessible,
7305 AR_inaccessible,
7306 AR_dependent,
7307 AR_delayed
7308 };
7309
7310 bool SetMemberAccessSpecifier(NamedDecl *MemberDecl,
7311 NamedDecl *PrevMemberDecl,
7312 AccessSpecifier LexicalAS);
7313
7314 AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E,
7315 DeclAccessPair FoundDecl);
7316 AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E,
7317 DeclAccessPair FoundDecl);
7318 AccessResult CheckAllocationAccess(SourceLocation OperatorLoc,
7319 SourceRange PlacementRange,
7320 CXXRecordDecl *NamingClass,
7321 DeclAccessPair FoundDecl,
7322 bool Diagnose = true);
7323 AccessResult CheckConstructorAccess(SourceLocation Loc,
7324 CXXConstructorDecl *D,
7325 DeclAccessPair FoundDecl,
7326 const InitializedEntity &Entity,
7327 bool IsCopyBindingRefToTemp = false);
7328 AccessResult CheckConstructorAccess(SourceLocation Loc,
7329 CXXConstructorDecl *D,
7330 DeclAccessPair FoundDecl,
7331 const InitializedEntity &Entity,
7332 const PartialDiagnostic &PDiag);
7333 AccessResult CheckDestructorAccess(SourceLocation Loc,
7334 CXXDestructorDecl *Dtor,
7335 const PartialDiagnostic &PDiag,
7336 QualType objectType = QualType());
7337 AccessResult CheckFriendAccess(NamedDecl *D);
7338 AccessResult CheckMemberAccess(SourceLocation UseLoc,
7339 CXXRecordDecl *NamingClass,
7340 DeclAccessPair Found);
7341 AccessResult
7342 CheckStructuredBindingMemberAccess(SourceLocation UseLoc,
7343 CXXRecordDecl *DecomposedClass,
7344 DeclAccessPair Field);
7345 AccessResult CheckMemberOperatorAccess(SourceLocation Loc,
7346 Expr *ObjectExpr,
7347 Expr *ArgExpr,
7348 DeclAccessPair FoundDecl);
7349 AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr,
7350 DeclAccessPair FoundDecl);
7351 AccessResult CheckBaseClassAccess(SourceLocation AccessLoc,
7352 QualType Base, QualType Derived,
7353 const CXXBasePath &Path,
7354 unsigned DiagID,
7355 bool ForceCheck = false,
7356 bool ForceUnprivileged = false);
7357 void CheckLookupAccess(const LookupResult &R);
7358 bool IsSimplyAccessible(NamedDecl *Decl, CXXRecordDecl *NamingClass,
7359 QualType BaseType);
7360 bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass,
7361 DeclAccessPair Found, QualType ObjectType,
7362 SourceLocation Loc,
7363 const PartialDiagnostic &Diag);
7364 bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass,
7365 DeclAccessPair Found,
7366 QualType ObjectType) {
7367 return isMemberAccessibleForDeletion(NamingClass, Found, ObjectType,
7368 SourceLocation(), PDiag());
7369 }
7370
7371 void HandleDependentAccessCheck(const DependentDiagnostic &DD,
7372 const MultiLevelTemplateArgumentList &TemplateArgs);
7373 void PerformDependentDiagnostics(const DeclContext *Pattern,
7374 const MultiLevelTemplateArgumentList &TemplateArgs);
7375
7376 void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx);
7377
7378 /// When true, access checking violations are treated as SFINAE
7379 /// failures rather than hard errors.
7380 bool AccessCheckingSFINAE;
7381
7382 enum AbstractDiagSelID {
7383 AbstractNone = -1,
7384 AbstractReturnType,
7385 AbstractParamType,
7386 AbstractVariableType,
7387 AbstractFieldType,
7388 AbstractIvarType,
7389 AbstractSynthesizedIvarType,
7390 AbstractArrayType
7391 };
7392
7393 bool isAbstractType(SourceLocation Loc, QualType T);
7394 bool RequireNonAbstractType(SourceLocation Loc, QualType T,
7395 TypeDiagnoser &Diagnoser);
7396 template <typename... Ts>
7397 bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID,
7398 const Ts &...Args) {
7399 BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
7400 return RequireNonAbstractType(Loc, T, Diagnoser);
7401 }
7402
7403 void DiagnoseAbstractType(const CXXRecordDecl *RD);
7404
7405 //===--------------------------------------------------------------------===//
7406 // C++ Overloaded Operators [C++ 13.5]
7407 //
7408
7409 bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl);
7410
7411 bool CheckLiteralOperatorDeclaration(FunctionDecl *FnDecl);
7412
7413 //===--------------------------------------------------------------------===//
7414 // C++ Templates [C++ 14]
7415 //
7416 void FilterAcceptableTemplateNames(LookupResult &R,
7417 bool AllowFunctionTemplates = true,
7418 bool AllowDependent = true);
7419 bool hasAnyAcceptableTemplateNames(LookupResult &R,
7420 bool AllowFunctionTemplates = true,
7421 bool AllowDependent = true,
7422 bool AllowNonTemplateFunctions = false);
7423 /// Try to interpret the lookup result D as a template-name.
7424 ///
7425 /// \param D A declaration found by name lookup.
7426 /// \param AllowFunctionTemplates Whether function templates should be
7427 /// considered valid results.
7428 /// \param AllowDependent Whether unresolved using declarations (that might
7429 /// name templates) should be considered valid results.
7430 static NamedDecl *getAsTemplateNameDecl(NamedDecl *D,
7431 bool AllowFunctionTemplates = true,
7432 bool AllowDependent = true);
7433
7434 enum TemplateNameIsRequiredTag { TemplateNameIsRequired };
7435 /// Whether and why a template name is required in this lookup.
7436 class RequiredTemplateKind {
7437 public:
7438 /// Template name is required if TemplateKWLoc is valid.
7439 RequiredTemplateKind(SourceLocation TemplateKWLoc = SourceLocation())
7440 : TemplateKW(TemplateKWLoc) {}
7441 /// Template name is unconditionally required.
7442 RequiredTemplateKind(TemplateNameIsRequiredTag) : TemplateKW() {}
7443
7444 SourceLocation getTemplateKeywordLoc() const {
7445 return TemplateKW.getValueOr(SourceLocation());
7446 }
7447 bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }
7448 bool isRequired() const { return TemplateKW != SourceLocation(); }
7449 explicit operator bool() const { return isRequired(); }
7450
7451 private:
7452 llvm::Optional<SourceLocation> TemplateKW;
7453 };
7454
7455 enum class AssumedTemplateKind {
7456 /// This is not assumed to be a template name.
7457 None,
7458 /// This is assumed to be a template name because lookup found nothing.
7459 FoundNothing,
7460 /// This is assumed to be a template name because lookup found one or more
7461 /// functions (but no function templates).
7462 FoundFunctions,
7463 };
7464 bool LookupTemplateName(
7465 LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType,
7466 bool EnteringContext, bool &MemberOfUnknownSpecialization,
7467 RequiredTemplateKind RequiredTemplate = SourceLocation(),
7468 AssumedTemplateKind *ATK = nullptr, bool AllowTypoCorrection = true);
7469
7470 TemplateNameKind isTemplateName(Scope *S,
7471 CXXScopeSpec &SS,
7472 bool hasTemplateKeyword,
7473 const UnqualifiedId &Name,
7474 ParsedType ObjectType,
7475 bool EnteringContext,
7476 TemplateTy &Template,
7477 bool &MemberOfUnknownSpecialization,
7478 bool Disambiguation = false);
7479
7480 /// Try to resolve an undeclared template name as a type template.
7481 ///
7482 /// Sets II to the identifier corresponding to the template name, and updates
7483 /// Name to a corresponding (typo-corrected) type template name and TNK to
7484 /// the corresponding kind, if possible.
7485 void ActOnUndeclaredTypeTemplateName(Scope *S, TemplateTy &Name,
7486 TemplateNameKind &TNK,
7487 SourceLocation NameLoc,
7488 IdentifierInfo *&II);
7489
7490 bool resolveAssumedTemplateNameAsType(Scope *S, TemplateName &Name,
7491 SourceLocation NameLoc,
7492 bool Diagnose = true);
7493
7494 /// Determine whether a particular identifier might be the name in a C++1z
7495 /// deduction-guide declaration.
7496 bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name,
7497 SourceLocation NameLoc,
7498 ParsedTemplateTy *Template = nullptr);
7499
7500 bool DiagnoseUnknownTemplateName(const IdentifierInfo &II,
7501 SourceLocation IILoc,
7502 Scope *S,
7503 const CXXScopeSpec *SS,
7504 TemplateTy &SuggestedTemplate,
7505 TemplateNameKind &SuggestedKind);
7506
7507 bool DiagnoseUninstantiableTemplate(SourceLocation PointOfInstantiation,
7508 NamedDecl *Instantiation,
7509 bool InstantiatedFromMember,
7510 const NamedDecl *Pattern,
7511 const NamedDecl *PatternDef,
7512 TemplateSpecializationKind TSK,
7513 bool Complain = true);
7514
7515 void DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl);
7516 TemplateDecl *AdjustDeclIfTemplate(Decl *&Decl);
7517
7518 NamedDecl *ActOnTypeParameter(Scope *S, bool Typename,
7519 SourceLocation EllipsisLoc,
7520 SourceLocation KeyLoc,
7521 IdentifierInfo *ParamName,
7522 SourceLocation ParamNameLoc,
7523 unsigned Depth, unsigned Position,
7524 SourceLocation EqualLoc,
7525 ParsedType DefaultArg, bool HasTypeConstraint);
7526
7527 bool ActOnTypeConstraint(const CXXScopeSpec &SS,
7528 TemplateIdAnnotation *TypeConstraint,
7529 TemplateTypeParmDecl *ConstrainedParameter,
7530 SourceLocation EllipsisLoc);
7531 bool BuildTypeConstraint(const CXXScopeSpec &SS,
7532 TemplateIdAnnotation *TypeConstraint,
7533 TemplateTypeParmDecl *ConstrainedParameter,
7534 SourceLocation EllipsisLoc,
7535 bool AllowUnexpandedPack);
7536
7537 bool AttachTypeConstraint(NestedNameSpecifierLoc NS,
7538 DeclarationNameInfo NameInfo,
7539 ConceptDecl *NamedConcept,
7540 const TemplateArgumentListInfo *TemplateArgs,
7541 TemplateTypeParmDecl *ConstrainedParameter,
7542 SourceLocation EllipsisLoc);
7543
7544 bool AttachTypeConstraint(AutoTypeLoc TL,
7545 NonTypeTemplateParmDecl *ConstrainedParameter,
7546 SourceLocation EllipsisLoc);
7547
7548 bool RequireStructuralType(QualType T, SourceLocation Loc);
7549
7550 QualType CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI,
7551 SourceLocation Loc);
7552 QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
7553
7554 NamedDecl *ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
7555 unsigned Depth,
7556 unsigned Position,
7557 SourceLocation EqualLoc,
7558 Expr *DefaultArg);
7559 NamedDecl *ActOnTemplateTemplateParameter(Scope *S,
7560 SourceLocation TmpLoc,
7561 TemplateParameterList *Params,
7562 SourceLocation EllipsisLoc,
7563 IdentifierInfo *ParamName,
7564 SourceLocation ParamNameLoc,
7565 unsigned Depth,
7566 unsigned Position,
7567 SourceLocation EqualLoc,
7568 ParsedTemplateArgument DefaultArg);
7569
7570 TemplateParameterList *
7571 ActOnTemplateParameterList(unsigned Depth,
7572 SourceLocation ExportLoc,
7573 SourceLocation TemplateLoc,
7574 SourceLocation LAngleLoc,
7575 ArrayRef<NamedDecl *> Params,
7576 SourceLocation RAngleLoc,
7577 Expr *RequiresClause);
7578
7579 /// The context in which we are checking a template parameter list.
7580 enum TemplateParamListContext {
7581 TPC_ClassTemplate,
7582 TPC_VarTemplate,
7583 TPC_FunctionTemplate,
7584 TPC_ClassTemplateMember,
7585 TPC_FriendClassTemplate,
7586 TPC_FriendFunctionTemplate,
7587 TPC_FriendFunctionTemplateDefinition,
7588 TPC_TypeAliasTemplate
7589 };
7590
7591 bool CheckTemplateParameterList(TemplateParameterList *NewParams,
7592 TemplateParameterList *OldParams,
7593 TemplateParamListContext TPC,
7594 SkipBodyInfo *SkipBody = nullptr);
7595 TemplateParameterList *MatchTemplateParametersToScopeSpecifier(
7596 SourceLocation DeclStartLoc, SourceLocation DeclLoc,
7597 const CXXScopeSpec &SS, TemplateIdAnnotation *TemplateId,
7598 ArrayRef<TemplateParameterList *> ParamLists,
7599 bool IsFriend, bool &IsMemberSpecialization, bool &Invalid,
7600 bool SuppressDiagnostic = false);
7601
7602 DeclResult CheckClassTemplate(
7603 Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
7604 CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc,
7605 const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams,
7606 AccessSpecifier AS, SourceLocation ModulePrivateLoc,
7607 SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists,
7608 TemplateParameterList **OuterTemplateParamLists,
7609 SkipBodyInfo *SkipBody = nullptr);
7610
7611 TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg,
7612 QualType NTTPType,
7613 SourceLocation Loc);
7614
7615 /// Get a template argument mapping the given template parameter to itself,
7616 /// e.g. for X in \c template<int X>, this would return an expression template
7617 /// argument referencing X.
7618 TemplateArgumentLoc getIdentityTemplateArgumentLoc(NamedDecl *Param,
7619 SourceLocation Location);
7620
7621 void translateTemplateArguments(const ASTTemplateArgsPtr &In,
7622 TemplateArgumentListInfo &Out);
7623
7624 ParsedTemplateArgument ActOnTemplateTypeArgument(TypeResult ParsedType);
7625
7626 void NoteAllFoundTemplates(TemplateName Name);
7627
7628 QualType CheckTemplateIdType(TemplateName Template,
7629 SourceLocation TemplateLoc,
7630 TemplateArgumentListInfo &TemplateArgs);
7631
7632 TypeResult
7633 ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
7634 TemplateTy Template, IdentifierInfo *TemplateII,
7635 SourceLocation TemplateIILoc, SourceLocation LAngleLoc,
7636 ASTTemplateArgsPtr TemplateArgs, SourceLocation RAngleLoc,
7637 bool IsCtorOrDtorName = false, bool IsClassName = false);
7638
7639 /// Parsed an elaborated-type-specifier that refers to a template-id,
7640 /// such as \c class T::template apply<U>.
7641 TypeResult ActOnTagTemplateIdType(TagUseKind TUK,
7642 TypeSpecifierType TagSpec,
7643 SourceLocation TagLoc,
7644 CXXScopeSpec &SS,
7645 SourceLocation TemplateKWLoc,
7646 TemplateTy TemplateD,
7647 SourceLocation TemplateLoc,
7648 SourceLocation LAngleLoc,
7649 ASTTemplateArgsPtr TemplateArgsIn,
7650 SourceLocation RAngleLoc);
7651
7652 DeclResult ActOnVarTemplateSpecialization(
7653 Scope *S, Declarator &D, TypeSourceInfo *DI,
7654 SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams,
7655 StorageClass SC, bool IsPartialSpecialization);
7656
7657 /// Get the specialization of the given variable template corresponding to
7658 /// the specified argument list, or a null-but-valid result if the arguments
7659 /// are dependent.
7660 DeclResult CheckVarTemplateId(VarTemplateDecl *Template,
7661 SourceLocation TemplateLoc,
7662 SourceLocation TemplateNameLoc,
7663 const TemplateArgumentListInfo &TemplateArgs);
7664
7665 /// Form a reference to the specialization of the given variable template
7666 /// corresponding to the specified argument list, or a null-but-valid result
7667 /// if the arguments are dependent.
7668 ExprResult CheckVarTemplateId(const CXXScopeSpec &SS,
7669 const DeclarationNameInfo &NameInfo,
7670 VarTemplateDecl *Template,
7671 SourceLocation TemplateLoc,
7672 const TemplateArgumentListInfo *TemplateArgs);
7673
7674 ExprResult
7675 CheckConceptTemplateId(const CXXScopeSpec &SS,
7676 SourceLocation TemplateKWLoc,
7677 const DeclarationNameInfo &ConceptNameInfo,
7678 NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
7679 const TemplateArgumentListInfo *TemplateArgs);
7680
7681 void diagnoseMissingTemplateArguments(TemplateName Name, SourceLocation Loc);
7682
7683 ExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS,
7684 SourceLocation TemplateKWLoc,
7685 LookupResult &R,
7686 bool RequiresADL,
7687 const TemplateArgumentListInfo *TemplateArgs);
7688
7689 ExprResult BuildQualifiedTemplateIdExpr(CXXScopeSpec &SS,
7690 SourceLocation TemplateKWLoc,
7691 const DeclarationNameInfo &NameInfo,
7692 const TemplateArgumentListInfo *TemplateArgs);
7693
7694 TemplateNameKind ActOnTemplateName(
7695 Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
7696 const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext,
7697 TemplateTy &Template, bool AllowInjectedClassName = false);
7698
7699 DeclResult ActOnClassTemplateSpecialization(
7700 Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc,
7701 SourceLocation ModulePrivateLoc, CXXScopeSpec &SS,
7702 TemplateIdAnnotation &TemplateId, const ParsedAttributesView &Attr,
7703 MultiTemplateParamsArg TemplateParameterLists,
7704 SkipBodyInfo *SkipBody = nullptr);
7705
7706 bool CheckTemplatePartialSpecializationArgs(SourceLocation Loc,
7707 TemplateDecl *PrimaryTemplate,
7708 unsigned NumExplicitArgs,
7709 ArrayRef<TemplateArgument> Args);
7710 void CheckTemplatePartialSpecialization(
7711 ClassTemplatePartialSpecializationDecl *Partial);
7712 void CheckTemplatePartialSpecialization(
7713 VarTemplatePartialSpecializationDecl *Partial);
7714
7715 Decl *ActOnTemplateDeclarator(Scope *S,
7716 MultiTemplateParamsArg TemplateParameterLists,
7717 Declarator &D);
7718
7719 bool
7720 CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
7721 TemplateSpecializationKind NewTSK,
7722 NamedDecl *PrevDecl,
7723 TemplateSpecializationKind PrevTSK,
7724 SourceLocation PrevPtOfInstantiation,
7725 bool &SuppressNew);
7726
7727 bool CheckDependentFunctionTemplateSpecialization(FunctionDecl *FD,
7728 const TemplateArgumentListInfo &ExplicitTemplateArgs,
7729 LookupResult &Previous);
7730
7731 bool CheckFunctionTemplateSpecialization(
7732 FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs,
7733 LookupResult &Previous, bool QualifiedFriend = false);
7734 bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous);
7735 void CompleteMemberSpecialization(NamedDecl *Member, LookupResult &Previous);
7736
7737 DeclResult ActOnExplicitInstantiation(
7738 Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc,
7739 unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS,
7740 TemplateTy Template, SourceLocation TemplateNameLoc,
7741 SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgs,
7742 SourceLocation RAngleLoc, const ParsedAttributesView &Attr);
7743
7744 DeclResult ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc,
7745 SourceLocation TemplateLoc,
7746 unsigned TagSpec, SourceLocation KWLoc,
7747 CXXScopeSpec &SS, IdentifierInfo *Name,
7748 SourceLocation NameLoc,
7749 const ParsedAttributesView &Attr);
7750
7751 DeclResult ActOnExplicitInstantiation(Scope *S,
7752 SourceLocation ExternLoc,
7753 SourceLocation TemplateLoc,
7754 Declarator &D);
7755
7756 TemplateArgumentLoc
7757 SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
7758 SourceLocation TemplateLoc,
7759 SourceLocation RAngleLoc,
7760 Decl *Param,
7761 SmallVectorImpl<TemplateArgument>
7762 &Converted,
7763 bool &HasDefaultArg);
7764
7765 /// Specifies the context in which a particular template
7766 /// argument is being checked.
7767 enum CheckTemplateArgumentKind {
7768 /// The template argument was specified in the code or was
7769 /// instantiated with some deduced template arguments.
7770 CTAK_Specified,
7771
7772 /// The template argument was deduced via template argument
7773 /// deduction.
7774 CTAK_Deduced,
7775
7776 /// The template argument was deduced from an array bound
7777 /// via template argument deduction.
7778 CTAK_DeducedFromArrayBound
7779 };
7780
7781 bool CheckTemplateArgument(NamedDecl *Param,
7782 TemplateArgumentLoc &Arg,
7783 NamedDecl *Template,
7784 SourceLocation TemplateLoc,
7785 SourceLocation RAngleLoc,
7786 unsigned ArgumentPackIndex,
7787 SmallVectorImpl<TemplateArgument> &Converted,
7788 CheckTemplateArgumentKind CTAK = CTAK_Specified);
7789
7790 /// Check that the given template arguments can be be provided to
7791 /// the given template, converting the arguments along the way.
7792 ///
7793 /// \param Template The template to which the template arguments are being
7794 /// provided.
7795 ///
7796 /// \param TemplateLoc The location of the template name in the source.
7797 ///
7798 /// \param TemplateArgs The list of template arguments. If the template is
7799 /// a template template parameter, this function may extend the set of
7800 /// template arguments to also include substituted, defaulted template
7801 /// arguments.
7802 ///
7803 /// \param PartialTemplateArgs True if the list of template arguments is
7804 /// intentionally partial, e.g., because we're checking just the initial
7805 /// set of template arguments.
7806 ///
7807 /// \param Converted Will receive the converted, canonicalized template
7808 /// arguments.
7809 ///
7810 /// \param UpdateArgsWithConversions If \c true, update \p TemplateArgs to
7811 /// contain the converted forms of the template arguments as written.
7812 /// Otherwise, \p TemplateArgs will not be modified.
7813 ///
7814 /// \param ConstraintsNotSatisfied If provided, and an error occured, will
7815 /// receive true if the cause for the error is the associated constraints of
7816 /// the template not being satisfied by the template arguments.
7817 ///
7818 /// \returns true if an error occurred, false otherwise.
7819 bool CheckTemplateArgumentList(TemplateDecl *Template,
7820 SourceLocation TemplateLoc,
7821 TemplateArgumentListInfo &TemplateArgs,
7822 bool PartialTemplateArgs,
7823 SmallVectorImpl<TemplateArgument> &Converted,
7824 bool UpdateArgsWithConversions = true,
7825 bool *ConstraintsNotSatisfied = nullptr);
7826
7827 bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
7828 TemplateArgumentLoc &Arg,
7829 SmallVectorImpl<TemplateArgument> &Converted);
7830
7831 bool CheckTemplateArgument(TypeSourceInfo *Arg);
7832 ExprResult CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
7833 QualType InstantiatedParamType, Expr *Arg,
7834 TemplateArgument &Converted,
7835 CheckTemplateArgumentKind CTAK = CTAK_Specified);
7836 bool CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
7837 TemplateParameterList *Params,
7838 TemplateArgumentLoc &Arg);
7839
7840 ExprResult
7841 BuildExpressionFromDeclTemplateArgument(const TemplateArgument &Arg,
7842 QualType ParamType,
7843 SourceLocation Loc);
7844 ExprResult
7845 BuildExpressionFromIntegralTemplateArgument(const TemplateArgument &Arg,
7846 SourceLocation Loc);
7847
7848 /// Enumeration describing how template parameter lists are compared
7849 /// for equality.
7850 enum TemplateParameterListEqualKind {
7851 /// We are matching the template parameter lists of two templates
7852 /// that might be redeclarations.
7853 ///
7854 /// \code
7855 /// template<typename T> struct X;
7856 /// template<typename T> struct X;
7857 /// \endcode
7858 TPL_TemplateMatch,
7859
7860 /// We are matching the template parameter lists of two template
7861 /// template parameters as part of matching the template parameter lists
7862 /// of two templates that might be redeclarations.
7863 ///
7864 /// \code
7865 /// template<template<int I> class TT> struct X;
7866 /// template<template<int Value> class Other> struct X;
7867 /// \endcode
7868 TPL_TemplateTemplateParmMatch,
7869
7870 /// We are matching the template parameter lists of a template
7871 /// template argument against the template parameter lists of a template
7872 /// template parameter.
7873 ///
7874 /// \code
7875 /// template<template<int Value> class Metafun> struct X;
7876 /// template<int Value> struct integer_c;
7877 /// X<integer_c> xic;
7878 /// \endcode
7879 TPL_TemplateTemplateArgumentMatch
7880 };
7881
7882 bool TemplateParameterListsAreEqual(TemplateParameterList *New,
7883 TemplateParameterList *Old,
7884 bool Complain,
7885 TemplateParameterListEqualKind Kind,
7886 SourceLocation TemplateArgLoc
7887 = SourceLocation());
7888
7889 bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams);
7890
7891 /// Called when the parser has parsed a C++ typename
7892 /// specifier, e.g., "typename T::type".
7893 ///
7894 /// \param S The scope in which this typename type occurs.
7895 /// \param TypenameLoc the location of the 'typename' keyword
7896 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
7897 /// \param II the identifier we're retrieving (e.g., 'type' in the example).
7898 /// \param IdLoc the location of the identifier.
7899 TypeResult
7900 ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
7901 const CXXScopeSpec &SS, const IdentifierInfo &II,
7902 SourceLocation IdLoc);
7903
7904 /// Called when the parser has parsed a C++ typename
7905 /// specifier that ends in a template-id, e.g.,
7906 /// "typename MetaFun::template apply<T1, T2>".
7907 ///
7908 /// \param S The scope in which this typename type occurs.
7909 /// \param TypenameLoc the location of the 'typename' keyword
7910 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
7911 /// \param TemplateLoc the location of the 'template' keyword, if any.
7912 /// \param TemplateName The template name.
7913 /// \param TemplateII The identifier used to name the template.
7914 /// \param TemplateIILoc The location of the template name.
7915 /// \param LAngleLoc The location of the opening angle bracket ('<').
7916 /// \param TemplateArgs The template arguments.
7917 /// \param RAngleLoc The location of the closing angle bracket ('>').
7918 TypeResult
7919 ActOnTypenameType(Scope *S, SourceLocation TypenameLoc,
7920 const CXXScopeSpec &SS,
7921 SourceLocation TemplateLoc,
7922 TemplateTy TemplateName,
7923 IdentifierInfo *TemplateII,
7924 SourceLocation TemplateIILoc,
7925 SourceLocation LAngleLoc,
7926 ASTTemplateArgsPtr TemplateArgs,
7927 SourceLocation RAngleLoc);
7928
7929 QualType CheckTypenameType(ElaboratedTypeKeyword Keyword,
7930 SourceLocation KeywordLoc,
7931 NestedNameSpecifierLoc QualifierLoc,
7932 const IdentifierInfo &II,
7933 SourceLocation IILoc,
7934 TypeSourceInfo **TSI,
7935 bool DeducedTSTContext);
7936
7937 QualType CheckTypenameType(ElaboratedTypeKeyword Keyword,
7938 SourceLocation KeywordLoc,
7939 NestedNameSpecifierLoc QualifierLoc,
7940 const IdentifierInfo &II,
7941 SourceLocation IILoc,
7942 bool DeducedTSTContext = true);
7943
7944
7945 TypeSourceInfo *RebuildTypeInCurrentInstantiation(TypeSourceInfo *T,
7946 SourceLocation Loc,
7947 DeclarationName Name);
7948 bool RebuildNestedNameSpecifierInCurrentInstantiation(CXXScopeSpec &SS);
7949
7950 ExprResult RebuildExprInCurrentInstantiation(Expr *E);
7951 bool RebuildTemplateParamsInCurrentInstantiation(
7952 TemplateParameterList *Params);
7953
7954 std::string
7955 getTemplateArgumentBindingsText(const TemplateParameterList *Params,
7956 const TemplateArgumentList &Args);
7957
7958 std::string
7959 getTemplateArgumentBindingsText(const TemplateParameterList *Params,
7960 const TemplateArgument *Args,
7961 unsigned NumArgs);
7962
7963 //===--------------------------------------------------------------------===//
7964 // C++ Concepts
7965 //===--------------------------------------------------------------------===//
7966 Decl *ActOnConceptDefinition(
7967 Scope *S, MultiTemplateParamsArg TemplateParameterLists,
7968 IdentifierInfo *Name, SourceLocation NameLoc, Expr *ConstraintExpr);
7969
7970 RequiresExprBodyDecl *
7971 ActOnStartRequiresExpr(SourceLocation RequiresKWLoc,
7972 ArrayRef<ParmVarDecl *> LocalParameters,
7973 Scope *BodyScope);
7974 void ActOnFinishRequiresExpr();
7975 concepts::Requirement *ActOnSimpleRequirement(Expr *E);
7976 concepts::Requirement *ActOnTypeRequirement(
7977 SourceLocation TypenameKWLoc, CXXScopeSpec &SS, SourceLocation NameLoc,
7978 IdentifierInfo *TypeName, TemplateIdAnnotation *TemplateId);
7979 concepts::Requirement *ActOnCompoundRequirement(Expr *E,
7980 SourceLocation NoexceptLoc);
7981 concepts::Requirement *
7982 ActOnCompoundRequirement(
7983 Expr *E, SourceLocation NoexceptLoc, CXXScopeSpec &SS,
7984 TemplateIdAnnotation *TypeConstraint, unsigned Depth);
7985 concepts::Requirement *ActOnNestedRequirement(Expr *Constraint);
7986 concepts::ExprRequirement *
7987 BuildExprRequirement(
7988 Expr *E, bool IsSatisfied, SourceLocation NoexceptLoc,
7989 concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement);
7990 concepts::ExprRequirement *
7991 BuildExprRequirement(
7992 concepts::Requirement::SubstitutionDiagnostic *ExprSubstDiag,
7993 bool IsSatisfied, SourceLocation NoexceptLoc,
7994 concepts::ExprRequirement::ReturnTypeRequirement ReturnTypeRequirement);
7995 concepts::TypeRequirement *BuildTypeRequirement(TypeSourceInfo *Type);
7996 concepts::TypeRequirement *
7997 BuildTypeRequirement(
7998 concepts::Requirement::SubstitutionDiagnostic *SubstDiag);
7999 concepts::NestedRequirement *BuildNestedRequirement(Expr *E);
8000 concepts::NestedRequirement *
8001 BuildNestedRequirement(
8002 concepts::Requirement::SubstitutionDiagnostic *SubstDiag);
8003 ExprResult ActOnRequiresExpr(SourceLocation RequiresKWLoc,
8004 RequiresExprBodyDecl *Body,
8005 ArrayRef<ParmVarDecl *> LocalParameters,
8006 ArrayRef<concepts::Requirement *> Requirements,
8007 SourceLocation ClosingBraceLoc);
8008
8009 //===--------------------------------------------------------------------===//
8010 // C++ Variadic Templates (C++0x [temp.variadic])
8011 //===--------------------------------------------------------------------===//
8012
8013 /// Determine whether an unexpanded parameter pack might be permitted in this
8014 /// location. Useful for error recovery.
8015 bool isUnexpandedParameterPackPermitted();
8016
8017 /// The context in which an unexpanded parameter pack is
8018 /// being diagnosed.
8019 ///
8020 /// Note that the values of this enumeration line up with the first
8021 /// argument to the \c err_unexpanded_parameter_pack diagnostic.
8022 enum UnexpandedParameterPackContext {
8023 /// An arbitrary expression.
8024 UPPC_Expression = 0,
8025
8026 /// The base type of a class type.
8027 UPPC_BaseType,
8028
8029 /// The type of an arbitrary declaration.
8030 UPPC_DeclarationType,
8031
8032 /// The type of a data member.
8033 UPPC_DataMemberType,
8034
8035 /// The size of a bit-field.
8036 UPPC_BitFieldWidth,
8037
8038 /// The expression in a static assertion.
8039 UPPC_StaticAssertExpression,
8040
8041 /// The fixed underlying type of an enumeration.
8042 UPPC_FixedUnderlyingType,
8043
8044 /// The enumerator value.
8045 UPPC_EnumeratorValue,
8046
8047 /// A using declaration.
8048 UPPC_UsingDeclaration,
8049
8050 /// A friend declaration.
8051 UPPC_FriendDeclaration,
8052
8053 /// A declaration qualifier.
8054 UPPC_DeclarationQualifier,
8055
8056 /// An initializer.
8057 UPPC_Initializer,
8058
8059 /// A default argument.
8060 UPPC_DefaultArgument,
8061
8062 /// The type of a non-type template parameter.
8063 UPPC_NonTypeTemplateParameterType,
8064
8065 /// The type of an exception.
8066 UPPC_ExceptionType,
8067
8068 /// Partial specialization.
8069 UPPC_PartialSpecialization,
8070
8071 /// Microsoft __if_exists.
8072 UPPC_IfExists,
8073
8074 /// Microsoft __if_not_exists.
8075 UPPC_IfNotExists,
8076
8077 /// Lambda expression.
8078 UPPC_Lambda,
8079
8080 /// Block expression.
8081 UPPC_Block,
8082
8083 /// A type constraint.
8084 UPPC_TypeConstraint,
8085
8086 // A requirement in a requires-expression.
8087 UPPC_Requirement,
8088
8089 // A requires-clause.
8090 UPPC_RequiresClause,
8091 };
8092
8093 /// Diagnose unexpanded parameter packs.
8094 ///
8095 /// \param Loc The location at which we should emit the diagnostic.
8096 ///
8097 /// \param UPPC The context in which we are diagnosing unexpanded
8098 /// parameter packs.
8099 ///
8100 /// \param Unexpanded the set of unexpanded parameter packs.
8101 ///
8102 /// \returns true if an error occurred, false otherwise.
8103 bool DiagnoseUnexpandedParameterPacks(SourceLocation Loc,
8104 UnexpandedParameterPackContext UPPC,
8105 ArrayRef<UnexpandedParameterPack> Unexpanded);
8106
8107 /// If the given type contains an unexpanded parameter pack,
8108 /// diagnose the error.
8109 ///
8110 /// \param Loc The source location where a diagnostc should be emitted.
8111 ///
8112 /// \param T The type that is being checked for unexpanded parameter
8113 /// packs.
8114 ///
8115 /// \returns true if an error occurred, false otherwise.
8116 bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T,
8117 UnexpandedParameterPackContext UPPC);
8118
8119 /// If the given expression contains an unexpanded parameter
8120 /// pack, diagnose the error.
8121 ///
8122 /// \param E The expression that is being checked for unexpanded
8123 /// parameter packs.
8124 ///
8125 /// \returns true if an error occurred, false otherwise.
8126 bool DiagnoseUnexpandedParameterPack(Expr *E,
8127 UnexpandedParameterPackContext UPPC = UPPC_Expression);
8128
8129 /// If the given requirees-expression contains an unexpanded reference to one
8130 /// of its own parameter packs, diagnose the error.
8131 ///
8132 /// \param RE The requiress-expression that is being checked for unexpanded
8133 /// parameter packs.
8134 ///
8135 /// \returns true if an error occurred, false otherwise.
8136 bool DiagnoseUnexpandedParameterPackInRequiresExpr(RequiresExpr *RE);
8137
8138 /// If the given nested-name-specifier contains an unexpanded
8139 /// parameter pack, diagnose the error.
8140 ///
8141 /// \param SS The nested-name-specifier that is being checked for
8142 /// unexpanded parameter packs.
8143 ///
8144 /// \returns true if an error occurred, false otherwise.
8145 bool DiagnoseUnexpandedParameterPack(const CXXScopeSpec &SS,
8146 UnexpandedParameterPackContext UPPC);
8147
8148 /// If the given name contains an unexpanded parameter pack,
8149 /// diagnose the error.
8150 ///
8151 /// \param NameInfo The name (with source location information) that
8152 /// is being checked for unexpanded parameter packs.
8153 ///
8154 /// \returns true if an error occurred, false otherwise.
8155 bool DiagnoseUnexpandedParameterPack(const DeclarationNameInfo &NameInfo,
8156 UnexpandedParameterPackContext UPPC);
8157
8158 /// If the given template name contains an unexpanded parameter pack,
8159 /// diagnose the error.
8160 ///
8161 /// \param Loc The location of the template name.
8162 ///
8163 /// \param Template The template name that is being checked for unexpanded
8164 /// parameter packs.
8165 ///
8166 /// \returns true if an error occurred, false otherwise.
8167 bool DiagnoseUnexpandedParameterPack(SourceLocation Loc,
8168 TemplateName Template,
8169 UnexpandedParameterPackContext UPPC);
8170
8171 /// If the given template argument contains an unexpanded parameter
8172 /// pack, diagnose the error.
8173 ///
8174 /// \param Arg The template argument that is being checked for unexpanded
8175 /// parameter packs.
8176 ///
8177 /// \returns true if an error occurred, false otherwise.
8178 bool DiagnoseUnexpandedParameterPack(TemplateArgumentLoc Arg,
8179 UnexpandedParameterPackContext UPPC);
8180
8181 /// Collect the set of unexpanded parameter packs within the given
8182 /// template argument.
8183 ///
8184 /// \param Arg The template argument that will be traversed to find
8185 /// unexpanded parameter packs.
8186 void collectUnexpandedParameterPacks(TemplateArgument Arg,
8187 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8188
8189 /// Collect the set of unexpanded parameter packs within the given
8190 /// template argument.
8191 ///
8192 /// \param Arg The template argument that will be traversed to find
8193 /// unexpanded parameter packs.
8194 void collectUnexpandedParameterPacks(TemplateArgumentLoc Arg,
8195 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8196
8197 /// Collect the set of unexpanded parameter packs within the given
8198 /// type.
8199 ///
8200 /// \param T The type that will be traversed to find
8201 /// unexpanded parameter packs.
8202 void collectUnexpandedParameterPacks(QualType T,
8203 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8204
8205 /// Collect the set of unexpanded parameter packs within the given
8206 /// type.
8207 ///
8208 /// \param TL The type that will be traversed to find
8209 /// unexpanded parameter packs.
8210 void collectUnexpandedParameterPacks(TypeLoc TL,
8211 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8212
8213 /// Collect the set of unexpanded parameter packs within the given
8214 /// nested-name-specifier.
8215 ///
8216 /// \param NNS The nested-name-specifier that will be traversed to find
8217 /// unexpanded parameter packs.
8218 void collectUnexpandedParameterPacks(NestedNameSpecifierLoc NNS,
8219 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8220
8221 /// Collect the set of unexpanded parameter packs within the given
8222 /// name.
8223 ///
8224 /// \param NameInfo The name that will be traversed to find
8225 /// unexpanded parameter packs.
8226 void collectUnexpandedParameterPacks(const DeclarationNameInfo &NameInfo,
8227 SmallVectorImpl<UnexpandedParameterPack> &Unexpanded);
8228
8229 /// Invoked when parsing a template argument followed by an
8230 /// ellipsis, which creates a pack expansion.
8231 ///
8232 /// \param Arg The template argument preceding the ellipsis, which
8233 /// may already be invalid.
8234 ///
8235 /// \param EllipsisLoc The location of the ellipsis.
8236 ParsedTemplateArgument ActOnPackExpansion(const ParsedTemplateArgument &Arg,
8237 SourceLocation EllipsisLoc);
8238
8239 /// Invoked when parsing a type followed by an ellipsis, which
8240 /// creates a pack expansion.
8241 ///
8242 /// \param Type The type preceding the ellipsis, which will become
8243 /// the pattern of the pack expansion.
8244 ///
8245 /// \param EllipsisLoc The location of the ellipsis.
8246 TypeResult ActOnPackExpansion(ParsedType Type, SourceLocation EllipsisLoc);
8247
8248 /// Construct a pack expansion type from the pattern of the pack
8249 /// expansion.
8250 TypeSourceInfo *CheckPackExpansion(TypeSourceInfo *Pattern,
8251 SourceLocation EllipsisLoc,
8252 Optional<unsigned> NumExpansions);
8253
8254 /// Construct a pack expansion type from the pattern of the pack
8255 /// expansion.
8256 QualType CheckPackExpansion(QualType Pattern,
8257 SourceRange PatternRange,
8258 SourceLocation EllipsisLoc,
8259 Optional<unsigned> NumExpansions);
8260
8261 /// Invoked when parsing an expression followed by an ellipsis, which
8262 /// creates a pack expansion.
8263 ///
8264 /// \param Pattern The expression preceding the ellipsis, which will become
8265 /// the pattern of the pack expansion.
8266 ///
8267 /// \param EllipsisLoc The location of the ellipsis.
8268 ExprResult ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc);
8269
8270 /// Invoked when parsing an expression followed by an ellipsis, which
8271 /// creates a pack expansion.
8272 ///
8273 /// \param Pattern The expression preceding the ellipsis, which will become
8274 /// the pattern of the pack expansion.
8275 ///
8276 /// \param EllipsisLoc The location of the ellipsis.
8277 ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc,
8278 Optional<unsigned> NumExpansions);
8279
8280 /// Determine whether we could expand a pack expansion with the
8281 /// given set of parameter packs into separate arguments by repeatedly
8282 /// transforming the pattern.
8283 ///
8284 /// \param EllipsisLoc The location of the ellipsis that identifies the
8285 /// pack expansion.
8286 ///
8287 /// \param PatternRange The source range that covers the entire pattern of
8288 /// the pack expansion.
8289 ///
8290 /// \param Unexpanded The set of unexpanded parameter packs within the
8291 /// pattern.
8292 ///
8293 /// \param ShouldExpand Will be set to \c true if the transformer should
8294 /// expand the corresponding pack expansions into separate arguments. When
8295 /// set, \c NumExpansions must also be set.
8296 ///
8297 /// \param RetainExpansion Whether the caller should add an unexpanded
8298 /// pack expansion after all of the expanded arguments. This is used
8299 /// when extending explicitly-specified template argument packs per
8300 /// C++0x [temp.arg.explicit]p9.
8301 ///
8302 /// \param NumExpansions The number of separate arguments that will be in
8303 /// the expanded form of the corresponding pack expansion. This is both an
8304 /// input and an output parameter, which can be set by the caller if the
8305 /// number of expansions is known a priori (e.g., due to a prior substitution)
8306 /// and will be set by the callee when the number of expansions is known.
8307 /// The callee must set this value when \c ShouldExpand is \c true; it may
8308 /// set this value in other cases.
8309 ///
8310 /// \returns true if an error occurred (e.g., because the parameter packs
8311 /// are to be instantiated with arguments of different lengths), false
8312 /// otherwise. If false, \c ShouldExpand (and possibly \c NumExpansions)
8313 /// must be set.
8314 bool CheckParameterPacksForExpansion(SourceLocation EllipsisLoc,
8315 SourceRange PatternRange,
8316 ArrayRef<UnexpandedParameterPack> Unexpanded,
8317 const MultiLevelTemplateArgumentList &TemplateArgs,
8318 bool &ShouldExpand,
8319 bool &RetainExpansion,
8320 Optional<unsigned> &NumExpansions);
8321
8322 /// Determine the number of arguments in the given pack expansion
8323 /// type.
8324 ///
8325 /// This routine assumes that the number of arguments in the expansion is
8326 /// consistent across all of the unexpanded parameter packs in its pattern.
8327 ///
8328 /// Returns an empty Optional if the type can't be expanded.
8329 Optional<unsigned> getNumArgumentsInExpansion(QualType T,
8330 const MultiLevelTemplateArgumentList &TemplateArgs);
8331
8332 /// Determine whether the given declarator contains any unexpanded
8333 /// parameter packs.
8334 ///
8335 /// This routine is used by the parser to disambiguate function declarators
8336 /// with an ellipsis prior to the ')', e.g.,
8337 ///
8338 /// \code
8339 /// void f(T...);
8340 /// \endcode
8341 ///
8342 /// To determine whether we have an (unnamed) function parameter pack or
8343 /// a variadic function.
8344 ///
8345 /// \returns true if the declarator contains any unexpanded parameter packs,
8346 /// false otherwise.
8347 bool containsUnexpandedParameterPacks(Declarator &D);
8348
8349 /// Returns the pattern of the pack expansion for a template argument.
8350 ///
8351 /// \param OrigLoc The template argument to expand.
8352 ///
8353 /// \param Ellipsis Will be set to the location of the ellipsis.
8354 ///
8355 /// \param NumExpansions Will be set to the number of expansions that will
8356 /// be generated from this pack expansion, if known a priori.
8357 TemplateArgumentLoc getTemplateArgumentPackExpansionPattern(
8358 TemplateArgumentLoc OrigLoc,
8359 SourceLocation &Ellipsis,
8360 Optional<unsigned> &NumExpansions) const;
8361
8362 /// Given a template argument that contains an unexpanded parameter pack, but
8363 /// which has already been substituted, attempt to determine the number of
8364 /// elements that will be produced once this argument is fully-expanded.
8365 ///
8366 /// This is intended for use when transforming 'sizeof...(Arg)' in order to
8367 /// avoid actually expanding the pack where possible.
8368 Optional<unsigned> getFullyPackExpandedSize(TemplateArgument Arg);
8369
8370 //===--------------------------------------------------------------------===//
8371 // C++ Template Argument Deduction (C++ [temp.deduct])
8372 //===--------------------------------------------------------------------===//
8373
8374 /// Adjust the type \p ArgFunctionType to match the calling convention,
8375 /// noreturn, and optionally the exception specification of \p FunctionType.
8376 /// Deduction often wants to ignore these properties when matching function
8377 /// types.
8378 QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType,
8379 bool AdjustExceptionSpec = false);
8380
8381 /// Describes the result of template argument deduction.
8382 ///
8383 /// The TemplateDeductionResult enumeration describes the result of
8384 /// template argument deduction, as returned from
8385 /// DeduceTemplateArguments(). The separate TemplateDeductionInfo
8386 /// structure provides additional information about the results of
8387 /// template argument deduction, e.g., the deduced template argument
8388 /// list (if successful) or the specific template parameters or
8389 /// deduced arguments that were involved in the failure.
8390 enum TemplateDeductionResult {
8391 /// Template argument deduction was successful.
8392 TDK_Success = 0,
8393 /// The declaration was invalid; do nothing.
8394 TDK_Invalid,
8395 /// Template argument deduction exceeded the maximum template
8396 /// instantiation depth (which has already been diagnosed).
8397 TDK_InstantiationDepth,
8398 /// Template argument deduction did not deduce a value
8399 /// for every template parameter.
8400 TDK_Incomplete,
8401 /// Template argument deduction did not deduce a value for every
8402 /// expansion of an expanded template parameter pack.
8403 TDK_IncompletePack,
8404 /// Template argument deduction produced inconsistent
8405 /// deduced values for the given template parameter.
8406 TDK_Inconsistent,
8407 /// Template argument deduction failed due to inconsistent
8408 /// cv-qualifiers on a template parameter type that would
8409 /// otherwise be deduced, e.g., we tried to deduce T in "const T"
8410 /// but were given a non-const "X".
8411 TDK_Underqualified,
8412 /// Substitution of the deduced template argument values
8413 /// resulted in an error.
8414 TDK_SubstitutionFailure,
8415 /// After substituting deduced template arguments, a dependent
8416 /// parameter type did not match the corresponding argument.
8417 TDK_DeducedMismatch,
8418 /// After substituting deduced template arguments, an element of
8419 /// a dependent parameter type did not match the corresponding element
8420 /// of the corresponding argument (when deducing from an initializer list).
8421 TDK_DeducedMismatchNested,
8422 /// A non-depnedent component of the parameter did not match the
8423 /// corresponding component of the argument.
8424 TDK_NonDeducedMismatch,
8425 /// When performing template argument deduction for a function
8426 /// template, there were too many call arguments.
8427 TDK_TooManyArguments,
8428 /// When performing template argument deduction for a function
8429 /// template, there were too few call arguments.
8430 TDK_TooFewArguments,
8431 /// The explicitly-specified template arguments were not valid
8432 /// template arguments for the given template.
8433 TDK_InvalidExplicitArguments,
8434 /// Checking non-dependent argument conversions failed.
8435 TDK_NonDependentConversionFailure,
8436 /// The deduced arguments did not satisfy the constraints associated
8437 /// with the template.
8438 TDK_ConstraintsNotSatisfied,
8439 /// Deduction failed; that's all we know.
8440 TDK_MiscellaneousDeductionFailure,
8441 /// CUDA Target attributes do not match.
8442 TDK_CUDATargetMismatch
8443 };
8444
8445 TemplateDeductionResult
8446 DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
8447 const TemplateArgumentList &TemplateArgs,
8448 sema::TemplateDeductionInfo &Info);
8449
8450 TemplateDeductionResult
8451 DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial,
8452 const TemplateArgumentList &TemplateArgs,
8453 sema::TemplateDeductionInfo &Info);
8454
8455 TemplateDeductionResult SubstituteExplicitTemplateArguments(
8456 FunctionTemplateDecl *FunctionTemplate,
8457 TemplateArgumentListInfo &ExplicitTemplateArgs,
8458 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
8459 SmallVectorImpl<QualType> &ParamTypes, QualType *FunctionType,
8460 sema::TemplateDeductionInfo &Info);
8461
8462 /// brief A function argument from which we performed template argument
8463 // deduction for a call.
8464 struct OriginalCallArg {
8465 OriginalCallArg(QualType OriginalParamType, bool DecomposedParam,
8466 unsigned ArgIdx, QualType OriginalArgType)
8467 : OriginalParamType(OriginalParamType),
8468 DecomposedParam(DecomposedParam), ArgIdx(ArgIdx),
8469 OriginalArgType(OriginalArgType) {}
8470
8471 QualType OriginalParamType;
8472 bool DecomposedParam;
8473 unsigned ArgIdx;
8474 QualType OriginalArgType;
8475 };
8476
8477 TemplateDeductionResult FinishTemplateArgumentDeduction(
8478 FunctionTemplateDecl *FunctionTemplate,
8479 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
8480 unsigned NumExplicitlySpecified, FunctionDecl *&Specialization,
8481 sema::TemplateDeductionInfo &Info,
8482 SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs = nullptr,
8483 bool PartialOverloading = false,
8484 llvm::function_ref<bool()> CheckNonDependent = []{ return false; });
8485
8486 TemplateDeductionResult DeduceTemplateArguments(
8487 FunctionTemplateDecl *FunctionTemplate,
8488 TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
8489 FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info,
8490 bool PartialOverloading,
8491 llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent);
8492
8493 TemplateDeductionResult
8494 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
8495 TemplateArgumentListInfo *ExplicitTemplateArgs,
8496 QualType ArgFunctionType,
8497 FunctionDecl *&Specialization,
8498 sema::TemplateDeductionInfo &Info,
8499 bool IsAddressOfFunction = false);
8500
8501 TemplateDeductionResult
8502 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
8503 QualType ToType,
8504 CXXConversionDecl *&Specialization,
8505 sema::TemplateDeductionInfo &Info);
8506
8507 TemplateDeductionResult
8508 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
8509 TemplateArgumentListInfo *ExplicitTemplateArgs,
8510 FunctionDecl *&Specialization,
8511 sema::TemplateDeductionInfo &Info,
8512 bool IsAddressOfFunction = false);
8513
8514 /// Substitute Replacement for \p auto in \p TypeWithAuto
8515 QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement);
8516 /// Substitute Replacement for auto in TypeWithAuto
8517 TypeSourceInfo* SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,
8518 QualType Replacement);
8519 /// Completely replace the \c auto in \p TypeWithAuto by
8520 /// \p Replacement. This does not retain any \c auto type sugar.
8521 QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement);
8522 TypeSourceInfo *ReplaceAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,
8523 QualType Replacement);
8524
8525 /// Result type of DeduceAutoType.
8526 enum DeduceAutoResult {
8527 DAR_Succeeded,
8528 DAR_Failed,
8529 DAR_FailedAlreadyDiagnosed
8530 };
8531
8532 DeduceAutoResult
8533 DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result,
8534 Optional<unsigned> DependentDeductionDepth = None,
8535 bool IgnoreConstraints = false);
8536 DeduceAutoResult
8537 DeduceAutoType(TypeLoc AutoTypeLoc, Expr *&Initializer, QualType &Result,
8538 Optional<unsigned> DependentDeductionDepth = None,
8539 bool IgnoreConstraints = false);
8540 void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init);
8541 bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc,
8542 bool Diagnose = true);
8543
8544 /// Declare implicit deduction guides for a class template if we've
8545 /// not already done so.
8546 void DeclareImplicitDeductionGuides(TemplateDecl *Template,
8547 SourceLocation Loc);
8548
8549 QualType DeduceTemplateSpecializationFromInitializer(
8550 TypeSourceInfo *TInfo, const InitializedEntity &Entity,
8551 const InitializationKind &Kind, MultiExprArg Init);
8552
8553 QualType deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name,
8554 QualType Type, TypeSourceInfo *TSI,
8555 SourceRange Range, bool DirectInit,
8556 Expr *Init);
8557
8558 TypeLoc getReturnTypeLoc(FunctionDecl *FD) const;
8559
8560 bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD,
8561 SourceLocation ReturnLoc,
8562 Expr *&RetExpr, AutoType *AT);
8563
8564 FunctionTemplateDecl *getMoreSpecializedTemplate(
8565 FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc,
8566 TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1,
8567 unsigned NumCallArguments2, bool Reversed = false);
8568 UnresolvedSetIterator
8569 getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd,
8570 TemplateSpecCandidateSet &FailedCandidates,
8571 SourceLocation Loc,
8572 const PartialDiagnostic &NoneDiag,
8573 const PartialDiagnostic &AmbigDiag,
8574 const PartialDiagnostic &CandidateDiag,
8575 bool Complain = true, QualType TargetType = QualType());
8576
8577 ClassTemplatePartialSpecializationDecl *
8578 getMoreSpecializedPartialSpecialization(
8579 ClassTemplatePartialSpecializationDecl *PS1,
8580 ClassTemplatePartialSpecializationDecl *PS2,
8581 SourceLocation Loc);
8582
8583 bool isMoreSpecializedThanPrimary(ClassTemplatePartialSpecializationDecl *T,
8584 sema::TemplateDeductionInfo &Info);
8585
8586 VarTemplatePartialSpecializationDecl *getMoreSpecializedPartialSpecialization(
8587 VarTemplatePartialSpecializationDecl *PS1,
8588 VarTemplatePartialSpecializationDecl *PS2, SourceLocation Loc);
8589
8590 bool isMoreSpecializedThanPrimary(VarTemplatePartialSpecializationDecl *T,
8591 sema::TemplateDeductionInfo &Info);
8592
8593 bool isTemplateTemplateParameterAtLeastAsSpecializedAs(
8594 TemplateParameterList *PParam, TemplateDecl *AArg, SourceLocation Loc);
8595
8596 void MarkUsedTemplateParameters(const Expr *E, bool OnlyDeduced,
8597 unsigned Depth, llvm::SmallBitVector &Used);
8598
8599 void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
8600 bool OnlyDeduced,
8601 unsigned Depth,
8602 llvm::SmallBitVector &Used);
8603 void MarkDeducedTemplateParameters(
8604 const FunctionTemplateDecl *FunctionTemplate,
8605 llvm::SmallBitVector &Deduced) {
8606 return MarkDeducedTemplateParameters(Context, FunctionTemplate, Deduced);
8607 }
8608 static void MarkDeducedTemplateParameters(ASTContext &Ctx,
8609 const FunctionTemplateDecl *FunctionTemplate,
8610 llvm::SmallBitVector &Deduced);
8611
8612 //===--------------------------------------------------------------------===//
8613 // C++ Template Instantiation
8614 //
8615
8616 MultiLevelTemplateArgumentList
8617 getTemplateInstantiationArgs(NamedDecl *D,
8618 const TemplateArgumentList *Innermost = nullptr,
8619 bool RelativeToPrimary = false,
8620 const FunctionDecl *Pattern = nullptr);
8621
8622 /// A context in which code is being synthesized (where a source location
8623 /// alone is not sufficient to identify the context). This covers template
8624 /// instantiation and various forms of implicitly-generated functions.
8625 struct CodeSynthesisContext {
8626 /// The kind of template instantiation we are performing
8627 enum SynthesisKind {
8628 /// We are instantiating a template declaration. The entity is
8629 /// the declaration we're instantiating (e.g., a CXXRecordDecl).
8630 TemplateInstantiation,
8631
8632 /// We are instantiating a default argument for a template
8633 /// parameter. The Entity is the template parameter whose argument is
8634 /// being instantiated, the Template is the template, and the
8635 /// TemplateArgs/NumTemplateArguments provide the template arguments as
8636 /// specified.
8637 DefaultTemplateArgumentInstantiation,
8638
8639 /// We are instantiating a default argument for a function.
8640 /// The Entity is the ParmVarDecl, and TemplateArgs/NumTemplateArgs
8641 /// provides the template arguments as specified.
8642 DefaultFunctionArgumentInstantiation,
8643
8644 /// We are substituting explicit template arguments provided for
8645 /// a function template. The entity is a FunctionTemplateDecl.
8646 ExplicitTemplateArgumentSubstitution,
8647
8648 /// We are substituting template argument determined as part of
8649 /// template argument deduction for either a class template
8650 /// partial specialization or a function template. The
8651 /// Entity is either a {Class|Var}TemplatePartialSpecializationDecl or
8652 /// a TemplateDecl.
8653 DeducedTemplateArgumentSubstitution,
8654
8655 /// We are substituting prior template arguments into a new
8656 /// template parameter. The template parameter itself is either a
8657 /// NonTypeTemplateParmDecl or a TemplateTemplateParmDecl.
8658 PriorTemplateArgumentSubstitution,
8659
8660 /// We are checking the validity of a default template argument that
8661 /// has been used when naming a template-id.
8662 DefaultTemplateArgumentChecking,
8663
8664 /// We are computing the exception specification for a defaulted special
8665 /// member function.
8666 ExceptionSpecEvaluation,
8667
8668 /// We are instantiating the exception specification for a function
8669 /// template which was deferred until it was needed.
8670 ExceptionSpecInstantiation,
8671
8672 /// We are instantiating a requirement of a requires expression.
8673 RequirementInstantiation,
8674
8675 /// We are checking the satisfaction of a nested requirement of a requires
8676 /// expression.
8677 NestedRequirementConstraintsCheck,
8678
8679 /// We are declaring an implicit special member function.
8680 DeclaringSpecialMember,
8681
8682 /// We are declaring an implicit 'operator==' for a defaulted
8683 /// 'operator<=>'.
8684 DeclaringImplicitEqualityComparison,
8685
8686 /// We are defining a synthesized function (such as a defaulted special
8687 /// member).
8688 DefiningSynthesizedFunction,
8689
8690 // We are checking the constraints associated with a constrained entity or
8691 // the constraint expression of a concept. This includes the checks that
8692 // atomic constraints have the type 'bool' and that they can be constant
8693 // evaluated.
8694 ConstraintsCheck,
8695
8696 // We are substituting template arguments into a constraint expression.
8697 ConstraintSubstitution,
8698
8699 // We are normalizing a constraint expression.
8700 ConstraintNormalization,
8701
8702 // We are substituting into the parameter mapping of an atomic constraint
8703 // during normalization.
8704 ParameterMappingSubstitution,
8705
8706 /// We are rewriting a comparison operator in terms of an operator<=>.
8707 RewritingOperatorAsSpaceship,
8708
8709 /// We are initializing a structured binding.
8710 InitializingStructuredBinding,
8711
8712 /// We are marking a class as __dllexport.
8713 MarkingClassDllexported,
8714
8715 /// Added for Template instantiation observation.
8716 /// Memoization means we are _not_ instantiating a template because
8717 /// it is already instantiated (but we entered a context where we
8718 /// would have had to if it was not already instantiated).
8719 Memoization
8720 } Kind;
8721
8722 /// Was the enclosing context a non-instantiation SFINAE context?
8723 bool SavedInNonInstantiationSFINAEContext;
8724
8725 /// The point of instantiation or synthesis within the source code.
8726 SourceLocation PointOfInstantiation;
8727
8728 /// The entity that is being synthesized.
8729 Decl *Entity;
8730
8731 /// The template (or partial specialization) in which we are
8732 /// performing the instantiation, for substitutions of prior template
8733 /// arguments.
8734 NamedDecl *Template;
8735
8736 /// The list of template arguments we are substituting, if they
8737 /// are not part of the entity.
8738 const TemplateArgument *TemplateArgs;
8739
8740 // FIXME: Wrap this union around more members, or perhaps store the
8741 // kind-specific members in the RAII object owning the context.
8742 union {
8743 /// The number of template arguments in TemplateArgs.
8744 unsigned NumTemplateArgs;
8745
8746 /// The special member being declared or defined.
8747 CXXSpecialMember SpecialMember;
8748 };
8749
8750 ArrayRef<TemplateArgument> template_arguments() const {
8751 assert(Kind != DeclaringSpecialMember)((void)0);
8752 return {TemplateArgs, NumTemplateArgs};
8753 }
8754
8755 /// The template deduction info object associated with the
8756 /// substitution or checking of explicit or deduced template arguments.
8757 sema::TemplateDeductionInfo *DeductionInfo;
8758
8759 /// The source range that covers the construct that cause
8760 /// the instantiation, e.g., the template-id that causes a class
8761 /// template instantiation.
8762 SourceRange InstantiationRange;
8763
8764 CodeSynthesisContext()
8765 : Kind(TemplateInstantiation),
8766 SavedInNonInstantiationSFINAEContext(false), Entity(nullptr),
8767 Template(nullptr), TemplateArgs(nullptr), NumTemplateArgs(0),
8768 DeductionInfo(nullptr) {}
8769
8770 /// Determines whether this template is an actual instantiation
8771 /// that should be counted toward the maximum instantiation depth.
8772 bool isInstantiationRecord() const;
8773 };
8774
8775 /// List of active code synthesis contexts.
8776 ///
8777 /// This vector is treated as a stack. As synthesis of one entity requires
8778 /// synthesis of another, additional contexts are pushed onto the stack.
8779 SmallVector<CodeSynthesisContext, 16> CodeSynthesisContexts;
8780
8781 /// Specializations whose definitions are currently being instantiated.
8782 llvm::DenseSet<std::pair<Decl *, unsigned>> InstantiatingSpecializations;
8783
8784 /// Non-dependent types used in templates that have already been instantiated
8785 /// by some template instantiation.
8786 llvm::DenseSet<QualType> InstantiatedNonDependentTypes;
8787
8788 /// Extra modules inspected when performing a lookup during a template
8789 /// instantiation. Computed lazily.
8790 SmallVector<Module*, 16> CodeSynthesisContextLookupModules;
8791
8792 /// Cache of additional modules that should be used for name lookup
8793 /// within the current template instantiation. Computed lazily; use
8794 /// getLookupModules() to get a complete set.
8795 llvm::DenseSet<Module*> LookupModulesCache;
8796
8797 /// Get the set of additional modules that should be checked during
8798 /// name lookup. A module and its imports become visible when instanting a
8799 /// template defined within it.
8800 llvm::DenseSet<Module*> &getLookupModules();
8801
8802 /// Map from the most recent declaration of a namespace to the most
8803 /// recent visible declaration of that namespace.
8804 llvm::DenseMap<NamedDecl*, NamedDecl*> VisibleNamespaceCache;
8805
8806 /// Whether we are in a SFINAE context that is not associated with
8807 /// template instantiation.
8808 ///
8809 /// This is used when setting up a SFINAE trap (\c see SFINAETrap) outside
8810 /// of a template instantiation or template argument deduction.
8811 bool InNonInstantiationSFINAEContext;
8812
8813 /// The number of \p CodeSynthesisContexts that are not template
8814 /// instantiations and, therefore, should not be counted as part of the
8815 /// instantiation depth.
8816 ///
8817 /// When the instantiation depth reaches the user-configurable limit
8818 /// \p LangOptions::InstantiationDepth we will abort instantiation.
8819 // FIXME: Should we have a similar limit for other forms of synthesis?
8820 unsigned NonInstantiationEntries;
8821
8822 /// The depth of the context stack at the point when the most recent
8823 /// error or warning was produced.
8824 ///
8825 /// This value is used to suppress printing of redundant context stacks
8826 /// when there are multiple errors or warnings in the same instantiation.
8827 // FIXME: Does this belong in Sema? It's tough to implement it anywhere else.
8828 unsigned LastEmittedCodeSynthesisContextDepth = 0;
8829
8830 /// The template instantiation callbacks to trace or track
8831 /// instantiations (objects can be chained).
8832 ///
8833 /// This callbacks is used to print, trace or track template
8834 /// instantiations as they are being constructed.
8835 std::vector<std::unique_ptr<TemplateInstantiationCallback>>
8836 TemplateInstCallbacks;
8837
8838 /// The current index into pack expansion arguments that will be
8839 /// used for substitution of parameter packs.
8840 ///
8841 /// The pack expansion index will be -1 to indicate that parameter packs
8842 /// should be instantiated as themselves. Otherwise, the index specifies
8843 /// which argument within the parameter pack will be used for substitution.
8844 int ArgumentPackSubstitutionIndex;
8845
8846 /// RAII object used to change the argument pack substitution index
8847 /// within a \c Sema object.
8848 ///
8849 /// See \c ArgumentPackSubstitutionIndex for more information.
8850 class ArgumentPackSubstitutionIndexRAII {
8851 Sema &Self;
8852 int OldSubstitutionIndex;
8853
8854 public:
8855 ArgumentPackSubstitutionIndexRAII(Sema &Self, int NewSubstitutionIndex)
8856 : Self(Self), OldSubstitutionIndex(Self.ArgumentPackSubstitutionIndex) {
8857 Self.ArgumentPackSubstitutionIndex = NewSubstitutionIndex;
8858 }
8859
8860 ~ArgumentPackSubstitutionIndexRAII() {
8861 Self.ArgumentPackSubstitutionIndex = OldSubstitutionIndex;
8862 }
8863 };
8864
8865 friend class ArgumentPackSubstitutionRAII;
8866
8867 /// For each declaration that involved template argument deduction, the
8868 /// set of diagnostics that were suppressed during that template argument
8869 /// deduction.
8870 ///
8871 /// FIXME: Serialize this structure to the AST file.
8872 typedef llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> >
8873 SuppressedDiagnosticsMap;
8874 SuppressedDiagnosticsMap SuppressedDiagnostics;
8875
8876 /// A stack object to be created when performing template
8877 /// instantiation.
8878 ///
8879 /// Construction of an object of type \c InstantiatingTemplate
8880 /// pushes the current instantiation onto the stack of active
8881 /// instantiations. If the size of this stack exceeds the maximum
8882 /// number of recursive template instantiations, construction
8883 /// produces an error and evaluates true.
8884 ///
8885 /// Destruction of this object will pop the named instantiation off
8886 /// the stack.
8887 struct InstantiatingTemplate {
8888 /// Note that we are instantiating a class template,
8889 /// function template, variable template, alias template,
8890 /// or a member thereof.
8891 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8892 Decl *Entity,
8893 SourceRange InstantiationRange = SourceRange());
8894
8895 struct ExceptionSpecification {};
8896 /// Note that we are instantiating an exception specification
8897 /// of a function template.
8898 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8899 FunctionDecl *Entity, ExceptionSpecification,
8900 SourceRange InstantiationRange = SourceRange());
8901
8902 /// Note that we are instantiating a default argument in a
8903 /// template-id.
8904 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8905 TemplateParameter Param, TemplateDecl *Template,
8906 ArrayRef<TemplateArgument> TemplateArgs,
8907 SourceRange InstantiationRange = SourceRange());
8908
8909 /// Note that we are substituting either explicitly-specified or
8910 /// deduced template arguments during function template argument deduction.
8911 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8912 FunctionTemplateDecl *FunctionTemplate,
8913 ArrayRef<TemplateArgument> TemplateArgs,
8914 CodeSynthesisContext::SynthesisKind Kind,
8915 sema::TemplateDeductionInfo &DeductionInfo,
8916 SourceRange InstantiationRange = SourceRange());
8917
8918 /// Note that we are instantiating as part of template
8919 /// argument deduction for a class template declaration.
8920 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8921 TemplateDecl *Template,
8922 ArrayRef<TemplateArgument> TemplateArgs,
8923 sema::TemplateDeductionInfo &DeductionInfo,
8924 SourceRange InstantiationRange = SourceRange());
8925
8926 /// Note that we are instantiating as part of template
8927 /// argument deduction for a class template partial
8928 /// specialization.
8929 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8930 ClassTemplatePartialSpecializationDecl *PartialSpec,
8931 ArrayRef<TemplateArgument> TemplateArgs,
8932 sema::TemplateDeductionInfo &DeductionInfo,
8933 SourceRange InstantiationRange = SourceRange());
8934
8935 /// Note that we are instantiating as part of template
8936 /// argument deduction for a variable template partial
8937 /// specialization.
8938 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8939 VarTemplatePartialSpecializationDecl *PartialSpec,
8940 ArrayRef<TemplateArgument> TemplateArgs,
8941 sema::TemplateDeductionInfo &DeductionInfo,
8942 SourceRange InstantiationRange = SourceRange());
8943
8944 /// Note that we are instantiating a default argument for a function
8945 /// parameter.
8946 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8947 ParmVarDecl *Param,
8948 ArrayRef<TemplateArgument> TemplateArgs,
8949 SourceRange InstantiationRange = SourceRange());
8950
8951 /// Note that we are substituting prior template arguments into a
8952 /// non-type parameter.
8953 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8954 NamedDecl *Template,
8955 NonTypeTemplateParmDecl *Param,
8956 ArrayRef<TemplateArgument> TemplateArgs,
8957 SourceRange InstantiationRange);
8958
8959 /// Note that we are substituting prior template arguments into a
8960 /// template template parameter.
8961 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8962 NamedDecl *Template,
8963 TemplateTemplateParmDecl *Param,
8964 ArrayRef<TemplateArgument> TemplateArgs,
8965 SourceRange InstantiationRange);
8966
8967 /// Note that we are checking the default template argument
8968 /// against the template parameter for a given template-id.
8969 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8970 TemplateDecl *Template,
8971 NamedDecl *Param,
8972 ArrayRef<TemplateArgument> TemplateArgs,
8973 SourceRange InstantiationRange);
8974
8975 struct ConstraintsCheck {};
8976 /// \brief Note that we are checking the constraints associated with some
8977 /// constrained entity (a concept declaration or a template with associated
8978 /// constraints).
8979 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8980 ConstraintsCheck, NamedDecl *Template,
8981 ArrayRef<TemplateArgument> TemplateArgs,
8982 SourceRange InstantiationRange);
8983
8984 struct ConstraintSubstitution {};
8985 /// \brief Note that we are checking a constraint expression associated
8986 /// with a template declaration or as part of the satisfaction check of a
8987 /// concept.
8988 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8989 ConstraintSubstitution, NamedDecl *Template,
8990 sema::TemplateDeductionInfo &DeductionInfo,
8991 SourceRange InstantiationRange);
8992
8993 struct ConstraintNormalization {};
8994 /// \brief Note that we are normalizing a constraint expression.
8995 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
8996 ConstraintNormalization, NamedDecl *Template,
8997 SourceRange InstantiationRange);
8998
8999 struct ParameterMappingSubstitution {};
9000 /// \brief Note that we are subtituting into the parameter mapping of an
9001 /// atomic constraint during constraint normalization.
9002 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
9003 ParameterMappingSubstitution, NamedDecl *Template,
9004 SourceRange InstantiationRange);
9005
9006 /// \brief Note that we are substituting template arguments into a part of
9007 /// a requirement of a requires expression.
9008 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
9009 concepts::Requirement *Req,
9010 sema::TemplateDeductionInfo &DeductionInfo,
9011 SourceRange InstantiationRange = SourceRange());
9012
9013 /// \brief Note that we are checking the satisfaction of the constraint
9014 /// expression inside of a nested requirement.
9015 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
9016 concepts::NestedRequirement *Req, ConstraintsCheck,
9017 SourceRange InstantiationRange = SourceRange());
9018
9019 /// Note that we have finished instantiating this template.
9020 void Clear();
9021
9022 ~InstantiatingTemplate() { Clear(); }
9023
9024 /// Determines whether we have exceeded the maximum
9025 /// recursive template instantiations.
9026 bool isInvalid() const { return Invalid; }
9027
9028 /// Determine whether we are already instantiating this
9029 /// specialization in some surrounding active instantiation.
9030 bool isAlreadyInstantiating() const { return AlreadyInstantiating; }
9031
9032 private:
9033 Sema &SemaRef;
9034 bool Invalid;
9035 bool AlreadyInstantiating;
9036 bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,
9037 SourceRange InstantiationRange);
9038
9039 InstantiatingTemplate(
9040 Sema &SemaRef, CodeSynthesisContext::SynthesisKind Kind,
9041 SourceLocation PointOfInstantiation, SourceRange InstantiationRange,
9042 Decl *Entity, NamedDecl *Template = nullptr,
9043 ArrayRef<TemplateArgument> TemplateArgs = None,
9044 sema::TemplateDeductionInfo *DeductionInfo = nullptr);
9045
9046 InstantiatingTemplate(const InstantiatingTemplate&) = delete;
9047
9048 InstantiatingTemplate&
9049 operator=(const InstantiatingTemplate&) = delete;
9050 };
9051
9052 void pushCodeSynthesisContext(CodeSynthesisContext Ctx);
9053 void popCodeSynthesisContext();
9054
9055 /// Determine whether we are currently performing template instantiation.
9056 bool inTemplateInstantiation() const {
9057 return CodeSynthesisContexts.size() > NonInstantiationEntries;
9058 }
9059
9060 void PrintContextStack() {
9061 if (!CodeSynthesisContexts.empty() &&
9062 CodeSynthesisContexts.size() != LastEmittedCodeSynthesisContextDepth) {
9063 PrintInstantiationStack();
9064 LastEmittedCodeSynthesisContextDepth = CodeSynthesisContexts.size();
9065 }
9066 if (PragmaAttributeCurrentTargetDecl)
9067 PrintPragmaAttributeInstantiationPoint();
9068 }
9069 void PrintInstantiationStack();
9070
9071 void PrintPragmaAttributeInstantiationPoint();
9072
9073 /// Determines whether we are currently in a context where
9074 /// template argument substitution failures are not considered
9075 /// errors.
9076 ///
9077 /// \returns An empty \c Optional if we're not in a SFINAE context.
9078 /// Otherwise, contains a pointer that, if non-NULL, contains the nearest
9079 /// template-deduction context object, which can be used to capture
9080 /// diagnostics that will be suppressed.
9081 Optional<sema::TemplateDeductionInfo *> isSFINAEContext() const;
9082
9083 /// Determines whether we are currently in a context that
9084 /// is not evaluated as per C++ [expr] p5.
9085 bool isUnevaluatedContext() const {
9086 assert(!ExprEvalContexts.empty() &&((void)0)
9087 "Must be in an expression evaluation context")((void)0);
9088 return ExprEvalContexts.back().isUnevaluated();
6
Calling 'ExpressionEvaluationContextRecord::isUnevaluated'
11
Returning from 'ExpressionEvaluationContextRecord::isUnevaluated'
12
Returning zero, which participates in a condition later
9089 }
9090
9091 /// RAII class used to determine whether SFINAE has
9092 /// trapped any errors that occur during template argument
9093 /// deduction.
9094 class SFINAETrap {
9095 Sema &SemaRef;
9096 unsigned PrevSFINAEErrors;
9097 bool PrevInNonInstantiationSFINAEContext;
9098 bool PrevAccessCheckingSFINAE;
9099 bool PrevLastDiagnosticIgnored;
9100
9101 public:
9102 explicit SFINAETrap(Sema &SemaRef, bool AccessCheckingSFINAE = false)
9103 : SemaRef(SemaRef), PrevSFINAEErrors(SemaRef.NumSFINAEErrors),
9104 PrevInNonInstantiationSFINAEContext(
9105 SemaRef.InNonInstantiationSFINAEContext),
9106 PrevAccessCheckingSFINAE(SemaRef.AccessCheckingSFINAE),
9107 PrevLastDiagnosticIgnored(
9108 SemaRef.getDiagnostics().isLastDiagnosticIgnored())
9109 {
9110 if (!SemaRef.isSFINAEContext())
9111 SemaRef.InNonInstantiationSFINAEContext = true;
9112 SemaRef.AccessCheckingSFINAE = AccessCheckingSFINAE;
9113 }
9114
9115 ~SFINAETrap() {
9116 SemaRef.NumSFINAEErrors = PrevSFINAEErrors;
9117 SemaRef.InNonInstantiationSFINAEContext
9118 = PrevInNonInstantiationSFINAEContext;
9119 SemaRef.AccessCheckingSFINAE = PrevAccessCheckingSFINAE;
9120 SemaRef.getDiagnostics().setLastDiagnosticIgnored(
9121 PrevLastDiagnosticIgnored);
9122 }
9123
9124 /// Determine whether any SFINAE errors have been trapped.
9125 bool hasErrorOccurred() const {
9126 return SemaRef.NumSFINAEErrors > PrevSFINAEErrors;
9127 }
9128 };
9129
9130 /// RAII class used to indicate that we are performing provisional
9131 /// semantic analysis to determine the validity of a construct, so
9132 /// typo-correction and diagnostics in the immediate context (not within
9133 /// implicitly-instantiated templates) should be suppressed.
9134 class TentativeAnalysisScope {
9135 Sema &SemaRef;
9136 // FIXME: Using a SFINAETrap for this is a hack.
9137 SFINAETrap Trap;
9138 bool PrevDisableTypoCorrection;
9139 public:
9140 explicit TentativeAnalysisScope(Sema &SemaRef)
9141 : SemaRef(SemaRef), Trap(SemaRef, true),
9142 PrevDisableTypoCorrection(SemaRef.DisableTypoCorrection) {
9143 SemaRef.DisableTypoCorrection = true;
9144 }
9145 ~TentativeAnalysisScope() {
9146 SemaRef.DisableTypoCorrection = PrevDisableTypoCorrection;
9147 }
9148 };
9149
9150 /// The current instantiation scope used to store local
9151 /// variables.
9152 LocalInstantiationScope *CurrentInstantiationScope;
9153
9154 /// Tracks whether we are in a context where typo correction is
9155 /// disabled.
9156 bool DisableTypoCorrection;
9157
9158 /// The number of typos corrected by CorrectTypo.
9159 unsigned TyposCorrected;
9160
9161 typedef llvm::SmallSet<SourceLocation, 2> SrcLocSet;
9162 typedef llvm::DenseMap<IdentifierInfo *, SrcLocSet> IdentifierSourceLocations;
9163
9164 /// A cache containing identifiers for which typo correction failed and
9165 /// their locations, so that repeated attempts to correct an identifier in a
9166 /// given location are ignored if typo correction already failed for it.
9167 IdentifierSourceLocations TypoCorrectionFailures;
9168
9169 /// Worker object for performing CFG-based warnings.
9170 sema::AnalysisBasedWarnings AnalysisWarnings;
9171 threadSafety::BeforeSet *ThreadSafetyDeclCache;
9172
9173 /// An entity for which implicit template instantiation is required.
9174 ///
9175 /// The source location associated with the declaration is the first place in
9176 /// the source code where the declaration was "used". It is not necessarily
9177 /// the point of instantiation (which will be either before or after the
9178 /// namespace-scope declaration that triggered this implicit instantiation),
9179 /// However, it is the location that diagnostics should generally refer to,
9180 /// because users will need to know what code triggered the instantiation.
9181 typedef std::pair<ValueDecl *, SourceLocation> PendingImplicitInstantiation;
9182
9183 /// The queue of implicit template instantiations that are required
9184 /// but have not yet been performed.
9185 std::deque<PendingImplicitInstantiation> PendingInstantiations;
9186
9187 /// Queue of implicit template instantiations that cannot be performed
9188 /// eagerly.
9189 SmallVector<PendingImplicitInstantiation, 1> LateParsedInstantiations;
9190
9191 class GlobalEagerInstantiationScope {
9192 public:
9193 GlobalEagerInstantiationScope(Sema &S, bool Enabled)
9194 : S(S), Enabled(Enabled) {
9195 if (!Enabled) return;
9196
9197 SavedPendingInstantiations.swap(S.PendingInstantiations);
9198 SavedVTableUses.swap(S.VTableUses);
9199 }
9200
9201 void perform() {
9202 if (Enabled) {
9203 S.DefineUsedVTables();
9204 S.PerformPendingInstantiations();
9205 }
9206 }
9207
9208 ~GlobalEagerInstantiationScope() {
9209 if (!Enabled) return;
9210
9211 // Restore the set of pending vtables.
9212 assert(S.VTableUses.empty() &&((void)0)
9213 "VTableUses should be empty before it is discarded.")((void)0);
9214 S.VTableUses.swap(SavedVTableUses);
9215
9216 // Restore the set of pending implicit instantiations.
9217 if (S.TUKind != TU_Prefix || !S.LangOpts.PCHInstantiateTemplates) {
9218 assert(S.PendingInstantiations.empty() &&((void)0)
9219 "PendingInstantiations should be empty before it is discarded.")((void)0);
9220 S.PendingInstantiations.swap(SavedPendingInstantiations);
9221 } else {
9222 // Template instantiations in the PCH may be delayed until the TU.
9223 S.PendingInstantiations.swap(SavedPendingInstantiations);
9224 S.PendingInstantiations.insert(S.PendingInstantiations.end(),
9225 SavedPendingInstantiations.begin(),
9226 SavedPendingInstantiations.end());
9227 }
9228 }
9229
9230 private:
9231 Sema &S;
9232 SmallVector<VTableUse, 16> SavedVTableUses;
9233 std::deque<PendingImplicitInstantiation> SavedPendingInstantiations;
9234 bool Enabled;
9235 };
9236
9237 /// The queue of implicit template instantiations that are required
9238 /// and must be performed within the current local scope.
9239 ///
9240 /// This queue is only used for member functions of local classes in
9241 /// templates, which must be instantiated in the same scope as their
9242 /// enclosing function, so that they can reference function-local
9243 /// types, static variables, enumerators, etc.
9244 std::deque<PendingImplicitInstantiation> PendingLocalImplicitInstantiations;
9245
9246 class LocalEagerInstantiationScope {
9247 public:
9248 LocalEagerInstantiationScope(Sema &S) : S(S) {
9249 SavedPendingLocalImplicitInstantiations.swap(
9250 S.PendingLocalImplicitInstantiations);
9251 }
9252
9253 void perform() { S.PerformPendingInstantiations(/*LocalOnly=*/true); }
9254
9255 ~LocalEagerInstantiationScope() {
9256 assert(S.PendingLocalImplicitInstantiations.empty() &&((void)0)
9257 "there shouldn't be any pending local implicit instantiations")((void)0);
9258 SavedPendingLocalImplicitInstantiations.swap(
9259 S.PendingLocalImplicitInstantiations);
9260 }
9261
9262 private:
9263 Sema &S;
9264 std::deque<PendingImplicitInstantiation>
9265 SavedPendingLocalImplicitInstantiations;
9266 };
9267
9268 /// A helper class for building up ExtParameterInfos.
9269 class ExtParameterInfoBuilder {
9270 SmallVector<FunctionProtoType::ExtParameterInfo, 16> Infos;
9271 bool HasInteresting = false;
9272
9273 public:
9274 /// Set the ExtParameterInfo for the parameter at the given index,
9275 ///
9276 void set(unsigned index, FunctionProtoType::ExtParameterInfo info) {
9277 assert(Infos.size() <= index)((void)0);
9278 Infos.resize(index);
9279 Infos.push_back(info);
9280
9281 if (!HasInteresting)
9282 HasInteresting = (info != FunctionProtoType::ExtParameterInfo());
9283 }
9284
9285 /// Return a pointer (suitable for setting in an ExtProtoInfo) to the
9286 /// ExtParameterInfo array we've built up.
9287 const FunctionProtoType::ExtParameterInfo *
9288 getPointerOrNull(unsigned numParams) {
9289 if (!HasInteresting) return nullptr;
9290 Infos.resize(numParams);
9291 return Infos.data();
9292 }
9293 };
9294
9295 void PerformPendingInstantiations(bool LocalOnly = false);
9296
9297 TypeSourceInfo *SubstType(TypeSourceInfo *T,
9298 const MultiLevelTemplateArgumentList &TemplateArgs,
9299 SourceLocation Loc, DeclarationName Entity,
9300 bool AllowDeducedTST = false);
9301
9302 QualType SubstType(QualType T,
9303 const MultiLevelTemplateArgumentList &TemplateArgs,
9304 SourceLocation Loc, DeclarationName Entity);
9305
9306 TypeSourceInfo *SubstType(TypeLoc TL,
9307 const MultiLevelTemplateArgumentList &TemplateArgs,
9308 SourceLocation Loc, DeclarationName Entity);
9309
9310 TypeSourceInfo *SubstFunctionDeclType(TypeSourceInfo *T,
9311 const MultiLevelTemplateArgumentList &TemplateArgs,
9312 SourceLocation Loc,
9313 DeclarationName Entity,
9314 CXXRecordDecl *ThisContext,
9315 Qualifiers ThisTypeQuals);
9316 void SubstExceptionSpec(FunctionDecl *New, const FunctionProtoType *Proto,
9317 const MultiLevelTemplateArgumentList &Args);
9318 bool SubstExceptionSpec(SourceLocation Loc,
9319 FunctionProtoType::ExceptionSpecInfo &ESI,
9320 SmallVectorImpl<QualType> &ExceptionStorage,
9321 const MultiLevelTemplateArgumentList &Args);
9322 ParmVarDecl *SubstParmVarDecl(ParmVarDecl *D,
9323 const MultiLevelTemplateArgumentList &TemplateArgs,
9324 int indexAdjustment,
9325 Optional<unsigned> NumExpansions,
9326 bool ExpectParameterPack);
9327 bool SubstParmTypes(SourceLocation Loc, ArrayRef<ParmVarDecl *> Params,
9328 const FunctionProtoType::ExtParameterInfo *ExtParamInfos,
9329 const MultiLevelTemplateArgumentList &TemplateArgs,
9330 SmallVectorImpl<QualType> &ParamTypes,
9331 SmallVectorImpl<ParmVarDecl *> *OutParams,
9332 ExtParameterInfoBuilder &ParamInfos);
9333 ExprResult SubstExpr(Expr *E,
9334 const MultiLevelTemplateArgumentList &TemplateArgs);
9335
9336 /// Substitute the given template arguments into a list of
9337 /// expressions, expanding pack expansions if required.
9338 ///
9339 /// \param Exprs The list of expressions to substitute into.
9340 ///
9341 /// \param IsCall Whether this is some form of call, in which case
9342 /// default arguments will be dropped.
9343 ///
9344 /// \param TemplateArgs The set of template arguments to substitute.
9345 ///
9346 /// \param Outputs Will receive all of the substituted arguments.
9347 ///
9348 /// \returns true if an error occurred, false otherwise.
9349 bool SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
9350 const MultiLevelTemplateArgumentList &TemplateArgs,
9351 SmallVectorImpl<Expr *> &Outputs);
9352
9353 StmtResult SubstStmt(Stmt *S,
9354 const MultiLevelTemplateArgumentList &TemplateArgs);
9355
9356 TemplateParameterList *
9357 SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner,
9358 const MultiLevelTemplateArgumentList &TemplateArgs);
9359
9360 bool
9361 SubstTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
9362 const MultiLevelTemplateArgumentList &TemplateArgs,
9363 TemplateArgumentListInfo &Outputs);
9364
9365
9366 Decl *SubstDecl(Decl *D, DeclContext *Owner,
9367 const MultiLevelTemplateArgumentList &TemplateArgs);
9368
9369 /// Substitute the name and return type of a defaulted 'operator<=>' to form
9370 /// an implicit 'operator=='.
9371 FunctionDecl *SubstSpaceshipAsEqualEqual(CXXRecordDecl *RD,
9372 FunctionDecl *Spaceship);
9373
9374 ExprResult SubstInitializer(Expr *E,
9375 const MultiLevelTemplateArgumentList &TemplateArgs,
9376 bool CXXDirectInit);
9377
9378 bool
9379 SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
9380 CXXRecordDecl *Pattern,
9381 const MultiLevelTemplateArgumentList &TemplateArgs);
9382
9383 bool
9384 InstantiateClass(SourceLocation PointOfInstantiation,
9385 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
9386 const MultiLevelTemplateArgumentList &TemplateArgs,
9387 TemplateSpecializationKind TSK,
9388 bool Complain = true);
9389
9390 bool InstantiateEnum(SourceLocation PointOfInstantiation,
9391 EnumDecl *Instantiation, EnumDecl *Pattern,
9392 const MultiLevelTemplateArgumentList &TemplateArgs,
9393 TemplateSpecializationKind TSK);
9394
9395 bool InstantiateInClassInitializer(
9396 SourceLocation PointOfInstantiation, FieldDecl *Instantiation,
9397 FieldDecl *Pattern, const MultiLevelTemplateArgumentList &TemplateArgs);
9398
9399 struct LateInstantiatedAttribute {
9400 const Attr *TmplAttr;
9401 LocalInstantiationScope *Scope;
9402 Decl *NewDecl;
9403
9404 LateInstantiatedAttribute(const Attr *A, LocalInstantiationScope *S,
9405 Decl *D)
9406 : TmplAttr(A), Scope(S), NewDecl(D)
9407 { }
9408 };
9409 typedef SmallVector<LateInstantiatedAttribute, 16> LateInstantiatedAttrVec;
9410
9411 void InstantiateAttrs(const MultiLevelTemplateArgumentList &TemplateArgs,
9412 const Decl *Pattern, Decl *Inst,
9413 LateInstantiatedAttrVec *LateAttrs = nullptr,
9414 LocalInstantiationScope *OuterMostScope = nullptr);
9415
9416 void
9417 InstantiateAttrsForDecl(const MultiLevelTemplateArgumentList &TemplateArgs,
9418 const Decl *Pattern, Decl *Inst,
9419 LateInstantiatedAttrVec *LateAttrs = nullptr,
9420 LocalInstantiationScope *OuterMostScope = nullptr);
9421
9422 void InstantiateDefaultCtorDefaultArgs(CXXConstructorDecl *Ctor);
9423
9424 bool usesPartialOrExplicitSpecialization(
9425 SourceLocation Loc, ClassTemplateSpecializationDecl *ClassTemplateSpec);
9426
9427 bool
9428 InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation,
9429 ClassTemplateSpecializationDecl *ClassTemplateSpec,
9430 TemplateSpecializationKind TSK,
9431 bool Complain = true);
9432
9433 void InstantiateClassMembers(SourceLocation PointOfInstantiation,
9434 CXXRecordDecl *Instantiation,
9435 const MultiLevelTemplateArgumentList &TemplateArgs,
9436 TemplateSpecializationKind TSK);
9437
9438 void InstantiateClassTemplateSpecializationMembers(
9439 SourceLocation PointOfInstantiation,
9440 ClassTemplateSpecializationDecl *ClassTemplateSpec,
9441 TemplateSpecializationKind TSK);
9442
9443 NestedNameSpecifierLoc
9444 SubstNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS,
9445 const MultiLevelTemplateArgumentList &TemplateArgs);
9446
9447 DeclarationNameInfo
9448 SubstDeclarationNameInfo(const DeclarationNameInfo &NameInfo,
9449 const MultiLevelTemplateArgumentList &TemplateArgs);
9450 TemplateName
9451 SubstTemplateName(NestedNameSpecifierLoc QualifierLoc, TemplateName Name,
9452 SourceLocation Loc,
9453 const MultiLevelTemplateArgumentList &TemplateArgs);
9454 bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs,
9455 TemplateArgumentListInfo &Result,
9456 const MultiLevelTemplateArgumentList &TemplateArgs);
9457
9458 bool InstantiateDefaultArgument(SourceLocation CallLoc, FunctionDecl *FD,
9459 ParmVarDecl *Param);
9460 void InstantiateExceptionSpec(SourceLocation PointOfInstantiation,
9461 FunctionDecl *Function);
9462 bool CheckInstantiatedFunctionTemplateConstraints(
9463 SourceLocation PointOfInstantiation, FunctionDecl *Decl,
9464 ArrayRef<TemplateArgument> TemplateArgs,
9465 ConstraintSatisfaction &Satisfaction);
9466 FunctionDecl *InstantiateFunctionDeclaration(FunctionTemplateDecl *FTD,
9467 const TemplateArgumentList *Args,
9468 SourceLocation Loc);
9469 void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
9470 FunctionDecl *Function,
9471 bool Recursive = false,
9472 bool DefinitionRequired = false,
9473 bool AtEndOfTU = false);
9474 VarTemplateSpecializationDecl *BuildVarTemplateInstantiation(
9475 VarTemplateDecl *VarTemplate, VarDecl *FromVar,
9476 const TemplateArgumentList &TemplateArgList,
9477 const TemplateArgumentListInfo &TemplateArgsInfo,
9478 SmallVectorImpl<TemplateArgument> &Converted,
9479 SourceLocation PointOfInstantiation,
9480 LateInstantiatedAttrVec *LateAttrs = nullptr,
9481 LocalInstantiationScope *StartingScope = nullptr);
9482 VarTemplateSpecializationDecl *CompleteVarTemplateSpecializationDecl(
9483 VarTemplateSpecializationDecl *VarSpec, VarDecl *PatternDecl,
9484 const MultiLevelTemplateArgumentList &TemplateArgs);
9485 void
9486 BuildVariableInstantiation(VarDecl *NewVar, VarDecl *OldVar,
9487 const MultiLevelTemplateArgumentList &TemplateArgs,
9488 LateInstantiatedAttrVec *LateAttrs,
9489 DeclContext *Owner,
9490 LocalInstantiationScope *StartingScope,
9491 bool InstantiatingVarTemplate = false,
9492 VarTemplateSpecializationDecl *PrevVTSD = nullptr);
9493
9494 void InstantiateVariableInitializer(
9495 VarDecl *Var, VarDecl *OldVar,
9496 const MultiLevelTemplateArgumentList &TemplateArgs);
9497 void InstantiateVariableDefinition(SourceLocation PointOfInstantiation,
9498 VarDecl *Var, bool Recursive = false,
9499 bool DefinitionRequired = false,
9500 bool AtEndOfTU = false);
9501
9502 void InstantiateMemInitializers(CXXConstructorDecl *New,
9503 const CXXConstructorDecl *Tmpl,
9504 const MultiLevelTemplateArgumentList &TemplateArgs);
9505
9506 NamedDecl *FindInstantiatedDecl(SourceLocation Loc, NamedDecl *D,
9507 const MultiLevelTemplateArgumentList &TemplateArgs,
9508 bool FindingInstantiatedContext = false);
9509 DeclContext *FindInstantiatedContext(SourceLocation Loc, DeclContext *DC,
9510 const MultiLevelTemplateArgumentList &TemplateArgs);
9511
9512 // Objective-C declarations.
9513 enum ObjCContainerKind {
9514 OCK_None = -1,
9515 OCK_Interface = 0,
9516 OCK_Protocol,
9517 OCK_Category,
9518 OCK_ClassExtension,
9519 OCK_Implementation,
9520 OCK_CategoryImplementation
9521 };
9522 ObjCContainerKind getObjCContainerKind() const;
9523
9524 DeclResult actOnObjCTypeParam(Scope *S,
9525 ObjCTypeParamVariance variance,
9526 SourceLocation varianceLoc,
9527 unsigned index,
9528 IdentifierInfo *paramName,
9529 SourceLocation paramLoc,
9530 SourceLocation colonLoc,
9531 ParsedType typeBound);
9532
9533 ObjCTypeParamList *actOnObjCTypeParamList(Scope *S, SourceLocation lAngleLoc,
9534 ArrayRef<Decl *> typeParams,
9535 SourceLocation rAngleLoc);
9536 void popObjCTypeParamList(Scope *S, ObjCTypeParamList *typeParamList);
9537
9538 Decl *ActOnStartClassInterface(
9539 Scope *S, SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName,
9540 SourceLocation ClassLoc, ObjCTypeParamList *typeParamList,
9541 IdentifierInfo *SuperName, SourceLocation SuperLoc,
9542 ArrayRef<ParsedType> SuperTypeArgs, SourceRange SuperTypeArgsRange,
9543 Decl *const *ProtoRefs, unsigned NumProtoRefs,
9544 const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc,
9545 const ParsedAttributesView &AttrList);
9546
9547 void ActOnSuperClassOfClassInterface(Scope *S,
9548 SourceLocation AtInterfaceLoc,
9549 ObjCInterfaceDecl *IDecl,
9550 IdentifierInfo *ClassName,
9551 SourceLocation ClassLoc,
9552 IdentifierInfo *SuperName,
9553 SourceLocation SuperLoc,
9554 ArrayRef<ParsedType> SuperTypeArgs,
9555 SourceRange SuperTypeArgsRange);
9556
9557 void ActOnTypedefedProtocols(SmallVectorImpl<Decl *> &ProtocolRefs,
9558 SmallVectorImpl<SourceLocation> &ProtocolLocs,
9559 IdentifierInfo *SuperName,
9560 SourceLocation SuperLoc);
9561
9562 Decl *ActOnCompatibilityAlias(
9563 SourceLocation AtCompatibilityAliasLoc,
9564 IdentifierInfo *AliasName, SourceLocation AliasLocation,
9565 IdentifierInfo *ClassName, SourceLocation ClassLocation);
9566
9567 bool CheckForwardProtocolDeclarationForCircularDependency(
9568 IdentifierInfo *PName,
9569 SourceLocation &PLoc, SourceLocation PrevLoc,
9570 const ObjCList<ObjCProtocolDecl> &PList);
9571
9572 Decl *ActOnStartProtocolInterface(
9573 SourceLocation AtProtoInterfaceLoc, IdentifierInfo *ProtocolName,
9574 SourceLocation ProtocolLoc, Decl *const *ProtoRefNames,
9575 unsigned NumProtoRefs, const SourceLocation *ProtoLocs,
9576 SourceLocation EndProtoLoc, const ParsedAttributesView &AttrList);
9577
9578 Decl *ActOnStartCategoryInterface(
9579 SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName,
9580 SourceLocation ClassLoc, ObjCTypeParamList *typeParamList,
9581 IdentifierInfo *CategoryName, SourceLocation CategoryLoc,
9582 Decl *const *ProtoRefs, unsigned NumProtoRefs,
9583 const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc,
9584 const ParsedAttributesView &AttrList);
9585
9586 Decl *ActOnStartClassImplementation(SourceLocation AtClassImplLoc,
9587 IdentifierInfo *ClassName,
9588 SourceLocation ClassLoc,
9589 IdentifierInfo *SuperClassname,
9590 SourceLocation SuperClassLoc,
9591 const ParsedAttributesView &AttrList);
9592
9593 Decl *ActOnStartCategoryImplementation(SourceLocation AtCatImplLoc,
9594 IdentifierInfo *ClassName,
9595 SourceLocation ClassLoc,
9596 IdentifierInfo *CatName,
9597 SourceLocation CatLoc,
9598 const ParsedAttributesView &AttrList);
9599
9600 DeclGroupPtrTy ActOnFinishObjCImplementation(Decl *ObjCImpDecl,
9601 ArrayRef<Decl *> Decls);
9602
9603 DeclGroupPtrTy ActOnForwardClassDeclaration(SourceLocation Loc,
9604 IdentifierInfo **IdentList,
9605 SourceLocation *IdentLocs,
9606 ArrayRef<ObjCTypeParamList *> TypeParamLists,
9607 unsigned NumElts);
9608
9609 DeclGroupPtrTy
9610 ActOnForwardProtocolDeclaration(SourceLocation AtProtoclLoc,
9611 ArrayRef<IdentifierLocPair> IdentList,
9612 const ParsedAttributesView &attrList);
9613
9614 void FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer,
9615 ArrayRef<IdentifierLocPair> ProtocolId,
9616 SmallVectorImpl<Decl *> &Protocols);
9617
9618 void DiagnoseTypeArgsAndProtocols(IdentifierInfo *ProtocolId,
9619 SourceLocation ProtocolLoc,
9620 IdentifierInfo *TypeArgId,
9621 SourceLocation TypeArgLoc,
9622 bool SelectProtocolFirst = false);
9623
9624 /// Given a list of identifiers (and their locations), resolve the
9625 /// names to either Objective-C protocol qualifiers or type
9626 /// arguments, as appropriate.
9627 void actOnObjCTypeArgsOrProtocolQualifiers(
9628 Scope *S,
9629 ParsedType baseType,
9630 SourceLocation lAngleLoc,
9631 ArrayRef<IdentifierInfo *> identifiers,
9632 ArrayRef<SourceLocation> identifierLocs,
9633 SourceLocation rAngleLoc,
9634 SourceLocation &typeArgsLAngleLoc,
9635 SmallVectorImpl<ParsedType> &typeArgs,
9636 SourceLocation &typeArgsRAngleLoc,
9637 SourceLocation &protocolLAngleLoc,
9638 SmallVectorImpl<Decl *> &protocols,
9639 SourceLocation &protocolRAngleLoc,
9640 bool warnOnIncompleteProtocols);
9641
9642 /// Build a an Objective-C protocol-qualified 'id' type where no
9643 /// base type was specified.
9644 TypeResult actOnObjCProtocolQualifierType(
9645 SourceLocation lAngleLoc,
9646 ArrayRef<Decl *> protocols,
9647 ArrayRef<SourceLocation> protocolLocs,
9648 SourceLocation rAngleLoc);
9649
9650 /// Build a specialized and/or protocol-qualified Objective-C type.
9651 TypeResult actOnObjCTypeArgsAndProtocolQualifiers(
9652 Scope *S,
9653 SourceLocation Loc,
9654 ParsedType BaseType,
9655 SourceLocation TypeArgsLAngleLoc,
9656 ArrayRef<ParsedType> TypeArgs,
9657 SourceLocation TypeArgsRAngleLoc,
9658 SourceLocation ProtocolLAngleLoc,
9659 ArrayRef<Decl *> Protocols,
9660 ArrayRef<SourceLocation> ProtocolLocs,
9661 SourceLocation ProtocolRAngleLoc);
9662
9663 /// Build an Objective-C type parameter type.
9664 QualType BuildObjCTypeParamType(const ObjCTypeParamDecl *Decl,
9665 SourceLocation ProtocolLAngleLoc,
9666 ArrayRef<ObjCProtocolDecl *> Protocols,
9667 ArrayRef<SourceLocation> ProtocolLocs,
9668 SourceLocation ProtocolRAngleLoc,
9669 bool FailOnError = false);
9670
9671 /// Build an Objective-C object pointer type.
9672 QualType BuildObjCObjectType(QualType BaseType,
9673 SourceLocation Loc,
9674 SourceLocation TypeArgsLAngleLoc,
9675 ArrayRef<TypeSourceInfo *> TypeArgs,
9676 SourceLocation TypeArgsRAngleLoc,
9677 SourceLocation ProtocolLAngleLoc,
9678 ArrayRef<ObjCProtocolDecl *> Protocols,
9679 ArrayRef<SourceLocation> ProtocolLocs,
9680 SourceLocation ProtocolRAngleLoc,
9681 bool FailOnError = false);
9682
9683 /// Ensure attributes are consistent with type.
9684 /// \param [in, out] Attributes The attributes to check; they will
9685 /// be modified to be consistent with \p PropertyTy.
9686 void CheckObjCPropertyAttributes(Decl *PropertyPtrTy,
9687 SourceLocation Loc,
9688 unsigned &Attributes,
9689 bool propertyInPrimaryClass);
9690
9691 /// Process the specified property declaration and create decls for the
9692 /// setters and getters as needed.
9693 /// \param property The property declaration being processed
9694 void ProcessPropertyDecl(ObjCPropertyDecl *property);
9695
9696
9697 void DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
9698 ObjCPropertyDecl *SuperProperty,
9699 const IdentifierInfo *Name,
9700 bool OverridingProtocolProperty);
9701
9702 void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
9703 ObjCInterfaceDecl *ID);
9704
9705 Decl *ActOnAtEnd(Scope *S, SourceRange AtEnd,
9706 ArrayRef<Decl *> allMethods = None,
9707 ArrayRef<DeclGroupPtrTy> allTUVars = None);
9708
9709 Decl *ActOnProperty(Scope *S, SourceLocation AtLoc,
9710 SourceLocation LParenLoc,
9711 FieldDeclarator &FD, ObjCDeclSpec &ODS,
9712 Selector GetterSel, Selector SetterSel,
9713 tok::ObjCKeywordKind MethodImplKind,
9714 DeclContext *lexicalDC = nullptr);
9715
9716 Decl *ActOnPropertyImplDecl(Scope *S,
9717 SourceLocation AtLoc,
9718 SourceLocation PropertyLoc,
9719 bool ImplKind,
9720 IdentifierInfo *PropertyId,
9721 IdentifierInfo *PropertyIvar,
9722 SourceLocation PropertyIvarLoc,
9723 ObjCPropertyQueryKind QueryKind);
9724
9725 enum ObjCSpecialMethodKind {
9726 OSMK_None,
9727 OSMK_Alloc,
9728 OSMK_New,
9729 OSMK_Copy,
9730 OSMK_RetainingInit,
9731 OSMK_NonRetainingInit
9732 };
9733
9734 struct ObjCArgInfo {
9735 IdentifierInfo *Name;
9736 SourceLocation NameLoc;
9737 // The Type is null if no type was specified, and the DeclSpec is invalid
9738 // in this case.
9739 ParsedType Type;
9740 ObjCDeclSpec DeclSpec;
9741
9742 /// ArgAttrs - Attribute list for this argument.
9743 ParsedAttributesView ArgAttrs;
9744 };
9745
9746 Decl *ActOnMethodDeclaration(
9747 Scope *S,
9748 SourceLocation BeginLoc, // location of the + or -.
9749 SourceLocation EndLoc, // location of the ; or {.
9750 tok::TokenKind MethodType, ObjCDeclSpec &ReturnQT, ParsedType ReturnType,
9751 ArrayRef<SourceLocation> SelectorLocs, Selector Sel,
9752 // optional arguments. The number of types/arguments is obtained
9753 // from the Sel.getNumArgs().
9754 ObjCArgInfo *ArgInfo, DeclaratorChunk::ParamInfo *CParamInfo,
9755 unsigned CNumArgs, // c-style args
9756 const ParsedAttributesView &AttrList, tok::ObjCKeywordKind MethodImplKind,
9757 bool isVariadic, bool MethodDefinition);
9758
9759 ObjCMethodDecl *LookupMethodInQualifiedType(Selector Sel,
9760 const ObjCObjectPointerType *OPT,
9761 bool IsInstance);
9762 ObjCMethodDecl *LookupMethodInObjectType(Selector Sel, QualType Ty,
9763 bool IsInstance);
9764
9765 bool CheckARCMethodDecl(ObjCMethodDecl *method);
9766 bool inferObjCARCLifetime(ValueDecl *decl);
9767
9768 void deduceOpenCLAddressSpace(ValueDecl *decl);
9769
9770 ExprResult
9771 HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT,
9772 Expr *BaseExpr,
9773 SourceLocation OpLoc,
9774 DeclarationName MemberName,
9775 SourceLocation MemberLoc,
9776 SourceLocation SuperLoc, QualType SuperType,
9777 bool Super);
9778
9779 ExprResult
9780 ActOnClassPropertyRefExpr(IdentifierInfo &receiverName,
9781 IdentifierInfo &propertyName,
9782 SourceLocation receiverNameLoc,
9783 SourceLocation propertyNameLoc);
9784
9785 ObjCMethodDecl *tryCaptureObjCSelf(SourceLocation Loc);
9786
9787 /// Describes the kind of message expression indicated by a message
9788 /// send that starts with an identifier.
9789 enum ObjCMessageKind {
9790 /// The message is sent to 'super'.
9791 ObjCSuperMessage,
9792 /// The message is an instance message.
9793 ObjCInstanceMessage,
9794 /// The message is a class message, and the identifier is a type
9795 /// name.
9796 ObjCClassMessage
9797 };
9798
9799 ObjCMessageKind getObjCMessageKind(Scope *S,
9800 IdentifierInfo *Name,
9801 SourceLocation NameLoc,
9802 bool IsSuper,
9803 bool HasTrailingDot,
9804 ParsedType &ReceiverType);
9805
9806 ExprResult ActOnSuperMessage(Scope *S, SourceLocation SuperLoc,
9807 Selector Sel,
9808 SourceLocation LBracLoc,
9809 ArrayRef<SourceLocation> SelectorLocs,
9810 SourceLocation RBracLoc,
9811 MultiExprArg Args);
9812
9813 ExprResult BuildClassMessage(TypeSourceInfo *ReceiverTypeInfo,
9814 QualType ReceiverType,
9815 SourceLocation SuperLoc,
9816 Selector Sel,
9817 ObjCMethodDecl *Method,
9818 SourceLocation LBracLoc,
9819 ArrayRef<SourceLocation> SelectorLocs,
9820 SourceLocation RBracLoc,
9821 MultiExprArg Args,
9822 bool isImplicit = false);
9823
9824 ExprResult BuildClassMessageImplicit(QualType ReceiverType,
9825 bool isSuperReceiver,
9826 SourceLocation Loc,
9827 Selector Sel,
9828 ObjCMethodDecl *Method,
9829 MultiExprArg Args);
9830
9831 ExprResult ActOnClassMessage(Scope *S,
9832 ParsedType Receiver,
9833 Selector Sel,
9834 SourceLocation LBracLoc,
9835 ArrayRef<SourceLocation> SelectorLocs,
9836 SourceLocation RBracLoc,
9837 MultiExprArg Args);
9838
9839 ExprResult BuildInstanceMessage(Expr *Receiver,
9840 QualType ReceiverType,
9841 SourceLocation SuperLoc,
9842 Selector Sel,
9843 ObjCMethodDecl *Method,
9844 SourceLocation LBracLoc,
9845 ArrayRef<SourceLocation> SelectorLocs,
9846 SourceLocation RBracLoc,
9847 MultiExprArg Args,
9848 bool isImplicit = false);
9849
9850 ExprResult BuildInstanceMessageImplicit(Expr *Receiver,
9851 QualType ReceiverType,
9852 SourceLocation Loc,
9853 Selector Sel,
9854 ObjCMethodDecl *Method,
9855 MultiExprArg Args);
9856
9857 ExprResult ActOnInstanceMessage(Scope *S,
9858 Expr *Receiver,
9859 Selector Sel,
9860 SourceLocation LBracLoc,
9861 ArrayRef<SourceLocation> SelectorLocs,
9862 SourceLocation RBracLoc,
9863 MultiExprArg Args);
9864
9865 ExprResult BuildObjCBridgedCast(SourceLocation LParenLoc,
9866 ObjCBridgeCastKind Kind,
9867 SourceLocation BridgeKeywordLoc,
9868 TypeSourceInfo *TSInfo,
9869 Expr *SubExpr);
9870
9871 ExprResult ActOnObjCBridgedCast(Scope *S,
9872 SourceLocation LParenLoc,
9873 ObjCBridgeCastKind Kind,
9874 SourceLocation BridgeKeywordLoc,
9875 ParsedType Type,
9876 SourceLocation RParenLoc,
9877 Expr *SubExpr);
9878
9879 void CheckTollFreeBridgeCast(QualType castType, Expr *castExpr);
9880
9881 void CheckObjCBridgeRelatedCast(QualType castType, Expr *castExpr);
9882
9883 bool CheckTollFreeBridgeStaticCast(QualType castType, Expr *castExpr,
9884 CastKind &Kind);
9885
9886 bool checkObjCBridgeRelatedComponents(SourceLocation Loc,
9887 QualType DestType, QualType SrcType,
9888 ObjCInterfaceDecl *&RelatedClass,
9889 ObjCMethodDecl *&ClassMethod,
9890 ObjCMethodDecl *&InstanceMethod,
9891 TypedefNameDecl *&TDNDecl,
9892 bool CfToNs, bool Diagnose = true);
9893
9894 bool CheckObjCBridgeRelatedConversions(SourceLocation Loc,
9895 QualType DestType, QualType SrcType,
9896 Expr *&SrcExpr, bool Diagnose = true);
9897
9898 bool CheckConversionToObjCLiteral(QualType DstType, Expr *&SrcExpr,
9899 bool Diagnose = true);
9900
9901 bool checkInitMethod(ObjCMethodDecl *method, QualType receiverTypeIfCall);
9902
9903 /// Check whether the given new method is a valid override of the
9904 /// given overridden method, and set any properties that should be inherited.
9905 void CheckObjCMethodOverride(ObjCMethodDecl *NewMethod,
9906 const ObjCMethodDecl *Overridden);
9907
9908 /// Describes the compatibility of a result type with its method.
9909 enum ResultTypeCompatibilityKind {
9910 RTC_Compatible,
9911 RTC_Incompatible,
9912 RTC_Unknown
9913 };
9914
9915 void CheckObjCMethodDirectOverrides(ObjCMethodDecl *method,
9916 ObjCMethodDecl *overridden);
9917
9918 void CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod,
9919 ObjCInterfaceDecl *CurrentClass,
9920 ResultTypeCompatibilityKind RTC);
9921
9922 enum PragmaOptionsAlignKind {
9923 POAK_Native, // #pragma options align=native
9924 POAK_Natural, // #pragma options align=natural
9925 POAK_Packed, // #pragma options align=packed
9926 POAK_Power, // #pragma options align=power
9927 POAK_Mac68k, // #pragma options align=mac68k
9928 POAK_Reset // #pragma options align=reset
9929 };
9930
9931 /// ActOnPragmaClangSection - Called on well formed \#pragma clang section
9932 void ActOnPragmaClangSection(SourceLocation PragmaLoc,
9933 PragmaClangSectionAction Action,
9934 PragmaClangSectionKind SecKind, StringRef SecName);
9935
9936 /// ActOnPragmaOptionsAlign - Called on well formed \#pragma options align.
9937 void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
9938 SourceLocation PragmaLoc);
9939
9940 /// ActOnPragmaPack - Called on well formed \#pragma pack(...).
9941 void ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,
9942 StringRef SlotLabel, Expr *Alignment);
9943
9944 enum class PragmaAlignPackDiagnoseKind {
9945 NonDefaultStateAtInclude,
9946 ChangedStateAtExit
9947 };
9948
9949 void DiagnoseNonDefaultPragmaAlignPack(PragmaAlignPackDiagnoseKind Kind,
9950 SourceLocation IncludeLoc);
9951 void DiagnoseUnterminatedPragmaAlignPack();
9952
9953 /// ActOnPragmaMSStruct - Called on well formed \#pragma ms_struct [on|off].
9954 void ActOnPragmaMSStruct(PragmaMSStructKind Kind);
9955
9956 /// ActOnPragmaMSComment - Called on well formed
9957 /// \#pragma comment(kind, "arg").
9958 void ActOnPragmaMSComment(SourceLocation CommentLoc, PragmaMSCommentKind Kind,
9959 StringRef Arg);
9960
9961 /// ActOnPragmaMSPointersToMembers - called on well formed \#pragma
9962 /// pointers_to_members(representation method[, general purpose
9963 /// representation]).
9964 void ActOnPragmaMSPointersToMembers(
9965 LangOptions::PragmaMSPointersToMembersKind Kind,
9966 SourceLocation PragmaLoc);
9967
9968 /// Called on well formed \#pragma vtordisp().
9969 void ActOnPragmaMSVtorDisp(PragmaMsStackAction Action,
9970 SourceLocation PragmaLoc,
9971 MSVtorDispMode Value);
9972
9973 enum PragmaSectionKind {
9974 PSK_DataSeg,
9975 PSK_BSSSeg,
9976 PSK_ConstSeg,
9977 PSK_CodeSeg,
9978 };
9979
9980 bool UnifySection(StringRef SectionName, int SectionFlags,
9981 NamedDecl *TheDecl);
9982 bool UnifySection(StringRef SectionName,
9983 int SectionFlags,
9984 SourceLocation PragmaSectionLocation);
9985
9986 /// Called on well formed \#pragma bss_seg/data_seg/const_seg/code_seg.
9987 void ActOnPragmaMSSeg(SourceLocation PragmaLocation,
9988 PragmaMsStackAction Action,
9989 llvm::StringRef StackSlotLabel,
9990 StringLiteral *SegmentName,
9991 llvm::StringRef PragmaName);
9992
9993 /// Called on well formed \#pragma section().
9994 void ActOnPragmaMSSection(SourceLocation PragmaLocation,
9995 int SectionFlags, StringLiteral *SegmentName);
9996
9997 /// Called on well-formed \#pragma init_seg().
9998 void ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
9999 StringLiteral *SegmentName);
10000
10001 /// Called on #pragma clang __debug dump II
10002 void ActOnPragmaDump(Scope *S, SourceLocation Loc, IdentifierInfo *II);
10003
10004 /// ActOnPragmaDetectMismatch - Call on well-formed \#pragma detect_mismatch
10005 void ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,
10006 StringRef Value);
10007
10008 /// Are precise floating point semantics currently enabled?
10009 bool isPreciseFPEnabled() {
10010 return !CurFPFeatures.getAllowFPReassociate() &&
10011 !CurFPFeatures.getNoSignedZero() &&
10012 !CurFPFeatures.getAllowReciprocal() &&
10013 !CurFPFeatures.getAllowApproxFunc();
10014 }
10015
10016 /// ActOnPragmaFloatControl - Call on well-formed \#pragma float_control
10017 void ActOnPragmaFloatControl(SourceLocation Loc, PragmaMsStackAction Action,
10018 PragmaFloatControlKind Value);
10019
10020 /// ActOnPragmaUnused - Called on well-formed '\#pragma unused'.
10021 void ActOnPragmaUnused(const Token &Identifier,
10022 Scope *curScope,
10023 SourceLocation PragmaLoc);
10024
10025 /// ActOnPragmaVisibility - Called on well formed \#pragma GCC visibility... .
10026 void ActOnPragmaVisibility(const IdentifierInfo* VisType,
10027 SourceLocation PragmaLoc);
10028
10029 NamedDecl *DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,
10030 SourceLocation Loc);
10031 void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W);
10032
10033 /// ActOnPragmaWeakID - Called on well formed \#pragma weak ident.
10034 void ActOnPragmaWeakID(IdentifierInfo* WeakName,
10035 SourceLocation PragmaLoc,
10036 SourceLocation WeakNameLoc);
10037
10038 /// ActOnPragmaRedefineExtname - Called on well formed
10039 /// \#pragma redefine_extname oldname newname.
10040 void ActOnPragmaRedefineExtname(IdentifierInfo* WeakName,
10041 IdentifierInfo* AliasName,
10042 SourceLocation PragmaLoc,
10043 SourceLocation WeakNameLoc,
10044 SourceLocation AliasNameLoc);
10045
10046 /// ActOnPragmaWeakAlias - Called on well formed \#pragma weak ident = ident.
10047 void ActOnPragmaWeakAlias(IdentifierInfo* WeakName,
10048 IdentifierInfo* AliasName,
10049 SourceLocation PragmaLoc,
10050 SourceLocation WeakNameLoc,
10051 SourceLocation AliasNameLoc);
10052
10053 /// ActOnPragmaFPContract - Called on well formed
10054 /// \#pragma {STDC,OPENCL} FP_CONTRACT and
10055 /// \#pragma clang fp contract
10056 void ActOnPragmaFPContract(SourceLocation Loc, LangOptions::FPModeKind FPC);
10057
10058 /// Called on well formed
10059 /// \#pragma clang fp reassociate
10060 void ActOnPragmaFPReassociate(SourceLocation Loc, bool IsEnabled);
10061
10062 /// ActOnPragmaFenvAccess - Called on well formed
10063 /// \#pragma STDC FENV_ACCESS
10064 void ActOnPragmaFEnvAccess(SourceLocation Loc, bool IsEnabled);
10065
10066 /// Called on well formed '\#pragma clang fp' that has option 'exceptions'.
10067 void ActOnPragmaFPExceptions(SourceLocation Loc,
10068 LangOptions::FPExceptionModeKind);
10069
10070 /// Called to set constant rounding mode for floating point operations.
10071 void setRoundingMode(SourceLocation Loc, llvm::RoundingMode);
10072
10073 /// Called to set exception behavior for floating point operations.
10074 void setExceptionMode(SourceLocation Loc, LangOptions::FPExceptionModeKind);
10075
10076 /// AddAlignmentAttributesForRecord - Adds any needed alignment attributes to
10077 /// a the record decl, to handle '\#pragma pack' and '\#pragma options align'.
10078 void AddAlignmentAttributesForRecord(RecordDecl *RD);
10079
10080 /// AddMsStructLayoutForRecord - Adds ms_struct layout attribute to record.
10081 void AddMsStructLayoutForRecord(RecordDecl *RD);
10082
10083 /// PushNamespaceVisibilityAttr - Note that we've entered a
10084 /// namespace with a visibility attribute.
10085 void PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
10086 SourceLocation Loc);
10087
10088 /// AddPushedVisibilityAttribute - If '\#pragma GCC visibility' was used,
10089 /// add an appropriate visibility attribute.
10090 void AddPushedVisibilityAttribute(Decl *RD);
10091
10092 /// PopPragmaVisibility - Pop the top element of the visibility stack; used
10093 /// for '\#pragma GCC visibility' and visibility attributes on namespaces.
10094 void PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc);
10095
10096 /// FreeVisContext - Deallocate and null out VisContext.
10097 void FreeVisContext();
10098
10099 /// AddCFAuditedAttribute - Check whether we're currently within
10100 /// '\#pragma clang arc_cf_code_audited' and, if so, consider adding
10101 /// the appropriate attribute.
10102 void AddCFAuditedAttribute(Decl *D);
10103
10104 void ActOnPragmaAttributeAttribute(ParsedAttr &Attribute,
10105 SourceLocation PragmaLoc,
10106 attr::ParsedSubjectMatchRuleSet Rules);
10107 void ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc,
10108 const IdentifierInfo *Namespace);
10109
10110 /// Called on well-formed '\#pragma clang attribute pop'.
10111 void ActOnPragmaAttributePop(SourceLocation PragmaLoc,
10112 const IdentifierInfo *Namespace);
10113
10114 /// Adds the attributes that have been specified using the
10115 /// '\#pragma clang attribute push' directives to the given declaration.
10116 void AddPragmaAttributes(Scope *S, Decl *D);
10117
10118 void DiagnoseUnterminatedPragmaAttribute();
10119
10120 /// Called on well formed \#pragma clang optimize.
10121 void ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc);
10122
10123 /// Get the location for the currently active "\#pragma clang optimize
10124 /// off". If this location is invalid, then the state of the pragma is "on".
10125 SourceLocation getOptimizeOffPragmaLocation() const {
10126 return OptimizeOffPragmaLocation;
10127 }
10128
10129 /// Only called on function definitions; if there is a pragma in scope
10130 /// with the effect of a range-based optnone, consider marking the function
10131 /// with attribute optnone.
10132 void AddRangeBasedOptnone(FunctionDecl *FD);
10133
10134 /// Adds the 'optnone' attribute to the function declaration if there
10135 /// are no conflicts; Loc represents the location causing the 'optnone'
10136 /// attribute to be added (usually because of a pragma).
10137 void AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD, SourceLocation Loc);
10138
10139 /// AddAlignedAttr - Adds an aligned attribute to a particular declaration.
10140 void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
10141 bool IsPackExpansion);
10142 void AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, TypeSourceInfo *T,
10143 bool IsPackExpansion);
10144
10145 /// AddAssumeAlignedAttr - Adds an assume_aligned attribute to a particular
10146 /// declaration.
10147 void AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
10148 Expr *OE);
10149
10150 /// AddAllocAlignAttr - Adds an alloc_align attribute to a particular
10151 /// declaration.
10152 void AddAllocAlignAttr(Decl *D, const AttributeCommonInfo &CI,
10153 Expr *ParamExpr);
10154
10155 /// AddAlignValueAttr - Adds an align_value attribute to a particular
10156 /// declaration.
10157 void AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E);
10158
10159 /// AddAnnotationAttr - Adds an annotation Annot with Args arguments to D.
10160 void AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI,
10161 StringRef Annot, MutableArrayRef<Expr *> Args);
10162
10163 /// AddLaunchBoundsAttr - Adds a launch_bounds attribute to a particular
10164 /// declaration.
10165 void AddLaunchBoundsAttr(Decl *D, const AttributeCommonInfo &CI,
10166 Expr *MaxThreads, Expr *MinBlocks);
10167
10168 /// AddModeAttr - Adds a mode attribute to a particular declaration.
10169 void AddModeAttr(Decl *D, const AttributeCommonInfo &CI, IdentifierInfo *Name,
10170 bool InInstantiation = false);
10171
10172 void AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI,
10173 ParameterABI ABI);
10174
10175 enum class RetainOwnershipKind {NS, CF, OS};
10176 void AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI,
10177 RetainOwnershipKind K, bool IsTemplateInstantiation);
10178
10179 /// addAMDGPUFlatWorkGroupSizeAttr - Adds an amdgpu_flat_work_group_size
10180 /// attribute to a particular declaration.
10181 void addAMDGPUFlatWorkGroupSizeAttr(Decl *D, const AttributeCommonInfo &CI,
10182 Expr *Min, Expr *Max);
10183
10184 /// addAMDGPUWavePersEUAttr - Adds an amdgpu_waves_per_eu attribute to a
10185 /// particular declaration.
10186 void addAMDGPUWavesPerEUAttr(Decl *D, const AttributeCommonInfo &CI,
10187 Expr *Min, Expr *Max);
10188
10189 bool checkNSReturnsRetainedReturnType(SourceLocation loc, QualType type);
10190
10191 //===--------------------------------------------------------------------===//
10192 // C++ Coroutines TS
10193 //
10194 bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc,
10195 StringRef Keyword);
10196 ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E);
10197 ExprResult ActOnCoyieldExpr(Scope *S, SourceLocation KwLoc, Expr *E);
10198 StmtResult ActOnCoreturnStmt(Scope *S, SourceLocation KwLoc, Expr *E);
10199
10200 ExprResult BuildResolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
10201 bool IsImplicit = false);
10202 ExprResult BuildUnresolvedCoawaitExpr(SourceLocation KwLoc, Expr *E,
10203 UnresolvedLookupExpr* Lookup);
10204 ExprResult BuildCoyieldExpr(SourceLocation KwLoc, Expr *E);
10205 StmtResult BuildCoreturnStmt(SourceLocation KwLoc, Expr *E,
10206 bool IsImplicit = false);
10207 StmtResult BuildCoroutineBodyStmt(CoroutineBodyStmt::CtorArgs);
10208 bool buildCoroutineParameterMoves(SourceLocation Loc);
10209 VarDecl *buildCoroutinePromise(SourceLocation Loc);
10210 void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body);
10211 ClassTemplateDecl *lookupCoroutineTraits(SourceLocation KwLoc,
10212 SourceLocation FuncLoc);
10213 /// Check that the expression co_await promise.final_suspend() shall not be
10214 /// potentially-throwing.
10215 bool checkFinalSuspendNoThrow(const Stmt *FinalSuspend);
10216
10217 //===--------------------------------------------------------------------===//
10218 // OpenMP directives and clauses.
10219 //
10220private:
10221 void *VarDataSharingAttributesStack;
10222
10223 struct DeclareTargetContextInfo {
10224 struct MapInfo {
10225 OMPDeclareTargetDeclAttr::MapTypeTy MT;
10226 SourceLocation Loc;
10227 };
10228 /// Explicitly listed variables and functions in a 'to' or 'link' clause.
10229 llvm::DenseMap<NamedDecl *, MapInfo> ExplicitlyMapped;
10230
10231 /// The 'device_type' as parsed from the clause.
10232 OMPDeclareTargetDeclAttr::DevTypeTy DT = OMPDeclareTargetDeclAttr::DT_Any;
10233
10234 /// The directive kind, `begin declare target` or `declare target`.
10235 OpenMPDirectiveKind Kind;
10236
10237 /// The directive location.
10238 SourceLocation Loc;
10239
10240 DeclareTargetContextInfo(OpenMPDirectiveKind Kind, SourceLocation Loc)
10241 : Kind(Kind), Loc(Loc) {}
10242 };
10243
10244 /// Number of nested '#pragma omp declare target' directives.
10245 SmallVector<DeclareTargetContextInfo, 4> DeclareTargetNesting;
10246
10247 /// Initialization of data-sharing attributes stack.
10248 void InitDataSharingAttributesStack();
10249 void DestroyDataSharingAttributesStack();
10250 ExprResult
10251 VerifyPositiveIntegerConstantInClause(Expr *Op, OpenMPClauseKind CKind,
10252 bool StrictlyPositive = true,
10253 bool SuppressExprDiags = false);
10254 /// Returns OpenMP nesting level for current directive.
10255 unsigned getOpenMPNestingLevel() const;
10256
10257 /// Adjusts the function scopes index for the target-based regions.
10258 void adjustOpenMPTargetScopeIndex(unsigned &FunctionScopesIndex,
10259 unsigned Level) const;
10260
10261 /// Returns the number of scopes associated with the construct on the given
10262 /// OpenMP level.
10263 int getNumberOfConstructScopes(unsigned Level) const;
10264
10265 /// Push new OpenMP function region for non-capturing function.
10266 void pushOpenMPFunctionRegion();
10267
10268 /// Pop OpenMP function region for non-capturing function.
10269 void popOpenMPFunctionRegion(const sema::FunctionScopeInfo *OldFSI);
10270
10271 /// Analyzes and checks a loop nest for use by a loop transformation.
10272 ///
10273 /// \param Kind The loop transformation directive kind.
10274 /// \param NumLoops How many nested loops the directive is expecting.
10275 /// \param AStmt Associated statement of the transformation directive.
10276 /// \param LoopHelpers [out] The loop analysis result.
10277 /// \param Body [out] The body code nested in \p NumLoops loop.
10278 /// \param OriginalInits [out] Collection of statements and declarations that
10279 /// must have been executed/declared before entering the
10280 /// loop.
10281 ///
10282 /// \return Whether there was any error.
10283 bool checkTransformableLoopNest(
10284 OpenMPDirectiveKind Kind, Stmt *AStmt, int NumLoops,
10285 SmallVectorImpl<OMPLoopBasedDirective::HelperExprs> &LoopHelpers,
10286 Stmt *&Body,
10287 SmallVectorImpl<SmallVector<llvm::PointerUnion<Stmt *, Decl *>, 0>>
10288 &OriginalInits);
10289
10290 /// Helper to keep information about the current `omp begin/end declare
10291 /// variant` nesting.
10292 struct OMPDeclareVariantScope {
10293 /// The associated OpenMP context selector.
10294 OMPTraitInfo *TI;
10295
10296 /// The associated OpenMP context selector mangling.
10297 std::string NameSuffix;
10298
10299 OMPDeclareVariantScope(OMPTraitInfo &TI);
10300 };
10301
10302 /// Return the OMPTraitInfo for the surrounding scope, if any.
10303 OMPTraitInfo *getOMPTraitInfoForSurroundingScope() {
10304 return OMPDeclareVariantScopes.empty() ? nullptr
10305 : OMPDeclareVariantScopes.back().TI;
10306 }
10307
10308 /// The current `omp begin/end declare variant` scopes.
10309 SmallVector<OMPDeclareVariantScope, 4> OMPDeclareVariantScopes;
10310
10311 /// The current `omp begin/end assumes` scopes.
10312 SmallVector<AssumptionAttr *, 4> OMPAssumeScoped;
10313
10314 /// All `omp assumes` we encountered so far.
10315 SmallVector<AssumptionAttr *, 4> OMPAssumeGlobal;
10316
10317public:
10318 /// The declarator \p D defines a function in the scope \p S which is nested
10319 /// in an `omp begin/end declare variant` scope. In this method we create a
10320 /// declaration for \p D and rename \p D according to the OpenMP context
10321 /// selector of the surrounding scope. Return all base functions in \p Bases.
10322 void ActOnStartOfFunctionDefinitionInOpenMPDeclareVariantScope(
10323 Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParameterLists,
10324 SmallVectorImpl<FunctionDecl *> &Bases);
10325
10326 /// Register \p D as specialization of all base functions in \p Bases in the
10327 /// current `omp begin/end declare variant` scope.
10328 void ActOnFinishedFunctionDefinitionInOpenMPDeclareVariantScope(
10329 Decl *D, SmallVectorImpl<FunctionDecl *> &Bases);
10330
10331 /// Act on \p D, a function definition inside of an `omp [begin/end] assumes`.
10332 void ActOnFinishedFunctionDefinitionInOpenMPAssumeScope(Decl *D);
10333
10334 /// Can we exit an OpenMP declare variant scope at the moment.
10335 bool isInOpenMPDeclareVariantScope() const {
10336 return !OMPDeclareVariantScopes.empty();
10337 }
10338
10339 /// Given the potential call expression \p Call, determine if there is a
10340 /// specialization via the OpenMP declare variant mechanism available. If
10341 /// there is, return the specialized call expression, otherwise return the
10342 /// original \p Call.
10343 ExprResult ActOnOpenMPCall(ExprResult Call, Scope *Scope,
10344 SourceLocation LParenLoc, MultiExprArg ArgExprs,
10345 SourceLocation RParenLoc, Expr *ExecConfig);
10346
10347 /// Handle a `omp begin declare variant`.
10348 void ActOnOpenMPBeginDeclareVariant(SourceLocation Loc, OMPTraitInfo &TI);
10349
10350 /// Handle a `omp end declare variant`.
10351 void ActOnOpenMPEndDeclareVariant();
10352
10353 /// Checks if the variant/multiversion functions are compatible.
10354 bool areMultiversionVariantFunctionsCompatible(
10355 const FunctionDecl *OldFD, const FunctionDecl *NewFD,
10356 const PartialDiagnostic &NoProtoDiagID,
10357 const PartialDiagnosticAt &NoteCausedDiagIDAt,
10358 const PartialDiagnosticAt &NoSupportDiagIDAt,
10359 const PartialDiagnosticAt &DiffDiagIDAt, bool TemplatesSupported,
10360 bool ConstexprSupported, bool CLinkageMayDiffer);
10361
10362 /// Function tries to capture lambda's captured variables in the OpenMP region
10363 /// before the original lambda is captured.
10364 void tryCaptureOpenMPLambdas(ValueDecl *V);
10365
10366 /// Return true if the provided declaration \a VD should be captured by
10367 /// reference.
10368 /// \param Level Relative level of nested OpenMP construct for that the check
10369 /// is performed.
10370 /// \param OpenMPCaptureLevel Capture level within an OpenMP construct.
10371 bool isOpenMPCapturedByRef(const ValueDecl *D, unsigned Level,
10372 unsigned OpenMPCaptureLevel) const;
10373
10374 /// Check if the specified variable is used in one of the private
10375 /// clauses (private, firstprivate, lastprivate, reduction etc.) in OpenMP
10376 /// constructs.
10377 VarDecl *isOpenMPCapturedDecl(ValueDecl *D, bool CheckScopeInfo = false,
10378 unsigned StopAt = 0);
10379 ExprResult getOpenMPCapturedExpr(VarDecl *Capture, ExprValueKind VK,
10380 ExprObjectKind OK, SourceLocation Loc);
10381
10382 /// If the current region is a loop-based region, mark the start of the loop
10383 /// construct.
10384 void startOpenMPLoop();
10385
10386 /// If the current region is a range loop-based region, mark the start of the
10387 /// loop construct.
10388 void startOpenMPCXXRangeFor();
10389
10390 /// Check if the specified variable is used in 'private' clause.
10391 /// \param Level Relative level of nested OpenMP construct for that the check
10392 /// is performed.
10393 OpenMPClauseKind isOpenMPPrivateDecl(ValueDecl *D, unsigned Level,
10394 unsigned CapLevel) const;
10395
10396 /// Sets OpenMP capture kind (OMPC_private, OMPC_firstprivate, OMPC_map etc.)
10397 /// for \p FD based on DSA for the provided corresponding captured declaration
10398 /// \p D.
10399 void setOpenMPCaptureKind(FieldDecl *FD, const ValueDecl *D, unsigned Level);
10400
10401 /// Check if the specified variable is captured by 'target' directive.
10402 /// \param Level Relative level of nested OpenMP construct for that the check
10403 /// is performed.
10404 bool isOpenMPTargetCapturedDecl(const ValueDecl *D, unsigned Level,
10405 unsigned CaptureLevel) const;
10406
10407 /// Check if the specified global variable must be captured by outer capture
10408 /// regions.
10409 /// \param Level Relative level of nested OpenMP construct for that
10410 /// the check is performed.
10411 bool isOpenMPGlobalCapturedDecl(ValueDecl *D, unsigned Level,
10412 unsigned CaptureLevel) const;
10413
10414 ExprResult PerformOpenMPImplicitIntegerConversion(SourceLocation OpLoc,
10415 Expr *Op);
10416 /// Called on start of new data sharing attribute block.
10417 void StartOpenMPDSABlock(OpenMPDirectiveKind K,
10418 const DeclarationNameInfo &DirName, Scope *CurScope,
10419 SourceLocation Loc);
10420 /// Start analysis of clauses.
10421 void StartOpenMPClause(OpenMPClauseKind K);
10422 /// End analysis of clauses.
10423 void EndOpenMPClause();
10424 /// Called on end of data sharing attribute block.
10425 void EndOpenMPDSABlock(Stmt *CurDirective);
10426
10427 /// Check if the current region is an OpenMP loop region and if it is,
10428 /// mark loop control variable, used in \p Init for loop initialization, as
10429 /// private by default.
10430 /// \param Init First part of the for loop.
10431 void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init);
10432
10433 // OpenMP directives and clauses.
10434 /// Called on correct id-expression from the '#pragma omp
10435 /// threadprivate'.
10436 ExprResult ActOnOpenMPIdExpression(Scope *CurScope, CXXScopeSpec &ScopeSpec,
10437 const DeclarationNameInfo &Id,
10438 OpenMPDirectiveKind Kind);
10439 /// Called on well-formed '#pragma omp threadprivate'.
10440 DeclGroupPtrTy ActOnOpenMPThreadprivateDirective(
10441 SourceLocation Loc,
10442 ArrayRef<Expr *> VarList);
10443 /// Builds a new OpenMPThreadPrivateDecl and checks its correctness.
10444 OMPThreadPrivateDecl *CheckOMPThreadPrivateDecl(SourceLocation Loc,
10445 ArrayRef<Expr *> VarList);
10446 /// Called on well-formed '#pragma omp allocate'.
10447 DeclGroupPtrTy ActOnOpenMPAllocateDirective(SourceLocation Loc,
10448 ArrayRef<Expr *> VarList,
10449 ArrayRef<OMPClause *> Clauses,
10450 DeclContext *Owner = nullptr);
10451
10452 /// Called on well-formed '#pragma omp [begin] assume[s]'.
10453 void ActOnOpenMPAssumesDirective(SourceLocation Loc,
10454 OpenMPDirectiveKind DKind,
10455 ArrayRef<StringRef> Assumptions,
10456 bool SkippedClauses);
10457
10458 /// Check if there is an active global `omp begin assumes` directive.
10459 bool isInOpenMPAssumeScope() const { return !OMPAssumeScoped.empty(); }
10460
10461 /// Check if there is an active global `omp assumes` directive.
10462 bool hasGlobalOpenMPAssumes() const { return !OMPAssumeGlobal.empty(); }
10463
10464 /// Called on well-formed '#pragma omp end assumes'.
10465 void ActOnOpenMPEndAssumesDirective();
10466
10467 /// Called on well-formed '#pragma omp requires'.
10468 DeclGroupPtrTy ActOnOpenMPRequiresDirective(SourceLocation Loc,
10469 ArrayRef<OMPClause *> ClauseList);
10470 /// Check restrictions on Requires directive
10471 OMPRequiresDecl *CheckOMPRequiresDecl(SourceLocation Loc,
10472 ArrayRef<OMPClause *> Clauses);
10473 /// Check if the specified type is allowed to be used in 'omp declare
10474 /// reduction' construct.
10475 QualType ActOnOpenMPDeclareReductionType(SourceLocation TyLoc,
10476 TypeResult ParsedType);
10477 /// Called on start of '#pragma omp declare reduction'.
10478 DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveStart(
10479 Scope *S, DeclContext *DC, DeclarationName Name,
10480 ArrayRef<std::pair<QualType, SourceLocation>> ReductionTypes,
10481 AccessSpecifier AS, Decl *PrevDeclInScope = nullptr);
10482 /// Initialize declare reduction construct initializer.
10483 void ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D);
10484 /// Finish current declare reduction construct initializer.
10485 void ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner);
10486 /// Initialize declare reduction construct initializer.
10487 /// \return omp_priv variable.
10488 VarDecl *ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D);
10489 /// Finish current declare reduction construct initializer.
10490 void ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, Expr *Initializer,
10491 VarDecl *OmpPrivParm);
10492 /// Called at the end of '#pragma omp declare reduction'.
10493 DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveEnd(
10494 Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid);
10495
10496 /// Check variable declaration in 'omp declare mapper' construct.
10497 TypeResult ActOnOpenMPDeclareMapperVarDecl(Scope *S, Declarator &D);
10498 /// Check if the specified type is allowed to be used in 'omp declare
10499 /// mapper' construct.
10500 QualType ActOnOpenMPDeclareMapperType(SourceLocation TyLoc,
10501 TypeResult ParsedType);
10502 /// Called on start of '#pragma omp declare mapper'.
10503 DeclGroupPtrTy ActOnOpenMPDeclareMapperDirective(
10504 Scope *S, DeclContext *DC, DeclarationName Name, QualType MapperType,
10505 SourceLocation StartLoc, DeclarationName VN, AccessSpecifier AS,
10506 Expr *MapperVarRef, ArrayRef<OMPClause *> Clauses,
10507 Decl *PrevDeclInScope = nullptr);
10508 /// Build the mapper variable of '#pragma omp declare mapper'.
10509 ExprResult ActOnOpenMPDeclareMapperDirectiveVarDecl(Scope *S,
10510 QualType MapperType,
10511 SourceLocation StartLoc,
10512 DeclarationName VN);
10513 bool isOpenMPDeclareMapperVarDeclAllowed(const VarDecl *VD) const;
10514 const ValueDecl *getOpenMPDeclareMapperVarName() const;
10515
10516 /// Called on the start of target region i.e. '#pragma omp declare target'.
10517 bool ActOnStartOpenMPDeclareTargetContext(DeclareTargetContextInfo &DTCI);
10518
10519 /// Called at the end of target region i.e. '#pragma omp end declare target'.
10520 const DeclareTargetContextInfo ActOnOpenMPEndDeclareTargetDirective();
10521
10522 /// Called once a target context is completed, that can be when a
10523 /// '#pragma omp end declare target' was encountered or when a
10524 /// '#pragma omp declare target' without declaration-definition-seq was
10525 /// encountered.
10526 void ActOnFinishedOpenMPDeclareTargetContext(DeclareTargetContextInfo &DTCI);
10527
10528 /// Searches for the provided declaration name for OpenMP declare target
10529 /// directive.
10530 NamedDecl *lookupOpenMPDeclareTargetName(Scope *CurScope,
10531 CXXScopeSpec &ScopeSpec,
10532 const DeclarationNameInfo &Id);
10533
10534 /// Called on correct id-expression from the '#pragma omp declare target'.
10535 void ActOnOpenMPDeclareTargetName(NamedDecl *ND, SourceLocation Loc,
10536 OMPDeclareTargetDeclAttr::MapTypeTy MT,
10537 OMPDeclareTargetDeclAttr::DevTypeTy DT);
10538
10539 /// Check declaration inside target region.
10540 void
10541 checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D,
10542 SourceLocation IdLoc = SourceLocation());
10543 /// Finishes analysis of the deferred functions calls that may be declared as
10544 /// host/nohost during device/host compilation.
10545 void finalizeOpenMPDelayedAnalysis(const FunctionDecl *Caller,
10546 const FunctionDecl *Callee,
10547 SourceLocation Loc);
10548 /// Return true inside OpenMP declare target region.
10549 bool isInOpenMPDeclareTargetContext() const {
10550 return !DeclareTargetNesting.empty();
10551 }
10552 /// Return true inside OpenMP target region.
10553 bool isInOpenMPTargetExecutionDirective() const;
10554
10555 /// Return the number of captured regions created for an OpenMP directive.
10556 static int getOpenMPCaptureLevels(OpenMPDirectiveKind Kind);
10557
10558 /// Initialization of captured region for OpenMP region.
10559 void ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope);
10560
10561 /// Called for syntactical loops (ForStmt or CXXForRangeStmt) associated to
10562 /// an OpenMP loop directive.
10563 StmtResult ActOnOpenMPCanonicalLoop(Stmt *AStmt);
10564
10565 /// End of OpenMP region.
10566 ///
10567 /// \param S Statement associated with the current OpenMP region.
10568 /// \param Clauses List of clauses for the current OpenMP region.
10569 ///
10570 /// \returns Statement for finished OpenMP region.
10571 StmtResult ActOnOpenMPRegionEnd(StmtResult S, ArrayRef<OMPClause *> Clauses);
10572 StmtResult ActOnOpenMPExecutableDirective(
10573 OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,
10574 OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
10575 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);
10576 /// Called on well-formed '\#pragma omp parallel' after parsing
10577 /// of the associated statement.
10578 StmtResult ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
10579 Stmt *AStmt,
10580 SourceLocation StartLoc,
10581 SourceLocation EndLoc);
10582 using VarsWithInheritedDSAType =
10583 llvm::SmallDenseMap<const ValueDecl *, const Expr *, 4>;
10584 /// Called on well-formed '\#pragma omp simd' after parsing
10585 /// of the associated statement.
10586 StmtResult
10587 ActOnOpenMPSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10588 SourceLocation StartLoc, SourceLocation EndLoc,
10589 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10590 /// Called on well-formed '#pragma omp tile' after parsing of its clauses and
10591 /// the associated statement.
10592 StmtResult ActOnOpenMPTileDirective(ArrayRef<OMPClause *> Clauses,
10593 Stmt *AStmt, SourceLocation StartLoc,
10594 SourceLocation EndLoc);
10595 /// Called on well-formed '#pragma omp unroll' after parsing of its clauses
10596 /// and the associated statement.
10597 StmtResult ActOnOpenMPUnrollDirective(ArrayRef<OMPClause *> Clauses,
10598 Stmt *AStmt, SourceLocation StartLoc,
10599 SourceLocation EndLoc);
10600 /// Called on well-formed '\#pragma omp for' after parsing
10601 /// of the associated statement.
10602 StmtResult
10603 ActOnOpenMPForDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10604 SourceLocation StartLoc, SourceLocation EndLoc,
10605 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10606 /// Called on well-formed '\#pragma omp for simd' after parsing
10607 /// of the associated statement.
10608 StmtResult
10609 ActOnOpenMPForSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10610 SourceLocation StartLoc, SourceLocation EndLoc,
10611 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10612 /// Called on well-formed '\#pragma omp sections' after parsing
10613 /// of the associated statement.
10614 StmtResult ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses,
10615 Stmt *AStmt, SourceLocation StartLoc,
10616 SourceLocation EndLoc);
10617 /// Called on well-formed '\#pragma omp section' after parsing of the
10618 /// associated statement.
10619 StmtResult ActOnOpenMPSectionDirective(Stmt *AStmt, SourceLocation StartLoc,
10620 SourceLocation EndLoc);
10621 /// Called on well-formed '\#pragma omp single' after parsing of the
10622 /// associated statement.
10623 StmtResult ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses,
10624 Stmt *AStmt, SourceLocation StartLoc,
10625 SourceLocation EndLoc);
10626 /// Called on well-formed '\#pragma omp master' after parsing of the
10627 /// associated statement.
10628 StmtResult ActOnOpenMPMasterDirective(Stmt *AStmt, SourceLocation StartLoc,
10629 SourceLocation EndLoc);
10630 /// Called on well-formed '\#pragma omp critical' after parsing of the
10631 /// associated statement.
10632 StmtResult ActOnOpenMPCriticalDirective(const DeclarationNameInfo &DirName,
10633 ArrayRef<OMPClause *> Clauses,
10634 Stmt *AStmt, SourceLocation StartLoc,
10635 SourceLocation EndLoc);
10636 /// Called on well-formed '\#pragma omp parallel for' after parsing
10637 /// of the associated statement.
10638 StmtResult ActOnOpenMPParallelForDirective(
10639 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10640 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10641 /// Called on well-formed '\#pragma omp parallel for simd' after
10642 /// parsing of the associated statement.
10643 StmtResult ActOnOpenMPParallelForSimdDirective(
10644 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10645 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10646 /// Called on well-formed '\#pragma omp parallel master' after
10647 /// parsing of the associated statement.
10648 StmtResult ActOnOpenMPParallelMasterDirective(ArrayRef<OMPClause *> Clauses,
10649 Stmt *AStmt,
10650 SourceLocation StartLoc,
10651 SourceLocation EndLoc);
10652 /// Called on well-formed '\#pragma omp parallel sections' after
10653 /// parsing of the associated statement.
10654 StmtResult ActOnOpenMPParallelSectionsDirective(ArrayRef<OMPClause *> Clauses,
10655 Stmt *AStmt,
10656 SourceLocation StartLoc,
10657 SourceLocation EndLoc);
10658 /// Called on well-formed '\#pragma omp task' after parsing of the
10659 /// associated statement.
10660 StmtResult ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses,
10661 Stmt *AStmt, SourceLocation StartLoc,
10662 SourceLocation EndLoc);
10663 /// Called on well-formed '\#pragma omp taskyield'.
10664 StmtResult ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc,
10665 SourceLocation EndLoc);
10666 /// Called on well-formed '\#pragma omp barrier'.
10667 StmtResult ActOnOpenMPBarrierDirective(SourceLocation StartLoc,
10668 SourceLocation EndLoc);
10669 /// Called on well-formed '\#pragma omp taskwait'.
10670 StmtResult ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc,
10671 SourceLocation EndLoc);
10672 /// Called on well-formed '\#pragma omp taskgroup'.
10673 StmtResult ActOnOpenMPTaskgroupDirective(ArrayRef<OMPClause *> Clauses,
10674 Stmt *AStmt, SourceLocation StartLoc,
10675 SourceLocation EndLoc);
10676 /// Called on well-formed '\#pragma omp flush'.
10677 StmtResult ActOnOpenMPFlushDirective(ArrayRef<OMPClause *> Clauses,
10678 SourceLocation StartLoc,
10679 SourceLocation EndLoc);
10680 /// Called on well-formed '\#pragma omp depobj'.
10681 StmtResult ActOnOpenMPDepobjDirective(ArrayRef<OMPClause *> Clauses,
10682 SourceLocation StartLoc,
10683 SourceLocation EndLoc);
10684 /// Called on well-formed '\#pragma omp scan'.
10685 StmtResult ActOnOpenMPScanDirective(ArrayRef<OMPClause *> Clauses,
10686 SourceLocation StartLoc,
10687 SourceLocation EndLoc);
10688 /// Called on well-formed '\#pragma omp ordered' after parsing of the
10689 /// associated statement.
10690 StmtResult ActOnOpenMPOrderedDirective(ArrayRef<OMPClause *> Clauses,
10691 Stmt *AStmt, SourceLocation StartLoc,
10692 SourceLocation EndLoc);
10693 /// Called on well-formed '\#pragma omp atomic' after parsing of the
10694 /// associated statement.
10695 StmtResult ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
10696 Stmt *AStmt, SourceLocation StartLoc,
10697 SourceLocation EndLoc);
10698 /// Called on well-formed '\#pragma omp target' after parsing of the
10699 /// associated statement.
10700 StmtResult ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses,
10701 Stmt *AStmt, SourceLocation StartLoc,
10702 SourceLocation EndLoc);
10703 /// Called on well-formed '\#pragma omp target data' after parsing of
10704 /// the associated statement.
10705 StmtResult ActOnOpenMPTargetDataDirective(ArrayRef<OMPClause *> Clauses,
10706 Stmt *AStmt, SourceLocation StartLoc,
10707 SourceLocation EndLoc);
10708 /// Called on well-formed '\#pragma omp target enter data' after
10709 /// parsing of the associated statement.
10710 StmtResult ActOnOpenMPTargetEnterDataDirective(ArrayRef<OMPClause *> Clauses,
10711 SourceLocation StartLoc,
10712 SourceLocation EndLoc,
10713 Stmt *AStmt);
10714 /// Called on well-formed '\#pragma omp target exit data' after
10715 /// parsing of the associated statement.
10716 StmtResult ActOnOpenMPTargetExitDataDirective(ArrayRef<OMPClause *> Clauses,
10717 SourceLocation StartLoc,
10718 SourceLocation EndLoc,
10719 Stmt *AStmt);
10720 /// Called on well-formed '\#pragma omp target parallel' after
10721 /// parsing of the associated statement.
10722 StmtResult ActOnOpenMPTargetParallelDirective(ArrayRef<OMPClause *> Clauses,
10723 Stmt *AStmt,
10724 SourceLocation StartLoc,
10725 SourceLocation EndLoc);
10726 /// Called on well-formed '\#pragma omp target parallel for' after
10727 /// parsing of the associated statement.
10728 StmtResult ActOnOpenMPTargetParallelForDirective(
10729 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10730 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10731 /// Called on well-formed '\#pragma omp teams' after parsing of the
10732 /// associated statement.
10733 StmtResult ActOnOpenMPTeamsDirective(ArrayRef<OMPClause *> Clauses,
10734 Stmt *AStmt, SourceLocation StartLoc,
10735 SourceLocation EndLoc);
10736 /// Called on well-formed '\#pragma omp cancellation point'.
10737 StmtResult
10738 ActOnOpenMPCancellationPointDirective(SourceLocation StartLoc,
10739 SourceLocation EndLoc,
10740 OpenMPDirectiveKind CancelRegion);
10741 /// Called on well-formed '\#pragma omp cancel'.
10742 StmtResult ActOnOpenMPCancelDirective(ArrayRef<OMPClause *> Clauses,
10743 SourceLocation StartLoc,
10744 SourceLocation EndLoc,
10745 OpenMPDirectiveKind CancelRegion);
10746 /// Called on well-formed '\#pragma omp taskloop' after parsing of the
10747 /// associated statement.
10748 StmtResult
10749 ActOnOpenMPTaskLoopDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10750 SourceLocation StartLoc, SourceLocation EndLoc,
10751 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10752 /// Called on well-formed '\#pragma omp taskloop simd' after parsing of
10753 /// the associated statement.
10754 StmtResult ActOnOpenMPTaskLoopSimdDirective(
10755 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10756 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10757 /// Called on well-formed '\#pragma omp master taskloop' after parsing of the
10758 /// associated statement.
10759 StmtResult ActOnOpenMPMasterTaskLoopDirective(
10760 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10761 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10762 /// Called on well-formed '\#pragma omp master taskloop simd' after parsing of
10763 /// the associated statement.
10764 StmtResult ActOnOpenMPMasterTaskLoopSimdDirective(
10765 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10766 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10767 /// Called on well-formed '\#pragma omp parallel master taskloop' after
10768 /// parsing of the associated statement.
10769 StmtResult ActOnOpenMPParallelMasterTaskLoopDirective(
10770 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10771 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10772 /// Called on well-formed '\#pragma omp parallel master taskloop simd' after
10773 /// parsing of the associated statement.
10774 StmtResult ActOnOpenMPParallelMasterTaskLoopSimdDirective(
10775 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10776 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10777 /// Called on well-formed '\#pragma omp distribute' after parsing
10778 /// of the associated statement.
10779 StmtResult
10780 ActOnOpenMPDistributeDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10781 SourceLocation StartLoc, SourceLocation EndLoc,
10782 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10783 /// Called on well-formed '\#pragma omp target update'.
10784 StmtResult ActOnOpenMPTargetUpdateDirective(ArrayRef<OMPClause *> Clauses,
10785 SourceLocation StartLoc,
10786 SourceLocation EndLoc,
10787 Stmt *AStmt);
10788 /// Called on well-formed '\#pragma omp distribute parallel for' after
10789 /// parsing of the associated statement.
10790 StmtResult ActOnOpenMPDistributeParallelForDirective(
10791 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10792 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10793 /// Called on well-formed '\#pragma omp distribute parallel for simd'
10794 /// after parsing of the associated statement.
10795 StmtResult ActOnOpenMPDistributeParallelForSimdDirective(
10796 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10797 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10798 /// Called on well-formed '\#pragma omp distribute simd' after
10799 /// parsing of the associated statement.
10800 StmtResult ActOnOpenMPDistributeSimdDirective(
10801 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10802 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10803 /// Called on well-formed '\#pragma omp target parallel for simd' after
10804 /// parsing of the associated statement.
10805 StmtResult ActOnOpenMPTargetParallelForSimdDirective(
10806 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10807 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10808 /// Called on well-formed '\#pragma omp target simd' after parsing of
10809 /// the associated statement.
10810 StmtResult
10811 ActOnOpenMPTargetSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
10812 SourceLocation StartLoc, SourceLocation EndLoc,
10813 VarsWithInheritedDSAType &VarsWithImplicitDSA);
10814 /// Called on well-formed '\#pragma omp teams distribute' after parsing of
10815 /// the associated statement.
10816 StmtResult ActOnOpenMPTeamsDistributeDirective(
10817 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10818 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10819 /// Called on well-formed '\#pragma omp teams distribute simd' after parsing
10820 /// of the associated statement.
10821 StmtResult ActOnOpenMPTeamsDistributeSimdDirective(
10822 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10823 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10824 /// Called on well-formed '\#pragma omp teams distribute parallel for simd'
10825 /// after parsing of the associated statement.
10826 StmtResult ActOnOpenMPTeamsDistributeParallelForSimdDirective(
10827 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10828 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10829 /// Called on well-formed '\#pragma omp teams distribute parallel for'
10830 /// after parsing of the associated statement.
10831 StmtResult ActOnOpenMPTeamsDistributeParallelForDirective(
10832 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10833 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10834 /// Called on well-formed '\#pragma omp target teams' after parsing of the
10835 /// associated statement.
10836 StmtResult ActOnOpenMPTargetTeamsDirective(ArrayRef<OMPClause *> Clauses,
10837 Stmt *AStmt,
10838 SourceLocation StartLoc,
10839 SourceLocation EndLoc);
10840 /// Called on well-formed '\#pragma omp target teams distribute' after parsing
10841 /// of the associated statement.
10842 StmtResult ActOnOpenMPTargetTeamsDistributeDirective(
10843 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10844 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10845 /// Called on well-formed '\#pragma omp target teams distribute parallel for'
10846 /// after parsing of the associated statement.
10847 StmtResult ActOnOpenMPTargetTeamsDistributeParallelForDirective(
10848 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10849 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10850 /// Called on well-formed '\#pragma omp target teams distribute parallel for
10851 /// simd' after parsing of the associated statement.
10852 StmtResult ActOnOpenMPTargetTeamsDistributeParallelForSimdDirective(
10853 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10854 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10855 /// Called on well-formed '\#pragma omp target teams distribute simd' after
10856 /// parsing of the associated statement.
10857 StmtResult ActOnOpenMPTargetTeamsDistributeSimdDirective(
10858 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10859 SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
10860 /// Called on well-formed '\#pragma omp interop'.
10861 StmtResult ActOnOpenMPInteropDirective(ArrayRef<OMPClause *> Clauses,
10862 SourceLocation StartLoc,
10863 SourceLocation EndLoc);
10864 /// Called on well-formed '\#pragma omp dispatch' after parsing of the
10865 // /associated statement.
10866 StmtResult ActOnOpenMPDispatchDirective(ArrayRef<OMPClause *> Clauses,
10867 Stmt *AStmt, SourceLocation StartLoc,
10868 SourceLocation EndLoc);
10869 /// Called on well-formed '\#pragma omp masked' after parsing of the
10870 // /associated statement.
10871 StmtResult ActOnOpenMPMaskedDirective(ArrayRef<OMPClause *> Clauses,
10872 Stmt *AStmt, SourceLocation StartLoc,
10873 SourceLocation EndLoc);
10874
10875 /// Checks correctness of linear modifiers.
10876 bool CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind,
10877 SourceLocation LinLoc);
10878 /// Checks that the specified declaration matches requirements for the linear
10879 /// decls.
10880 bool CheckOpenMPLinearDecl(const ValueDecl *D, SourceLocation ELoc,
10881 OpenMPLinearClauseKind LinKind, QualType Type,
10882 bool IsDeclareSimd = false);
10883
10884 /// Called on well-formed '\#pragma omp declare simd' after parsing of
10885 /// the associated method/function.
10886 DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective(
10887 DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS,
10888 Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
10889 ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
10890 ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR);
10891
10892 /// Checks '\#pragma omp declare variant' variant function and original
10893 /// functions after parsing of the associated method/function.
10894 /// \param DG Function declaration to which declare variant directive is
10895 /// applied to.
10896 /// \param VariantRef Expression that references the variant function, which
10897 /// must be used instead of the original one, specified in \p DG.
10898 /// \param TI The trait info object representing the match clause.
10899 /// \returns None, if the function/variant function are not compatible with
10900 /// the pragma, pair of original function/variant ref expression otherwise.
10901 Optional<std::pair<FunctionDecl *, Expr *>>
10902 checkOpenMPDeclareVariantFunction(DeclGroupPtrTy DG, Expr *VariantRef,
10903 OMPTraitInfo &TI, SourceRange SR);
10904
10905 /// Called on well-formed '\#pragma omp declare variant' after parsing of
10906 /// the associated method/function.
10907 /// \param FD Function declaration to which declare variant directive is
10908 /// applied to.
10909 /// \param VariantRef Expression that references the variant function, which
10910 /// must be used instead of the original one, specified in \p DG.
10911 /// \param TI The context traits associated with the function variant.
10912 void ActOnOpenMPDeclareVariantDirective(FunctionDecl *FD, Expr *VariantRef,
10913 OMPTraitInfo &TI, SourceRange SR);
10914
10915 OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,
10916 Expr *Expr,
10917 SourceLocation StartLoc,
10918 SourceLocation LParenLoc,
10919 SourceLocation EndLoc);
10920 /// Called on well-formed 'allocator' clause.
10921 OMPClause *ActOnOpenMPAllocatorClause(Expr *Allocator,
10922 SourceLocation StartLoc,
10923 SourceLocation LParenLoc,
10924 SourceLocation EndLoc);
10925 /// Called on well-formed 'if' clause.
10926 OMPClause *ActOnOpenMPIfClause(OpenMPDirectiveKind NameModifier,
10927 Expr *Condition, SourceLocation StartLoc,
10928 SourceLocation LParenLoc,
10929 SourceLocation NameModifierLoc,
10930 SourceLocation ColonLoc,
10931 SourceLocation EndLoc);
10932 /// Called on well-formed 'final' clause.
10933 OMPClause *ActOnOpenMPFinalClause(Expr *Condition, SourceLocation StartLoc,
10934 SourceLocation LParenLoc,
10935 SourceLocation EndLoc);
10936 /// Called on well-formed 'num_threads' clause.
10937 OMPClause *ActOnOpenMPNumThreadsClause(Expr *NumThreads,
10938 SourceLocation StartLoc,
10939 SourceLocation LParenLoc,
10940 SourceLocation EndLoc);
10941 /// Called on well-formed 'safelen' clause.
10942 OMPClause *ActOnOpenMPSafelenClause(Expr *Length,
10943 SourceLocation StartLoc,
10944 SourceLocation LParenLoc,
10945 SourceLocation EndLoc);
10946 /// Called on well-formed 'simdlen' clause.
10947 OMPClause *ActOnOpenMPSimdlenClause(Expr *Length, SourceLocation StartLoc,
10948 SourceLocation LParenLoc,
10949 SourceLocation EndLoc);
10950 /// Called on well-form 'sizes' clause.
10951 OMPClause *ActOnOpenMPSizesClause(ArrayRef<Expr *> SizeExprs,
10952 SourceLocation StartLoc,
10953 SourceLocation LParenLoc,
10954 SourceLocation EndLoc);
10955 /// Called on well-form 'full' clauses.
10956 OMPClause *ActOnOpenMPFullClause(SourceLocation StartLoc,
10957 SourceLocation EndLoc);
10958 /// Called on well-form 'partial' clauses.
10959 OMPClause *ActOnOpenMPPartialClause(Expr *FactorExpr, SourceLocation StartLoc,
10960 SourceLocation LParenLoc,
10961 SourceLocation EndLoc);
10962 /// Called on well-formed 'collapse' clause.
10963 OMPClause *ActOnOpenMPCollapseClause(Expr *NumForLoops,
10964 SourceLocation StartLoc,
10965 SourceLocation LParenLoc,
10966 SourceLocation EndLoc);
10967 /// Called on well-formed 'ordered' clause.
10968 OMPClause *
10969 ActOnOpenMPOrderedClause(SourceLocation StartLoc, SourceLocation EndLoc,
10970 SourceLocation LParenLoc = SourceLocation(),
10971 Expr *NumForLoops = nullptr);
10972 /// Called on well-formed 'grainsize' clause.
10973 OMPClause *ActOnOpenMPGrainsizeClause(Expr *Size, SourceLocation StartLoc,
10974 SourceLocation LParenLoc,
10975 SourceLocation EndLoc);
10976 /// Called on well-formed 'num_tasks' clause.
10977 OMPClause *ActOnOpenMPNumTasksClause(Expr *NumTasks, SourceLocation StartLoc,
10978 SourceLocation LParenLoc,
10979 SourceLocation EndLoc);
10980 /// Called on well-formed 'hint' clause.
10981 OMPClause *ActOnOpenMPHintClause(Expr *Hint, SourceLocation StartLoc,
10982 SourceLocation LParenLoc,
10983 SourceLocation EndLoc);
10984 /// Called on well-formed 'detach' clause.
10985 OMPClause *ActOnOpenMPDetachClause(Expr *Evt, SourceLocation StartLoc,
10986 SourceLocation LParenLoc,
10987 SourceLocation EndLoc);
10988
10989 OMPClause *ActOnOpenMPSimpleClause(OpenMPClauseKind Kind,
10990 unsigned Argument,
10991 SourceLocation ArgumentLoc,
10992 SourceLocation StartLoc,
10993 SourceLocation LParenLoc,
10994 SourceLocation EndLoc);
10995 /// Called on well-formed 'default' clause.
10996 OMPClause *ActOnOpenMPDefaultClause(llvm::omp::DefaultKind Kind,
10997 SourceLocation KindLoc,
10998 SourceLocation StartLoc,
10999 SourceLocation LParenLoc,
11000 SourceLocation EndLoc);
11001 /// Called on well-formed 'proc_bind' clause.
11002 OMPClause *ActOnOpenMPProcBindClause(llvm::omp::ProcBindKind Kind,
11003 SourceLocation KindLoc,
11004 SourceLocation StartLoc,
11005 SourceLocation LParenLoc,
11006 SourceLocation EndLoc);
11007 /// Called on well-formed 'order' clause.
11008 OMPClause *ActOnOpenMPOrderClause(OpenMPOrderClauseKind Kind,
11009 SourceLocation KindLoc,
11010 SourceLocation StartLoc,
11011 SourceLocation LParenLoc,
11012 SourceLocation EndLoc);
11013 /// Called on well-formed 'update' clause.
11014 OMPClause *ActOnOpenMPUpdateClause(OpenMPDependClauseKind Kind,
11015 SourceLocation KindLoc,
11016 SourceLocation StartLoc,
11017 SourceLocation LParenLoc,
11018 SourceLocation EndLoc);
11019
11020 OMPClause *ActOnOpenMPSingleExprWithArgClause(
11021 OpenMPClauseKind Kind, ArrayRef<unsigned> Arguments, Expr *Expr,
11022 SourceLocation StartLoc, SourceLocation LParenLoc,
11023 ArrayRef<SourceLocation> ArgumentsLoc, SourceLocation DelimLoc,
11024 SourceLocation EndLoc);
11025 /// Called on well-formed 'schedule' clause.
11026 OMPClause *ActOnOpenMPScheduleClause(
11027 OpenMPScheduleClauseModifier M1, OpenMPScheduleClauseModifier M2,
11028 OpenMPScheduleClauseKind Kind, Expr *ChunkSize, SourceLocation StartLoc,
11029 SourceLocation LParenLoc, SourceLocation M1Loc, SourceLocation M2Loc,
11030 SourceLocation KindLoc, SourceLocation CommaLoc, SourceLocation EndLoc);
11031
11032 OMPClause *ActOnOpenMPClause(OpenMPClauseKind Kind, SourceLocation StartLoc,
11033 SourceLocation EndLoc);
11034 /// Called on well-formed 'nowait' clause.
11035 OMPClause *ActOnOpenMPNowaitClause(SourceLocation StartLoc,
11036 SourceLocation EndLoc);
11037 /// Called on well-formed 'untied' clause.
11038 OMPClause *ActOnOpenMPUntiedClause(SourceLocation StartLoc,
11039 SourceLocation EndLoc);
11040 /// Called on well-formed 'mergeable' clause.
11041 OMPClause *ActOnOpenMPMergeableClause(SourceLocation StartLoc,
11042 SourceLocation EndLoc);
11043 /// Called on well-formed 'read' clause.
11044 OMPClause *ActOnOpenMPReadClause(SourceLocation StartLoc,
11045 SourceLocation EndLoc);
11046 /// Called on well-formed 'write' clause.
11047 OMPClause *ActOnOpenMPWriteClause(SourceLocation StartLoc,
11048 SourceLocation EndLoc);
11049 /// Called on well-formed 'update' clause.
11050 OMPClause *ActOnOpenMPUpdateClause(SourceLocation StartLoc,
11051 SourceLocation EndLoc);
11052 /// Called on well-formed 'capture' clause.
11053 OMPClause *ActOnOpenMPCaptureClause(SourceLocation StartLoc,
11054 SourceLocation EndLoc);
11055 /// Called on well-formed 'seq_cst' clause.
11056 OMPClause *ActOnOpenMPSeqCstClause(SourceLocation StartLoc,
11057 SourceLocation EndLoc);
11058 /// Called on well-formed 'acq_rel' clause.
11059 OMPClause *ActOnOpenMPAcqRelClause(SourceLocation StartLoc,
11060 SourceLocation EndLoc);
11061 /// Called on well-formed 'acquire' clause.
11062 OMPClause *ActOnOpenMPAcquireClause(SourceLocation StartLoc,
11063 SourceLocation EndLoc);
11064 /// Called on well-formed 'release' clause.
11065 OMPClause *ActOnOpenMPReleaseClause(SourceLocation StartLoc,
11066 SourceLocation EndLoc);
11067 /// Called on well-formed 'relaxed' clause.
11068 OMPClause *ActOnOpenMPRelaxedClause(SourceLocation StartLoc,
11069 SourceLocation EndLoc);
11070
11071 /// Called on well-formed 'init' clause.
11072 OMPClause *ActOnOpenMPInitClause(Expr *InteropVar, ArrayRef<Expr *> PrefExprs,
11073 bool IsTarget, bool IsTargetSync,
11074 SourceLocation StartLoc,
11075 SourceLocation LParenLoc,
11076 SourceLocation VarLoc,
11077 SourceLocation EndLoc);
11078
11079 /// Called on well-formed 'use' clause.
11080 OMPClause *ActOnOpenMPUseClause(Expr *InteropVar, SourceLocation StartLoc,
11081 SourceLocation LParenLoc,
11082 SourceLocation VarLoc, SourceLocation EndLoc);
11083
11084 /// Called on well-formed 'destroy' clause.
11085 OMPClause *ActOnOpenMPDestroyClause(Expr *InteropVar, SourceLocation StartLoc,
11086 SourceLocation LParenLoc,
11087 SourceLocation VarLoc,
11088 SourceLocation EndLoc);
11089 /// Called on well-formed 'novariants' clause.
11090 OMPClause *ActOnOpenMPNovariantsClause(Expr *Condition,
11091 SourceLocation StartLoc,
11092 SourceLocation LParenLoc,
11093 SourceLocation EndLoc);
11094 /// Called on well-formed 'nocontext' clause.
11095 OMPClause *ActOnOpenMPNocontextClause(Expr *Condition,
11096 SourceLocation StartLoc,
11097 SourceLocation LParenLoc,
11098 SourceLocation EndLoc);
11099 /// Called on well-formed 'filter' clause.
11100 OMPClause *ActOnOpenMPFilterClause(Expr *ThreadID, SourceLocation StartLoc,
11101 SourceLocation LParenLoc,
11102 SourceLocation EndLoc);
11103 /// Called on well-formed 'threads' clause.
11104 OMPClause *ActOnOpenMPThreadsClause(SourceLocation StartLoc,
11105 SourceLocation EndLoc);
11106 /// Called on well-formed 'simd' clause.
11107 OMPClause *ActOnOpenMPSIMDClause(SourceLocation StartLoc,
11108 SourceLocation EndLoc);
11109 /// Called on well-formed 'nogroup' clause.
11110 OMPClause *ActOnOpenMPNogroupClause(SourceLocation StartLoc,
11111 SourceLocation EndLoc);
11112 /// Called on well-formed 'unified_address' clause.
11113 OMPClause *ActOnOpenMPUnifiedAddressClause(SourceLocation StartLoc,
11114 SourceLocation EndLoc);
11115
11116 /// Called on well-formed 'unified_address' clause.
11117 OMPClause *ActOnOpenMPUnifiedSharedMemoryClause(SourceLocation StartLoc,
11118 SourceLocation EndLoc);
11119
11120 /// Called on well-formed 'reverse_offload' clause.
11121 OMPClause *ActOnOpenMPReverseOffloadClause(SourceLocation StartLoc,
11122 SourceLocation EndLoc);
11123
11124 /// Called on well-formed 'dynamic_allocators' clause.
11125 OMPClause *ActOnOpenMPDynamicAllocatorsClause(SourceLocation StartLoc,
11126 SourceLocation EndLoc);
11127
11128 /// Called on well-formed 'atomic_default_mem_order' clause.
11129 OMPClause *ActOnOpenMPAtomicDefaultMemOrderClause(
11130 OpenMPAtomicDefaultMemOrderClauseKind Kind, SourceLocation KindLoc,
11131 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc);
11132
11133 OMPClause *ActOnOpenMPVarListClause(
11134 OpenMPClauseKind Kind, ArrayRef<Expr *> Vars, Expr *DepModOrTailExpr,
11135 const OMPVarListLocTy &Locs, SourceLocation ColonLoc,
11136 CXXScopeSpec &ReductionOrMapperIdScopeSpec,
11137 DeclarationNameInfo &ReductionOrMapperId, int ExtraModifier,
11138 ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
11139 ArrayRef<SourceLocation> MapTypeModifiersLoc, bool IsMapTypeImplicit,
11140 SourceLocation ExtraModifierLoc,
11141 ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
11142 ArrayRef<SourceLocation> MotionModifiersLoc);
11143 /// Called on well-formed 'inclusive' clause.
11144 OMPClause *ActOnOpenMPInclusiveClause(ArrayRef<Expr *> VarList,
11145 SourceLocation StartLoc,
11146 SourceLocation LParenLoc,
11147 SourceLocation EndLoc);
11148 /// Called on well-formed 'exclusive' clause.
11149 OMPClause *ActOnOpenMPExclusiveClause(ArrayRef<Expr *> VarList,
11150 SourceLocation StartLoc,
11151 SourceLocation LParenLoc,
11152 SourceLocation EndLoc);
11153 /// Called on well-formed 'allocate' clause.
11154 OMPClause *
11155 ActOnOpenMPAllocateClause(Expr *Allocator, ArrayRef<Expr *> VarList,
11156 SourceLocation StartLoc, SourceLocation ColonLoc,
11157 SourceLocation LParenLoc, SourceLocation EndLoc);
11158 /// Called on well-formed 'private' clause.
11159 OMPClause *ActOnOpenMPPrivateClause(ArrayRef<Expr *> VarList,
11160 SourceLocation StartLoc,
11161 SourceLocation LParenLoc,
11162 SourceLocation EndLoc);
11163 /// Called on well-formed 'firstprivate' clause.
11164 OMPClause *ActOnOpenMPFirstprivateClause(ArrayRef<Expr *> VarList,
11165 SourceLocation StartLoc,
11166 SourceLocation LParenLoc,
11167 SourceLocation EndLoc);
11168 /// Called on well-formed 'lastprivate' clause.
11169 OMPClause *ActOnOpenMPLastprivateClause(
11170 ArrayRef<Expr *> VarList, OpenMPLastprivateModifier LPKind,
11171 SourceLocation LPKindLoc, SourceLocation ColonLoc,
11172 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc);
11173 /// Called on well-formed 'shared' clause.
11174 OMPClause *ActOnOpenMPSharedClause(ArrayRef<Expr *> VarList,
11175 SourceLocation StartLoc,
11176 SourceLocation LParenLoc,
11177 SourceLocation EndLoc);
11178 /// Called on well-formed 'reduction' clause.
11179 OMPClause *ActOnOpenMPReductionClause(
11180 ArrayRef<Expr *> VarList, OpenMPReductionClauseModifier Modifier,
11181 SourceLocation StartLoc, SourceLocation LParenLoc,
11182 SourceLocation ModifierLoc, SourceLocation ColonLoc,
11183 SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec,
11184 const DeclarationNameInfo &ReductionId,
11185 ArrayRef<Expr *> UnresolvedReductions = llvm::None);
11186 /// Called on well-formed 'task_reduction' clause.
11187 OMPClause *ActOnOpenMPTaskReductionClause(
11188 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
11189 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
11190 CXXScopeSpec &ReductionIdScopeSpec,
11191 const DeclarationNameInfo &ReductionId,
11192 ArrayRef<Expr *> UnresolvedReductions = llvm::None);
11193 /// Called on well-formed 'in_reduction' clause.
11194 OMPClause *ActOnOpenMPInReductionClause(
11195 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
11196 SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc,
11197 CXXScopeSpec &ReductionIdScopeSpec,
11198 const DeclarationNameInfo &ReductionId,
11199 ArrayRef<Expr *> UnresolvedReductions = llvm::None);
11200 /// Called on well-formed 'linear' clause.
11201 OMPClause *
11202 ActOnOpenMPLinearClause(ArrayRef<Expr *> VarList, Expr *Step,
11203 SourceLocation StartLoc, SourceLocation LParenLoc,
11204 OpenMPLinearClauseKind LinKind, SourceLocation LinLoc,
11205 SourceLocation ColonLoc, SourceLocation EndLoc);
11206 /// Called on well-formed 'aligned' clause.
11207 OMPClause *ActOnOpenMPAlignedClause(ArrayRef<Expr *> VarList,
11208 Expr *Alignment,
11209 SourceLocation StartLoc,
11210 SourceLocation LParenLoc,
11211 SourceLocation ColonLoc,
11212 SourceLocation EndLoc);
11213 /// Called on well-formed 'copyin' clause.
11214 OMPClause *ActOnOpenMPCopyinClause(ArrayRef<Expr *> VarList,
11215 SourceLocation StartLoc,
11216 SourceLocation LParenLoc,
11217 SourceLocation EndLoc);
11218 /// Called on well-formed 'copyprivate' clause.
11219 OMPClause *ActOnOpenMPCopyprivateClause(ArrayRef<Expr *> VarList,
11220 SourceLocation StartLoc,
11221 SourceLocation LParenLoc,
11222 SourceLocation EndLoc);
11223 /// Called on well-formed 'flush' pseudo clause.
11224 OMPClause *ActOnOpenMPFlushClause(ArrayRef<Expr *> VarList,
11225 SourceLocation StartLoc,
11226 SourceLocation LParenLoc,
11227 SourceLocation EndLoc);
11228 /// Called on well-formed 'depobj' pseudo clause.
11229 OMPClause *ActOnOpenMPDepobjClause(Expr *Depobj, SourceLocation StartLoc,
11230 SourceLocation LParenLoc,
11231 SourceLocation EndLoc);
11232 /// Called on well-formed 'depend' clause.
11233 OMPClause *
11234 ActOnOpenMPDependClause(Expr *DepModifier, OpenMPDependClauseKind DepKind,
11235 SourceLocation DepLoc, SourceLocation ColonLoc,
11236 ArrayRef<Expr *> VarList, SourceLocation StartLoc,
11237 SourceLocation LParenLoc, SourceLocation EndLoc);
11238 /// Called on well-formed 'device' clause.
11239 OMPClause *ActOnOpenMPDeviceClause(OpenMPDeviceClauseModifier Modifier,
11240 Expr *Device, SourceLocation StartLoc,
11241 SourceLocation LParenLoc,
11242 SourceLocation ModifierLoc,
11243 SourceLocation EndLoc);
11244 /// Called on well-formed 'map' clause.
11245 OMPClause *
11246 ActOnOpenMPMapClause(ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
11247 ArrayRef<SourceLocation> MapTypeModifiersLoc,
11248 CXXScopeSpec &MapperIdScopeSpec,
11249 DeclarationNameInfo &MapperId,
11250 OpenMPMapClauseKind MapType, bool IsMapTypeImplicit,
11251 SourceLocation MapLoc, SourceLocation ColonLoc,
11252 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
11253 ArrayRef<Expr *> UnresolvedMappers = llvm::None);
11254 /// Called on well-formed 'num_teams' clause.
11255 OMPClause *ActOnOpenMPNumTeamsClause(Expr *NumTeams, SourceLocation StartLoc,
11256 SourceLocation LParenLoc,
11257 SourceLocation EndLoc);
11258 /// Called on well-formed 'thread_limit' clause.
11259 OMPClause *ActOnOpenMPThreadLimitClause(Expr *ThreadLimit,
11260 SourceLocation StartLoc,
11261 SourceLocation LParenLoc,
11262 SourceLocation EndLoc);
11263 /// Called on well-formed 'priority' clause.
11264 OMPClause *ActOnOpenMPPriorityClause(Expr *Priority, SourceLocation StartLoc,
11265 SourceLocation LParenLoc,
11266 SourceLocation EndLoc);
11267 /// Called on well-formed 'dist_schedule' clause.
11268 OMPClause *ActOnOpenMPDistScheduleClause(
11269 OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize,
11270 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation KindLoc,
11271 SourceLocation CommaLoc, SourceLocation EndLoc);
11272 /// Called on well-formed 'defaultmap' clause.
11273 OMPClause *ActOnOpenMPDefaultmapClause(
11274 OpenMPDefaultmapClauseModifier M, OpenMPDefaultmapClauseKind Kind,
11275 SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation MLoc,
11276 SourceLocation KindLoc, SourceLocation EndLoc);
11277 /// Called on well-formed 'to' clause.
11278 OMPClause *
11279 ActOnOpenMPToClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
11280 ArrayRef<SourceLocation> MotionModifiersLoc,
11281 CXXScopeSpec &MapperIdScopeSpec,
11282 DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
11283 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
11284 ArrayRef<Expr *> UnresolvedMappers = llvm::None);
11285 /// Called on well-formed 'from' clause.
11286 OMPClause *
11287 ActOnOpenMPFromClause(ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
11288 ArrayRef<SourceLocation> MotionModifiersLoc,
11289 CXXScopeSpec &MapperIdScopeSpec,
11290 DeclarationNameInfo &MapperId, SourceLocation ColonLoc,
11291 ArrayRef<Expr *> VarList, const OMPVarListLocTy &Locs,
11292 ArrayRef<Expr *> UnresolvedMappers = llvm::None);
11293 /// Called on well-formed 'use_device_ptr' clause.
11294 OMPClause *ActOnOpenMPUseDevicePtrClause(ArrayRef<Expr *> VarList,
11295 const OMPVarListLocTy &Locs);
11296 /// Called on well-formed 'use_device_addr' clause.
11297 OMPClause *ActOnOpenMPUseDeviceAddrClause(ArrayRef<Expr *> VarList,
11298 const OMPVarListLocTy &Locs);
11299 /// Called on well-formed 'is_device_ptr' clause.
11300 OMPClause *ActOnOpenMPIsDevicePtrClause(ArrayRef<Expr *> VarList,
11301 const OMPVarListLocTy &Locs);
11302 /// Called on well-formed 'nontemporal' clause.
11303 OMPClause *ActOnOpenMPNontemporalClause(ArrayRef<Expr *> VarList,
11304 SourceLocation StartLoc,
11305 SourceLocation LParenLoc,
11306 SourceLocation EndLoc);
11307
11308 /// Data for list of allocators.
11309 struct UsesAllocatorsData {
11310 /// Allocator.
11311 Expr *Allocator = nullptr;
11312 /// Allocator traits.
11313 Expr *AllocatorTraits = nullptr;
11314 /// Locations of '(' and ')' symbols.
11315 SourceLocation LParenLoc, RParenLoc;
11316 };
11317 /// Called on well-formed 'uses_allocators' clause.
11318 OMPClause *ActOnOpenMPUsesAllocatorClause(SourceLocation StartLoc,
11319 SourceLocation LParenLoc,
11320 SourceLocation EndLoc,
11321 ArrayRef<UsesAllocatorsData> Data);
11322 /// Called on well-formed 'affinity' clause.
11323 OMPClause *ActOnOpenMPAffinityClause(SourceLocation StartLoc,
11324 SourceLocation LParenLoc,
11325 SourceLocation ColonLoc,
11326 SourceLocation EndLoc, Expr *Modifier,
11327 ArrayRef<Expr *> Locators);
11328
11329 /// The kind of conversion being performed.
11330 enum CheckedConversionKind {
11331 /// An implicit conversion.
11332 CCK_ImplicitConversion,
11333 /// A C-style cast.
11334 CCK_CStyleCast,
11335 /// A functional-style cast.
11336 CCK_FunctionalCast,
11337 /// A cast other than a C-style cast.
11338 CCK_OtherCast,
11339 /// A conversion for an operand of a builtin overloaded operator.
11340 CCK_ForBuiltinOverloadedOp
11341 };
11342
11343 static bool isCast(CheckedConversionKind CCK) {
11344 return CCK == CCK_CStyleCast || CCK == CCK_FunctionalCast ||
11345 CCK == CCK_OtherCast;
11346 }
11347
11348 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
11349 /// cast. If there is already an implicit cast, merge into the existing one.
11350 /// If isLvalue, the result of the cast is an lvalue.
11351 ExprResult
11352 ImpCastExprToType(Expr *E, QualType Type, CastKind CK,
11353 ExprValueKind VK = VK_PRValue,
11354 const CXXCastPath *BasePath = nullptr,
11355 CheckedConversionKind CCK = CCK_ImplicitConversion);
11356
11357 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
11358 /// to the conversion from scalar type ScalarTy to the Boolean type.
11359 static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy);
11360
11361 /// IgnoredValueConversions - Given that an expression's result is
11362 /// syntactically ignored, perform any conversions that are
11363 /// required.
11364 ExprResult IgnoredValueConversions(Expr *E);
11365
11366 // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts
11367 // functions and arrays to their respective pointers (C99 6.3.2.1).
11368 ExprResult UsualUnaryConversions(Expr *E);
11369
11370 /// CallExprUnaryConversions - a special case of an unary conversion
11371 /// performed on a function designator of a call expression.
11372 ExprResult CallExprUnaryConversions(Expr *E);
11373
11374 // DefaultFunctionArrayConversion - converts functions and arrays
11375 // to their respective pointers (C99 6.3.2.1).
11376 ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose = true);
11377
11378 // DefaultFunctionArrayLvalueConversion - converts functions and
11379 // arrays to their respective pointers and performs the
11380 // lvalue-to-rvalue conversion.
11381 ExprResult DefaultFunctionArrayLvalueConversion(Expr *E,
11382 bool Diagnose = true);
11383
11384 // DefaultLvalueConversion - performs lvalue-to-rvalue conversion on
11385 // the operand. This function is a no-op if the operand has a function type
11386 // or an array type.
11387 ExprResult DefaultLvalueConversion(Expr *E);
11388
11389 // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
11390 // do not have a prototype. Integer promotions are performed on each
11391 // argument, and arguments that have type float are promoted to double.
11392 ExprResult DefaultArgumentPromotion(Expr *E);
11393
11394 /// If \p E is a prvalue denoting an unmaterialized temporary, materialize
11395 /// it as an xvalue. In C++98, the result will still be a prvalue, because
11396 /// we don't have xvalues there.
11397 ExprResult TemporaryMaterializationConversion(Expr *E);
11398
11399 // Used for emitting the right warning by DefaultVariadicArgumentPromotion
11400 enum VariadicCallType {
11401 VariadicFunction,
11402 VariadicBlock,
11403 VariadicMethod,
11404 VariadicConstructor,
11405 VariadicDoesNotApply
11406 };
11407
11408 VariadicCallType getVariadicCallType(FunctionDecl *FDecl,
11409 const FunctionProtoType *Proto,
11410 Expr *Fn);
11411
11412 // Used for determining in which context a type is allowed to be passed to a
11413 // vararg function.
11414 enum VarArgKind {
11415 VAK_Valid,
11416 VAK_ValidInCXX11,
11417 VAK_Undefined,
11418 VAK_MSVCUndefined,
11419 VAK_Invalid
11420 };
11421
11422 // Determines which VarArgKind fits an expression.
11423 VarArgKind isValidVarArgType(const QualType &Ty);
11424
11425 /// Check to see if the given expression is a valid argument to a variadic
11426 /// function, issuing a diagnostic if not.
11427 void checkVariadicArgument(const Expr *E, VariadicCallType CT);
11428
11429 /// Check whether the given statement can have musttail applied to it,
11430 /// issuing a diagnostic and returning false if not. In the success case,
11431 /// the statement is rewritten to remove implicit nodes from the return
11432 /// value.
11433 bool checkAndRewriteMustTailAttr(Stmt *St, const Attr &MTA);
11434
11435private:
11436 /// Check whether the given statement can have musttail applied to it,
11437 /// issuing a diagnostic and returning false if not.
11438 bool checkMustTailAttr(const Stmt *St, const Attr &MTA);
11439
11440public:
11441 /// Check to see if a given expression could have '.c_str()' called on it.
11442 bool hasCStrMethod(const Expr *E);
11443
11444 /// GatherArgumentsForCall - Collector argument expressions for various
11445 /// form of call prototypes.
11446 bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
11447 const FunctionProtoType *Proto,
11448 unsigned FirstParam, ArrayRef<Expr *> Args,
11449 SmallVectorImpl<Expr *> &AllArgs,
11450 VariadicCallType CallType = VariadicDoesNotApply,
11451 bool AllowExplicit = false,
11452 bool IsListInitialization = false);
11453
11454 // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
11455 // will create a runtime trap if the resulting type is not a POD type.
11456 ExprResult DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,
11457 FunctionDecl *FDecl);
11458
11459 /// Context in which we're performing a usual arithmetic conversion.
11460 enum ArithConvKind {
11461 /// An arithmetic operation.
11462 ACK_Arithmetic,
11463 /// A bitwise operation.
11464 ACK_BitwiseOp,
11465 /// A comparison.
11466 ACK_Comparison,
11467 /// A conditional (?:) operator.
11468 ACK_Conditional,
11469 /// A compound assignment expression.
11470 ACK_CompAssign,
11471 };
11472
11473 // UsualArithmeticConversions - performs the UsualUnaryConversions on it's
11474 // operands and then handles various conversions that are common to binary
11475 // operators (C99 6.3.1.8). If both operands aren't arithmetic, this
11476 // routine returns the first non-arithmetic type found. The client is
11477 // responsible for emitting appropriate error diagnostics.
11478 QualType UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS,
11479 SourceLocation Loc, ArithConvKind ACK);
11480
11481 /// AssignConvertType - All of the 'assignment' semantic checks return this
11482 /// enum to indicate whether the assignment was allowed. These checks are
11483 /// done for simple assignments, as well as initialization, return from
11484 /// function, argument passing, etc. The query is phrased in terms of a
11485 /// source and destination type.
11486 enum AssignConvertType {
11487 /// Compatible - the types are compatible according to the standard.
11488 Compatible,
11489
11490 /// PointerToInt - The assignment converts a pointer to an int, which we
11491 /// accept as an extension.
11492 PointerToInt,
11493
11494 /// IntToPointer - The assignment converts an int to a pointer, which we
11495 /// accept as an extension.
11496 IntToPointer,
11497
11498 /// FunctionVoidPointer - The assignment is between a function pointer and
11499 /// void*, which the standard doesn't allow, but we accept as an extension.
11500 FunctionVoidPointer,
11501
11502 /// IncompatiblePointer - The assignment is between two pointers types that
11503 /// are not compatible, but we accept them as an extension.
11504 IncompatiblePointer,
11505
11506 /// IncompatibleFunctionPointer - The assignment is between two function
11507 /// pointers types that are not compatible, but we accept them as an
11508 /// extension.
11509 IncompatibleFunctionPointer,
11510
11511 /// IncompatiblePointerSign - The assignment is between two pointers types
11512 /// which point to integers which have a different sign, but are otherwise
11513 /// identical. This is a subset of the above, but broken out because it's by
11514 /// far the most common case of incompatible pointers.
11515 IncompatiblePointerSign,
11516
11517 /// CompatiblePointerDiscardsQualifiers - The assignment discards
11518 /// c/v/r qualifiers, which we accept as an extension.
11519 CompatiblePointerDiscardsQualifiers,
11520
11521 /// IncompatiblePointerDiscardsQualifiers - The assignment
11522 /// discards qualifiers that we don't permit to be discarded,
11523 /// like address spaces.
11524 IncompatiblePointerDiscardsQualifiers,
11525
11526 /// IncompatibleNestedPointerAddressSpaceMismatch - The assignment
11527 /// changes address spaces in nested pointer types which is not allowed.
11528 /// For instance, converting __private int ** to __generic int ** is
11529 /// illegal even though __private could be converted to __generic.
11530 IncompatibleNestedPointerAddressSpaceMismatch,
11531
11532 /// IncompatibleNestedPointerQualifiers - The assignment is between two
11533 /// nested pointer types, and the qualifiers other than the first two
11534 /// levels differ e.g. char ** -> const char **, but we accept them as an
11535 /// extension.
11536 IncompatibleNestedPointerQualifiers,
11537
11538 /// IncompatibleVectors - The assignment is between two vector types that
11539 /// have the same size, which we accept as an extension.
11540 IncompatibleVectors,
11541
11542 /// IntToBlockPointer - The assignment converts an int to a block
11543 /// pointer. We disallow this.
11544 IntToBlockPointer,
11545
11546 /// IncompatibleBlockPointer - The assignment is between two block
11547 /// pointers types that are not compatible.
11548 IncompatibleBlockPointer,
11549
11550 /// IncompatibleObjCQualifiedId - The assignment is between a qualified
11551 /// id type and something else (that is incompatible with it). For example,
11552 /// "id <XXX>" = "Foo *", where "Foo *" doesn't implement the XXX protocol.
11553 IncompatibleObjCQualifiedId,
11554
11555 /// IncompatibleObjCWeakRef - Assigning a weak-unavailable object to an
11556 /// object with __weak qualifier.
11557 IncompatibleObjCWeakRef,
11558
11559 /// Incompatible - We reject this conversion outright, it is invalid to
11560 /// represent it in the AST.
11561 Incompatible
11562 };
11563
11564 /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the
11565 /// assignment conversion type specified by ConvTy. This returns true if the
11566 /// conversion was invalid or false if the conversion was accepted.
11567 bool DiagnoseAssignmentResult(AssignConvertType ConvTy,
11568 SourceLocation Loc,
11569 QualType DstType, QualType SrcType,
11570 Expr *SrcExpr, AssignmentAction Action,
11571 bool *Complained = nullptr);
11572
11573 /// IsValueInFlagEnum - Determine if a value is allowed as part of a flag
11574 /// enum. If AllowMask is true, then we also allow the complement of a valid
11575 /// value, to be used as a mask.
11576 bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val,
11577 bool AllowMask) const;
11578
11579 /// DiagnoseAssignmentEnum - Warn if assignment to enum is a constant
11580 /// integer not in the range of enum values.
11581 void DiagnoseAssignmentEnum(QualType DstType, QualType SrcType,
11582 Expr *SrcExpr);
11583
11584 /// CheckAssignmentConstraints - Perform type checking for assignment,
11585 /// argument passing, variable initialization, and function return values.
11586 /// C99 6.5.16.
11587 AssignConvertType CheckAssignmentConstraints(SourceLocation Loc,
11588 QualType LHSType,
11589 QualType RHSType);
11590
11591 /// Check assignment constraints and optionally prepare for a conversion of
11592 /// the RHS to the LHS type. The conversion is prepared for if ConvertRHS
11593 /// is true.
11594 AssignConvertType CheckAssignmentConstraints(QualType LHSType,
11595 ExprResult &RHS,
11596 CastKind &Kind,
11597 bool ConvertRHS = true);
11598
11599 /// Check assignment constraints for an assignment of RHS to LHSType.
11600 ///
11601 /// \param LHSType The destination type for the assignment.
11602 /// \param RHS The source expression for the assignment.
11603 /// \param Diagnose If \c true, diagnostics may be produced when checking
11604 /// for assignability. If a diagnostic is produced, \p RHS will be
11605 /// set to ExprError(). Note that this function may still return
11606 /// without producing a diagnostic, even for an invalid assignment.
11607 /// \param DiagnoseCFAudited If \c true, the target is a function parameter
11608 /// in an audited Core Foundation API and does not need to be checked
11609 /// for ARC retain issues.
11610 /// \param ConvertRHS If \c true, \p RHS will be updated to model the
11611 /// conversions necessary to perform the assignment. If \c false,
11612 /// \p Diagnose must also be \c false.
11613 AssignConvertType CheckSingleAssignmentConstraints(
11614 QualType LHSType, ExprResult &RHS, bool Diagnose = true,
11615 bool DiagnoseCFAudited = false, bool ConvertRHS = true);
11616
11617 // If the lhs type is a transparent union, check whether we
11618 // can initialize the transparent union with the given expression.
11619 AssignConvertType CheckTransparentUnionArgumentConstraints(QualType ArgType,
11620 ExprResult &RHS);
11621
11622 bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType);
11623
11624 bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType);
11625
11626 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
11627 AssignmentAction Action,
11628 bool AllowExplicit = false);
11629 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
11630 const ImplicitConversionSequence& ICS,
11631 AssignmentAction Action,
11632 CheckedConversionKind CCK
11633 = CCK_ImplicitConversion);
11634 ExprResult PerformImplicitConversion(Expr *From, QualType ToType,
11635 const StandardConversionSequence& SCS,
11636 AssignmentAction Action,
11637 CheckedConversionKind CCK);
11638
11639 ExprResult PerformQualificationConversion(
11640 Expr *E, QualType Ty, ExprValueKind VK = VK_PRValue,
11641 CheckedConversionKind CCK = CCK_ImplicitConversion);
11642
11643 /// the following "Check" methods will return a valid/converted QualType
11644 /// or a null QualType (indicating an error diagnostic was issued).
11645
11646 /// type checking binary operators (subroutines of CreateBuiltinBinOp).
11647 QualType InvalidOperands(SourceLocation Loc, ExprResult &LHS,
11648 ExprResult &RHS);
11649 QualType InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS,
11650 ExprResult &RHS);
11651 QualType CheckPointerToMemberOperands( // C++ 5.5
11652 ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK,
11653 SourceLocation OpLoc, bool isIndirect);
11654 QualType CheckMultiplyDivideOperands( // C99 6.5.5
11655 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign,
11656 bool IsDivide);
11657 QualType CheckRemainderOperands( // C99 6.5.5
11658 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11659 bool IsCompAssign = false);
11660 QualType CheckAdditionOperands( // C99 6.5.6
11661 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11662 BinaryOperatorKind Opc, QualType* CompLHSTy = nullptr);
11663 QualType CheckSubtractionOperands( // C99 6.5.6
11664 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11665 QualType* CompLHSTy = nullptr);
11666 QualType CheckShiftOperands( // C99 6.5.7
11667 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11668 BinaryOperatorKind Opc, bool IsCompAssign = false);
11669 void CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE);
11670 QualType CheckCompareOperands( // C99 6.5.8/9
11671 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11672 BinaryOperatorKind Opc);
11673 QualType CheckBitwiseOperands( // C99 6.5.[10...12]
11674 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11675 BinaryOperatorKind Opc);
11676 QualType CheckLogicalOperands( // C99 6.5.[13,14]
11677 ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
11678 BinaryOperatorKind Opc);
11679 // CheckAssignmentOperands is used for both simple and compound assignment.
11680 // For simple assignment, pass both expressions and a null converted type.
11681 // For compound assignment, pass both expressions and the converted type.
11682 QualType CheckAssignmentOperands( // C99 6.5.16.[1,2]
11683 Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType);
11684
11685 ExprResult checkPseudoObjectIncDec(Scope *S, SourceLocation OpLoc,
11686 UnaryOperatorKind Opcode, Expr *Op);
11687 ExprResult checkPseudoObjectAssignment(Scope *S, SourceLocation OpLoc,
11688 BinaryOperatorKind Opcode,
11689 Expr *LHS, Expr *RHS);
11690 ExprResult checkPseudoObjectRValue(Expr *E);
11691 Expr *recreateSyntacticForm(PseudoObjectExpr *E);
11692
11693 QualType CheckConditionalOperands( // C99 6.5.15
11694 ExprResult &Cond, ExprResult &LHS, ExprResult &RHS,
11695 ExprValueKind &VK, ExprObjectKind &OK, SourceLocation QuestionLoc);
11696 QualType CXXCheckConditionalOperands( // C++ 5.16
11697 ExprResult &cond, ExprResult &lhs, ExprResult &rhs,
11698 ExprValueKind &VK, ExprObjectKind &OK, SourceLocation questionLoc);
11699 QualType CheckVectorConditionalTypes(ExprResult &Cond, ExprResult &LHS,
11700 ExprResult &RHS,
11701 SourceLocation QuestionLoc);
11702 QualType FindCompositePointerType(SourceLocation Loc, Expr *&E1, Expr *&E2,
11703 bool ConvertArgs = true);
11704 QualType FindCompositePointerType(SourceLocation Loc,
11705 ExprResult &E1, ExprResult &E2,
11706 bool ConvertArgs = true) {
11707 Expr *E1Tmp = E1.get(), *E2Tmp = E2.get();
11708 QualType Composite =
11709 FindCompositePointerType(Loc, E1Tmp, E2Tmp, ConvertArgs);
11710 E1 = E1Tmp;
11711 E2 = E2Tmp;
11712 return Composite;
11713 }
11714
11715 QualType FindCompositeObjCPointerType(ExprResult &LHS, ExprResult &RHS,
11716 SourceLocation QuestionLoc);
11717
11718 bool DiagnoseConditionalForNull(Expr *LHSExpr, Expr *RHSExpr,
11719 SourceLocation QuestionLoc);
11720
11721 void DiagnoseAlwaysNonNullPointer(Expr *E,
11722 Expr::NullPointerConstantKind NullType,
11723 bool IsEqual, SourceRange Range);
11724
11725 /// type checking for vector binary operators.
11726 QualType CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
11727 SourceLocation Loc, bool IsCompAssign,
11728 bool AllowBothBool, bool AllowBoolConversion);
11729 QualType GetSignedVectorType(QualType V);
11730 QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS,
11731 SourceLocation Loc,
11732 BinaryOperatorKind Opc);
11733 QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,
11734 SourceLocation Loc);
11735
11736 /// Type checking for matrix binary operators.
11737 QualType CheckMatrixElementwiseOperands(ExprResult &LHS, ExprResult &RHS,
11738 SourceLocation Loc,
11739 bool IsCompAssign);
11740 QualType CheckMatrixMultiplyOperands(ExprResult &LHS, ExprResult &RHS,
11741 SourceLocation Loc, bool IsCompAssign);
11742
11743 bool isValidSveBitcast(QualType srcType, QualType destType);
11744
11745 bool areMatrixTypesOfTheSameDimension(QualType srcTy, QualType destTy);
11746
11747 bool areVectorTypesSameSize(QualType srcType, QualType destType);
11748 bool areLaxCompatibleVectorTypes(QualType srcType, QualType destType);
11749 bool isLaxVectorConversion(QualType srcType, QualType destType);
11750
11751 /// type checking declaration initializers (C99 6.7.8)
11752 bool CheckForConstantInitializer(Expr *e, QualType t);
11753
11754 // type checking C++ declaration initializers (C++ [dcl.init]).
11755
11756 /// ReferenceCompareResult - Expresses the result of comparing two
11757 /// types (cv1 T1 and cv2 T2) to determine their compatibility for the
11758 /// purposes of initialization by reference (C++ [dcl.init.ref]p4).
11759 enum ReferenceCompareResult {
11760 /// Ref_Incompatible - The two types are incompatible, so direct
11761 /// reference binding is not possible.
11762 Ref_Incompatible = 0,
11763 /// Ref_Related - The two types are reference-related, which means
11764 /// that their unqualified forms (T1 and T2) are either the same
11765 /// or T1 is a base class of T2.
11766 Ref_Related,
11767 /// Ref_Compatible - The two types are reference-compatible.
11768 Ref_Compatible
11769 };
11770
11771 // Fake up a scoped enumeration that still contextually converts to bool.
11772 struct ReferenceConversionsScope {
11773 /// The conversions that would be performed on an lvalue of type T2 when
11774 /// binding a reference of type T1 to it, as determined when evaluating
11775 /// whether T1 is reference-compatible with T2.
11776 enum ReferenceConversions {
11777 Qualification = 0x1,
11778 NestedQualification = 0x2,
11779 Function = 0x4,
11780 DerivedToBase = 0x8,
11781 ObjC = 0x10,
11782 ObjCLifetime = 0x20,
11783
11784 LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/ObjCLifetime)LLVM_BITMASK_LARGEST_ENUMERATOR = ObjCLifetime
11785 };
11786 };
11787 using ReferenceConversions = ReferenceConversionsScope::ReferenceConversions;
11788
11789 ReferenceCompareResult
11790 CompareReferenceRelationship(SourceLocation Loc, QualType T1, QualType T2,
11791 ReferenceConversions *Conv = nullptr);
11792
11793 ExprResult checkUnknownAnyCast(SourceRange TypeRange, QualType CastType,
11794 Expr *CastExpr, CastKind &CastKind,
11795 ExprValueKind &VK, CXXCastPath &Path);
11796
11797 /// Force an expression with unknown-type to an expression of the
11798 /// given type.
11799 ExprResult forceUnknownAnyToType(Expr *E, QualType ToType);
11800
11801 /// Type-check an expression that's being passed to an
11802 /// __unknown_anytype parameter.
11803 ExprResult checkUnknownAnyArg(SourceLocation callLoc,
11804 Expr *result, QualType &paramType);
11805
11806 // CheckMatrixCast - Check type constraints for matrix casts.
11807 // We allow casting between matrixes of the same dimensions i.e. when they
11808 // have the same number of rows and column. Returns true if the cast is
11809 // invalid.
11810 bool CheckMatrixCast(SourceRange R, QualType DestTy, QualType SrcTy,
11811 CastKind &Kind);
11812
11813 // CheckVectorCast - check type constraints for vectors.
11814 // Since vectors are an extension, there are no C standard reference for this.
11815 // We allow casting between vectors and integer datatypes of the same size.
11816 // returns true if the cast is invalid
11817 bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
11818 CastKind &Kind);
11819
11820 /// Prepare `SplattedExpr` for a vector splat operation, adding
11821 /// implicit casts if necessary.
11822 ExprResult prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr);
11823
11824 // CheckExtVectorCast - check type constraints for extended vectors.
11825 // Since vectors are an extension, there are no C standard reference for this.
11826 // We allow casting between vectors and integer datatypes of the same size,
11827 // or vectors and the element type of that vector.
11828 // returns the cast expr
11829 ExprResult CheckExtVectorCast(SourceRange R, QualType DestTy, Expr *CastExpr,
11830 CastKind &Kind);
11831
11832 ExprResult BuildCXXFunctionalCastExpr(TypeSourceInfo *TInfo, QualType Type,
11833 SourceLocation LParenLoc,
11834 Expr *CastExpr,
11835 SourceLocation RParenLoc);
11836
11837 enum ARCConversionResult { ACR_okay, ACR_unbridged, ACR_error };
11838
11839 /// Checks for invalid conversions and casts between
11840 /// retainable pointers and other pointer kinds for ARC and Weak.
11841 ARCConversionResult CheckObjCConversion(SourceRange castRange,
11842 QualType castType, Expr *&op,
11843 CheckedConversionKind CCK,
11844 bool Diagnose = true,
11845 bool DiagnoseCFAudited = false,
11846 BinaryOperatorKind Opc = BO_PtrMemD
11847 );
11848
11849 Expr *stripARCUnbridgedCast(Expr *e);
11850 void diagnoseARCUnbridgedCast(Expr *e);
11851
11852 bool CheckObjCARCUnavailableWeakConversion(QualType castType,
11853 QualType ExprType);
11854
11855 /// checkRetainCycles - Check whether an Objective-C message send
11856 /// might create an obvious retain cycle.
11857 void checkRetainCycles(ObjCMessageExpr *msg);
11858 void checkRetainCycles(Expr *receiver, Expr *argument);
11859 void checkRetainCycles(VarDecl *Var, Expr *Init);
11860
11861 /// checkUnsafeAssigns - Check whether +1 expr is being assigned
11862 /// to weak/__unsafe_unretained type.
11863 bool checkUnsafeAssigns(SourceLocation Loc, QualType LHS, Expr *RHS);
11864
11865 /// checkUnsafeExprAssigns - Check whether +1 expr is being assigned
11866 /// to weak/__unsafe_unretained expression.
11867 void checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS);
11868
11869 /// CheckMessageArgumentTypes - Check types in an Obj-C message send.
11870 /// \param Method - May be null.
11871 /// \param [out] ReturnType - The return type of the send.
11872 /// \return true iff there were any incompatible types.
11873 bool CheckMessageArgumentTypes(const Expr *Receiver, QualType ReceiverType,
11874 MultiExprArg Args, Selector Sel,
11875 ArrayRef<SourceLocation> SelectorLocs,
11876 ObjCMethodDecl *Method, bool isClassMessage,
11877 bool isSuperMessage, SourceLocation lbrac,
11878 SourceLocation rbrac, SourceRange RecRange,
11879 QualType &ReturnType, ExprValueKind &VK);
11880
11881 /// Determine the result of a message send expression based on
11882 /// the type of the receiver, the method expected to receive the message,
11883 /// and the form of the message send.
11884 QualType getMessageSendResultType(const Expr *Receiver, QualType ReceiverType,
11885 ObjCMethodDecl *Method, bool isClassMessage,
11886 bool isSuperMessage);
11887
11888 /// If the given expression involves a message send to a method
11889 /// with a related result type, emit a note describing what happened.
11890 void EmitRelatedResultTypeNote(const Expr *E);
11891
11892 /// Given that we had incompatible pointer types in a return
11893 /// statement, check whether we're in a method with a related result
11894 /// type, and if so, emit a note describing what happened.
11895 void EmitRelatedResultTypeNoteForReturn(QualType destType);
11896
11897 class ConditionResult {
11898 Decl *ConditionVar;
11899 FullExprArg Condition;
11900 bool Invalid;
11901 bool HasKnownValue;
11902 bool KnownValue;
11903
11904 friend class Sema;
11905 ConditionResult(Sema &S, Decl *ConditionVar, FullExprArg Condition,
11906 bool IsConstexpr)
11907 : ConditionVar(ConditionVar), Condition(Condition), Invalid(false),
11908 HasKnownValue(IsConstexpr && Condition.get() &&
11909 !Condition.get()->isValueDependent()),
11910 KnownValue(HasKnownValue &&
11911 !!Condition.get()->EvaluateKnownConstInt(S.Context)) {}
11912 explicit ConditionResult(bool Invalid)
11913 : ConditionVar(nullptr), Condition(nullptr), Invalid(Invalid),
11914 HasKnownValue(false), KnownValue(false) {}
11915
11916 public:
11917 ConditionResult() : ConditionResult(false) {}
11918 bool isInvalid() const { return Invalid; }
11919 std::pair<VarDecl *, Expr *> get() const {
11920 return std::make_pair(cast_or_null<VarDecl>(ConditionVar),
11921 Condition.get());
11922 }
11923 llvm::Optional<bool> getKnownValue() const {
11924 if (!HasKnownValue)
11925 return None;
11926 return KnownValue;
11927 }
11928 };
11929 static ConditionResult ConditionError() { return ConditionResult(true); }
11930
11931 enum class ConditionKind {
11932 Boolean, ///< A boolean condition, from 'if', 'while', 'for', or 'do'.
11933 ConstexprIf, ///< A constant boolean condition from 'if constexpr'.
11934 Switch ///< An integral condition for a 'switch' statement.
11935 };
11936
11937 ConditionResult ActOnCondition(Scope *S, SourceLocation Loc,
11938 Expr *SubExpr, ConditionKind CK);
11939
11940 ConditionResult ActOnConditionVariable(Decl *ConditionVar,
11941 SourceLocation StmtLoc,
11942 ConditionKind CK);
11943
11944 DeclResult ActOnCXXConditionDeclaration(Scope *S, Declarator &D);
11945
11946 ExprResult CheckConditionVariable(VarDecl *ConditionVar,
11947 SourceLocation StmtLoc,
11948 ConditionKind CK);
11949 ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond);
11950
11951 /// CheckBooleanCondition - Diagnose problems involving the use of
11952 /// the given expression as a boolean condition (e.g. in an if
11953 /// statement). Also performs the standard function and array
11954 /// decays, possibly changing the input variable.
11955 ///
11956 /// \param Loc - A location associated with the condition, e.g. the
11957 /// 'if' keyword.
11958 /// \return true iff there were any errors
11959 ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E,
11960 bool IsConstexpr = false);
11961
11962 /// ActOnExplicitBoolSpecifier - Build an ExplicitSpecifier from an expression
11963 /// found in an explicit(bool) specifier.
11964 ExplicitSpecifier ActOnExplicitBoolSpecifier(Expr *E);
11965
11966 /// tryResolveExplicitSpecifier - Attempt to resolve the explict specifier.
11967 /// Returns true if the explicit specifier is now resolved.
11968 bool tryResolveExplicitSpecifier(ExplicitSpecifier &ExplicitSpec);
11969
11970 /// DiagnoseAssignmentAsCondition - Given that an expression is
11971 /// being used as a boolean condition, warn if it's an assignment.
11972 void DiagnoseAssignmentAsCondition(Expr *E);
11973
11974 /// Redundant parentheses over an equality comparison can indicate
11975 /// that the user intended an assignment used as condition.
11976 void DiagnoseEqualityWithExtraParens(ParenExpr *ParenE);
11977
11978 /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
11979 ExprResult CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr = false);
11980
11981 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
11982 /// the specified width and sign. If an overflow occurs, detect it and emit
11983 /// the specified diagnostic.
11984 void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal,
11985 unsigned NewWidth, bool NewSign,
11986 SourceLocation Loc, unsigned DiagID);
11987
11988 /// Checks that the Objective-C declaration is declared in the global scope.
11989 /// Emits an error and marks the declaration as invalid if it's not declared
11990 /// in the global scope.
11991 bool CheckObjCDeclScope(Decl *D);
11992
11993 /// Abstract base class used for diagnosing integer constant
11994 /// expression violations.
11995 class VerifyICEDiagnoser {
11996 public:
11997 bool Suppress;
11998
11999 VerifyICEDiagnoser(bool Suppress = false) : Suppress(Suppress) { }
12000
12001 virtual SemaDiagnosticBuilder
12002 diagnoseNotICEType(Sema &S, SourceLocation Loc, QualType T);
12003 virtual SemaDiagnosticBuilder diagnoseNotICE(Sema &S,
12004 SourceLocation Loc) = 0;
12005 virtual SemaDiagnosticBuilder diagnoseFold(Sema &S, SourceLocation Loc);
12006 virtual ~VerifyICEDiagnoser() {}
12007 };
12008
12009 enum AllowFoldKind {
12010 NoFold,
12011 AllowFold,
12012 };
12013
12014 /// VerifyIntegerConstantExpression - Verifies that an expression is an ICE,
12015 /// and reports the appropriate diagnostics. Returns false on success.
12016 /// Can optionally return the value of the expression.
12017 ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
12018 VerifyICEDiagnoser &Diagnoser,
12019 AllowFoldKind CanFold = NoFold);
12020 ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
12021 unsigned DiagID,
12022 AllowFoldKind CanFold = NoFold);
12023 ExprResult VerifyIntegerConstantExpression(Expr *E,
12024 llvm::APSInt *Result = nullptr,
12025 AllowFoldKind CanFold = NoFold);
12026 ExprResult VerifyIntegerConstantExpression(Expr *E,
12027 AllowFoldKind CanFold = NoFold) {
12028 return VerifyIntegerConstantExpression(E, nullptr, CanFold);
12029 }
12030
12031 /// VerifyBitField - verifies that a bit field expression is an ICE and has
12032 /// the correct width, and that the field type is valid.
12033 /// Returns false on success.
12034 /// Can optionally return whether the bit-field is of width 0
12035 ExprResult VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
12036 QualType FieldTy, bool IsMsStruct,
12037 Expr *BitWidth, bool *ZeroWidth = nullptr);
12038
12039private:
12040 unsigned ForceCUDAHostDeviceDepth = 0;
12041
12042public:
12043 /// Increments our count of the number of times we've seen a pragma forcing
12044 /// functions to be __host__ __device__. So long as this count is greater
12045 /// than zero, all functions encountered will be __host__ __device__.
12046 void PushForceCUDAHostDevice();
12047
12048 /// Decrements our count of the number of times we've seen a pragma forcing
12049 /// functions to be __host__ __device__. Returns false if the count is 0
12050 /// before incrementing, so you can emit an error.
12051 bool PopForceCUDAHostDevice();
12052
12053 /// Diagnostics that are emitted only if we discover that the given function
12054 /// must be codegen'ed. Because handling these correctly adds overhead to
12055 /// compilation, this is currently only enabled for CUDA compilations.
12056 llvm::DenseMap<CanonicalDeclPtr<FunctionDecl>,
12057 std::vector<PartialDiagnosticAt>>
12058 DeviceDeferredDiags;
12059
12060 /// A pair of a canonical FunctionDecl and a SourceLocation. When used as the
12061 /// key in a hashtable, both the FD and location are hashed.
12062 struct FunctionDeclAndLoc {
12063 CanonicalDeclPtr<FunctionDecl> FD;
12064 SourceLocation Loc;
12065 };
12066
12067 /// FunctionDecls and SourceLocations for which CheckCUDACall has emitted a
12068 /// (maybe deferred) "bad call" diagnostic. We use this to avoid emitting the
12069 /// same deferred diag twice.
12070 llvm::DenseSet<FunctionDeclAndLoc> LocsWithCUDACallDiags;
12071
12072 /// An inverse call graph, mapping known-emitted functions to one of their
12073 /// known-emitted callers (plus the location of the call).
12074 ///
12075 /// Functions that we can tell a priori must be emitted aren't added to this
12076 /// map.
12077 llvm::DenseMap</* Callee = */ CanonicalDeclPtr<FunctionDecl>,
12078 /* Caller = */ FunctionDeclAndLoc>
12079 DeviceKnownEmittedFns;
12080
12081 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12082 /// context is "used as device code".
12083 ///
12084 /// - If CurContext is a __host__ function, does not emit any diagnostics
12085 /// unless \p EmitOnBothSides is true.
12086 /// - If CurContext is a __device__ or __global__ function, emits the
12087 /// diagnostics immediately.
12088 /// - If CurContext is a __host__ __device__ function and we are compiling for
12089 /// the device, creates a diagnostic which is emitted if and when we realize
12090 /// that the function will be codegen'ed.
12091 ///
12092 /// Example usage:
12093 ///
12094 /// // Variable-length arrays are not allowed in CUDA device code.
12095 /// if (CUDADiagIfDeviceCode(Loc, diag::err_cuda_vla) << CurrentCUDATarget())
12096 /// return ExprError();
12097 /// // Otherwise, continue parsing as normal.
12098 SemaDiagnosticBuilder CUDADiagIfDeviceCode(SourceLocation Loc,
12099 unsigned DiagID);
12100
12101 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12102 /// context is "used as host code".
12103 ///
12104 /// Same as CUDADiagIfDeviceCode, with "host" and "device" switched.
12105 SemaDiagnosticBuilder CUDADiagIfHostCode(SourceLocation Loc, unsigned DiagID);
12106
12107 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12108 /// context is "used as device code".
12109 ///
12110 /// - If CurContext is a `declare target` function or it is known that the
12111 /// function is emitted for the device, emits the diagnostics immediately.
12112 /// - If CurContext is a non-`declare target` function and we are compiling
12113 /// for the device, creates a diagnostic which is emitted if and when we
12114 /// realize that the function will be codegen'ed.
12115 ///
12116 /// Example usage:
12117 ///
12118 /// // Variable-length arrays are not allowed in NVPTX device code.
12119 /// if (diagIfOpenMPDeviceCode(Loc, diag::err_vla_unsupported))
12120 /// return ExprError();
12121 /// // Otherwise, continue parsing as normal.
12122 SemaDiagnosticBuilder
12123 diagIfOpenMPDeviceCode(SourceLocation Loc, unsigned DiagID, FunctionDecl *FD);
12124
12125 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12126 /// context is "used as host code".
12127 ///
12128 /// - If CurContext is a `declare target` function or it is known that the
12129 /// function is emitted for the host, emits the diagnostics immediately.
12130 /// - If CurContext is a non-host function, just ignore it.
12131 ///
12132 /// Example usage:
12133 ///
12134 /// // Variable-length arrays are not allowed in NVPTX device code.
12135 /// if (diagIfOpenMPHostode(Loc, diag::err_vla_unsupported))
12136 /// return ExprError();
12137 /// // Otherwise, continue parsing as normal.
12138 SemaDiagnosticBuilder diagIfOpenMPHostCode(SourceLocation Loc,
12139 unsigned DiagID, FunctionDecl *FD);
12140
12141 SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID,
12142 FunctionDecl *FD = nullptr);
12143 SemaDiagnosticBuilder targetDiag(SourceLocation Loc,
12144 const PartialDiagnostic &PD,
12145 FunctionDecl *FD = nullptr) {
12146 return targetDiag(Loc, PD.getDiagID(), FD) << PD;
12147 }
12148
12149 /// Check if the expression is allowed to be used in expressions for the
12150 /// offloading devices.
12151 void checkDeviceDecl(ValueDecl *D, SourceLocation Loc);
12152
12153 enum CUDAFunctionTarget {
12154 CFT_Device,
12155 CFT_Global,
12156 CFT_Host,
12157 CFT_HostDevice,
12158 CFT_InvalidTarget
12159 };
12160
12161 /// Determines whether the given function is a CUDA device/host/kernel/etc.
12162 /// function.
12163 ///
12164 /// Use this rather than examining the function's attributes yourself -- you
12165 /// will get it wrong. Returns CFT_Host if D is null.
12166 CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D,
12167 bool IgnoreImplicitHDAttr = false);
12168 CUDAFunctionTarget IdentifyCUDATarget(const ParsedAttributesView &Attrs);
12169
12170 enum CUDAVariableTarget {
12171 CVT_Device, /// Emitted on device side with a shadow variable on host side
12172 CVT_Host, /// Emitted on host side only
12173 CVT_Both, /// Emitted on both sides with different addresses
12174 CVT_Unified, /// Emitted as a unified address, e.g. managed variables
12175 };
12176 /// Determines whether the given variable is emitted on host or device side.
12177 CUDAVariableTarget IdentifyCUDATarget(const VarDecl *D);
12178
12179 /// Gets the CUDA target for the current context.
12180 CUDAFunctionTarget CurrentCUDATarget() {
12181 return IdentifyCUDATarget(dyn_cast<FunctionDecl>(CurContext));
12182 }
12183
12184 static bool isCUDAImplicitHostDeviceFunction(const FunctionDecl *D);
12185
12186 // CUDA function call preference. Must be ordered numerically from
12187 // worst to best.
12188 enum CUDAFunctionPreference {
12189 CFP_Never, // Invalid caller/callee combination.
12190 CFP_WrongSide, // Calls from host-device to host or device
12191 // function that do not match current compilation
12192 // mode.
12193 CFP_HostDevice, // Any calls to host/device functions.
12194 CFP_SameSide, // Calls from host-device to host or device
12195 // function matching current compilation mode.
12196 CFP_Native, // host-to-host or device-to-device calls.
12197 };
12198
12199 /// Identifies relative preference of a given Caller/Callee
12200 /// combination, based on their host/device attributes.
12201 /// \param Caller function which needs address of \p Callee.
12202 /// nullptr in case of global context.
12203 /// \param Callee target function
12204 ///
12205 /// \returns preference value for particular Caller/Callee combination.
12206 CUDAFunctionPreference IdentifyCUDAPreference(const FunctionDecl *Caller,
12207 const FunctionDecl *Callee);
12208
12209 /// Determines whether Caller may invoke Callee, based on their CUDA
12210 /// host/device attributes. Returns false if the call is not allowed.
12211 ///
12212 /// Note: Will return true for CFP_WrongSide calls. These may appear in
12213 /// semantically correct CUDA programs, but only if they're never codegen'ed.
12214 bool IsAllowedCUDACall(const FunctionDecl *Caller,
12215 const FunctionDecl *Callee) {
12216 return IdentifyCUDAPreference(Caller, Callee) != CFP_Never;
12217 }
12218
12219 /// May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD,
12220 /// depending on FD and the current compilation settings.
12221 void maybeAddCUDAHostDeviceAttrs(FunctionDecl *FD,
12222 const LookupResult &Previous);
12223
12224 /// May add implicit CUDAConstantAttr attribute to VD, depending on VD
12225 /// and current compilation settings.
12226 void MaybeAddCUDAConstantAttr(VarDecl *VD);
12227
12228public:
12229 /// Check whether we're allowed to call Callee from the current context.
12230 ///
12231 /// - If the call is never allowed in a semantically-correct program
12232 /// (CFP_Never), emits an error and returns false.
12233 ///
12234 /// - If the call is allowed in semantically-correct programs, but only if
12235 /// it's never codegen'ed (CFP_WrongSide), creates a deferred diagnostic to
12236 /// be emitted if and when the caller is codegen'ed, and returns true.
12237 ///
12238 /// Will only create deferred diagnostics for a given SourceLocation once,
12239 /// so you can safely call this multiple times without generating duplicate
12240 /// deferred errors.
12241 ///
12242 /// - Otherwise, returns true without emitting any diagnostics.
12243 bool CheckCUDACall(SourceLocation Loc, FunctionDecl *Callee);
12244
12245 void CUDACheckLambdaCapture(CXXMethodDecl *D, const sema::Capture &Capture);
12246
12247 /// Set __device__ or __host__ __device__ attributes on the given lambda
12248 /// operator() method.
12249 ///
12250 /// CUDA lambdas by default is host device function unless it has explicit
12251 /// host or device attribute.
12252 void CUDASetLambdaAttrs(CXXMethodDecl *Method);
12253
12254 /// Finds a function in \p Matches with highest calling priority
12255 /// from \p Caller context and erases all functions with lower
12256 /// calling priority.
12257 void EraseUnwantedCUDAMatches(
12258 const FunctionDecl *Caller,
12259 SmallVectorImpl<std::pair<DeclAccessPair, FunctionDecl *>> &Matches);
12260
12261 /// Given a implicit special member, infer its CUDA target from the
12262 /// calls it needs to make to underlying base/field special members.
12263 /// \param ClassDecl the class for which the member is being created.
12264 /// \param CSM the kind of special member.
12265 /// \param MemberDecl the special member itself.
12266 /// \param ConstRHS true if this is a copy operation with a const object on
12267 /// its RHS.
12268 /// \param Diagnose true if this call should emit diagnostics.
12269 /// \return true if there was an error inferring.
12270 /// The result of this call is implicit CUDA target attribute(s) attached to
12271 /// the member declaration.
12272 bool inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl,
12273 CXXSpecialMember CSM,
12274 CXXMethodDecl *MemberDecl,
12275 bool ConstRHS,
12276 bool Diagnose);
12277
12278 /// \return true if \p CD can be considered empty according to CUDA
12279 /// (E.2.3.1 in CUDA 7.5 Programming guide).
12280 bool isEmptyCudaConstructor(SourceLocation Loc, CXXConstructorDecl *CD);
12281 bool isEmptyCudaDestructor(SourceLocation Loc, CXXDestructorDecl *CD);
12282
12283 // \brief Checks that initializers of \p Var satisfy CUDA restrictions. In
12284 // case of error emits appropriate diagnostic and invalidates \p Var.
12285 //
12286 // \details CUDA allows only empty constructors as initializers for global
12287 // variables (see E.2.3.1, CUDA 7.5). The same restriction also applies to all
12288 // __shared__ variables whether they are local or not (they all are implicitly
12289 // static in CUDA). One exception is that CUDA allows constant initializers
12290 // for __constant__ and __device__ variables.
12291 void checkAllowedCUDAInitializer(VarDecl *VD);
12292
12293 /// Check whether NewFD is a valid overload for CUDA. Emits
12294 /// diagnostics and invalidates NewFD if not.
12295 void checkCUDATargetOverload(FunctionDecl *NewFD,
12296 const LookupResult &Previous);
12297 /// Copies target attributes from the template TD to the function FD.
12298 void inheritCUDATargetAttrs(FunctionDecl *FD, const FunctionTemplateDecl &TD);
12299
12300 /// Returns the name of the launch configuration function. This is the name
12301 /// of the function that will be called to configure kernel call, with the
12302 /// parameters specified via <<<>>>.
12303 std::string getCudaConfigureFuncName() const;
12304
12305 /// \name Code completion
12306 //@{
12307 /// Describes the context in which code completion occurs.
12308 enum ParserCompletionContext {
12309 /// Code completion occurs at top-level or namespace context.
12310 PCC_Namespace,
12311 /// Code completion occurs within a class, struct, or union.
12312 PCC_Class,
12313 /// Code completion occurs within an Objective-C interface, protocol,
12314 /// or category.
12315 PCC_ObjCInterface,
12316 /// Code completion occurs within an Objective-C implementation or
12317 /// category implementation
12318 PCC_ObjCImplementation,
12319 /// Code completion occurs within the list of instance variables
12320 /// in an Objective-C interface, protocol, category, or implementation.
12321 PCC_ObjCInstanceVariableList,
12322 /// Code completion occurs following one or more template
12323 /// headers.
12324 PCC_Template,
12325 /// Code completion occurs following one or more template
12326 /// headers within a class.
12327 PCC_MemberTemplate,
12328 /// Code completion occurs within an expression.
12329 PCC_Expression,
12330 /// Code completion occurs within a statement, which may
12331 /// also be an expression or a declaration.
12332 PCC_Statement,
12333 /// Code completion occurs at the beginning of the
12334 /// initialization statement (or expression) in a for loop.
12335 PCC_ForInit,
12336 /// Code completion occurs within the condition of an if,
12337 /// while, switch, or for statement.
12338 PCC_Condition,
12339 /// Code completion occurs within the body of a function on a
12340 /// recovery path, where we do not have a specific handle on our position
12341 /// in the grammar.
12342 PCC_RecoveryInFunction,
12343 /// Code completion occurs where only a type is permitted.
12344 PCC_Type,
12345 /// Code completion occurs in a parenthesized expression, which
12346 /// might also be a type cast.
12347 PCC_ParenthesizedExpression,
12348 /// Code completion occurs within a sequence of declaration
12349 /// specifiers within a function, method, or block.
12350 PCC_LocalDeclarationSpecifiers
12351 };
12352
12353 void CodeCompleteModuleImport(SourceLocation ImportLoc, ModuleIdPath Path);
12354 void CodeCompleteOrdinaryName(Scope *S,
12355 ParserCompletionContext CompletionContext);
12356 void CodeCompleteDeclSpec(Scope *S, DeclSpec &DS,
12357 bool AllowNonIdentifiers,
12358 bool AllowNestedNameSpecifiers);
12359
12360 struct CodeCompleteExpressionData;
12361 void CodeCompleteExpression(Scope *S,
12362 const CodeCompleteExpressionData &Data);
12363 void CodeCompleteExpression(Scope *S, QualType PreferredType,
12364 bool IsParenthesized = false);
12365 void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, Expr *OtherOpBase,
12366 SourceLocation OpLoc, bool IsArrow,
12367 bool IsBaseExprStatement,
12368 QualType PreferredType);
12369 void CodeCompletePostfixExpression(Scope *S, ExprResult LHS,
12370 QualType PreferredType);
12371 void CodeCompleteTag(Scope *S, unsigned TagSpec);
12372 void CodeCompleteTypeQualifiers(DeclSpec &DS);
12373 void CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D,
12374 const VirtSpecifiers *VS = nullptr);
12375 void CodeCompleteBracketDeclarator(Scope *S);
12376 void CodeCompleteCase(Scope *S);
12377 /// Determines the preferred type of the current function argument, by
12378 /// examining the signatures of all possible overloads.
12379 /// Returns null if unknown or ambiguous, or if code completion is off.
12380 ///
12381 /// If the code completion point has been reached, also reports the function
12382 /// signatures that were considered.
12383 ///
12384 /// FIXME: rename to GuessCallArgumentType to reduce confusion.
12385 QualType ProduceCallSignatureHelp(Scope *S, Expr *Fn, ArrayRef<Expr *> Args,
12386 SourceLocation OpenParLoc);
12387 QualType ProduceConstructorSignatureHelp(Scope *S, QualType Type,
12388 SourceLocation Loc,
12389 ArrayRef<Expr *> Args,
12390 SourceLocation OpenParLoc);
12391 QualType ProduceCtorInitMemberSignatureHelp(Scope *S, Decl *ConstructorDecl,
12392 CXXScopeSpec SS,
12393 ParsedType TemplateTypeTy,
12394 ArrayRef<Expr *> ArgExprs,
12395 IdentifierInfo *II,
12396 SourceLocation OpenParLoc);
12397 void CodeCompleteInitializer(Scope *S, Decl *D);
12398 /// Trigger code completion for a record of \p BaseType. \p InitExprs are
12399 /// expressions in the initializer list seen so far and \p D is the current
12400 /// Designation being parsed.
12401 void CodeCompleteDesignator(const QualType BaseType,
12402 llvm::ArrayRef<Expr *> InitExprs,
12403 const Designation &D);
12404 void CodeCompleteAfterIf(Scope *S, bool IsBracedThen);
12405
12406 void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, bool EnteringContext,
12407 bool IsUsingDeclaration, QualType BaseType,
12408 QualType PreferredType);
12409 void CodeCompleteUsing(Scope *S);
12410 void CodeCompleteUsingDirective(Scope *S);
12411 void CodeCompleteNamespaceDecl(Scope *S);
12412 void CodeCompleteNamespaceAliasDecl(Scope *S);
12413 void CodeCompleteOperatorName(Scope *S);
12414 void CodeCompleteConstructorInitializer(
12415 Decl *Constructor,
12416 ArrayRef<CXXCtorInitializer *> Initializers);
12417
12418 void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro,
12419 bool AfterAmpersand);
12420 void CodeCompleteAfterFunctionEquals(Declarator &D);
12421
12422 void CodeCompleteObjCAtDirective(Scope *S);
12423 void CodeCompleteObjCAtVisibility(Scope *S);
12424 void CodeCompleteObjCAtStatement(Scope *S);
12425 void CodeCompleteObjCAtExpression(Scope *S);
12426 void CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS);
12427 void CodeCompleteObjCPropertyGetter(Scope *S);
12428 void CodeCompleteObjCPropertySetter(Scope *S);
12429 void CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS,
12430 bool IsParameter);
12431 void CodeCompleteObjCMessageReceiver(Scope *S);
12432 void CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc,
12433 ArrayRef<IdentifierInfo *> SelIdents,
12434 bool AtArgumentExpression);
12435 void CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver,
12436 ArrayRef<IdentifierInfo *> SelIdents,
12437 bool AtArgumentExpression,
12438 bool IsSuper = false);
12439 void CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver,
12440 ArrayRef<IdentifierInfo *> SelIdents,
12441 bool AtArgumentExpression,
12442 ObjCInterfaceDecl *Super = nullptr);
12443 void CodeCompleteObjCForCollection(Scope *S,
12444 DeclGroupPtrTy IterationVar);
12445 void CodeCompleteObjCSelector(Scope *S,
12446 ArrayRef<IdentifierInfo *> SelIdents);
12447 void CodeCompleteObjCProtocolReferences(
12448 ArrayRef<IdentifierLocPair> Protocols);
12449 void CodeCompleteObjCProtocolDecl(Scope *S);
12450 void CodeCompleteObjCInterfaceDecl(Scope *S);
12451 void CodeCompleteObjCSuperclass(Scope *S,
12452 IdentifierInfo *ClassName,
12453 SourceLocation ClassNameLoc);
12454 void CodeCompleteObjCImplementationDecl(Scope *S);
12455 void CodeCompleteObjCInterfaceCategory(Scope *S,
12456 IdentifierInfo *ClassName,
12457 SourceLocation ClassNameLoc);
12458 void CodeCompleteObjCImplementationCategory(Scope *S,
12459 IdentifierInfo *ClassName,
12460 SourceLocation ClassNameLoc);
12461 void CodeCompleteObjCPropertyDefinition(Scope *S);
12462 void CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
12463 IdentifierInfo *PropertyName);
12464 void CodeCompleteObjCMethodDecl(Scope *S, Optional<bool> IsInstanceMethod,
12465 ParsedType ReturnType);
12466 void CodeCompleteObjCMethodDeclSelector(Scope *S,
12467 bool IsInstanceMethod,
12468 bool AtParameterName,
12469 ParsedType ReturnType,
12470 ArrayRef<IdentifierInfo *> SelIdents);
12471 void CodeCompleteObjCClassPropertyRefExpr(Scope *S, IdentifierInfo &ClassName,
12472 SourceLocation ClassNameLoc,
12473 bool IsBaseExprStatement);
12474 void CodeCompletePreprocessorDirective(bool InConditional);
12475 void CodeCompleteInPreprocessorConditionalExclusion(Scope *S);
12476 void CodeCompletePreprocessorMacroName(bool IsDefinition);
12477 void CodeCompletePreprocessorExpression();
12478 void CodeCompletePreprocessorMacroArgument(Scope *S,
12479 IdentifierInfo *Macro,
12480 MacroInfo *MacroInfo,
12481 unsigned Argument);
12482 void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled);
12483 void CodeCompleteNaturalLanguage();
12484 void CodeCompleteAvailabilityPlatformName();
12485 void GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator,
12486 CodeCompletionTUInfo &CCTUInfo,
12487 SmallVectorImpl<CodeCompletionResult> &Results);
12488 //@}
12489
12490 //===--------------------------------------------------------------------===//
12491 // Extra semantic analysis beyond the C type system
12492
12493public:
12494 SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL,
12495 unsigned ByteNo) const;
12496
12497private:
12498 void CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr,
12499 const ArraySubscriptExpr *ASE=nullptr,
12500 bool AllowOnePastEnd=true, bool IndexNegated=false);
12501 void CheckArrayAccess(const Expr *E);
12502 // Used to grab the relevant information from a FormatAttr and a
12503 // FunctionDeclaration.
12504 struct FormatStringInfo {
12505 unsigned FormatIdx;
12506 unsigned FirstDataArg;
12507 bool HasVAListArg;
12508 };
12509
12510 static bool getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember,
12511 FormatStringInfo *FSI);
12512 bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
12513 const FunctionProtoType *Proto);
12514 bool CheckObjCMethodCall(ObjCMethodDecl *Method, SourceLocation loc,
12515 ArrayRef<const Expr *> Args);
12516 bool CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,
12517 const FunctionProtoType *Proto);
12518 bool CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto);
12519 void CheckConstructorCall(FunctionDecl *FDecl, QualType ThisType,
12520 ArrayRef<const Expr *> Args,
12521 const FunctionProtoType *Proto, SourceLocation Loc);
12522
12523 void CheckArgAlignment(SourceLocation Loc, NamedDecl *FDecl,
12524 StringRef ParamName, QualType ArgTy, QualType ParamTy);
12525
12526 void checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto,
12527 const Expr *ThisArg, ArrayRef<const Expr *> Args,
12528 bool IsMemberFunction, SourceLocation Loc, SourceRange Range,
12529 VariadicCallType CallType);
12530
12531 bool CheckObjCString(Expr *Arg);
12532 ExprResult CheckOSLogFormatStringArg(Expr *Arg);
12533
12534 ExprResult CheckBuiltinFunctionCall(FunctionDecl *FDecl,
12535 unsigned BuiltinID, CallExpr *TheCall);
12536
12537 bool CheckTSBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12538 CallExpr *TheCall);
12539
12540 void checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD, CallExpr *TheCall);
12541
12542 bool CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,
12543 unsigned MaxWidth);
12544 bool CheckNeonBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12545 CallExpr *TheCall);
12546 bool CheckMVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12547 bool CheckSVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12548 bool CheckCDEBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12549 CallExpr *TheCall);
12550 bool CheckARMCoprocessorImmediate(const TargetInfo &TI, const Expr *CoprocArg,
12551 bool WantCDE);
12552 bool CheckARMBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12553 CallExpr *TheCall);
12554
12555 bool CheckAArch64BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12556 CallExpr *TheCall);
12557 bool CheckBPFBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12558 bool CheckHexagonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12559 bool CheckHexagonBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall);
12560 bool CheckMipsBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12561 CallExpr *TheCall);
12562 bool CheckMipsBuiltinCpu(const TargetInfo &TI, unsigned BuiltinID,
12563 CallExpr *TheCall);
12564 bool CheckMipsBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall);
12565 bool CheckSystemZBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12566 bool CheckX86BuiltinRoundingOrSAE(unsigned BuiltinID, CallExpr *TheCall);
12567 bool CheckX86BuiltinGatherScatterScale(unsigned BuiltinID, CallExpr *TheCall);
12568 bool CheckX86BuiltinTileArguments(unsigned BuiltinID, CallExpr *TheCall);
12569 bool CheckX86BuiltinTileArgumentsRange(CallExpr *TheCall,
12570 ArrayRef<int> ArgNums);
12571 bool CheckX86BuiltinTileDuplicate(CallExpr *TheCall, ArrayRef<int> ArgNums);
12572 bool CheckX86BuiltinTileRangeAndDuplicate(CallExpr *TheCall,
12573 ArrayRef<int> ArgNums);
12574 bool CheckX86BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12575 CallExpr *TheCall);
12576 bool CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12577 CallExpr *TheCall);
12578 bool CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
12579 bool CheckRISCVLMUL(CallExpr *TheCall, unsigned ArgNum);
12580 bool CheckRISCVBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
12581 CallExpr *TheCall);
12582
12583 bool SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall);
12584 bool SemaBuiltinVAStartARMMicrosoft(CallExpr *Call);
12585 bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
12586 bool SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs);
12587 bool SemaBuiltinComplex(CallExpr *TheCall);
12588 bool SemaBuiltinVSX(CallExpr *TheCall);
12589 bool SemaBuiltinOSLogFormat(CallExpr *TheCall);
12590 bool SemaValueIsRunOfOnes(CallExpr *TheCall, unsigned ArgNum);
12591
12592public:
12593 // Used by C++ template instantiation.
12594 ExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
12595 ExprResult SemaConvertVectorExpr(Expr *E, TypeSourceInfo *TInfo,
12596 SourceLocation BuiltinLoc,
12597 SourceLocation RParenLoc);
12598
12599private:
12600 bool SemaBuiltinPrefetch(CallExpr *TheCall);
12601 bool SemaBuiltinAllocaWithAlign(CallExpr *TheCall);
12602 bool SemaBuiltinArithmeticFence(CallExpr *TheCall);
12603 bool SemaBuiltinAssume(CallExpr *TheCall);
12604 bool SemaBuiltinAssumeAligned(CallExpr *TheCall);
12605 bool SemaBuiltinLongjmp(CallExpr *TheCall);
12606 bool SemaBuiltinSetjmp(CallExpr *TheCall);
12607 ExprResult SemaBuiltinAtomicOverloaded(ExprResult TheCallResult);
12608 ExprResult SemaBuiltinNontemporalOverloaded(ExprResult TheCallResult);
12609 ExprResult SemaAtomicOpsOverloaded(ExprResult TheCallResult,
12610 AtomicExpr::AtomicOp Op);
12611 ExprResult SemaBuiltinOperatorNewDeleteOverloaded(ExprResult TheCallResult,
12612 bool IsDelete);
12613 bool SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,
12614 llvm::APSInt &Result);
12615 bool SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, int Low,
12616 int High, bool RangeIsError = true);
12617 bool SemaBuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum,
12618 unsigned Multiple);
12619 bool SemaBuiltinConstantArgPower2(CallExpr *TheCall, int ArgNum);
12620 bool SemaBuiltinConstantArgShiftedByte(CallExpr *TheCall, int ArgNum,
12621 unsigned ArgBits);
12622 bool SemaBuiltinConstantArgShiftedByteOrXXFF(CallExpr *TheCall, int ArgNum,
12623 unsigned ArgBits);
12624 bool SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,
12625 int ArgNum, unsigned ExpectedFieldNum,
12626 bool AllowName);
12627 bool SemaBuiltinARMMemoryTaggingCall(unsigned BuiltinID, CallExpr *TheCall);
12628 bool SemaBuiltinPPCMMACall(CallExpr *TheCall, const char *TypeDesc);
12629
12630 bool CheckPPCMMAType(QualType Type, SourceLocation TypeLoc);
12631
12632 // Matrix builtin handling.
12633 ExprResult SemaBuiltinMatrixTranspose(CallExpr *TheCall,
12634 ExprResult CallResult);
12635 ExprResult SemaBuiltinMatrixColumnMajorLoad(CallExpr *TheCall,
12636 ExprResult CallResult);
12637 ExprResult SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall,
12638 ExprResult CallResult);
12639
12640public:
12641 enum FormatStringType {
12642 FST_Scanf,
12643 FST_Printf,
12644 FST_NSString,
12645 FST_Strftime,
12646 FST_Strfmon,
12647 FST_Kprintf,
12648 FST_FreeBSDKPrintf,
12649 FST_OSTrace,
12650 FST_OSLog,
12651 FST_Syslog,
12652 FST_Unknown
12653 };
12654 static FormatStringType GetFormatStringType(const FormatAttr *Format);
12655
12656 bool FormatStringHasSArg(const StringLiteral *FExpr);
12657
12658 static bool GetFormatNSStringIdx(const FormatAttr *Format, unsigned &Idx);
12659
12660private:
12661 bool CheckFormatArguments(const FormatAttr *Format,
12662 ArrayRef<const Expr *> Args,
12663 bool IsCXXMember,
12664 VariadicCallType CallType,
12665 SourceLocation Loc, SourceRange Range,
12666 llvm::SmallBitVector &CheckedVarArgs);
12667 bool CheckFormatArguments(ArrayRef<const Expr *> Args,
12668 bool HasVAListArg, unsigned format_idx,
12669 unsigned firstDataArg, FormatStringType Type,
12670 VariadicCallType CallType,
12671 SourceLocation Loc, SourceRange range,
12672 llvm::SmallBitVector &CheckedVarArgs);
12673
12674 void CheckAbsoluteValueFunction(const CallExpr *Call,
12675 const FunctionDecl *FDecl);
12676
12677 void CheckMaxUnsignedZero(const CallExpr *Call, const FunctionDecl *FDecl);
12678
12679 void CheckMemaccessArguments(const CallExpr *Call,
12680 unsigned BId,
12681 IdentifierInfo *FnName);
12682
12683 void CheckStrlcpycatArguments(const CallExpr *Call,
12684 IdentifierInfo *FnName);
12685
12686 void CheckStrncatArguments(const CallExpr *Call,
12687 IdentifierInfo *FnName);
12688
12689 void CheckFreeArguments(const CallExpr *E);
12690
12691 void CheckReturnValExpr(Expr *RetValExp, QualType lhsType,
12692 SourceLocation ReturnLoc,
12693 bool isObjCMethod = false,
12694 const AttrVec *Attrs = nullptr,
12695 const FunctionDecl *FD = nullptr);
12696
12697public:
12698 void CheckFloatComparison(SourceLocation Loc, Expr *LHS, Expr *RHS);
12699
12700private:
12701 void CheckImplicitConversions(Expr *E, SourceLocation CC = SourceLocation());
12702 void CheckBoolLikeConversion(Expr *E, SourceLocation CC);
12703 void CheckForIntOverflow(Expr *E);
12704 void CheckUnsequencedOperations(const Expr *E);
12705
12706 /// Perform semantic checks on a completed expression. This will either
12707 /// be a full-expression or a default argument expression.
12708 void CheckCompletedExpr(Expr *E, SourceLocation CheckLoc = SourceLocation(),
12709 bool IsConstexpr = false);
12710
12711 void CheckBitFieldInitialization(SourceLocation InitLoc, FieldDecl *Field,
12712 Expr *Init);
12713
12714 /// Check if there is a field shadowing.
12715 void CheckShadowInheritedFields(const SourceLocation &Loc,
12716 DeclarationName FieldName,
12717 const CXXRecordDecl *RD,
12718 bool DeclIsField = true);
12719
12720 /// Check if the given expression contains 'break' or 'continue'
12721 /// statement that produces control flow different from GCC.
12722 void CheckBreakContinueBinding(Expr *E);
12723
12724 /// Check whether receiver is mutable ObjC container which
12725 /// attempts to add itself into the container
12726 void CheckObjCCircularContainer(ObjCMessageExpr *Message);
12727
12728 void CheckTCBEnforcement(const CallExpr *TheCall, const FunctionDecl *Callee);
12729
12730 void AnalyzeDeleteExprMismatch(const CXXDeleteExpr *DE);
12731 void AnalyzeDeleteExprMismatch(FieldDecl *Field, SourceLocation DeleteLoc,
12732 bool DeleteWasArrayForm);
12733public:
12734 /// Register a magic integral constant to be used as a type tag.
12735 void RegisterTypeTagForDatatype(const IdentifierInfo *ArgumentKind,
12736 uint64_t MagicValue, QualType Type,
12737 bool LayoutCompatible, bool MustBeNull);
12738
12739 struct TypeTagData {
12740 TypeTagData() {}
12741
12742 TypeTagData(QualType Type, bool LayoutCompatible, bool MustBeNull) :
12743 Type(Type), LayoutCompatible(LayoutCompatible),
12744 MustBeNull(MustBeNull)
12745 {}
12746
12747 QualType Type;
12748
12749 /// If true, \c Type should be compared with other expression's types for
12750 /// layout-compatibility.
12751 unsigned LayoutCompatible : 1;
12752 unsigned MustBeNull : 1;
12753 };
12754
12755 /// A pair of ArgumentKind identifier and magic value. This uniquely
12756 /// identifies the magic value.
12757 typedef std::pair<const IdentifierInfo *, uint64_t> TypeTagMagicValue;
12758
12759private:
12760 /// A map from magic value to type information.
12761 std::unique_ptr<llvm::DenseMap<TypeTagMagicValue, TypeTagData>>
12762 TypeTagForDatatypeMagicValues;
12763
12764 /// Peform checks on a call of a function with argument_with_type_tag
12765 /// or pointer_with_type_tag attributes.
12766 void CheckArgumentWithTypeTag(const ArgumentWithTypeTagAttr *Attr,
12767 const ArrayRef<const Expr *> ExprArgs,
12768 SourceLocation CallSiteLoc);
12769
12770 /// Check if we are taking the address of a packed field
12771 /// as this may be a problem if the pointer value is dereferenced.
12772 void CheckAddressOfPackedMember(Expr *rhs);
12773
12774 /// The parser's current scope.
12775 ///
12776 /// The parser maintains this state here.
12777 Scope *CurScope;
12778
12779 mutable IdentifierInfo *Ident_super;
12780 mutable IdentifierInfo *Ident___float128;
12781
12782 /// Nullability type specifiers.
12783 IdentifierInfo *Ident__Nonnull = nullptr;
12784 IdentifierInfo *Ident__Nullable = nullptr;
12785 IdentifierInfo *Ident__Nullable_result = nullptr;
12786 IdentifierInfo *Ident__Null_unspecified = nullptr;
12787
12788 IdentifierInfo *Ident_NSError = nullptr;
12789
12790 /// The handler for the FileChanged preprocessor events.
12791 ///
12792 /// Used for diagnostics that implement custom semantic analysis for #include
12793 /// directives, like -Wpragma-pack.
12794 sema::SemaPPCallbacks *SemaPPCallbackHandler;
12795
12796protected:
12797 friend class Parser;
12798 friend class InitializationSequence;
12799 friend class ASTReader;
12800 friend class ASTDeclReader;
12801 friend class ASTWriter;
12802
12803public:
12804 /// Retrieve the keyword associated
12805 IdentifierInfo *getNullabilityKeyword(NullabilityKind nullability);
12806
12807 /// The struct behind the CFErrorRef pointer.
12808 RecordDecl *CFError = nullptr;
12809 bool isCFError(RecordDecl *D);
12810
12811 /// Retrieve the identifier "NSError".
12812 IdentifierInfo *getNSErrorIdent();
12813
12814 /// Retrieve the parser's current scope.
12815 ///
12816 /// This routine must only be used when it is certain that semantic analysis
12817 /// and the parser are in precisely the same context, which is not the case
12818 /// when, e.g., we are performing any kind of template instantiation.
12819 /// Therefore, the only safe places to use this scope are in the parser
12820 /// itself and in routines directly invoked from the parser and *never* from
12821 /// template substitution or instantiation.
12822 Scope *getCurScope() const { return CurScope; }
12823
12824 void incrementMSManglingNumber() const {
12825 return CurScope->incrementMSManglingNumber();
12826 }
12827
12828 IdentifierInfo *getSuperIdentifier() const;
12829 IdentifierInfo *getFloat128Identifier() const;
12830
12831 Decl *getObjCDeclContext() const;
12832
12833 DeclContext *getCurLexicalContext() const {
12834 return OriginalLexicalContext ? OriginalLexicalContext : CurContext;
12835 }
12836
12837 const DeclContext *getCurObjCLexicalContext() const {
12838 const DeclContext *DC = getCurLexicalContext();
12839 // A category implicitly has the attribute of the interface.
12840 if (const ObjCCategoryDecl *CatD = dyn_cast<ObjCCategoryDecl>(DC))
12841 DC = CatD->getClassInterface();
12842 return DC;
12843 }
12844
12845 /// Determine the number of levels of enclosing template parameters. This is
12846 /// only usable while parsing. Note that this does not include dependent
12847 /// contexts in which no template parameters have yet been declared, such as
12848 /// in a terse function template or generic lambda before the first 'auto' is
12849 /// encountered.
12850 unsigned getTemplateDepth(Scope *S) const;
12851
12852 /// To be used for checking whether the arguments being passed to
12853 /// function exceeds the number of parameters expected for it.
12854 static bool TooManyArguments(size_t NumParams, size_t NumArgs,
12855 bool PartialOverloading = false) {
12856 // We check whether we're just after a comma in code-completion.
12857 if (NumArgs > 0 && PartialOverloading)
12858 return NumArgs + 1 > NumParams; // If so, we view as an extra argument.
12859 return NumArgs > NumParams;
12860 }
12861
12862 // Emitting members of dllexported classes is delayed until the class
12863 // (including field initializers) is fully parsed.
12864 SmallVector<CXXRecordDecl*, 4> DelayedDllExportClasses;
12865 SmallVector<CXXMethodDecl*, 4> DelayedDllExportMemberFunctions;
12866
12867private:
12868 int ParsingClassDepth = 0;
12869
12870 class SavePendingParsedClassStateRAII {
12871 public:
12872 SavePendingParsedClassStateRAII(Sema &S) : S(S) { swapSavedState(); }
12873
12874 ~SavePendingParsedClassStateRAII() {
12875 assert(S.DelayedOverridingExceptionSpecChecks.empty() &&((void)0)
12876 "there shouldn't be any pending delayed exception spec checks")((void)0);
12877 assert(S.DelayedEquivalentExceptionSpecChecks.empty() &&((void)0)
12878 "there shouldn't be any pending delayed exception spec checks")((void)0);
12879 swapSavedState();
12880 }
12881
12882 private:
12883 Sema &S;
12884 decltype(DelayedOverridingExceptionSpecChecks)
12885 SavedOverridingExceptionSpecChecks;
12886 decltype(DelayedEquivalentExceptionSpecChecks)
12887 SavedEquivalentExceptionSpecChecks;
12888
12889 void swapSavedState() {
12890 SavedOverridingExceptionSpecChecks.swap(
12891 S.DelayedOverridingExceptionSpecChecks);
12892 SavedEquivalentExceptionSpecChecks.swap(
12893 S.DelayedEquivalentExceptionSpecChecks);
12894 }
12895 };
12896
12897 /// Helper class that collects misaligned member designations and
12898 /// their location info for delayed diagnostics.
12899 struct MisalignedMember {
12900 Expr *E;
12901 RecordDecl *RD;
12902 ValueDecl *MD;
12903 CharUnits Alignment;
12904
12905 MisalignedMember() : E(), RD(), MD(), Alignment() {}
12906 MisalignedMember(Expr *E, RecordDecl *RD, ValueDecl *MD,
12907 CharUnits Alignment)
12908 : E(E), RD(RD), MD(MD), Alignment(Alignment) {}
12909 explicit MisalignedMember(Expr *E)
12910 : MisalignedMember(E, nullptr, nullptr, CharUnits()) {}
12911
12912 bool operator==(const MisalignedMember &m) { return this->E == m.E; }
12913 };
12914 /// Small set of gathered accesses to potentially misaligned members
12915 /// due to the packed attribute.
12916 SmallVector<MisalignedMember, 4> MisalignedMembers;
12917
12918 /// Adds an expression to the set of gathered misaligned members.
12919 void AddPotentialMisalignedMembers(Expr *E, RecordDecl *RD, ValueDecl *MD,
12920 CharUnits Alignment);
12921
12922public:
12923 /// Diagnoses the current set of gathered accesses. This typically
12924 /// happens at full expression level. The set is cleared after emitting the
12925 /// diagnostics.
12926 void DiagnoseMisalignedMembers();
12927
12928 /// This function checks if the expression is in the sef of potentially
12929 /// misaligned members and it is converted to some pointer type T with lower
12930 /// or equal alignment requirements. If so it removes it. This is used when
12931 /// we do not want to diagnose such misaligned access (e.g. in conversions to
12932 /// void*).
12933 void DiscardMisalignedMemberAddress(const Type *T, Expr *E);
12934
12935 /// This function calls Action when it determines that E designates a
12936 /// misaligned member due to the packed attribute. This is used to emit
12937 /// local diagnostics like in reference binding.
12938 void RefersToMemberWithReducedAlignment(
12939 Expr *E,
12940 llvm::function_ref<void(Expr *, RecordDecl *, FieldDecl *, CharUnits)>
12941 Action);
12942
12943 /// Describes the reason a calling convention specification was ignored, used
12944 /// for diagnostics.
12945 enum class CallingConventionIgnoredReason {
12946 ForThisTarget = 0,
12947 VariadicFunction,
12948 ConstructorDestructor,
12949 BuiltinFunction
12950 };
12951 /// Creates a SemaDiagnosticBuilder that emits the diagnostic if the current
12952 /// context is "used as device code".
12953 ///
12954 /// - If CurLexicalContext is a kernel function or it is known that the
12955 /// function will be emitted for the device, emits the diagnostics
12956 /// immediately.
12957 /// - If CurLexicalContext is a function and we are compiling
12958 /// for the device, but we don't know that this function will be codegen'ed
12959 /// for devive yet, creates a diagnostic which is emitted if and when we
12960 /// realize that the function will be codegen'ed.
12961 ///
12962 /// Example usage:
12963 ///
12964 /// Diagnose __float128 type usage only from SYCL device code if the current
12965 /// target doesn't support it
12966 /// if (!S.Context.getTargetInfo().hasFloat128Type() &&
12967 /// S.getLangOpts().SYCLIsDevice)
12968 /// SYCLDiagIfDeviceCode(Loc, diag::err_type_unsupported) << "__float128";
12969 SemaDiagnosticBuilder SYCLDiagIfDeviceCode(SourceLocation Loc,
12970 unsigned DiagID);
12971
12972 /// Check whether we're allowed to call Callee from the current context.
12973 ///
12974 /// - If the call is never allowed in a semantically-correct program
12975 /// emits an error and returns false.
12976 ///
12977 /// - If the call is allowed in semantically-correct programs, but only if
12978 /// it's never codegen'ed, creates a deferred diagnostic to be emitted if
12979 /// and when the caller is codegen'ed, and returns true.
12980 ///
12981 /// - Otherwise, returns true without emitting any diagnostics.
12982 ///
12983 /// Adds Callee to DeviceCallGraph if we don't know if its caller will be
12984 /// codegen'ed yet.
12985 bool checkSYCLDeviceFunction(SourceLocation Loc, FunctionDecl *Callee);
12986};
12987
12988/// RAII object that enters a new expression evaluation context.
12989class EnterExpressionEvaluationContext {
12990 Sema &Actions;
12991 bool Entered = true;
12992
12993public:
12994 EnterExpressionEvaluationContext(
12995 Sema &Actions, Sema::ExpressionEvaluationContext NewContext,
12996 Decl *LambdaContextDecl = nullptr,
12997 Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext =
12998 Sema::ExpressionEvaluationContextRecord::EK_Other,
12999 bool ShouldEnter = true)
13000 : Actions(Actions), Entered(ShouldEnter) {
13001 if (Entered)
13002 Actions.PushExpressionEvaluationContext(NewContext, LambdaContextDecl,
13003 ExprContext);
13004 }
13005 EnterExpressionEvaluationContext(
13006 Sema &Actions, Sema::ExpressionEvaluationContext NewContext,
13007 Sema::ReuseLambdaContextDecl_t,
13008 Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext =
13009 Sema::ExpressionEvaluationContextRecord::EK_Other)
13010 : Actions(Actions) {
13011 Actions.PushExpressionEvaluationContext(
13012 NewContext, Sema::ReuseLambdaContextDecl, ExprContext);
13013 }
13014
13015 enum InitListTag { InitList };
13016 EnterExpressionEvaluationContext(Sema &Actions, InitListTag,
13017 bool ShouldEnter = true)
13018 : Actions(Actions), Entered(false) {
13019 // In C++11 onwards, narrowing checks are performed on the contents of
13020 // braced-init-lists, even when they occur within unevaluated operands.
13021 // Therefore we still need to instantiate constexpr functions used in such
13022 // a context.
13023 if (ShouldEnter && Actions.isUnevaluatedContext() &&
13024 Actions.getLangOpts().CPlusPlus11) {
13025 Actions.PushExpressionEvaluationContext(
13026 Sema::ExpressionEvaluationContext::UnevaluatedList);
13027 Entered = true;
13028 }
13029 }
13030
13031 ~EnterExpressionEvaluationContext() {
13032 if (Entered)
13033 Actions.PopExpressionEvaluationContext();
13034 }
13035};
13036
13037DeductionFailureInfo
13038MakeDeductionFailureInfo(ASTContext &Context, Sema::TemplateDeductionResult TDK,
13039 sema::TemplateDeductionInfo &Info);
13040
13041/// Contains a late templated function.
13042/// Will be parsed at the end of the translation unit, used by Sema & Parser.
13043struct LateParsedTemplate {
13044 CachedTokens Toks;
13045 /// The template function declaration to be late parsed.
13046 Decl *D;
13047};
13048
13049template <>
13050void Sema::PragmaStack<Sema::AlignPackInfo>::Act(SourceLocation PragmaLocation,
13051 PragmaMsStackAction Action,
13052 llvm::StringRef StackSlotLabel,
13053 AlignPackInfo Value);
13054
13055} // end namespace clang
13056
13057namespace llvm {
13058// Hash a FunctionDeclAndLoc by looking at both its FunctionDecl and its
13059// SourceLocation.
13060template <> struct DenseMapInfo<clang::Sema::FunctionDeclAndLoc> {
13061 using FunctionDeclAndLoc = clang::Sema::FunctionDeclAndLoc;
13062 using FDBaseInfo = DenseMapInfo<clang::CanonicalDeclPtr<clang::FunctionDecl>>;
13063
13064 static FunctionDeclAndLoc getEmptyKey() {
13065 return {FDBaseInfo::getEmptyKey(), clang::SourceLocation()};
13066 }
13067
13068 static FunctionDeclAndLoc getTombstoneKey() {
13069 return {FDBaseInfo::getTombstoneKey(), clang::SourceLocation()};
13070 }
13071
13072 static unsigned getHashValue(const FunctionDeclAndLoc &FDL) {
13073 return hash_combine(FDBaseInfo::getHashValue(FDL.FD),
13074 FDL.Loc.getHashValue());
13075 }
13076
13077 static bool isEqual(const FunctionDeclAndLoc &LHS,
13078 const FunctionDeclAndLoc &RHS) {
13079 return LHS.FD == RHS.FD && LHS.Loc == RHS.Loc;
13080 }
13081};
13082} // namespace llvm
13083
13084#endif