clang 20.0.0git
SemaStmt.cpp
Go to the documentation of this file.
1//===--- SemaStmt.cpp - Semantic Analysis for Statements ------------------===//
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 implements semantic analysis for statements.
10//
11//===----------------------------------------------------------------------===//
12
13#include "CheckExprLifetime.h"
15#include "clang/AST/ASTLambda.h"
17#include "clang/AST/CharUnits.h"
18#include "clang/AST/DeclObjC.h"
21#include "clang/AST/ExprCXX.h"
22#include "clang/AST/ExprObjC.h"
24#include "clang/AST/StmtCXX.h"
25#include "clang/AST/StmtObjC.h"
26#include "clang/AST/TypeLoc.h"
32#include "clang/Sema/Lookup.h"
34#include "clang/Sema/Scope.h"
36#include "clang/Sema/SemaCUDA.h"
37#include "clang/Sema/SemaObjC.h"
39#include "llvm/ADT/ArrayRef.h"
40#include "llvm/ADT/DenseMap.h"
41#include "llvm/ADT/STLExtras.h"
42#include "llvm/ADT/STLForwardCompat.h"
43#include "llvm/ADT/SmallVector.h"
44#include "llvm/ADT/StringExtras.h"
45
46using namespace clang;
47using namespace sema;
48
49StmtResult Sema::ActOnExprStmt(ExprResult FE, bool DiscardedValue) {
50 if (FE.isInvalid())
51 return StmtError();
52
53 FE = ActOnFinishFullExpr(FE.get(), FE.get()->getExprLoc(), DiscardedValue);
54 if (FE.isInvalid())
55 return StmtError();
56
57 // C99 6.8.3p2: The expression in an expression statement is evaluated as a
58 // void expression for its side effects. Conversion to void allows any
59 // operand, even incomplete types.
60
61 // Same thing in for stmt first clause (when expr) and third clause.
62 return StmtResult(FE.getAs<Stmt>());
63}
64
65
68 return StmtError();
69}
70
72 bool HasLeadingEmptyMacro) {
73 return new (Context) NullStmt(SemiLoc, HasLeadingEmptyMacro);
74}
75
77 SourceLocation EndLoc) {
78 DeclGroupRef DG = dg.get();
79
80 // If we have an invalid decl, just return an error.
81 if (DG.isNull()) return StmtError();
82
83 return new (Context) DeclStmt(DG, StartLoc, EndLoc);
84}
85
87 DeclGroupRef DG = dg.get();
88
89 // If we don't have a declaration, or we have an invalid declaration,
90 // just return.
91 if (DG.isNull() || !DG.isSingleDecl())
92 return;
93
94 Decl *decl = DG.getSingleDecl();
95 if (!decl || decl->isInvalidDecl())
96 return;
97
98 // Only variable declarations are permitted.
99 VarDecl *var = dyn_cast<VarDecl>(decl);
100 if (!var) {
101 Diag(decl->getLocation(), diag::err_non_variable_decl_in_for);
102 decl->setInvalidDecl();
103 return;
104 }
105
106 // foreach variables are never actually initialized in the way that
107 // the parser came up with.
108 var->setInit(nullptr);
109
110 // In ARC, we don't need to retain the iteration variable of a fast
111 // enumeration loop. Rather than actually trying to catch that
112 // during declaration processing, we remove the consequences here.
113 if (getLangOpts().ObjCAutoRefCount) {
114 QualType type = var->getType();
115
116 // Only do this if we inferred the lifetime. Inferred lifetime
117 // will show up as a local qualifier because explicit lifetime
118 // should have shown up as an AttributedType instead.
119 if (type.getLocalQualifiers().getObjCLifetime() == Qualifiers::OCL_Strong) {
120 // Add 'const' and mark the variable as pseudo-strong.
121 var->setType(type.withConst());
122 var->setARCPseudoStrong(true);
123 }
124 }
125}
126
127/// Diagnose unused comparisons, both builtin and overloaded operators.
128/// For '==' and '!=', suggest fixits for '=' or '|='.
129///
130/// Adding a cast to void (or other expression wrappers) will prevent the
131/// warning from firing.
132static bool DiagnoseUnusedComparison(Sema &S, const Expr *E) {
134 bool CanAssign;
135 enum { Equality, Inequality, Relational, ThreeWay } Kind;
136
137 if (const BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) {
138 if (!Op->isComparisonOp())
139 return false;
140
141 if (Op->getOpcode() == BO_EQ)
142 Kind = Equality;
143 else if (Op->getOpcode() == BO_NE)
144 Kind = Inequality;
145 else if (Op->getOpcode() == BO_Cmp)
146 Kind = ThreeWay;
147 else {
148 assert(Op->isRelationalOp());
149 Kind = Relational;
150 }
151 Loc = Op->getOperatorLoc();
152 CanAssign = Op->getLHS()->IgnoreParenImpCasts()->isLValue();
153 } else if (const CXXOperatorCallExpr *Op = dyn_cast<CXXOperatorCallExpr>(E)) {
154 switch (Op->getOperator()) {
155 case OO_EqualEqual:
156 Kind = Equality;
157 break;
158 case OO_ExclaimEqual:
159 Kind = Inequality;
160 break;
161 case OO_Less:
162 case OO_Greater:
163 case OO_GreaterEqual:
164 case OO_LessEqual:
165 Kind = Relational;
166 break;
167 case OO_Spaceship:
168 Kind = ThreeWay;
169 break;
170 default:
171 return false;
172 }
173
174 Loc = Op->getOperatorLoc();
175 CanAssign = Op->getArg(0)->IgnoreParenImpCasts()->isLValue();
176 } else {
177 // Not a typo-prone comparison.
178 return false;
179 }
180
181 // Suppress warnings when the operator, suspicious as it may be, comes from
182 // a macro expansion.
184 return false;
185
186 S.Diag(Loc, diag::warn_unused_comparison)
187 << (unsigned)Kind << E->getSourceRange();
188
189 // If the LHS is a plausible entity to assign to, provide a fixit hint to
190 // correct common typos.
191 if (CanAssign) {
192 if (Kind == Inequality)
193 S.Diag(Loc, diag::note_inequality_comparison_to_or_assign)
195 else if (Kind == Equality)
196 S.Diag(Loc, diag::note_equality_comparison_to_assign)
198 }
199
200 return true;
201}
202
203static bool DiagnoseNoDiscard(Sema &S, const NamedDecl *OffendingDecl,
204 const WarnUnusedResultAttr *A, SourceLocation Loc,
205 SourceRange R1, SourceRange R2, bool IsCtor) {
206 if (!A)
207 return false;
208 StringRef Msg = A->getMessage();
209
210 if (Msg.empty()) {
211 if (OffendingDecl)
212 return S.Diag(Loc, diag::warn_unused_return_type)
213 << IsCtor << A << OffendingDecl << false << R1 << R2;
214 if (IsCtor)
215 return S.Diag(Loc, diag::warn_unused_constructor)
216 << A << false << R1 << R2;
217 return S.Diag(Loc, diag::warn_unused_result) << A << false << R1 << R2;
218 }
219
220 if (OffendingDecl)
221 return S.Diag(Loc, diag::warn_unused_return_type)
222 << IsCtor << A << OffendingDecl << true << Msg << R1 << R2;
223 if (IsCtor)
224 return S.Diag(Loc, diag::warn_unused_constructor)
225 << A << true << Msg << R1 << R2;
226 return S.Diag(Loc, diag::warn_unused_result) << A << true << Msg << R1 << R2;
227}
228
229namespace {
230
231// Diagnoses unused expressions that call functions marked [[nodiscard]],
232// [[gnu::warn_unused_result]] and similar.
233// Additionally, a DiagID can be provided to emit a warning in additional
234// contexts (such as for an unused LHS of a comma expression)
235void DiagnoseUnused(Sema &S, const Expr *E, std::optional<unsigned> DiagID) {
236 bool NoDiscardOnly = !DiagID.has_value();
237
238 // If we are in an unevaluated expression context, then there can be no unused
239 // results because the results aren't expected to be used in the first place.
240 if (S.isUnevaluatedContext())
241 return;
242
244 // In most cases, we don't want to warn if the expression is written in a
245 // macro body, or if the macro comes from a system header. If the offending
246 // expression is a call to a function with the warn_unused_result attribute,
247 // we warn no matter the location. Because of the order in which the various
248 // checks need to happen, we factor out the macro-related test here.
249 bool ShouldSuppress = S.SourceMgr.isMacroBodyExpansion(ExprLoc) ||
250 S.SourceMgr.isInSystemMacro(ExprLoc);
251
252 const Expr *WarnExpr;
254 SourceRange R1, R2;
255 if (!E->isUnusedResultAWarning(WarnExpr, Loc, R1, R2, S.Context))
256 return;
257
258 if (!NoDiscardOnly) {
259 // If this is a GNU statement expression expanded from a macro, it is
260 // probably unused because it is a function-like macro that can be used as
261 // either an expression or statement. Don't warn, because it is almost
262 // certainly a false positive.
263 if (isa<StmtExpr>(E) && Loc.isMacroID())
264 return;
265
266 // Check if this is the UNREFERENCED_PARAMETER from the Microsoft headers.
267 // That macro is frequently used to suppress "unused parameter" warnings,
268 // but its implementation makes clang's -Wunused-value fire. Prevent this.
269 if (isa<ParenExpr>(E->IgnoreImpCasts()) && Loc.isMacroID()) {
270 SourceLocation SpellLoc = Loc;
271 if (S.findMacroSpelling(SpellLoc, "UNREFERENCED_PARAMETER"))
272 return;
273 }
274 }
275
276 // Okay, we have an unused result. Depending on what the base expression is,
277 // we might want to make a more specific diagnostic. Check for one of these
278 // cases now.
279 if (const FullExpr *Temps = dyn_cast<FullExpr>(E))
280 E = Temps->getSubExpr();
281 if (const CXXBindTemporaryExpr *TempExpr = dyn_cast<CXXBindTemporaryExpr>(E))
282 E = TempExpr->getSubExpr();
283
285 return;
286
287 E = WarnExpr;
288 if (const auto *Cast = dyn_cast<CastExpr>(E))
289 if (Cast->getCastKind() == CK_NoOp ||
290 Cast->getCastKind() == CK_ConstructorConversion ||
291 Cast->getCastKind() == CK_IntegralCast)
292 E = Cast->getSubExpr()->IgnoreImpCasts();
293
294 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
295 if (E->getType()->isVoidType())
296 return;
297
298 auto [OffendingDecl, A] = CE->getUnusedResultAttr(S.Context);
299 if (DiagnoseNoDiscard(S, OffendingDecl,
300 cast_or_null<WarnUnusedResultAttr>(A), Loc, R1, R2,
301 /*isCtor=*/false))
302 return;
303
304 // If the callee has attribute pure, const, or warn_unused_result, warn with
305 // a more specific message to make it clear what is happening. If the call
306 // is written in a macro body, only warn if it has the warn_unused_result
307 // attribute.
308 if (const Decl *FD = CE->getCalleeDecl()) {
309 if (ShouldSuppress)
310 return;
311 if (FD->hasAttr<PureAttr>()) {
312 S.Diag(Loc, diag::warn_unused_call) << R1 << R2 << "pure";
313 return;
314 }
315 if (FD->hasAttr<ConstAttr>()) {
316 S.Diag(Loc, diag::warn_unused_call) << R1 << R2 << "const";
317 return;
318 }
319 }
320 } else if (const auto *CE = dyn_cast<CXXConstructExpr>(E)) {
321 if (const CXXConstructorDecl *Ctor = CE->getConstructor()) {
322 const NamedDecl *OffendingDecl = nullptr;
323 const auto *A = Ctor->getAttr<WarnUnusedResultAttr>();
324 if (!A) {
325 OffendingDecl = Ctor->getParent();
326 A = OffendingDecl->getAttr<WarnUnusedResultAttr>();
327 }
328 if (DiagnoseNoDiscard(S, OffendingDecl, A, Loc, R1, R2,
329 /*isCtor=*/true))
330 return;
331 }
332 } else if (const auto *ILE = dyn_cast<InitListExpr>(E)) {
333 if (const TagDecl *TD = ILE->getType()->getAsTagDecl()) {
334
335 if (DiagnoseNoDiscard(S, TD, TD->getAttr<WarnUnusedResultAttr>(), Loc, R1,
336 R2, /*isCtor=*/false))
337 return;
338 }
339 } else if (ShouldSuppress)
340 return;
341
342 E = WarnExpr;
343 if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {
344 if (S.getLangOpts().ObjCAutoRefCount && ME->isDelegateInitCall()) {
345 S.Diag(Loc, diag::err_arc_unused_init_message) << R1;
346 return;
347 }
348 const ObjCMethodDecl *MD = ME->getMethodDecl();
349 if (MD) {
350 if (DiagnoseNoDiscard(S, nullptr, MD->getAttr<WarnUnusedResultAttr>(),
351 Loc, R1, R2,
352 /*isCtor=*/false))
353 return;
354 }
355 } else if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) {
356 const Expr *Source = POE->getSyntacticForm();
357 // Handle the actually selected call of an OpenMP specialized call.
358 if (S.LangOpts.OpenMP && isa<CallExpr>(Source) &&
359 POE->getNumSemanticExprs() == 1 &&
360 isa<CallExpr>(POE->getSemanticExpr(0)))
361 return DiagnoseUnused(S, POE->getSemanticExpr(0), DiagID);
362 if (isa<ObjCSubscriptRefExpr>(Source))
363 DiagID = diag::warn_unused_container_subscript_expr;
364 else if (isa<ObjCPropertyRefExpr>(Source))
365 DiagID = diag::warn_unused_property_expr;
366 } else if (const CXXFunctionalCastExpr *FC
367 = dyn_cast<CXXFunctionalCastExpr>(E)) {
368 const Expr *E = FC->getSubExpr();
369 if (const CXXBindTemporaryExpr *TE = dyn_cast<CXXBindTemporaryExpr>(E))
370 E = TE->getSubExpr();
371 if (isa<CXXTemporaryObjectExpr>(E))
372 return;
373 if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(E))
374 if (const CXXRecordDecl *RD = CE->getType()->getAsCXXRecordDecl())
375 if (!RD->getAttr<WarnUnusedAttr>())
376 return;
377 }
378
379 if (NoDiscardOnly)
380 return;
381
382 // Diagnose "(void*) blah" as a typo for "(void) blah".
383 if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(E)) {
384 TypeSourceInfo *TI = CE->getTypeInfoAsWritten();
385 QualType T = TI->getType();
386
387 // We really do want to use the non-canonical type here.
388 if (T == S.Context.VoidPtrTy) {
390
391 S.Diag(Loc, diag::warn_unused_voidptr)
393 return;
394 }
395 }
396
397 // Tell the user to assign it into a variable to force a volatile load if this
398 // isn't an array.
399 if (E->isGLValue() && E->getType().isVolatileQualified() &&
400 !E->getType()->isArrayType()) {
401 S.Diag(Loc, diag::warn_unused_volatile) << R1 << R2;
402 return;
403 }
404
405 // Do not diagnose use of a comma operator in a SFINAE context because the
406 // type of the left operand could be used for SFINAE, so technically it is
407 // *used*.
408 if (DiagID == diag::warn_unused_comma_left_operand && S.isSFINAEContext())
409 return;
410
412 S.PDiag(*DiagID) << R1 << R2);
413}
414} // namespace
415
417 DiagnoseUnused(*this, E, std::nullopt);
418}
419
420void Sema::DiagnoseUnusedExprResult(const Stmt *S, unsigned DiagID) {
421 if (const LabelStmt *Label = dyn_cast_if_present<LabelStmt>(S))
422 S = Label->getSubStmt();
423
424 const Expr *E = dyn_cast_if_present<Expr>(S);
425 if (!E)
426 return;
427
428 DiagnoseUnused(*this, E, DiagID);
429}
430
431void Sema::ActOnStartOfCompoundStmt(bool IsStmtExpr) {
432 PushCompoundScope(IsStmtExpr);
433}
434
436 if (getCurFPFeatures().isFPConstrained()) {
438 assert(FSI);
439 FSI->setUsesFPIntrin();
440 }
441}
442
445}
446
448 return getCurFunction()->CompoundScopes.back();
449}
450
452 ArrayRef<Stmt *> Elts, bool isStmtExpr) {
453 const unsigned NumElts = Elts.size();
454
455 // If we're in C mode, check that we don't have any decls after stmts. If
456 // so, emit an extension diagnostic in C89 and potentially a warning in later
457 // versions.
458 const unsigned MixedDeclsCodeID = getLangOpts().C99
459 ? diag::warn_mixed_decls_code
460 : diag::ext_mixed_decls_code;
461 if (!getLangOpts().CPlusPlus && !Diags.isIgnored(MixedDeclsCodeID, L)) {
462 // Note that __extension__ can be around a decl.
463 unsigned i = 0;
464 // Skip over all declarations.
465 for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i)
466 /*empty*/;
467
468 // We found the end of the list or a statement. Scan for another declstmt.
469 for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i)
470 /*empty*/;
471
472 if (i != NumElts) {
473 Decl *D = *cast<DeclStmt>(Elts[i])->decl_begin();
474 Diag(D->getLocation(), MixedDeclsCodeID);
475 }
476 }
477
478 // Check for suspicious empty body (null statement) in `for' and `while'
479 // statements. Don't do anything for template instantiations, this just adds
480 // noise.
481 if (NumElts != 0 && !CurrentInstantiationScope &&
482 getCurCompoundScope().HasEmptyLoopBodies) {
483 for (unsigned i = 0; i != NumElts - 1; ++i)
484 DiagnoseEmptyLoopBody(Elts[i], Elts[i + 1]);
485 }
486
487 // Calculate difference between FP options in this compound statement and in
488 // the enclosing one. If this is a function body, take the difference against
489 // default options. In this case the difference will indicate options that are
490 // changed upon entry to the statement.
491 FPOptions FPO = (getCurFunction()->CompoundScopes.size() == 1)
495
496 return CompoundStmt::Create(Context, Elts, FPDiff, L, R);
497}
498
501 if (!Val.get())
502 return Val;
503
505 return ExprError();
506
507 // If we're not inside a switch, let the 'case' statement handling diagnose
508 // this. Just clean up after the expression as best we can.
509 if (getCurFunction()->SwitchStack.empty())
510 return ActOnFinishFullExpr(Val.get(), Val.get()->getExprLoc(), false,
512
513 Expr *CondExpr =
514 getCurFunction()->SwitchStack.back().getPointer()->getCond();
515 if (!CondExpr)
516 return ExprError();
517 QualType CondType = CondExpr->getType();
518
519 auto CheckAndFinish = [&](Expr *E) {
520 if (CondType->isDependentType() || E->isTypeDependent())
521 return ExprResult(E);
522
523 if (getLangOpts().CPlusPlus11) {
524 // C++11 [stmt.switch]p2: the constant-expression shall be a converted
525 // constant expression of the promoted type of the switch condition.
526 llvm::APSInt TempVal;
527 return CheckConvertedConstantExpression(E, CondType, TempVal,
529 }
530
531 ExprResult ER = E;
532 if (!E->isValueDependent())
534 if (!ER.isInvalid())
535 ER = DefaultLvalueConversion(ER.get());
536 if (!ER.isInvalid())
537 ER = ImpCastExprToType(ER.get(), CondType, CK_IntegralCast);
538 if (!ER.isInvalid())
539 ER = ActOnFinishFullExpr(ER.get(), ER.get()->getExprLoc(), false);
540 return ER;
541 };
542
544 Val, /*InitDecl=*/nullptr, /*RecoverUncorrectedTypos=*/false,
545 CheckAndFinish);
546 if (Converted.get() == Val.get())
547 Converted = CheckAndFinish(Val.get());
548 return Converted;
549}
550
553 SourceLocation DotDotDotLoc, ExprResult RHSVal,
554 SourceLocation ColonLoc) {
555 assert((LHSVal.isInvalid() || LHSVal.get()) && "missing LHS value");
556 assert((DotDotDotLoc.isInvalid() ? RHSVal.isUnset()
557 : RHSVal.isInvalid() || RHSVal.get()) &&
558 "missing RHS value");
559
560 if (getCurFunction()->SwitchStack.empty()) {
561 Diag(CaseLoc, diag::err_case_not_in_switch);
562 return StmtError();
563 }
564
565 if (LHSVal.isInvalid() || RHSVal.isInvalid()) {
566 getCurFunction()->SwitchStack.back().setInt(true);
567 return StmtError();
568 }
569
570 if (LangOpts.OpenACC &&
571 getCurScope()->isInOpenACCComputeConstructScope(Scope::SwitchScope)) {
572 Diag(CaseLoc, diag::err_acc_branch_in_out_compute_construct)
573 << /*branch*/ 0 << /*into*/ 1;
574 return StmtError();
575 }
576
577 auto *CS = CaseStmt::Create(Context, LHSVal.get(), RHSVal.get(),
578 CaseLoc, DotDotDotLoc, ColonLoc);
579 getCurFunction()->SwitchStack.back().getPointer()->addSwitchCase(CS);
580 return CS;
581}
582
584 cast<CaseStmt>(S)->setSubStmt(SubStmt);
585}
586
589 Stmt *SubStmt, Scope *CurScope) {
590 if (getCurFunction()->SwitchStack.empty()) {
591 Diag(DefaultLoc, diag::err_default_not_in_switch);
592 return SubStmt;
593 }
594
595 if (LangOpts.OpenACC &&
596 getCurScope()->isInOpenACCComputeConstructScope(Scope::SwitchScope)) {
597 Diag(DefaultLoc, diag::err_acc_branch_in_out_compute_construct)
598 << /*branch*/ 0 << /*into*/ 1;
599 return StmtError();
600 }
601
602 DefaultStmt *DS = new (Context) DefaultStmt(DefaultLoc, ColonLoc, SubStmt);
603 getCurFunction()->SwitchStack.back().getPointer()->addSwitchCase(DS);
604 return DS;
605}
606
609 SourceLocation ColonLoc, Stmt *SubStmt) {
610 // If the label was multiply defined, reject it now.
611 if (TheDecl->getStmt()) {
612 Diag(IdentLoc, diag::err_redefinition_of_label) << TheDecl->getDeclName();
613 Diag(TheDecl->getLocation(), diag::note_previous_definition);
614 return SubStmt;
615 }
616
618 if (isReservedInAllContexts(Status) &&
620 Diag(IdentLoc, diag::warn_reserved_extern_symbol)
621 << TheDecl << static_cast<int>(Status);
622
623 // If this label is in a compute construct scope, we need to make sure we
624 // check gotos in/out.
625 if (getCurScope()->isInOpenACCComputeConstructScope())
627
628 // OpenACC3.3 2.14.4:
629 // The update directive is executable. It must not appear in place of the
630 // statement following an 'if', 'while', 'do', 'switch', or 'label' in C or
631 // C++.
632 if (isa<OpenACCUpdateConstruct>(SubStmt)) {
633 Diag(SubStmt->getBeginLoc(), diag::err_acc_update_as_body) << /*Label*/ 4;
634 SubStmt = new (Context) NullStmt(SubStmt->getBeginLoc());
635 }
636
637 // Otherwise, things are good. Fill in the declaration and return it.
638 LabelStmt *LS = new (Context) LabelStmt(IdentLoc, TheDecl, SubStmt);
639 TheDecl->setStmt(LS);
640 if (!TheDecl->isGnuLocal()) {
641 TheDecl->setLocStart(IdentLoc);
642 if (!TheDecl->isMSAsmLabel()) {
643 // Don't update the location of MS ASM labels. These will result in
644 // a diagnostic, and changing the location here will mess that up.
645 TheDecl->setLocation(IdentLoc);
646 }
647 }
648 return LS;
649}
650
653 Stmt *SubStmt) {
654 // FIXME: this code should move when a planned refactoring around statement
655 // attributes lands.
656 for (const auto *A : Attrs) {
657 if (A->getKind() == attr::MustTail) {
658 if (!checkAndRewriteMustTailAttr(SubStmt, *A)) {
659 return SubStmt;
660 }
662 }
663 }
664
665 return AttributedStmt::Create(Context, AttrsLoc, Attrs, SubStmt);
666}
667
669 Stmt *SubStmt) {
670 SmallVector<const Attr *, 1> SemanticAttrs;
671 ProcessStmtAttributes(SubStmt, Attrs, SemanticAttrs);
672 if (!SemanticAttrs.empty())
673 return BuildAttributedStmt(Attrs.Range.getBegin(), SemanticAttrs, SubStmt);
674 // If none of the attributes applied, that's fine, we can recover by
675 // returning the substatement directly instead of making an AttributedStmt
676 // with no attributes on it.
677 return SubStmt;
678}
679
681 ReturnStmt *R = cast<ReturnStmt>(St);
682 Expr *E = R->getRetValue();
683
685 // We have to suspend our check until template instantiation time.
686 return true;
687
688 if (!checkMustTailAttr(St, MTA))
689 return false;
690
691 // FIXME: Replace Expr::IgnoreImplicitAsWritten() with this function.
692 // Currently it does not skip implicit constructors in an initialization
693 // context.
694 auto IgnoreImplicitAsWritten = [](Expr *E) -> Expr * {
697 };
698
699 // Now that we have verified that 'musttail' is valid here, rewrite the
700 // return value to remove all implicit nodes, but retain parentheses.
701 R->setRetValue(IgnoreImplicitAsWritten(E));
702 return true;
703}
704
705bool Sema::checkMustTailAttr(const Stmt *St, const Attr &MTA) {
706 assert(!CurContext->isDependentContext() &&
707 "musttail cannot be checked from a dependent context");
708
709 // FIXME: Add Expr::IgnoreParenImplicitAsWritten() with this definition.
710 auto IgnoreParenImplicitAsWritten = [](const Expr *E) -> const Expr * {
711 return IgnoreExprNodes(const_cast<Expr *>(E), IgnoreParensSingleStep,
714 };
715
716 const Expr *E = cast<ReturnStmt>(St)->getRetValue();
717 const auto *CE = dyn_cast_or_null<CallExpr>(IgnoreParenImplicitAsWritten(E));
718
719 if (!CE) {
720 Diag(St->getBeginLoc(), diag::err_musttail_needs_call) << &MTA;
721 return false;
722 }
723
724 if (const auto *EWC = dyn_cast<ExprWithCleanups>(E)) {
725 if (EWC->cleanupsHaveSideEffects()) {
726 Diag(St->getBeginLoc(), diag::err_musttail_needs_trivial_args) << &MTA;
727 return false;
728 }
729 }
730
731 // We need to determine the full function type (including "this" type, if any)
732 // for both caller and callee.
733 struct FuncType {
734 enum {
735 ft_non_member,
736 ft_static_member,
737 ft_non_static_member,
738 ft_pointer_to_member,
739 } MemberType = ft_non_member;
740
742 const FunctionProtoType *Func;
743 const CXXMethodDecl *Method = nullptr;
744 } CallerType, CalleeType;
745
746 auto GetMethodType = [this, St, MTA](const CXXMethodDecl *CMD, FuncType &Type,
747 bool IsCallee) -> bool {
748 if (isa<CXXConstructorDecl, CXXDestructorDecl>(CMD)) {
749 Diag(St->getBeginLoc(), diag::err_musttail_structors_forbidden)
750 << IsCallee << isa<CXXDestructorDecl>(CMD);
751 if (IsCallee)
752 Diag(CMD->getBeginLoc(), diag::note_musttail_structors_forbidden)
753 << isa<CXXDestructorDecl>(CMD);
754 Diag(MTA.getLocation(), diag::note_tail_call_required) << &MTA;
755 return false;
756 }
757 if (CMD->isStatic())
758 Type.MemberType = FuncType::ft_static_member;
759 else {
760 Type.This = CMD->getFunctionObjectParameterType();
761 Type.MemberType = FuncType::ft_non_static_member;
762 }
763 Type.Func = CMD->getType()->castAs<FunctionProtoType>();
764 return true;
765 };
766
767 const auto *CallerDecl = dyn_cast<FunctionDecl>(CurContext);
768
769 // Find caller function signature.
770 if (!CallerDecl) {
771 int ContextType;
772 if (isa<BlockDecl>(CurContext))
773 ContextType = 0;
774 else if (isa<ObjCMethodDecl>(CurContext))
775 ContextType = 1;
776 else
777 ContextType = 2;
778 Diag(St->getBeginLoc(), diag::err_musttail_forbidden_from_this_context)
779 << &MTA << ContextType;
780 return false;
781 } else if (const auto *CMD = dyn_cast<CXXMethodDecl>(CurContext)) {
782 // Caller is a class/struct method.
783 if (!GetMethodType(CMD, CallerType, false))
784 return false;
785 } else {
786 // Caller is a non-method function.
787 CallerType.Func = CallerDecl->getType()->getAs<FunctionProtoType>();
788 }
789
790 const Expr *CalleeExpr = CE->getCallee()->IgnoreParens();
791 const auto *CalleeBinOp = dyn_cast<BinaryOperator>(CalleeExpr);
792 SourceLocation CalleeLoc = CE->getCalleeDecl()
793 ? CE->getCalleeDecl()->getBeginLoc()
794 : St->getBeginLoc();
795
796 // Find callee function signature.
797 if (const CXXMethodDecl *CMD =
798 dyn_cast_or_null<CXXMethodDecl>(CE->getCalleeDecl())) {
799 // Call is: obj.method(), obj->method(), functor(), etc.
800 if (!GetMethodType(CMD, CalleeType, true))
801 return false;
802 } else if (CalleeBinOp && CalleeBinOp->isPtrMemOp()) {
803 // Call is: obj->*method_ptr or obj.*method_ptr
804 const auto *MPT =
805 CalleeBinOp->getRHS()->getType()->castAs<MemberPointerType>();
806 CalleeType.This = QualType(MPT->getClass(), 0);
807 CalleeType.Func = MPT->getPointeeType()->castAs<FunctionProtoType>();
808 CalleeType.MemberType = FuncType::ft_pointer_to_member;
809 } else if (isa<CXXPseudoDestructorExpr>(CalleeExpr)) {
810 Diag(St->getBeginLoc(), diag::err_musttail_structors_forbidden)
811 << /* IsCallee = */ 1 << /* IsDestructor = */ 1;
812 Diag(MTA.getLocation(), diag::note_tail_call_required) << &MTA;
813 return false;
814 } else {
815 // Non-method function.
816 CalleeType.Func =
817 CalleeExpr->getType()->getPointeeType()->getAs<FunctionProtoType>();
818 }
819
820 // Both caller and callee must have a prototype (no K&R declarations).
821 if (!CalleeType.Func || !CallerType.Func) {
822 Diag(St->getBeginLoc(), diag::err_musttail_needs_prototype) << &MTA;
823 if (!CalleeType.Func && CE->getDirectCallee()) {
824 Diag(CE->getDirectCallee()->getBeginLoc(),
825 diag::note_musttail_fix_non_prototype);
826 }
827 if (!CallerType.Func)
828 Diag(CallerDecl->getBeginLoc(), diag::note_musttail_fix_non_prototype);
829 return false;
830 }
831
832 // Caller and callee must have matching calling conventions.
833 //
834 // Some calling conventions are physically capable of supporting tail calls
835 // even if the function types don't perfectly match. LLVM is currently too
836 // strict to allow this, but if LLVM added support for this in the future, we
837 // could exit early here and skip the remaining checks if the functions are
838 // using such a calling convention.
839 if (CallerType.Func->getCallConv() != CalleeType.Func->getCallConv()) {
840 if (const auto *ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl()))
841 Diag(St->getBeginLoc(), diag::err_musttail_callconv_mismatch)
842 << true << ND->getDeclName();
843 else
844 Diag(St->getBeginLoc(), diag::err_musttail_callconv_mismatch) << false;
845 Diag(CalleeLoc, diag::note_musttail_callconv_mismatch)
846 << FunctionType::getNameForCallConv(CallerType.Func->getCallConv())
847 << FunctionType::getNameForCallConv(CalleeType.Func->getCallConv());
848 Diag(MTA.getLocation(), diag::note_tail_call_required) << &MTA;
849 return false;
850 }
851
852 if (CalleeType.Func->isVariadic() || CallerType.Func->isVariadic()) {
853 Diag(St->getBeginLoc(), diag::err_musttail_no_variadic) << &MTA;
854 return false;
855 }
856
857 const auto *CalleeDecl = CE->getCalleeDecl();
858 if (CalleeDecl && CalleeDecl->hasAttr<CXX11NoReturnAttr>()) {
859 Diag(St->getBeginLoc(), diag::err_musttail_no_return) << &MTA;
860 return false;
861 }
862
863 // Caller and callee must match in whether they have a "this" parameter.
864 if (CallerType.This.isNull() != CalleeType.This.isNull()) {
865 if (const auto *ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl())) {
866 Diag(St->getBeginLoc(), diag::err_musttail_member_mismatch)
867 << CallerType.MemberType << CalleeType.MemberType << true
868 << ND->getDeclName();
869 Diag(CalleeLoc, diag::note_musttail_callee_defined_here)
870 << ND->getDeclName();
871 } else
872 Diag(St->getBeginLoc(), diag::err_musttail_member_mismatch)
873 << CallerType.MemberType << CalleeType.MemberType << false;
874 Diag(MTA.getLocation(), diag::note_tail_call_required) << &MTA;
875 return false;
876 }
877
878 auto CheckTypesMatch = [this](FuncType CallerType, FuncType CalleeType,
879 PartialDiagnostic &PD) -> bool {
880 enum {
885 };
886
887 auto DoTypesMatch = [this, &PD](QualType A, QualType B,
888 unsigned Select) -> bool {
889 if (!Context.hasSimilarType(A, B)) {
890 PD << Select << A.getUnqualifiedType() << B.getUnqualifiedType();
891 return false;
892 }
893 return true;
894 };
895
896 if (!CallerType.This.isNull() &&
897 !DoTypesMatch(CallerType.This, CalleeType.This, ft_different_class))
898 return false;
899
900 if (!DoTypesMatch(CallerType.Func->getReturnType(),
901 CalleeType.Func->getReturnType(), ft_return_type))
902 return false;
903
904 if (CallerType.Func->getNumParams() != CalleeType.Func->getNumParams()) {
905 PD << ft_parameter_arity << CallerType.Func->getNumParams()
906 << CalleeType.Func->getNumParams();
907 return false;
908 }
909
910 ArrayRef<QualType> CalleeParams = CalleeType.Func->getParamTypes();
911 ArrayRef<QualType> CallerParams = CallerType.Func->getParamTypes();
912 size_t N = CallerType.Func->getNumParams();
913 for (size_t I = 0; I < N; I++) {
914 if (!DoTypesMatch(CalleeParams[I], CallerParams[I],
916 PD << static_cast<int>(I) + 1;
917 return false;
918 }
919 }
920
921 return true;
922 };
923
924 PartialDiagnostic PD = PDiag(diag::note_musttail_mismatch);
925 if (!CheckTypesMatch(CallerType, CalleeType, PD)) {
926 if (const auto *ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl()))
927 Diag(St->getBeginLoc(), diag::err_musttail_mismatch)
928 << true << ND->getDeclName();
929 else
930 Diag(St->getBeginLoc(), diag::err_musttail_mismatch) << false;
931 Diag(CalleeLoc, PD);
932 Diag(MTA.getLocation(), diag::note_tail_call_required) << &MTA;
933 return false;
934 }
935
936 // The lifetimes of locals and incoming function parameters must end before
937 // the call, because we can't have a stack frame to store them, so diagnose
938 // any pointers or references to them passed into the musttail call.
939 for (auto ArgExpr : CE->arguments()) {
941 Context, ArgExpr->getType(), false);
942 checkExprLifetimeMustTailArg(*this, Entity, const_cast<Expr *>(ArgExpr));
943 }
944
945 return true;
946}
947
948namespace {
949class CommaVisitor : public EvaluatedExprVisitor<CommaVisitor> {
950 typedef EvaluatedExprVisitor<CommaVisitor> Inherited;
951 Sema &SemaRef;
952public:
953 CommaVisitor(Sema &SemaRef) : Inherited(SemaRef.Context), SemaRef(SemaRef) {}
954 void VisitBinaryOperator(BinaryOperator *E) {
955 if (E->getOpcode() == BO_Comma)
956 SemaRef.DiagnoseCommaOperator(E->getLHS(), E->getExprLoc());
958 }
959};
960}
961
963 IfStatementKind StatementKind,
964 SourceLocation LParenLoc, Stmt *InitStmt,
965 ConditionResult Cond, SourceLocation RParenLoc,
966 Stmt *thenStmt, SourceLocation ElseLoc,
967 Stmt *elseStmt) {
968 if (Cond.isInvalid())
969 return StmtError();
970
971 bool ConstevalOrNegatedConsteval =
972 StatementKind == IfStatementKind::ConstevalNonNegated ||
973 StatementKind == IfStatementKind::ConstevalNegated;
974
975 Expr *CondExpr = Cond.get().second;
976 assert((CondExpr || ConstevalOrNegatedConsteval) &&
977 "If statement: missing condition");
978 // Only call the CommaVisitor when not C89 due to differences in scope flags.
979 if (CondExpr && (getLangOpts().C99 || getLangOpts().CPlusPlus) &&
980 !Diags.isIgnored(diag::warn_comma_operator, CondExpr->getExprLoc()))
981 CommaVisitor(*this).Visit(CondExpr);
982
983 if (!ConstevalOrNegatedConsteval && !elseStmt)
984 DiagnoseEmptyStmtBody(RParenLoc, thenStmt, diag::warn_empty_if_body);
985
986 if (ConstevalOrNegatedConsteval ||
987 StatementKind == IfStatementKind::Constexpr) {
988 auto DiagnoseLikelihood = [&](const Stmt *S) {
989 if (const Attr *A = Stmt::getLikelihoodAttr(S)) {
990 Diags.Report(A->getLocation(),
991 diag::warn_attribute_has_no_effect_on_compile_time_if)
992 << A << ConstevalOrNegatedConsteval << A->getRange();
993 Diags.Report(IfLoc,
994 diag::note_attribute_has_no_effect_on_compile_time_if_here)
995 << ConstevalOrNegatedConsteval
996 << SourceRange(IfLoc, (ConstevalOrNegatedConsteval
997 ? thenStmt->getBeginLoc()
998 : LParenLoc)
999 .getLocWithOffset(-1));
1000 }
1001 };
1002 DiagnoseLikelihood(thenStmt);
1003 DiagnoseLikelihood(elseStmt);
1004 } else {
1005 std::tuple<bool, const Attr *, const Attr *> LHC =
1006 Stmt::determineLikelihoodConflict(thenStmt, elseStmt);
1007 if (std::get<0>(LHC)) {
1008 const Attr *ThenAttr = std::get<1>(LHC);
1009 const Attr *ElseAttr = std::get<2>(LHC);
1010 Diags.Report(ThenAttr->getLocation(),
1011 diag::warn_attributes_likelihood_ifstmt_conflict)
1012 << ThenAttr << ThenAttr->getRange();
1013 Diags.Report(ElseAttr->getLocation(), diag::note_conflicting_attribute)
1014 << ElseAttr << ElseAttr->getRange();
1015 }
1016 }
1017
1018 if (ConstevalOrNegatedConsteval) {
1019 bool Immediate = ExprEvalContexts.back().Context ==
1022 const auto *FD =
1023 dyn_cast<FunctionDecl>(Decl::castFromDeclContext(CurContext));
1024 if (FD && FD->isImmediateFunction())
1025 Immediate = true;
1026 }
1027 if (isUnevaluatedContext() || Immediate)
1028 Diags.Report(IfLoc, diag::warn_consteval_if_always_true) << Immediate;
1029 }
1030
1031 // OpenACC3.3 2.14.4:
1032 // The update directive is executable. It must not appear in place of the
1033 // statement following an 'if', 'while', 'do', 'switch', or 'label' in C or
1034 // C++.
1035 if (isa<OpenACCUpdateConstruct>(thenStmt)) {
1036 Diag(thenStmt->getBeginLoc(), diag::err_acc_update_as_body) << /*if*/ 0;
1037 thenStmt = new (Context) NullStmt(thenStmt->getBeginLoc());
1038 }
1039
1040 return BuildIfStmt(IfLoc, StatementKind, LParenLoc, InitStmt, Cond, RParenLoc,
1041 thenStmt, ElseLoc, elseStmt);
1042}
1043
1045 IfStatementKind StatementKind,
1046 SourceLocation LParenLoc, Stmt *InitStmt,
1047 ConditionResult Cond, SourceLocation RParenLoc,
1048 Stmt *thenStmt, SourceLocation ElseLoc,
1049 Stmt *elseStmt) {
1050 if (Cond.isInvalid())
1051 return StmtError();
1052
1053 if (StatementKind != IfStatementKind::Ordinary ||
1054 isa<ObjCAvailabilityCheckExpr>(Cond.get().second))
1056
1057 return IfStmt::Create(Context, IfLoc, StatementKind, InitStmt,
1058 Cond.get().first, Cond.get().second, LParenLoc,
1059 RParenLoc, thenStmt, ElseLoc, elseStmt);
1060}
1061
1062namespace {
1063 struct CaseCompareFunctor {
1064 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
1065 const llvm::APSInt &RHS) {
1066 return LHS.first < RHS;
1067 }
1068 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
1069 const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
1070 return LHS.first < RHS.first;
1071 }
1072 bool operator()(const llvm::APSInt &LHS,
1073 const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
1074 return LHS < RHS.first;
1075 }
1076 };
1077}
1078
1079/// CmpCaseVals - Comparison predicate for sorting case values.
1080///
1081static bool CmpCaseVals(const std::pair<llvm::APSInt, CaseStmt*>& lhs,
1082 const std::pair<llvm::APSInt, CaseStmt*>& rhs) {
1083 if (lhs.first < rhs.first)
1084 return true;
1085
1086 if (lhs.first == rhs.first &&
1087 lhs.second->getCaseLoc() < rhs.second->getCaseLoc())
1088 return true;
1089 return false;
1090}
1091
1092/// CmpEnumVals - Comparison predicate for sorting enumeration values.
1093///
1094static bool CmpEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
1095 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
1096{
1097 return lhs.first < rhs.first;
1098}
1099
1100/// EqEnumVals - Comparison preficate for uniqing enumeration values.
1101///
1102static bool EqEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
1103 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
1104{
1105 return lhs.first == rhs.first;
1106}
1107
1108/// GetTypeBeforeIntegralPromotion - Returns the pre-promotion type of
1109/// potentially integral-promoted expression @p expr.
1111 if (const auto *FE = dyn_cast<FullExpr>(E))
1112 E = FE->getSubExpr();
1113 while (const auto *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
1114 if (ImpCast->getCastKind() != CK_IntegralCast) break;
1115 E = ImpCast->getSubExpr();
1116 }
1117 return E->getType();
1118}
1119
1121 class SwitchConvertDiagnoser : public ICEConvertDiagnoser {
1122 Expr *Cond;
1123
1124 public:
1125 SwitchConvertDiagnoser(Expr *Cond)
1126 : ICEConvertDiagnoser(/*AllowScopedEnumerations*/true, false, true),
1127 Cond(Cond) {}
1128
1129 SemaDiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
1130 QualType T) override {
1131 return S.Diag(Loc, diag::err_typecheck_statement_requires_integer) << T;
1132 }
1133
1134 SemaDiagnosticBuilder diagnoseIncomplete(
1135 Sema &S, SourceLocation Loc, QualType T) override {
1136 return S.Diag(Loc, diag::err_switch_incomplete_class_type)
1137 << T << Cond->getSourceRange();
1138 }
1139
1140 SemaDiagnosticBuilder diagnoseExplicitConv(
1141 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
1142 return S.Diag(Loc, diag::err_switch_explicit_conversion) << T << ConvTy;
1143 }
1144
1145 SemaDiagnosticBuilder noteExplicitConv(
1146 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
1147 return S.Diag(Conv->getLocation(), diag::note_switch_conversion)
1148 << ConvTy->isEnumeralType() << ConvTy;
1149 }
1150
1151 SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
1152 QualType T) override {
1153 return S.Diag(Loc, diag::err_switch_multiple_conversions) << T;
1154 }
1155
1156 SemaDiagnosticBuilder noteAmbiguous(
1157 Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
1158 return S.Diag(Conv->getLocation(), diag::note_switch_conversion)
1159 << ConvTy->isEnumeralType() << ConvTy;
1160 }
1161
1162 SemaDiagnosticBuilder diagnoseConversion(
1163 Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
1164 llvm_unreachable("conversion functions are permitted");
1165 }
1166 } SwitchDiagnoser(Cond);
1167
1168 ExprResult CondResult =
1169 PerformContextualImplicitConversion(SwitchLoc, Cond, SwitchDiagnoser);
1170 if (CondResult.isInvalid())
1171 return ExprError();
1172
1173 // FIXME: PerformContextualImplicitConversion doesn't always tell us if it
1174 // failed and produced a diagnostic.
1175 Cond = CondResult.get();
1176 if (!Cond->isTypeDependent() &&
1178 return ExprError();
1179
1180 // C99 6.8.4.2p5 - Integer promotions are performed on the controlling expr.
1181 return UsualUnaryConversions(Cond);
1182}
1183
1185 SourceLocation LParenLoc,
1186 Stmt *InitStmt, ConditionResult Cond,
1187 SourceLocation RParenLoc) {
1188 Expr *CondExpr = Cond.get().second;
1189 assert((Cond.isInvalid() || CondExpr) && "switch with no condition");
1190
1191 if (CondExpr && !CondExpr->isTypeDependent()) {
1192 // We have already converted the expression to an integral or enumeration
1193 // type, when we parsed the switch condition. There are cases where we don't
1194 // have an appropriate type, e.g. a typo-expr Cond was corrected to an
1195 // inappropriate-type expr, we just return an error.
1196 if (!CondExpr->getType()->isIntegralOrEnumerationType())
1197 return StmtError();
1198 if (CondExpr->isKnownToHaveBooleanValue()) {
1199 // switch(bool_expr) {...} is often a programmer error, e.g.
1200 // switch(n && mask) { ... } // Doh - should be "n & mask".
1201 // One can always use an if statement instead of switch(bool_expr).
1202 Diag(SwitchLoc, diag::warn_bool_switch_condition)
1203 << CondExpr->getSourceRange();
1204 }
1205 }
1206
1208
1209 auto *SS = SwitchStmt::Create(Context, InitStmt, Cond.get().first, CondExpr,
1210 LParenLoc, RParenLoc);
1211 getCurFunction()->SwitchStack.push_back(
1213 return SS;
1214}
1215
1216static void AdjustAPSInt(llvm::APSInt &Val, unsigned BitWidth, bool IsSigned) {
1217 Val = Val.extOrTrunc(BitWidth);
1218 Val.setIsSigned(IsSigned);
1219}
1220
1221/// Check the specified case value is in range for the given unpromoted switch
1222/// type.
1223static void checkCaseValue(Sema &S, SourceLocation Loc, const llvm::APSInt &Val,
1224 unsigned UnpromotedWidth, bool UnpromotedSign) {
1225 // In C++11 onwards, this is checked by the language rules.
1226 if (S.getLangOpts().CPlusPlus11)
1227 return;
1228
1229 // If the case value was signed and negative and the switch expression is
1230 // unsigned, don't bother to warn: this is implementation-defined behavior.
1231 // FIXME: Introduce a second, default-ignored warning for this case?
1232 if (UnpromotedWidth < Val.getBitWidth()) {
1233 llvm::APSInt ConvVal(Val);
1234 AdjustAPSInt(ConvVal, UnpromotedWidth, UnpromotedSign);
1235 AdjustAPSInt(ConvVal, Val.getBitWidth(), Val.isSigned());
1236 // FIXME: Use different diagnostics for overflow in conversion to promoted
1237 // type versus "switch expression cannot have this value". Use proper
1238 // IntRange checking rather than just looking at the unpromoted type here.
1239 if (ConvVal != Val)
1240 S.Diag(Loc, diag::warn_case_value_overflow) << toString(Val, 10)
1241 << toString(ConvVal, 10);
1242 }
1243}
1244
1246
1247/// Returns true if we should emit a diagnostic about this case expression not
1248/// being a part of the enum used in the switch controlling expression.
1250 const EnumDecl *ED,
1251 const Expr *CaseExpr,
1252 EnumValsTy::iterator &EI,
1253 EnumValsTy::iterator &EIEnd,
1254 const llvm::APSInt &Val) {
1255 if (!ED->isClosed())
1256 return false;
1257
1258 if (const DeclRefExpr *DRE =
1259 dyn_cast<DeclRefExpr>(CaseExpr->IgnoreParenImpCasts())) {
1260 if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
1261 QualType VarType = VD->getType();
1263 if (VD->hasGlobalStorage() && VarType.isConstQualified() &&
1265 return false;
1266 }
1267 }
1268
1269 if (ED->hasAttr<FlagEnumAttr>())
1270 return !S.IsValueInFlagEnum(ED, Val, false);
1271
1272 while (EI != EIEnd && EI->first < Val)
1273 EI++;
1274
1275 if (EI != EIEnd && EI->first == Val)
1276 return false;
1277
1278 return true;
1279}
1280
1281static void checkEnumTypesInSwitchStmt(Sema &S, const Expr *Cond,
1282 const Expr *Case) {
1283 QualType CondType = Cond->getType();
1284 QualType CaseType = Case->getType();
1285
1286 const EnumType *CondEnumType = CondType->getAs<EnumType>();
1287 const EnumType *CaseEnumType = CaseType->getAs<EnumType>();
1288 if (!CondEnumType || !CaseEnumType)
1289 return;
1290
1291 // Ignore anonymous enums.
1292 if (!CondEnumType->getDecl()->getIdentifier() &&
1293 !CondEnumType->getDecl()->getTypedefNameForAnonDecl())
1294 return;
1295 if (!CaseEnumType->getDecl()->getIdentifier() &&
1296 !CaseEnumType->getDecl()->getTypedefNameForAnonDecl())
1297 return;
1298
1299 if (S.Context.hasSameUnqualifiedType(CondType, CaseType))
1300 return;
1301
1302 S.Diag(Case->getExprLoc(), diag::warn_comparison_of_mixed_enum_types_switch)
1303 << CondType << CaseType << Cond->getSourceRange()
1304 << Case->getSourceRange();
1305}
1306
1309 Stmt *BodyStmt) {
1310 SwitchStmt *SS = cast<SwitchStmt>(Switch);
1311 bool CaseListIsIncomplete = getCurFunction()->SwitchStack.back().getInt();
1312 assert(SS == getCurFunction()->SwitchStack.back().getPointer() &&
1313 "switch stack missing push/pop!");
1314
1315 getCurFunction()->SwitchStack.pop_back();
1316
1317 if (!BodyStmt) return StmtError();
1318
1319 // OpenACC3.3 2.14.4:
1320 // The update directive is executable. It must not appear in place of the
1321 // statement following an 'if', 'while', 'do', 'switch', or 'label' in C or
1322 // C++.
1323 if (isa<OpenACCUpdateConstruct>(BodyStmt)) {
1324 Diag(BodyStmt->getBeginLoc(), diag::err_acc_update_as_body) << /*switch*/ 3;
1325 BodyStmt = new (Context) NullStmt(BodyStmt->getBeginLoc());
1326 }
1327
1328 SS->setBody(BodyStmt, SwitchLoc);
1329
1330 Expr *CondExpr = SS->getCond();
1331 if (!CondExpr) return StmtError();
1332
1333 QualType CondType = CondExpr->getType();
1334
1335 // C++ 6.4.2.p2:
1336 // Integral promotions are performed (on the switch condition).
1337 //
1338 // A case value unrepresentable by the original switch condition
1339 // type (before the promotion) doesn't make sense, even when it can
1340 // be represented by the promoted type. Therefore we need to find
1341 // the pre-promotion type of the switch condition.
1342 const Expr *CondExprBeforePromotion = CondExpr;
1343 QualType CondTypeBeforePromotion =
1344 GetTypeBeforeIntegralPromotion(CondExprBeforePromotion);
1345
1346 // Get the bitwidth of the switched-on value after promotions. We must
1347 // convert the integer case values to this width before comparison.
1348 bool HasDependentValue
1349 = CondExpr->isTypeDependent() || CondExpr->isValueDependent();
1350 unsigned CondWidth = HasDependentValue ? 0 : Context.getIntWidth(CondType);
1351 bool CondIsSigned = CondType->isSignedIntegerOrEnumerationType();
1352
1353 // Get the width and signedness that the condition might actually have, for
1354 // warning purposes.
1355 // FIXME: Grab an IntRange for the condition rather than using the unpromoted
1356 // type.
1357 unsigned CondWidthBeforePromotion
1358 = HasDependentValue ? 0 : Context.getIntWidth(CondTypeBeforePromotion);
1359 bool CondIsSignedBeforePromotion
1360 = CondTypeBeforePromotion->isSignedIntegerOrEnumerationType();
1361
1362 // Accumulate all of the case values in a vector so that we can sort them
1363 // and detect duplicates. This vector contains the APInt for the case after
1364 // it has been converted to the condition type.
1365 typedef SmallVector<std::pair<llvm::APSInt, CaseStmt*>, 64> CaseValsTy;
1366 CaseValsTy CaseVals;
1367
1368 // Keep track of any GNU case ranges we see. The APSInt is the low value.
1369 typedef std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRangesTy;
1370 CaseRangesTy CaseRanges;
1371
1372 DefaultStmt *TheDefaultStmt = nullptr;
1373
1374 bool CaseListIsErroneous = false;
1375
1376 // FIXME: We'd better diagnose missing or duplicate default labels even
1377 // in the dependent case. Because default labels themselves are never
1378 // dependent.
1379 for (SwitchCase *SC = SS->getSwitchCaseList(); SC && !HasDependentValue;
1380 SC = SC->getNextSwitchCase()) {
1381
1382 if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) {
1383 if (TheDefaultStmt) {
1384 Diag(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined);
1385 Diag(TheDefaultStmt->getDefaultLoc(), diag::note_duplicate_case_prev);
1386
1387 // FIXME: Remove the default statement from the switch block so that
1388 // we'll return a valid AST. This requires recursing down the AST and
1389 // finding it, not something we are set up to do right now. For now,
1390 // just lop the entire switch stmt out of the AST.
1391 CaseListIsErroneous = true;
1392 }
1393 TheDefaultStmt = DS;
1394
1395 } else {
1396 CaseStmt *CS = cast<CaseStmt>(SC);
1397
1398 Expr *Lo = CS->getLHS();
1399
1400 if (Lo->isValueDependent()) {
1401 HasDependentValue = true;
1402 break;
1403 }
1404
1405 // We already verified that the expression has a constant value;
1406 // get that value (prior to conversions).
1407 const Expr *LoBeforePromotion = Lo;
1408 GetTypeBeforeIntegralPromotion(LoBeforePromotion);
1409 llvm::APSInt LoVal = LoBeforePromotion->EvaluateKnownConstInt(Context);
1410
1411 // Check the unconverted value is within the range of possible values of
1412 // the switch expression.
1413 checkCaseValue(*this, Lo->getBeginLoc(), LoVal, CondWidthBeforePromotion,
1414 CondIsSignedBeforePromotion);
1415
1416 // FIXME: This duplicates the check performed for warn_not_in_enum below.
1417 checkEnumTypesInSwitchStmt(*this, CondExprBeforePromotion,
1418 LoBeforePromotion);
1419
1420 // Convert the value to the same width/sign as the condition.
1421 AdjustAPSInt(LoVal, CondWidth, CondIsSigned);
1422
1423 // If this is a case range, remember it in CaseRanges, otherwise CaseVals.
1424 if (CS->getRHS()) {
1425 if (CS->getRHS()->isValueDependent()) {
1426 HasDependentValue = true;
1427 break;
1428 }
1429 CaseRanges.push_back(std::make_pair(LoVal, CS));
1430 } else
1431 CaseVals.push_back(std::make_pair(LoVal, CS));
1432 }
1433 }
1434
1435 if (!HasDependentValue) {
1436 // If we don't have a default statement, check whether the
1437 // condition is constant.
1438 llvm::APSInt ConstantCondValue;
1439 bool HasConstantCond = false;
1440 if (!TheDefaultStmt) {
1442 HasConstantCond = CondExpr->EvaluateAsInt(Result, Context,
1444 if (Result.Val.isInt())
1445 ConstantCondValue = Result.Val.getInt();
1446 assert(!HasConstantCond ||
1447 (ConstantCondValue.getBitWidth() == CondWidth &&
1448 ConstantCondValue.isSigned() == CondIsSigned));
1449 Diag(SwitchLoc, diag::warn_switch_default);
1450 }
1451 bool ShouldCheckConstantCond = HasConstantCond;
1452
1453 // Sort all the scalar case values so we can easily detect duplicates.
1454 llvm::stable_sort(CaseVals, CmpCaseVals);
1455
1456 if (!CaseVals.empty()) {
1457 for (unsigned i = 0, e = CaseVals.size(); i != e; ++i) {
1458 if (ShouldCheckConstantCond &&
1459 CaseVals[i].first == ConstantCondValue)
1460 ShouldCheckConstantCond = false;
1461
1462 if (i != 0 && CaseVals[i].first == CaseVals[i-1].first) {
1463 // If we have a duplicate, report it.
1464 // First, determine if either case value has a name
1465 StringRef PrevString, CurrString;
1466 Expr *PrevCase = CaseVals[i-1].second->getLHS()->IgnoreParenCasts();
1467 Expr *CurrCase = CaseVals[i].second->getLHS()->IgnoreParenCasts();
1468 if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(PrevCase)) {
1469 PrevString = DeclRef->getDecl()->getName();
1470 }
1471 if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(CurrCase)) {
1472 CurrString = DeclRef->getDecl()->getName();
1473 }
1474 SmallString<16> CaseValStr;
1475 CaseVals[i-1].first.toString(CaseValStr);
1476
1477 if (PrevString == CurrString)
1478 Diag(CaseVals[i].second->getLHS()->getBeginLoc(),
1479 diag::err_duplicate_case)
1480 << (PrevString.empty() ? CaseValStr.str() : PrevString);
1481 else
1482 Diag(CaseVals[i].second->getLHS()->getBeginLoc(),
1483 diag::err_duplicate_case_differing_expr)
1484 << (PrevString.empty() ? CaseValStr.str() : PrevString)
1485 << (CurrString.empty() ? CaseValStr.str() : CurrString)
1486 << CaseValStr;
1487
1488 Diag(CaseVals[i - 1].second->getLHS()->getBeginLoc(),
1489 diag::note_duplicate_case_prev);
1490 // FIXME: We really want to remove the bogus case stmt from the
1491 // substmt, but we have no way to do this right now.
1492 CaseListIsErroneous = true;
1493 }
1494 }
1495 }
1496
1497 // Detect duplicate case ranges, which usually don't exist at all in
1498 // the first place.
1499 if (!CaseRanges.empty()) {
1500 // Sort all the case ranges by their low value so we can easily detect
1501 // overlaps between ranges.
1502 llvm::stable_sort(CaseRanges);
1503
1504 // Scan the ranges, computing the high values and removing empty ranges.
1505 std::vector<llvm::APSInt> HiVals;
1506 for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
1507 llvm::APSInt &LoVal = CaseRanges[i].first;
1508 CaseStmt *CR = CaseRanges[i].second;
1509 Expr *Hi = CR->getRHS();
1510
1511 const Expr *HiBeforePromotion = Hi;
1512 GetTypeBeforeIntegralPromotion(HiBeforePromotion);
1513 llvm::APSInt HiVal = HiBeforePromotion->EvaluateKnownConstInt(Context);
1514
1515 // Check the unconverted value is within the range of possible values of
1516 // the switch expression.
1517 checkCaseValue(*this, Hi->getBeginLoc(), HiVal,
1518 CondWidthBeforePromotion, CondIsSignedBeforePromotion);
1519
1520 // Convert the value to the same width/sign as the condition.
1521 AdjustAPSInt(HiVal, CondWidth, CondIsSigned);
1522
1523 // If the low value is bigger than the high value, the case is empty.
1524 if (LoVal > HiVal) {
1525 Diag(CR->getLHS()->getBeginLoc(), diag::warn_case_empty_range)
1526 << SourceRange(CR->getLHS()->getBeginLoc(), Hi->getEndLoc());
1527 CaseRanges.erase(CaseRanges.begin()+i);
1528 --i;
1529 --e;
1530 continue;
1531 }
1532
1533 if (ShouldCheckConstantCond &&
1534 LoVal <= ConstantCondValue &&
1535 ConstantCondValue <= HiVal)
1536 ShouldCheckConstantCond = false;
1537
1538 HiVals.push_back(HiVal);
1539 }
1540
1541 // Rescan the ranges, looking for overlap with singleton values and other
1542 // ranges. Since the range list is sorted, we only need to compare case
1543 // ranges with their neighbors.
1544 for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
1545 llvm::APSInt &CRLo = CaseRanges[i].first;
1546 llvm::APSInt &CRHi = HiVals[i];
1547 CaseStmt *CR = CaseRanges[i].second;
1548
1549 // Check to see whether the case range overlaps with any
1550 // singleton cases.
1551 CaseStmt *OverlapStmt = nullptr;
1552 llvm::APSInt OverlapVal(32);
1553
1554 // Find the smallest value >= the lower bound. If I is in the
1555 // case range, then we have overlap.
1556 CaseValsTy::iterator I =
1557 llvm::lower_bound(CaseVals, CRLo, CaseCompareFunctor());
1558 if (I != CaseVals.end() && I->first < CRHi) {
1559 OverlapVal = I->first; // Found overlap with scalar.
1560 OverlapStmt = I->second;
1561 }
1562
1563 // Find the smallest value bigger than the upper bound.
1564 I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor());
1565 if (I != CaseVals.begin() && (I-1)->first >= CRLo) {
1566 OverlapVal = (I-1)->first; // Found overlap with scalar.
1567 OverlapStmt = (I-1)->second;
1568 }
1569
1570 // Check to see if this case stmt overlaps with the subsequent
1571 // case range.
1572 if (i && CRLo <= HiVals[i-1]) {
1573 OverlapVal = HiVals[i-1]; // Found overlap with range.
1574 OverlapStmt = CaseRanges[i-1].second;
1575 }
1576
1577 if (OverlapStmt) {
1578 // If we have a duplicate, report it.
1579 Diag(CR->getLHS()->getBeginLoc(), diag::err_duplicate_case)
1580 << toString(OverlapVal, 10);
1581 Diag(OverlapStmt->getLHS()->getBeginLoc(),
1582 diag::note_duplicate_case_prev);
1583 // FIXME: We really want to remove the bogus case stmt from the
1584 // substmt, but we have no way to do this right now.
1585 CaseListIsErroneous = true;
1586 }
1587 }
1588 }
1589
1590 // Complain if we have a constant condition and we didn't find a match.
1591 if (!CaseListIsErroneous && !CaseListIsIncomplete &&
1592 ShouldCheckConstantCond) {
1593 // TODO: it would be nice if we printed enums as enums, chars as
1594 // chars, etc.
1595 Diag(CondExpr->getExprLoc(), diag::warn_missing_case_for_condition)
1596 << toString(ConstantCondValue, 10)
1597 << CondExpr->getSourceRange();
1598 }
1599
1600 // Check to see if switch is over an Enum and handles all of its
1601 // values. We only issue a warning if there is not 'default:', but
1602 // we still do the analysis to preserve this information in the AST
1603 // (which can be used by flow-based analyes).
1604 //
1605 const EnumType *ET = CondTypeBeforePromotion->getAs<EnumType>();
1606
1607 // If switch has default case, then ignore it.
1608 if (!CaseListIsErroneous && !CaseListIsIncomplete && !HasConstantCond &&
1609 ET && ET->getDecl()->isCompleteDefinition() &&
1610 !ET->getDecl()->enumerators().empty()) {
1611 const EnumDecl *ED = ET->getDecl();
1612 EnumValsTy EnumVals;
1613
1614 // Gather all enum values, set their type and sort them,
1615 // allowing easier comparison with CaseVals.
1616 for (auto *EDI : ED->enumerators()) {
1617 llvm::APSInt Val = EDI->getInitVal();
1618 AdjustAPSInt(Val, CondWidth, CondIsSigned);
1619 EnumVals.push_back(std::make_pair(Val, EDI));
1620 }
1621 llvm::stable_sort(EnumVals, CmpEnumVals);
1622 auto EI = EnumVals.begin(), EIEnd =
1623 std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals);
1624
1625 // See which case values aren't in enum.
1626 for (CaseValsTy::const_iterator CI = CaseVals.begin();
1627 CI != CaseVals.end(); CI++) {
1628 Expr *CaseExpr = CI->second->getLHS();
1629 if (ShouldDiagnoseSwitchCaseNotInEnum(*this, ED, CaseExpr, EI, EIEnd,
1630 CI->first))
1631 Diag(CaseExpr->getExprLoc(), diag::warn_not_in_enum)
1632 << CondTypeBeforePromotion;
1633 }
1634
1635 // See which of case ranges aren't in enum
1636 EI = EnumVals.begin();
1637 for (CaseRangesTy::const_iterator RI = CaseRanges.begin();
1638 RI != CaseRanges.end(); RI++) {
1639 Expr *CaseExpr = RI->second->getLHS();
1640 if (ShouldDiagnoseSwitchCaseNotInEnum(*this, ED, CaseExpr, EI, EIEnd,
1641 RI->first))
1642 Diag(CaseExpr->getExprLoc(), diag::warn_not_in_enum)
1643 << CondTypeBeforePromotion;
1644
1645 llvm::APSInt Hi =
1646 RI->second->getRHS()->EvaluateKnownConstInt(Context);
1647 AdjustAPSInt(Hi, CondWidth, CondIsSigned);
1648
1649 CaseExpr = RI->second->getRHS();
1650 if (ShouldDiagnoseSwitchCaseNotInEnum(*this, ED, CaseExpr, EI, EIEnd,
1651 Hi))
1652 Diag(CaseExpr->getExprLoc(), diag::warn_not_in_enum)
1653 << CondTypeBeforePromotion;
1654 }
1655
1656 // Check which enum vals aren't in switch
1657 auto CI = CaseVals.begin();
1658 auto RI = CaseRanges.begin();
1659 bool hasCasesNotInSwitch = false;
1660
1661 SmallVector<DeclarationName,8> UnhandledNames;
1662
1663 for (EI = EnumVals.begin(); EI != EIEnd; EI++) {
1664 // Don't warn about omitted unavailable EnumConstantDecls.
1665 switch (EI->second->getAvailability()) {
1666 case AR_Deprecated:
1667 // Omitting a deprecated constant is ok; it should never materialize.
1668 case AR_Unavailable:
1669 continue;
1670
1672 // Partially available enum constants should be present. Note that we
1673 // suppress -Wunguarded-availability diagnostics for such uses.
1674 case AR_Available:
1675 break;
1676 }
1677
1678 if (EI->second->hasAttr<UnusedAttr>())
1679 continue;
1680
1681 // Drop unneeded case values
1682 while (CI != CaseVals.end() && CI->first < EI->first)
1683 CI++;
1684
1685 if (CI != CaseVals.end() && CI->first == EI->first)
1686 continue;
1687
1688 // Drop unneeded case ranges
1689 for (; RI != CaseRanges.end(); RI++) {
1690 llvm::APSInt Hi =
1691 RI->second->getRHS()->EvaluateKnownConstInt(Context);
1692 AdjustAPSInt(Hi, CondWidth, CondIsSigned);
1693 if (EI->first <= Hi)
1694 break;
1695 }
1696
1697 if (RI == CaseRanges.end() || EI->first < RI->first) {
1698 hasCasesNotInSwitch = true;
1699 UnhandledNames.push_back(EI->second->getDeclName());
1700 }
1701 }
1702
1703 if (TheDefaultStmt && UnhandledNames.empty() && ED->isClosedNonFlag())
1704 Diag(TheDefaultStmt->getDefaultLoc(), diag::warn_unreachable_default);
1705
1706 // Produce a nice diagnostic if multiple values aren't handled.
1707 if (!UnhandledNames.empty()) {
1708 auto DB = Diag(CondExpr->getExprLoc(), TheDefaultStmt
1709 ? diag::warn_def_missing_case
1710 : diag::warn_missing_case)
1711 << CondExpr->getSourceRange() << (int)UnhandledNames.size();
1712
1713 for (size_t I = 0, E = std::min(UnhandledNames.size(), (size_t)3);
1714 I != E; ++I)
1715 DB << UnhandledNames[I];
1716 }
1717
1718 if (!hasCasesNotInSwitch)
1720 }
1721 }
1722
1723 if (BodyStmt)
1724 DiagnoseEmptyStmtBody(CondExpr->getEndLoc(), BodyStmt,
1725 diag::warn_empty_switch_body);
1726
1727 // FIXME: If the case list was broken is some way, we don't have a good system
1728 // to patch it up. Instead, just return the whole substmt as broken.
1729 if (CaseListIsErroneous)
1730 return StmtError();
1731
1732 return SS;
1733}
1734
1735void
1737 Expr *SrcExpr) {
1738 if (Diags.isIgnored(diag::warn_not_in_enum_assignment, SrcExpr->getExprLoc()))
1739 return;
1740
1741 if (const EnumType *ET = DstType->getAs<EnumType>())
1742 if (!Context.hasSameUnqualifiedType(SrcType, DstType) &&
1743 SrcType->isIntegerType()) {
1744 if (!SrcExpr->isTypeDependent() && !SrcExpr->isValueDependent() &&
1745 SrcExpr->isIntegerConstantExpr(Context)) {
1746 // Get the bitwidth of the enum value before promotions.
1747 unsigned DstWidth = Context.getIntWidth(DstType);
1748 bool DstIsSigned = DstType->isSignedIntegerOrEnumerationType();
1749
1750 llvm::APSInt RhsVal = SrcExpr->EvaluateKnownConstInt(Context);
1751 AdjustAPSInt(RhsVal, DstWidth, DstIsSigned);
1752 const EnumDecl *ED = ET->getDecl();
1753
1754 if (!ED->isClosed())
1755 return;
1756
1757 if (ED->hasAttr<FlagEnumAttr>()) {
1758 if (!IsValueInFlagEnum(ED, RhsVal, true))
1759 Diag(SrcExpr->getExprLoc(), diag::warn_not_in_enum_assignment)
1760 << DstType.getUnqualifiedType();
1761 } else {
1763 EnumValsTy;
1764 EnumValsTy EnumVals;
1765
1766 // Gather all enum values, set their type and sort them,
1767 // allowing easier comparison with rhs constant.
1768 for (auto *EDI : ED->enumerators()) {
1769 llvm::APSInt Val = EDI->getInitVal();
1770 AdjustAPSInt(Val, DstWidth, DstIsSigned);
1771 EnumVals.push_back(std::make_pair(Val, EDI));
1772 }
1773 if (EnumVals.empty())
1774 return;
1775 llvm::stable_sort(EnumVals, CmpEnumVals);
1776 EnumValsTy::iterator EIend =
1777 std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals);
1778
1779 // See which values aren't in the enum.
1780 EnumValsTy::const_iterator EI = EnumVals.begin();
1781 while (EI != EIend && EI->first < RhsVal)
1782 EI++;
1783 if (EI == EIend || EI->first != RhsVal) {
1784 Diag(SrcExpr->getExprLoc(), diag::warn_not_in_enum_assignment)
1785 << DstType.getUnqualifiedType();
1786 }
1787 }
1788 }
1789 }
1790}
1791
1793 SourceLocation LParenLoc, ConditionResult Cond,
1794 SourceLocation RParenLoc, Stmt *Body) {
1795 if (Cond.isInvalid())
1796 return StmtError();
1797
1798 auto CondVal = Cond.get();
1799 CheckBreakContinueBinding(CondVal.second);
1800
1801 if (CondVal.second &&
1802 !Diags.isIgnored(diag::warn_comma_operator, CondVal.second->getExprLoc()))
1803 CommaVisitor(*this).Visit(CondVal.second);
1804
1805 // OpenACC3.3 2.14.4:
1806 // The update directive is executable. It must not appear in place of the
1807 // statement following an 'if', 'while', 'do', 'switch', or 'label' in C or
1808 // C++.
1809 if (isa<OpenACCUpdateConstruct>(Body)) {
1810 Diag(Body->getBeginLoc(), diag::err_acc_update_as_body) << /*while*/ 1;
1811 Body = new (Context) NullStmt(Body->getBeginLoc());
1812 }
1813
1814 if (isa<NullStmt>(Body))
1816
1817 return WhileStmt::Create(Context, CondVal.first, CondVal.second, Body,
1818 WhileLoc, LParenLoc, RParenLoc);
1819}
1820
1823 SourceLocation WhileLoc, SourceLocation CondLParen,
1824 Expr *Cond, SourceLocation CondRParen) {
1825 assert(Cond && "ActOnDoStmt(): missing expression");
1826
1827 CheckBreakContinueBinding(Cond);
1828 ExprResult CondResult = CheckBooleanCondition(DoLoc, Cond);
1829 if (CondResult.isInvalid())
1830 return StmtError();
1831 Cond = CondResult.get();
1832
1833 CondResult = ActOnFinishFullExpr(Cond, DoLoc, /*DiscardedValue*/ false);
1834 if (CondResult.isInvalid())
1835 return StmtError();
1836 Cond = CondResult.get();
1837
1838 // Only call the CommaVisitor for C89 due to differences in scope flags.
1839 if (Cond && !getLangOpts().C99 && !getLangOpts().CPlusPlus &&
1840 !Diags.isIgnored(diag::warn_comma_operator, Cond->getExprLoc()))
1841 CommaVisitor(*this).Visit(Cond);
1842
1843 // OpenACC3.3 2.14.4:
1844 // The update directive is executable. It must not appear in place of the
1845 // statement following an 'if', 'while', 'do', 'switch', or 'label' in C or
1846 // C++.
1847 if (isa<OpenACCUpdateConstruct>(Body)) {
1848 Diag(Body->getBeginLoc(), diag::err_acc_update_as_body) << /*do*/ 2;
1849 Body = new (Context) NullStmt(Body->getBeginLoc());
1850 }
1851
1852 return new (Context) DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen);
1853}
1854
1855namespace {
1856 // Use SetVector since the diagnostic cares about the ordering of the Decl's.
1857 using DeclSetVector = llvm::SmallSetVector<VarDecl *, 8>;
1858
1859 // This visitor will traverse a conditional statement and store all
1860 // the evaluated decls into a vector. Simple is set to true if none
1861 // of the excluded constructs are used.
1862 class DeclExtractor : public EvaluatedExprVisitor<DeclExtractor> {
1863 DeclSetVector &Decls;
1865 bool Simple;
1866 public:
1867 typedef EvaluatedExprVisitor<DeclExtractor> Inherited;
1868
1869 DeclExtractor(Sema &S, DeclSetVector &Decls,
1871 Inherited(S.Context),
1872 Decls(Decls),
1873 Ranges(Ranges),
1874 Simple(true) {}
1875
1876 bool isSimple() { return Simple; }
1877
1878 // Replaces the method in EvaluatedExprVisitor.
1879 void VisitMemberExpr(MemberExpr* E) {
1880 Simple = false;
1881 }
1882
1883 // Any Stmt not explicitly listed will cause the condition to be marked
1884 // complex.
1885 void VisitStmt(Stmt *S) { Simple = false; }
1886
1887 void VisitBinaryOperator(BinaryOperator *E) {
1888 Visit(E->getLHS());
1889 Visit(E->getRHS());
1890 }
1891
1892 void VisitCastExpr(CastExpr *E) {
1893 Visit(E->getSubExpr());
1894 }
1895
1896 void VisitUnaryOperator(UnaryOperator *E) {
1897 // Skip checking conditionals with derefernces.
1898 if (E->getOpcode() == UO_Deref)
1899 Simple = false;
1900 else
1901 Visit(E->getSubExpr());
1902 }
1903
1904 void VisitConditionalOperator(ConditionalOperator *E) {
1905 Visit(E->getCond());
1906 Visit(E->getTrueExpr());
1907 Visit(E->getFalseExpr());
1908 }
1909
1910 void VisitParenExpr(ParenExpr *E) {
1911 Visit(E->getSubExpr());
1912 }
1913
1914 void VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
1915 Visit(E->getOpaqueValue()->getSourceExpr());
1916 Visit(E->getFalseExpr());
1917 }
1918
1919 void VisitIntegerLiteral(IntegerLiteral *E) { }
1920 void VisitFloatingLiteral(FloatingLiteral *E) { }
1921 void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { }
1922 void VisitCharacterLiteral(CharacterLiteral *E) { }
1923 void VisitGNUNullExpr(GNUNullExpr *E) { }
1924 void VisitImaginaryLiteral(ImaginaryLiteral *E) { }
1925
1926 void VisitDeclRefExpr(DeclRefExpr *E) {
1927 VarDecl *VD = dyn_cast<VarDecl>(E->getDecl());
1928 if (!VD) {
1929 // Don't allow unhandled Decl types.
1930 Simple = false;
1931 return;
1932 }
1933
1934 Ranges.push_back(E->getSourceRange());
1935
1936 Decls.insert(VD);
1937 }
1938
1939 }; // end class DeclExtractor
1940
1941 // DeclMatcher checks to see if the decls are used in a non-evaluated
1942 // context.
1943 class DeclMatcher : public EvaluatedExprVisitor<DeclMatcher> {
1944 DeclSetVector &Decls;
1945 bool FoundDecl;
1946
1947 public:
1948 typedef EvaluatedExprVisitor<DeclMatcher> Inherited;
1949
1950 DeclMatcher(Sema &S, DeclSetVector &Decls, Stmt *Statement) :
1951 Inherited(S.Context), Decls(Decls), FoundDecl(false) {
1952 if (!Statement) return;
1953
1954 Visit(Statement);
1955 }
1956
1957 void VisitReturnStmt(ReturnStmt *S) {
1958 FoundDecl = true;
1959 }
1960
1961 void VisitBreakStmt(BreakStmt *S) {
1962 FoundDecl = true;
1963 }
1964
1965 void VisitGotoStmt(GotoStmt *S) {
1966 FoundDecl = true;
1967 }
1968
1969 void VisitCastExpr(CastExpr *E) {
1970 if (E->getCastKind() == CK_LValueToRValue)
1971 CheckLValueToRValueCast(E->getSubExpr());
1972 else
1973 Visit(E->getSubExpr());
1974 }
1975
1976 void CheckLValueToRValueCast(Expr *E) {
1977 E = E->IgnoreParenImpCasts();
1978
1979 if (isa<DeclRefExpr>(E)) {
1980 return;
1981 }
1982
1983 if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
1984 Visit(CO->getCond());
1985 CheckLValueToRValueCast(CO->getTrueExpr());
1986 CheckLValueToRValueCast(CO->getFalseExpr());
1987 return;
1988 }
1989
1990 if (BinaryConditionalOperator *BCO =
1991 dyn_cast<BinaryConditionalOperator>(E)) {
1992 CheckLValueToRValueCast(BCO->getOpaqueValue()->getSourceExpr());
1993 CheckLValueToRValueCast(BCO->getFalseExpr());
1994 return;
1995 }
1996
1997 Visit(E);
1998 }
1999
2000 void VisitDeclRefExpr(DeclRefExpr *E) {
2001 if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl()))
2002 if (Decls.count(VD))
2003 FoundDecl = true;
2004 }
2005
2006 void VisitPseudoObjectExpr(PseudoObjectExpr *POE) {
2007 // Only need to visit the semantics for POE.
2008 // SyntaticForm doesn't really use the Decal.
2009 for (auto *S : POE->semantics()) {
2010 if (auto *OVE = dyn_cast<OpaqueValueExpr>(S))
2011 // Look past the OVE into the expression it binds.
2012 Visit(OVE->getSourceExpr());
2013 else
2014 Visit(S);
2015 }
2016 }
2017
2018 bool FoundDeclInUse() { return FoundDecl; }
2019
2020 }; // end class DeclMatcher
2021
2022 void CheckForLoopConditionalStatement(Sema &S, Expr *Second,
2023 Expr *Third, Stmt *Body) {
2024 // Condition is empty
2025 if (!Second) return;
2026
2027 if (S.Diags.isIgnored(diag::warn_variables_not_in_loop_body,
2028 Second->getBeginLoc()))
2029 return;
2030
2031 PartialDiagnostic PDiag = S.PDiag(diag::warn_variables_not_in_loop_body);
2032 DeclSetVector Decls;
2034 DeclExtractor DE(S, Decls, Ranges);
2035 DE.Visit(Second);
2036
2037 // Don't analyze complex conditionals.
2038 if (!DE.isSimple()) return;
2039
2040 // No decls found.
2041 if (Decls.size() == 0) return;
2042
2043 // Don't warn on volatile, static, or global variables.
2044 for (auto *VD : Decls)
2045 if (VD->getType().isVolatileQualified() || VD->hasGlobalStorage())
2046 return;
2047
2048 if (DeclMatcher(S, Decls, Second).FoundDeclInUse() ||
2049 DeclMatcher(S, Decls, Third).FoundDeclInUse() ||
2050 DeclMatcher(S, Decls, Body).FoundDeclInUse())
2051 return;
2052
2053 // Load decl names into diagnostic.
2054 if (Decls.size() > 4) {
2055 PDiag << 0;
2056 } else {
2057 PDiag << (unsigned)Decls.size();
2058 for (auto *VD : Decls)
2059 PDiag << VD->getDeclName();
2060 }
2061
2062 for (auto Range : Ranges)
2063 PDiag << Range;
2064
2065 S.Diag(Ranges.begin()->getBegin(), PDiag);
2066 }
2067
2068 // If Statement is an incemement or decrement, return true and sets the
2069 // variables Increment and DRE.
2070 bool ProcessIterationStmt(Sema &S, Stmt* Statement, bool &Increment,
2071 DeclRefExpr *&DRE) {
2072 if (auto Cleanups = dyn_cast<ExprWithCleanups>(Statement))
2073 if (!Cleanups->cleanupsHaveSideEffects())
2074 Statement = Cleanups->getSubExpr();
2075
2076 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(Statement)) {
2077 switch (UO->getOpcode()) {
2078 default: return false;
2079 case UO_PostInc:
2080 case UO_PreInc:
2081 Increment = true;
2082 break;
2083 case UO_PostDec:
2084 case UO_PreDec:
2085 Increment = false;
2086 break;
2087 }
2088 DRE = dyn_cast<DeclRefExpr>(UO->getSubExpr());
2089 return DRE;
2090 }
2091
2092 if (CXXOperatorCallExpr *Call = dyn_cast<CXXOperatorCallExpr>(Statement)) {
2093 FunctionDecl *FD = Call->getDirectCallee();
2094 if (!FD || !FD->isOverloadedOperator()) return false;
2095 switch (FD->getOverloadedOperator()) {
2096 default: return false;
2097 case OO_PlusPlus:
2098 Increment = true;
2099 break;
2100 case OO_MinusMinus:
2101 Increment = false;
2102 break;
2103 }
2104 DRE = dyn_cast<DeclRefExpr>(Call->getArg(0));
2105 return DRE;
2106 }
2107
2108 return false;
2109 }
2110
2111 // A visitor to determine if a continue or break statement is a
2112 // subexpression.
2113 class BreakContinueFinder : public ConstEvaluatedExprVisitor<BreakContinueFinder> {
2114 SourceLocation BreakLoc;
2115 SourceLocation ContinueLoc;
2116 bool InSwitch = false;
2117
2118 public:
2119 BreakContinueFinder(Sema &S, const Stmt* Body) :
2120 Inherited(S.Context) {
2121 Visit(Body);
2122 }
2123
2125
2126 void VisitContinueStmt(const ContinueStmt* E) {
2127 ContinueLoc = E->getContinueLoc();
2128 }
2129
2130 void VisitBreakStmt(const BreakStmt* E) {
2131 if (!InSwitch)
2132 BreakLoc = E->getBreakLoc();
2133 }
2134
2135 void VisitSwitchStmt(const SwitchStmt* S) {
2136 if (const Stmt *Init = S->getInit())
2137 Visit(Init);
2138 if (const Stmt *CondVar = S->getConditionVariableDeclStmt())
2139 Visit(CondVar);
2140 if (const Stmt *Cond = S->getCond())
2141 Visit(Cond);
2142
2143 // Don't return break statements from the body of a switch.
2144 InSwitch = true;
2145 if (const Stmt *Body = S->getBody())
2146 Visit(Body);
2147 InSwitch = false;
2148 }
2149
2150 void VisitForStmt(const ForStmt *S) {
2151 // Only visit the init statement of a for loop; the body
2152 // has a different break/continue scope.
2153 if (const Stmt *Init = S->getInit())
2154 Visit(Init);
2155 }
2156
2157 void VisitWhileStmt(const WhileStmt *) {
2158 // Do nothing; the children of a while loop have a different
2159 // break/continue scope.
2160 }
2161
2162 void VisitDoStmt(const DoStmt *) {
2163 // Do nothing; the children of a while loop have a different
2164 // break/continue scope.
2165 }
2166
2167 void VisitCXXForRangeStmt(const CXXForRangeStmt *S) {
2168 // Only visit the initialization of a for loop; the body
2169 // has a different break/continue scope.
2170 if (const Stmt *Init = S->getInit())
2171 Visit(Init);
2172 if (const Stmt *Range = S->getRangeStmt())
2173 Visit(Range);
2174 if (const Stmt *Begin = S->getBeginStmt())
2175 Visit(Begin);
2176 if (const Stmt *End = S->getEndStmt())
2177 Visit(End);
2178 }
2179
2180 void VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) {
2181 // Only visit the initialization of a for loop; the body
2182 // has a different break/continue scope.
2183 if (const Stmt *Element = S->getElement())
2184 Visit(Element);
2185 if (const Stmt *Collection = S->getCollection())
2186 Visit(Collection);
2187 }
2188
2189 bool ContinueFound() { return ContinueLoc.isValid(); }
2190 bool BreakFound() { return BreakLoc.isValid(); }
2191 SourceLocation GetContinueLoc() { return ContinueLoc; }
2192 SourceLocation GetBreakLoc() { return BreakLoc; }
2193
2194 }; // end class BreakContinueFinder
2195
2196 // Emit a warning when a loop increment/decrement appears twice per loop
2197 // iteration. The conditions which trigger this warning are:
2198 // 1) The last statement in the loop body and the third expression in the
2199 // for loop are both increment or both decrement of the same variable
2200 // 2) No continue statements in the loop body.
2201 void CheckForRedundantIteration(Sema &S, Expr *Third, Stmt *Body) {
2202 // Return when there is nothing to check.
2203 if (!Body || !Third) return;
2204
2205 if (S.Diags.isIgnored(diag::warn_redundant_loop_iteration,
2206 Third->getBeginLoc()))
2207 return;
2208
2209 // Get the last statement from the loop body.
2210 CompoundStmt *CS = dyn_cast<CompoundStmt>(Body);
2211 if (!CS || CS->body_empty()) return;
2212 Stmt *LastStmt = CS->body_back();
2213 if (!LastStmt) return;
2214
2215 bool LoopIncrement, LastIncrement;
2216 DeclRefExpr *LoopDRE, *LastDRE;
2217
2218 if (!ProcessIterationStmt(S, Third, LoopIncrement, LoopDRE)) return;
2219 if (!ProcessIterationStmt(S, LastStmt, LastIncrement, LastDRE)) return;
2220
2221 // Check that the two statements are both increments or both decrements
2222 // on the same variable.
2223 if (LoopIncrement != LastIncrement ||
2224 LoopDRE->getDecl() != LastDRE->getDecl()) return;
2225
2226 if (BreakContinueFinder(S, Body).ContinueFound()) return;
2227
2228 S.Diag(LastDRE->getLocation(), diag::warn_redundant_loop_iteration)
2229 << LastDRE->getDecl() << LastIncrement;
2230 S.Diag(LoopDRE->getLocation(), diag::note_loop_iteration_here)
2231 << LoopIncrement;
2232 }
2233
2234} // end namespace
2235
2236
2237void Sema::CheckBreakContinueBinding(Expr *E) {
2238 if (!E || getLangOpts().CPlusPlus)
2239 return;
2240 BreakContinueFinder BCFinder(*this, E);
2241 Scope *BreakParent = CurScope->getBreakParent();
2242 if (BCFinder.BreakFound() && BreakParent) {
2243 if (BreakParent->getFlags() & Scope::SwitchScope) {
2244 Diag(BCFinder.GetBreakLoc(), diag::warn_break_binds_to_switch);
2245 } else {
2246 Diag(BCFinder.GetBreakLoc(), diag::warn_loop_ctrl_binds_to_inner)
2247 << "break";
2248 }
2249 } else if (BCFinder.ContinueFound() && CurScope->getContinueParent()) {
2250 Diag(BCFinder.GetContinueLoc(), diag::warn_loop_ctrl_binds_to_inner)
2251 << "continue";
2252 }
2253}
2254
2256 Stmt *First, ConditionResult Second,
2257 FullExprArg third, SourceLocation RParenLoc,
2258 Stmt *Body) {
2259 if (Second.isInvalid())
2260 return StmtError();
2261
2262 if (!getLangOpts().CPlusPlus) {
2263 if (DeclStmt *DS = dyn_cast_or_null<DeclStmt>(First)) {
2264 // C99 6.8.5p3: The declaration part of a 'for' statement shall only
2265 // declare identifiers for objects having storage class 'auto' or
2266 // 'register'.
2267 const Decl *NonVarSeen = nullptr;
2268 bool VarDeclSeen = false;
2269 for (auto *DI : DS->decls()) {
2270 if (VarDecl *VD = dyn_cast<VarDecl>(DI)) {
2271 VarDeclSeen = true;
2272 if (VD->isLocalVarDecl() && !VD->hasLocalStorage()) {
2273 Diag(DI->getLocation(), diag::err_non_local_variable_decl_in_for);
2274 DI->setInvalidDecl();
2275 }
2276 } else if (!NonVarSeen) {
2277 // Keep track of the first non-variable declaration we saw so that
2278 // we can diagnose if we don't see any variable declarations. This
2279 // covers a case like declaring a typedef, function, or structure
2280 // type rather than a variable.
2281 NonVarSeen = DI;
2282 }
2283 }
2284 // Diagnose if we saw a non-variable declaration but no variable
2285 // declarations.
2286 if (NonVarSeen && !VarDeclSeen)
2287 Diag(NonVarSeen->getLocation(), diag::err_non_variable_decl_in_for);
2288 }
2289 }
2290
2291 CheckBreakContinueBinding(Second.get().second);
2292 CheckBreakContinueBinding(third.get());
2293
2294 if (!Second.get().first)
2295 CheckForLoopConditionalStatement(*this, Second.get().second, third.get(),
2296 Body);
2297 CheckForRedundantIteration(*this, third.get(), Body);
2298
2299 if (Second.get().second &&
2300 !Diags.isIgnored(diag::warn_comma_operator,
2301 Second.get().second->getExprLoc()))
2302 CommaVisitor(*this).Visit(Second.get().second);
2303
2304 Expr *Third = third.release().getAs<Expr>();
2305 if (isa<NullStmt>(Body))
2307
2308 return new (Context)
2309 ForStmt(Context, First, Second.get().second, Second.get().first, Third,
2310 Body, ForLoc, LParenLoc, RParenLoc);
2311}
2312
2314 // Reduce placeholder expressions here. Note that this rejects the
2315 // use of pseudo-object l-values in this position.
2317 if (result.isInvalid()) return StmtError();
2318 E = result.get();
2319
2320 ExprResult FullExpr = ActOnFinishFullExpr(E, /*DiscardedValue*/ false);
2321 if (FullExpr.isInvalid())
2322 return StmtError();
2323 return StmtResult(static_cast<Stmt*>(FullExpr.get()));
2324}
2325
2326/// Finish building a variable declaration for a for-range statement.
2327/// \return true if an error occurs.
2329 SourceLocation Loc, int DiagID) {
2330 if (Decl->getType()->isUndeducedType()) {
2332 if (!Res.isUsable()) {
2334 return true;
2335 }
2336 Init = Res.get();
2337 }
2338
2339 // Deduce the type for the iterator variable now rather than leaving it to
2340 // AddInitializerToDecl, so we can produce a more suitable diagnostic.
2341 QualType InitType;
2342 if (!isa<InitListExpr>(Init) && Init->getType()->isVoidType()) {
2343 SemaRef.Diag(Loc, DiagID) << Init->getType();
2344 } else {
2345 TemplateDeductionInfo Info(Init->getExprLoc());
2347 Decl->getTypeSourceInfo()->getTypeLoc(), Init, InitType, Info);
2350 SemaRef.Diag(Loc, DiagID) << Init->getType();
2351 }
2352
2353 if (InitType.isNull()) {
2355 return true;
2356 }
2357 Decl->setType(InitType);
2358
2359 // In ARC, infer lifetime.
2360 // FIXME: ARC may want to turn this into 'const __unsafe_unretained' if
2361 // we're doing the equivalent of fast iteration.
2362 if (SemaRef.getLangOpts().ObjCAutoRefCount &&
2363 SemaRef.ObjC().inferObjCARCLifetime(Decl))
2365
2366 SemaRef.AddInitializerToDecl(Decl, Init, /*DirectInit=*/false);
2367 SemaRef.FinalizeDeclaration(Decl);
2368 SemaRef.CurContext->addHiddenDecl(Decl);
2369 return false;
2370}
2371
2372namespace {
2373// An enum to represent whether something is dealing with a call to begin()
2374// or a call to end() in a range-based for loop.
2375enum BeginEndFunction {
2376 BEF_begin,
2377 BEF_end
2378};
2379
2380/// Produce a note indicating which begin/end function was implicitly called
2381/// by a C++11 for-range statement. This is often not obvious from the code,
2382/// nor from the diagnostics produced when analysing the implicit expressions
2383/// required in a for-range statement.
2384void NoteForRangeBeginEndFunction(Sema &SemaRef, Expr *E,
2385 BeginEndFunction BEF) {
2386 CallExpr *CE = dyn_cast<CallExpr>(E);
2387 if (!CE)
2388 return;
2389 FunctionDecl *D = dyn_cast<FunctionDecl>(CE->getCalleeDecl());
2390 if (!D)
2391 return;
2393
2394 std::string Description;
2395 bool IsTemplate = false;
2396 if (FunctionTemplateDecl *FunTmpl = D->getPrimaryTemplate()) {
2397 Description = SemaRef.getTemplateArgumentBindingsText(
2398 FunTmpl->getTemplateParameters(), *D->getTemplateSpecializationArgs());
2399 IsTemplate = true;
2400 }
2401
2402 SemaRef.Diag(Loc, diag::note_for_range_begin_end)
2403 << BEF << IsTemplate << Description << E->getType();
2404}
2405
2406/// Build a variable declaration for a for-range statement.
2407VarDecl *BuildForRangeVarDecl(Sema &SemaRef, SourceLocation Loc,
2408 QualType Type, StringRef Name) {
2409 DeclContext *DC = SemaRef.CurContext;
2410 IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
2412 VarDecl *Decl = VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type,
2413 TInfo, SC_None);
2414 Decl->setImplicit();
2415 return Decl;
2416}
2417
2418}
2419
2420static bool ObjCEnumerationCollection(Expr *Collection) {
2421 return !Collection->isTypeDependent()
2422 && Collection->getType()->getAs<ObjCObjectPointerType>() != nullptr;
2423}
2424
2426 Scope *S, SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *InitStmt,
2427 Stmt *First, SourceLocation ColonLoc, Expr *Range, SourceLocation RParenLoc,
2428 BuildForRangeKind Kind,
2429 ArrayRef<MaterializeTemporaryExpr *> LifetimeExtendTemps) {
2430 // FIXME: recover in order to allow the body to be parsed.
2431 if (!First)
2432 return StmtError();
2433
2435 // FIXME: Support init-statements in Objective-C++20 ranged for statement.
2436 if (InitStmt)
2437 return Diag(InitStmt->getBeginLoc(), diag::err_objc_for_range_init_stmt)
2438 << InitStmt->getSourceRange();
2439 return ObjC().ActOnObjCForCollectionStmt(ForLoc, First, Range, RParenLoc);
2440 }
2441
2442 DeclStmt *DS = dyn_cast<DeclStmt>(First);
2443 assert(DS && "first part of for range not a decl stmt");
2444
2445 if (!DS->isSingleDecl()) {
2446 Diag(DS->getBeginLoc(), diag::err_type_defined_in_for_range);
2447 return StmtError();
2448 }
2449
2450 // This function is responsible for attaching an initializer to LoopVar. We
2451 // must call ActOnInitializerError if we fail to do so.
2452 Decl *LoopVar = DS->getSingleDecl();
2453 if (LoopVar->isInvalidDecl() || !Range ||
2455 ActOnInitializerError(LoopVar);
2456 return StmtError();
2457 }
2458
2459 // Build the coroutine state immediately and not later during template
2460 // instantiation
2461 if (!CoawaitLoc.isInvalid()) {
2462 if (!ActOnCoroutineBodyStart(S, CoawaitLoc, "co_await")) {
2463 ActOnInitializerError(LoopVar);
2464 return StmtError();
2465 }
2466 }
2467
2468 // Build auto && __range = range-init
2469 // Divide by 2, since the variables are in the inner scope (loop body).
2470 const auto DepthStr = std::to_string(S->getDepth() / 2);
2471 SourceLocation RangeLoc = Range->getBeginLoc();
2472 VarDecl *RangeVar = BuildForRangeVarDecl(*this, RangeLoc,
2474 std::string("__range") + DepthStr);
2475 if (FinishForRangeVarDecl(*this, RangeVar, Range, RangeLoc,
2476 diag::err_for_range_deduction_failure)) {
2477 ActOnInitializerError(LoopVar);
2478 return StmtError();
2479 }
2480
2481 // Claim the type doesn't contain auto: we've already done the checking.
2482 DeclGroupPtrTy RangeGroup =
2484 StmtResult RangeDecl = ActOnDeclStmt(RangeGroup, RangeLoc, RangeLoc);
2485 if (RangeDecl.isInvalid()) {
2486 ActOnInitializerError(LoopVar);
2487 return StmtError();
2488 }
2489
2491 ForLoc, CoawaitLoc, InitStmt, ColonLoc, RangeDecl.get(),
2492 /*BeginStmt=*/nullptr, /*EndStmt=*/nullptr,
2493 /*Cond=*/nullptr, /*Inc=*/nullptr, DS, RParenLoc, Kind,
2494 LifetimeExtendTemps);
2495 if (R.isInvalid()) {
2496 ActOnInitializerError(LoopVar);
2497 return StmtError();
2498 }
2499
2500 return R;
2501}
2502
2503/// Create the initialization, compare, and increment steps for
2504/// the range-based for loop expression.
2505/// This function does not handle array-based for loops,
2506/// which are created in Sema::BuildCXXForRangeStmt.
2507///
2508/// \returns a ForRangeStatus indicating success or what kind of error occurred.
2509/// BeginExpr and EndExpr are set and FRS_Success is returned on success;
2510/// CandidateSet and BEF are set and some non-success value is returned on
2511/// failure.
2513BuildNonArrayForRange(Sema &SemaRef, Expr *BeginRange, Expr *EndRange,
2514 QualType RangeType, VarDecl *BeginVar, VarDecl *EndVar,
2515 SourceLocation ColonLoc, SourceLocation CoawaitLoc,
2516 OverloadCandidateSet *CandidateSet, ExprResult *BeginExpr,
2517 ExprResult *EndExpr, BeginEndFunction *BEF) {
2518 DeclarationNameInfo BeginNameInfo(
2519 &SemaRef.PP.getIdentifierTable().get("begin"), ColonLoc);
2520 DeclarationNameInfo EndNameInfo(&SemaRef.PP.getIdentifierTable().get("end"),
2521 ColonLoc);
2522
2523 LookupResult BeginMemberLookup(SemaRef, BeginNameInfo,
2525 LookupResult EndMemberLookup(SemaRef, EndNameInfo, Sema::LookupMemberName);
2526
2527 auto BuildBegin = [&] {
2528 *BEF = BEF_begin;
2529 Sema::ForRangeStatus RangeStatus =
2530 SemaRef.BuildForRangeBeginEndCall(ColonLoc, ColonLoc, BeginNameInfo,
2531 BeginMemberLookup, CandidateSet,
2532 BeginRange, BeginExpr);
2533
2534 if (RangeStatus != Sema::FRS_Success) {
2535 if (RangeStatus == Sema::FRS_DiagnosticIssued)
2536 SemaRef.Diag(BeginRange->getBeginLoc(), diag::note_in_for_range)
2537 << ColonLoc << BEF_begin << BeginRange->getType();
2538 return RangeStatus;
2539 }
2540 if (!CoawaitLoc.isInvalid()) {
2541 // FIXME: getCurScope() should not be used during template instantiation.
2542 // We should pick up the set of unqualified lookup results for operator
2543 // co_await during the initial parse.
2544 *BeginExpr = SemaRef.ActOnCoawaitExpr(SemaRef.getCurScope(), ColonLoc,
2545 BeginExpr->get());
2546 if (BeginExpr->isInvalid())
2548 }
2549 if (FinishForRangeVarDecl(SemaRef, BeginVar, BeginExpr->get(), ColonLoc,
2550 diag::err_for_range_iter_deduction_failure)) {
2551 NoteForRangeBeginEndFunction(SemaRef, BeginExpr->get(), *BEF);
2553 }
2554 return Sema::FRS_Success;
2555 };
2556
2557 auto BuildEnd = [&] {
2558 *BEF = BEF_end;
2559 Sema::ForRangeStatus RangeStatus =
2560 SemaRef.BuildForRangeBeginEndCall(ColonLoc, ColonLoc, EndNameInfo,
2561 EndMemberLookup, CandidateSet,
2562 EndRange, EndExpr);
2563 if (RangeStatus != Sema::FRS_Success) {
2564 if (RangeStatus == Sema::FRS_DiagnosticIssued)
2565 SemaRef.Diag(EndRange->getBeginLoc(), diag::note_in_for_range)
2566 << ColonLoc << BEF_end << EndRange->getType();
2567 return RangeStatus;
2568 }
2569 if (FinishForRangeVarDecl(SemaRef, EndVar, EndExpr->get(), ColonLoc,
2570 diag::err_for_range_iter_deduction_failure)) {
2571 NoteForRangeBeginEndFunction(SemaRef, EndExpr->get(), *BEF);
2573 }
2574 return Sema::FRS_Success;
2575 };
2576
2577 if (CXXRecordDecl *D = RangeType->getAsCXXRecordDecl()) {
2578 // - if _RangeT is a class type, the unqualified-ids begin and end are
2579 // looked up in the scope of class _RangeT as if by class member access
2580 // lookup (3.4.5), and if either (or both) finds at least one
2581 // declaration, begin-expr and end-expr are __range.begin() and
2582 // __range.end(), respectively;
2583 SemaRef.LookupQualifiedName(BeginMemberLookup, D);
2584 if (BeginMemberLookup.isAmbiguous())
2586
2587 SemaRef.LookupQualifiedName(EndMemberLookup, D);
2588 if (EndMemberLookup.isAmbiguous())
2590
2591 if (BeginMemberLookup.empty() != EndMemberLookup.empty()) {
2592 // Look up the non-member form of the member we didn't find, first.
2593 // This way we prefer a "no viable 'end'" diagnostic over a "i found
2594 // a 'begin' but ignored it because there was no member 'end'"
2595 // diagnostic.
2596 auto BuildNonmember = [&](
2597 BeginEndFunction BEFFound, LookupResult &Found,
2598 llvm::function_ref<Sema::ForRangeStatus()> BuildFound,
2599 llvm::function_ref<Sema::ForRangeStatus()> BuildNotFound) {
2600 LookupResult OldFound = std::move(Found);
2601 Found.clear();
2602
2603 if (Sema::ForRangeStatus Result = BuildNotFound())
2604 return Result;
2605
2606 switch (BuildFound()) {
2607 case Sema::FRS_Success:
2608 return Sema::FRS_Success;
2609
2611 CandidateSet->NoteCandidates(
2612 PartialDiagnosticAt(BeginRange->getBeginLoc(),
2613 SemaRef.PDiag(diag::err_for_range_invalid)
2614 << BeginRange->getType() << BEFFound),
2615 SemaRef, OCD_AllCandidates, BeginRange);
2616 [[fallthrough]];
2617
2619 for (NamedDecl *D : OldFound) {
2620 SemaRef.Diag(D->getLocation(),
2621 diag::note_for_range_member_begin_end_ignored)
2622 << BeginRange->getType() << BEFFound;
2623 }
2625 }
2626 llvm_unreachable("unexpected ForRangeStatus");
2627 };
2628 if (BeginMemberLookup.empty())
2629 return BuildNonmember(BEF_end, EndMemberLookup, BuildEnd, BuildBegin);
2630 return BuildNonmember(BEF_begin, BeginMemberLookup, BuildBegin, BuildEnd);
2631 }
2632 } else {
2633 // - otherwise, begin-expr and end-expr are begin(__range) and
2634 // end(__range), respectively, where begin and end are looked up with
2635 // argument-dependent lookup (3.4.2). For the purposes of this name
2636 // lookup, namespace std is an associated namespace.
2637 }
2638
2639 if (Sema::ForRangeStatus Result = BuildBegin())
2640 return Result;
2641 return BuildEnd();
2642}
2643
2644/// Speculatively attempt to dereference an invalid range expression.
2645/// If the attempt fails, this function will return a valid, null StmtResult
2646/// and emit no diagnostics.
2648 SourceLocation ForLoc,
2649 SourceLocation CoawaitLoc,
2650 Stmt *InitStmt,
2651 Stmt *LoopVarDecl,
2652 SourceLocation ColonLoc,
2653 Expr *Range,
2654 SourceLocation RangeLoc,
2655 SourceLocation RParenLoc) {
2656 // Determine whether we can rebuild the for-range statement with a
2657 // dereferenced range expression.
2658 ExprResult AdjustedRange;
2659 {
2660 Sema::SFINAETrap Trap(SemaRef);
2661
2662 AdjustedRange = SemaRef.BuildUnaryOp(S, RangeLoc, UO_Deref, Range);
2663 if (AdjustedRange.isInvalid())
2664 return StmtResult();
2665
2666 StmtResult SR = SemaRef.ActOnCXXForRangeStmt(
2667 S, ForLoc, CoawaitLoc, InitStmt, LoopVarDecl, ColonLoc,
2668 AdjustedRange.get(), RParenLoc, Sema::BFRK_Check);
2669 if (SR.isInvalid())
2670 return StmtResult();
2671 }
2672
2673 // The attempt to dereference worked well enough that it could produce a valid
2674 // loop. Produce a fixit, and rebuild the loop with diagnostics enabled, in
2675 // case there are any other (non-fatal) problems with it.
2676 SemaRef.Diag(RangeLoc, diag::err_for_range_dereference)
2677 << Range->getType() << FixItHint::CreateInsertion(RangeLoc, "*");
2678 return SemaRef.ActOnCXXForRangeStmt(
2679 S, ForLoc, CoawaitLoc, InitStmt, LoopVarDecl, ColonLoc,
2680 AdjustedRange.get(), RParenLoc, Sema::BFRK_Rebuild);
2681}
2682
2684 SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *InitStmt,
2685 SourceLocation ColonLoc, Stmt *RangeDecl, Stmt *Begin, Stmt *End,
2686 Expr *Cond, Expr *Inc, Stmt *LoopVarDecl, SourceLocation RParenLoc,
2687 BuildForRangeKind Kind,
2688 ArrayRef<MaterializeTemporaryExpr *> LifetimeExtendTemps) {
2689 // FIXME: This should not be used during template instantiation. We should
2690 // pick up the set of unqualified lookup results for the != and + operators
2691 // in the initial parse.
2692 //
2693 // Testcase (accepts-invalid):
2694 // template<typename T> void f() { for (auto x : T()) {} }
2695 // namespace N { struct X { X begin(); X end(); int operator*(); }; }
2696 // bool operator!=(N::X, N::X); void operator++(N::X);
2697 // void g() { f<N::X>(); }
2698 Scope *S = getCurScope();
2699
2700 DeclStmt *RangeDS = cast<DeclStmt>(RangeDecl);
2701 VarDecl *RangeVar = cast<VarDecl>(RangeDS->getSingleDecl());
2702 QualType RangeVarType = RangeVar->getType();
2703
2704 DeclStmt *LoopVarDS = cast<DeclStmt>(LoopVarDecl);
2705 VarDecl *LoopVar = cast<VarDecl>(LoopVarDS->getSingleDecl());
2706
2707 StmtResult BeginDeclStmt = Begin;
2708 StmtResult EndDeclStmt = End;
2709 ExprResult NotEqExpr = Cond, IncrExpr = Inc;
2710
2711 if (RangeVarType->isDependentType()) {
2712 // The range is implicitly used as a placeholder when it is dependent.
2713 RangeVar->markUsed(Context);
2714
2715 // Deduce any 'auto's in the loop variable as 'DependentTy'. We'll fill
2716 // them in properly when we instantiate the loop.
2717 if (!LoopVar->isInvalidDecl() && Kind != BFRK_Check) {
2718 if (auto *DD = dyn_cast<DecompositionDecl>(LoopVar))
2719 for (auto *Binding : DD->bindings())
2720 Binding->setType(Context.DependentTy);
2721 LoopVar->setType(SubstAutoTypeDependent(LoopVar->getType()));
2722 }
2723 } else if (!BeginDeclStmt.get()) {
2724 SourceLocation RangeLoc = RangeVar->getLocation();
2725
2726 const QualType RangeVarNonRefType = RangeVarType.getNonReferenceType();
2727
2728 ExprResult BeginRangeRef = BuildDeclRefExpr(RangeVar, RangeVarNonRefType,
2729 VK_LValue, ColonLoc);
2730 if (BeginRangeRef.isInvalid())
2731 return StmtError();
2732
2733 ExprResult EndRangeRef = BuildDeclRefExpr(RangeVar, RangeVarNonRefType,
2734 VK_LValue, ColonLoc);
2735 if (EndRangeRef.isInvalid())
2736 return StmtError();
2737
2739 Expr *Range = RangeVar->getInit();
2740 if (!Range)
2741 return StmtError();
2742 QualType RangeType = Range->getType();
2743
2744 if (RequireCompleteType(RangeLoc, RangeType,
2745 diag::err_for_range_incomplete_type))
2746 return StmtError();
2747
2748 // P2718R0 - Lifetime extension in range-based for loops.
2749 if (getLangOpts().CPlusPlus23 && !LifetimeExtendTemps.empty()) {
2750 InitializedEntity Entity =
2752 for (auto *MTE : LifetimeExtendTemps)
2753 MTE->setExtendingDecl(RangeVar, Entity.allocateManglingNumber());
2754 }
2755
2756 // Build auto __begin = begin-expr, __end = end-expr.
2757 // Divide by 2, since the variables are in the inner scope (loop body).
2758 const auto DepthStr = std::to_string(S->getDepth() / 2);
2759 VarDecl *BeginVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
2760 std::string("__begin") + DepthStr);
2761 VarDecl *EndVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
2762 std::string("__end") + DepthStr);
2763
2764 // Build begin-expr and end-expr and attach to __begin and __end variables.
2765 ExprResult BeginExpr, EndExpr;
2766 if (const ArrayType *UnqAT = RangeType->getAsArrayTypeUnsafe()) {
2767 // - if _RangeT is an array type, begin-expr and end-expr are __range and
2768 // __range + __bound, respectively, where __bound is the array bound. If
2769 // _RangeT is an array of unknown size or an array of incomplete type,
2770 // the program is ill-formed;
2771
2772 // begin-expr is __range.
2773 BeginExpr = BeginRangeRef;
2774 if (!CoawaitLoc.isInvalid()) {
2775 BeginExpr = ActOnCoawaitExpr(S, ColonLoc, BeginExpr.get());
2776 if (BeginExpr.isInvalid())
2777 return StmtError();
2778 }
2779 if (FinishForRangeVarDecl(*this, BeginVar, BeginRangeRef.get(), ColonLoc,
2780 diag::err_for_range_iter_deduction_failure)) {
2781 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
2782 return StmtError();
2783 }
2784
2785 // Find the array bound.
2786 ExprResult BoundExpr;
2787 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(UnqAT))
2788 BoundExpr = IntegerLiteral::Create(
2789 Context, CAT->getSize(), Context.getPointerDiffType(), RangeLoc);
2790 else if (const VariableArrayType *VAT =
2791 dyn_cast<VariableArrayType>(UnqAT)) {
2792 // For a variably modified type we can't just use the expression within
2793 // the array bounds, since we don't want that to be re-evaluated here.
2794 // Rather, we need to determine what it was when the array was first
2795 // created - so we resort to using sizeof(vla)/sizeof(element).
2796 // For e.g.
2797 // void f(int b) {
2798 // int vla[b];
2799 // b = -1; <-- This should not affect the num of iterations below
2800 // for (int &c : vla) { .. }
2801 // }
2802
2803 // FIXME: This results in codegen generating IR that recalculates the
2804 // run-time number of elements (as opposed to just using the IR Value
2805 // that corresponds to the run-time value of each bound that was
2806 // generated when the array was created.) If this proves too embarrassing
2807 // even for unoptimized IR, consider passing a magic-value/cookie to
2808 // codegen that then knows to simply use that initial llvm::Value (that
2809 // corresponds to the bound at time of array creation) within
2810 // getelementptr. But be prepared to pay the price of increasing a
2811 // customized form of coupling between the two components - which could
2812 // be hard to maintain as the codebase evolves.
2813
2815 EndVar->getLocation(), UETT_SizeOf,
2816 /*IsType=*/true,
2818 VAT->desugar(), RangeLoc))
2819 .getAsOpaquePtr(),
2820 EndVar->getSourceRange());
2821 if (SizeOfVLAExprR.isInvalid())
2822 return StmtError();
2823
2824 ExprResult SizeOfEachElementExprR = ActOnUnaryExprOrTypeTraitExpr(
2825 EndVar->getLocation(), UETT_SizeOf,
2826 /*IsType=*/true,
2827 CreateParsedType(VAT->desugar(),
2829 VAT->getElementType(), RangeLoc))
2830 .getAsOpaquePtr(),
2831 EndVar->getSourceRange());
2832 if (SizeOfEachElementExprR.isInvalid())
2833 return StmtError();
2834
2835 BoundExpr =
2836 ActOnBinOp(S, EndVar->getLocation(), tok::slash,
2837 SizeOfVLAExprR.get(), SizeOfEachElementExprR.get());
2838 if (BoundExpr.isInvalid())
2839 return StmtError();
2840
2841 } else {
2842 // Can't be a DependentSizedArrayType or an IncompleteArrayType since
2843 // UnqAT is not incomplete and Range is not type-dependent.
2844 llvm_unreachable("Unexpected array type in for-range");
2845 }
2846
2847 // end-expr is __range + __bound.
2848 EndExpr = ActOnBinOp(S, ColonLoc, tok::plus, EndRangeRef.get(),
2849 BoundExpr.get());
2850 if (EndExpr.isInvalid())
2851 return StmtError();
2852 if (FinishForRangeVarDecl(*this, EndVar, EndExpr.get(), ColonLoc,
2853 diag::err_for_range_iter_deduction_failure)) {
2854 NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
2855 return StmtError();
2856 }
2857 } else {
2858 OverloadCandidateSet CandidateSet(RangeLoc,
2860 BeginEndFunction BEFFailure;
2862 *this, BeginRangeRef.get(), EndRangeRef.get(), RangeType, BeginVar,
2863 EndVar, ColonLoc, CoawaitLoc, &CandidateSet, &BeginExpr, &EndExpr,
2864 &BEFFailure);
2865
2866 if (Kind == BFRK_Build && RangeStatus == FRS_NoViableFunction &&
2867 BEFFailure == BEF_begin) {
2868 // If the range is being built from an array parameter, emit a
2869 // a diagnostic that it is being treated as a pointer.
2870 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Range)) {
2871 if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {
2872 QualType ArrayTy = PVD->getOriginalType();
2873 QualType PointerTy = PVD->getType();
2874 if (PointerTy->isPointerType() && ArrayTy->isArrayType()) {
2875 Diag(Range->getBeginLoc(), diag::err_range_on_array_parameter)
2876 << RangeLoc << PVD << ArrayTy << PointerTy;
2877 Diag(PVD->getLocation(), diag::note_declared_at);
2878 return StmtError();
2879 }
2880 }
2881 }
2882
2883 // If building the range failed, try dereferencing the range expression
2884 // unless a diagnostic was issued or the end function is problematic.
2885 StmtResult SR = RebuildForRangeWithDereference(*this, S, ForLoc,
2886 CoawaitLoc, InitStmt,
2887 LoopVarDecl, ColonLoc,
2888 Range, RangeLoc,
2889 RParenLoc);
2890 if (SR.isInvalid() || SR.isUsable())
2891 return SR;
2892 }
2893
2894 // Otherwise, emit diagnostics if we haven't already.
2895 if (RangeStatus == FRS_NoViableFunction) {
2896 Expr *Range = BEFFailure ? EndRangeRef.get() : BeginRangeRef.get();
2897 CandidateSet.NoteCandidates(
2898 PartialDiagnosticAt(Range->getBeginLoc(),
2899 PDiag(diag::err_for_range_invalid)
2900 << RangeLoc << Range->getType()
2901 << BEFFailure),
2902 *this, OCD_AllCandidates, Range);
2903 }
2904 // Return an error if no fix was discovered.
2905 if (RangeStatus != FRS_Success)
2906 return StmtError();
2907 }
2908
2909 assert(!BeginExpr.isInvalid() && !EndExpr.isInvalid() &&
2910 "invalid range expression in for loop");
2911
2912 // C++11 [dcl.spec.auto]p7: BeginType and EndType must be the same.
2913 // C++1z removes this restriction.
2914 QualType BeginType = BeginVar->getType(), EndType = EndVar->getType();
2915 if (!Context.hasSameType(BeginType, EndType)) {
2916 Diag(RangeLoc, getLangOpts().CPlusPlus17
2917 ? diag::warn_for_range_begin_end_types_differ
2918 : diag::ext_for_range_begin_end_types_differ)
2919 << BeginType << EndType;
2920 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
2921 NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
2922 }
2923
2924 BeginDeclStmt =
2925 ActOnDeclStmt(ConvertDeclToDeclGroup(BeginVar), ColonLoc, ColonLoc);
2926 EndDeclStmt =
2927 ActOnDeclStmt(ConvertDeclToDeclGroup(EndVar), ColonLoc, ColonLoc);
2928
2929 const QualType BeginRefNonRefType = BeginType.getNonReferenceType();
2930 ExprResult BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType,
2931 VK_LValue, ColonLoc);
2932 if (BeginRef.isInvalid())
2933 return StmtError();
2934
2935 ExprResult EndRef = BuildDeclRefExpr(EndVar, EndType.getNonReferenceType(),
2936 VK_LValue, ColonLoc);
2937 if (EndRef.isInvalid())
2938 return StmtError();
2939
2940 // Build and check __begin != __end expression.
2941 NotEqExpr = ActOnBinOp(S, ColonLoc, tok::exclaimequal,
2942 BeginRef.get(), EndRef.get());
2943 if (!NotEqExpr.isInvalid())
2944 NotEqExpr = CheckBooleanCondition(ColonLoc, NotEqExpr.get());
2945 if (!NotEqExpr.isInvalid())
2946 NotEqExpr =
2947 ActOnFinishFullExpr(NotEqExpr.get(), /*DiscardedValue*/ false);
2948 if (NotEqExpr.isInvalid()) {
2949 Diag(RangeLoc, diag::note_for_range_invalid_iterator)
2950 << RangeLoc << 0 << BeginRangeRef.get()->getType();
2951 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
2952 if (!Context.hasSameType(BeginType, EndType))
2953 NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
2954 return StmtError();
2955 }
2956
2957 // Build and check ++__begin expression.
2958 BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType,
2959 VK_LValue, ColonLoc);
2960 if (BeginRef.isInvalid())
2961 return StmtError();
2962
2963 IncrExpr = ActOnUnaryOp(S, ColonLoc, tok::plusplus, BeginRef.get());
2964 if (!IncrExpr.isInvalid() && CoawaitLoc.isValid())
2965 // FIXME: getCurScope() should not be used during template instantiation.
2966 // We should pick up the set of unqualified lookup results for operator
2967 // co_await during the initial parse.
2968 IncrExpr = ActOnCoawaitExpr(S, CoawaitLoc, IncrExpr.get());
2969 if (!IncrExpr.isInvalid())
2970 IncrExpr = ActOnFinishFullExpr(IncrExpr.get(), /*DiscardedValue*/ false);
2971 if (IncrExpr.isInvalid()) {
2972 Diag(RangeLoc, diag::note_for_range_invalid_iterator)
2973 << RangeLoc << 2 << BeginRangeRef.get()->getType() ;
2974 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
2975 return StmtError();
2976 }
2977
2978 // Build and check *__begin expression.
2979 BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType,
2980 VK_LValue, ColonLoc);
2981 if (BeginRef.isInvalid())
2982 return StmtError();
2983
2984 ExprResult DerefExpr = ActOnUnaryOp(S, ColonLoc, tok::star, BeginRef.get());
2985 if (DerefExpr.isInvalid()) {
2986 Diag(RangeLoc, diag::note_for_range_invalid_iterator)
2987 << RangeLoc << 1 << BeginRangeRef.get()->getType();
2988 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
2989 return StmtError();
2990 }
2991
2992 // Attach *__begin as initializer for VD. Don't touch it if we're just
2993 // trying to determine whether this would be a valid range.
2994 if (!LoopVar->isInvalidDecl() && Kind != BFRK_Check) {
2995 AddInitializerToDecl(LoopVar, DerefExpr.get(), /*DirectInit=*/false);
2996 if (LoopVar->isInvalidDecl() ||
2997 (LoopVar->getInit() && LoopVar->getInit()->containsErrors()))
2998 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
2999 }
3000 }
3001
3002 // Don't bother to actually allocate the result if we're just trying to
3003 // determine whether it would be valid.
3004 if (Kind == BFRK_Check)
3005 return StmtResult();
3006
3007 // In OpenMP loop region loop control variable must be private. Perform
3008 // analysis of first part (if any).
3009 if (getLangOpts().OpenMP >= 50 && BeginDeclStmt.isUsable())
3010 OpenMP().ActOnOpenMPLoopInitialization(ForLoc, BeginDeclStmt.get());
3011
3012 return new (Context) CXXForRangeStmt(
3013 InitStmt, RangeDS, cast_or_null<DeclStmt>(BeginDeclStmt.get()),
3014 cast_or_null<DeclStmt>(EndDeclStmt.get()), NotEqExpr.get(),
3015 IncrExpr.get(), LoopVarDS, /*Body=*/nullptr, ForLoc, CoawaitLoc,
3016 ColonLoc, RParenLoc);
3017}
3018
3019// Warn when the loop variable is a const reference that creates a copy.
3020// Suggest using the non-reference type for copies. If a copy can be prevented
3021// suggest the const reference type that would do so.
3022// For instance, given "for (const &Foo : Range)", suggest
3023// "for (const Foo : Range)" to denote a copy is made for the loop. If
3024// possible, also suggest "for (const &Bar : Range)" if this type prevents
3025// the copy altogether.
3027 const VarDecl *VD,
3028 QualType RangeInitType) {
3029 const Expr *InitExpr = VD->getInit();
3030 if (!InitExpr)
3031 return;
3032
3033 QualType VariableType = VD->getType();
3034
3035 if (auto Cleanups = dyn_cast<ExprWithCleanups>(InitExpr))
3036 if (!Cleanups->cleanupsHaveSideEffects())
3037 InitExpr = Cleanups->getSubExpr();
3038
3039 const MaterializeTemporaryExpr *MTE =
3040 dyn_cast<MaterializeTemporaryExpr>(InitExpr);
3041
3042 // No copy made.
3043 if (!MTE)
3044 return;
3045
3046 const Expr *E = MTE->getSubExpr()->IgnoreImpCasts();
3047
3048 // Searching for either UnaryOperator for dereference of a pointer or
3049 // CXXOperatorCallExpr for handling iterators.
3050 while (!isa<CXXOperatorCallExpr>(E) && !isa<UnaryOperator>(E)) {
3051 if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(E)) {
3052 E = CCE->getArg(0);
3053 } else if (const CXXMemberCallExpr *Call = dyn_cast<CXXMemberCallExpr>(E)) {
3054 const MemberExpr *ME = cast<MemberExpr>(Call->getCallee());
3055 E = ME->getBase();
3056 } else {
3057 const MaterializeTemporaryExpr *MTE = cast<MaterializeTemporaryExpr>(E);
3058 E = MTE->getSubExpr();
3059 }
3060 E = E->IgnoreImpCasts();
3061 }
3062
3063 QualType ReferenceReturnType;
3064 if (isa<UnaryOperator>(E)) {
3065 ReferenceReturnType = SemaRef.Context.getLValueReferenceType(E->getType());
3066 } else {
3067 const CXXOperatorCallExpr *Call = cast<CXXOperatorCallExpr>(E);
3068 const FunctionDecl *FD = Call->getDirectCallee();
3069 QualType ReturnType = FD->getReturnType();
3070 if (ReturnType->isReferenceType())
3071 ReferenceReturnType = ReturnType;
3072 }
3073
3074 if (!ReferenceReturnType.isNull()) {
3075 // Loop variable creates a temporary. Suggest either to go with
3076 // non-reference loop variable to indicate a copy is made, or
3077 // the correct type to bind a const reference.
3078 SemaRef.Diag(VD->getLocation(),
3079 diag::warn_for_range_const_ref_binds_temp_built_from_ref)
3080 << VD << VariableType << ReferenceReturnType;
3081 QualType NonReferenceType = VariableType.getNonReferenceType();
3082 NonReferenceType.removeLocalConst();
3083 QualType NewReferenceType =
3085 SemaRef.Diag(VD->getBeginLoc(), diag::note_use_type_or_non_reference)
3086 << NonReferenceType << NewReferenceType << VD->getSourceRange()
3088 } else if (!VariableType->isRValueReferenceType()) {
3089 // The range always returns a copy, so a temporary is always created.
3090 // Suggest removing the reference from the loop variable.
3091 // If the type is a rvalue reference do not warn since that changes the
3092 // semantic of the code.
3093 SemaRef.Diag(VD->getLocation(), diag::warn_for_range_ref_binds_ret_temp)
3094 << VD << RangeInitType;
3095 QualType NonReferenceType = VariableType.getNonReferenceType();
3096 NonReferenceType.removeLocalConst();
3097 SemaRef.Diag(VD->getBeginLoc(), diag::note_use_non_reference_type)
3098 << NonReferenceType << VD->getSourceRange()
3100 }
3101}
3102
3103/// Determines whether the @p VariableType's declaration is a record with the
3104/// clang::trivial_abi attribute.
3105static bool hasTrivialABIAttr(QualType VariableType) {
3106 if (CXXRecordDecl *RD = VariableType->getAsCXXRecordDecl())
3107 return RD->hasAttr<TrivialABIAttr>();
3108
3109 return false;
3110}
3111
3112// Warns when the loop variable can be changed to a reference type to
3113// prevent a copy. For instance, if given "for (const Foo x : Range)" suggest
3114// "for (const Foo &x : Range)" if this form does not make a copy.
3116 const VarDecl *VD) {
3117 const Expr *InitExpr = VD->getInit();
3118 if (!InitExpr)
3119 return;
3120
3121 QualType VariableType = VD->getType();
3122
3123 if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(InitExpr)) {
3124 if (!CE->getConstructor()->isCopyConstructor())
3125 return;
3126 } else if (const CastExpr *CE = dyn_cast<CastExpr>(InitExpr)) {
3127 if (CE->getCastKind() != CK_LValueToRValue)
3128 return;
3129 } else {
3130 return;
3131 }
3132
3133 // Small trivially copyable types are cheap to copy. Do not emit the
3134 // diagnostic for these instances. 64 bytes is a common size of a cache line.
3135 // (The function `getTypeSize` returns the size in bits.)
3136 ASTContext &Ctx = SemaRef.Context;
3137 if (Ctx.getTypeSize(VariableType) <= 64 * 8 &&
3138 (VariableType.isTriviallyCopyConstructibleType(Ctx) ||
3139 hasTrivialABIAttr(VariableType)))
3140 return;
3141
3142 // Suggest changing from a const variable to a const reference variable
3143 // if doing so will prevent a copy.
3144 SemaRef.Diag(VD->getLocation(), diag::warn_for_range_copy)
3145 << VD << VariableType;
3146 SemaRef.Diag(VD->getBeginLoc(), diag::note_use_reference_type)
3147 << SemaRef.Context.getLValueReferenceType(VariableType)
3148 << VD->getSourceRange()
3150}
3151
3152/// DiagnoseForRangeVariableCopies - Diagnose three cases and fixes for them.
3153/// 1) for (const foo &x : foos) where foos only returns a copy. Suggest
3154/// using "const foo x" to show that a copy is made
3155/// 2) for (const bar &x : foos) where bar is a temporary initialized by bar.
3156/// Suggest either "const bar x" to keep the copying or "const foo& x" to
3157/// prevent the copy.
3158/// 3) for (const foo x : foos) where x is constructed from a reference foo.
3159/// Suggest "const foo &x" to prevent the copy.
3161 const CXXForRangeStmt *ForStmt) {
3162 if (SemaRef.inTemplateInstantiation())
3163 return;
3164
3165 if (SemaRef.Diags.isIgnored(
3166 diag::warn_for_range_const_ref_binds_temp_built_from_ref,
3167 ForStmt->getBeginLoc()) &&
3168 SemaRef.Diags.isIgnored(diag::warn_for_range_ref_binds_ret_temp,
3169 ForStmt->getBeginLoc()) &&
3170 SemaRef.Diags.isIgnored(diag::warn_for_range_copy,
3171 ForStmt->getBeginLoc())) {
3172 return;
3173 }
3174
3175 const VarDecl *VD = ForStmt->getLoopVariable();
3176 if (!VD)
3177 return;
3178
3179 QualType VariableType = VD->getType();
3180
3181 if (VariableType->isIncompleteType())
3182 return;
3183
3184 const Expr *InitExpr = VD->getInit();
3185 if (!InitExpr)
3186 return;
3187
3188 if (InitExpr->getExprLoc().isMacroID())
3189 return;
3190
3191 if (VariableType->isReferenceType()) {
3193 ForStmt->getRangeInit()->getType());
3194 } else if (VariableType.isConstQualified()) {
3196 }
3197}
3198
3200 if (!S || !B)
3201 return StmtError();
3202
3203 if (isa<ObjCForCollectionStmt>(S))
3204 return ObjC().FinishObjCForCollectionStmt(S, B);
3205
3206 CXXForRangeStmt *ForStmt = cast<CXXForRangeStmt>(S);
3207 ForStmt->setBody(B);
3208
3210 diag::warn_empty_range_based_for_body);
3211
3213
3214 return S;
3215}
3216
3218 SourceLocation LabelLoc,
3219 LabelDecl *TheDecl) {
3221
3222 // If this goto is in a compute construct scope, we need to make sure we check
3223 // gotos in/out.
3224 if (getCurScope()->isInOpenACCComputeConstructScope())
3226
3227 TheDecl->markUsed(Context);
3228 return new (Context) GotoStmt(TheDecl, GotoLoc, LabelLoc);
3229}
3230
3233 Expr *E) {
3234 // Convert operand to void*
3235 if (!E->isTypeDependent()) {
3236 QualType ETy = E->getType();
3238 ExprResult ExprRes = E;
3239 AssignConvertType ConvTy =
3240 CheckSingleAssignmentConstraints(DestTy, ExprRes);
3241 if (ExprRes.isInvalid())
3242 return StmtError();
3243 E = ExprRes.get();
3244 if (DiagnoseAssignmentResult(ConvTy, StarLoc, DestTy, ETy, E,
3246 return StmtError();
3247 }
3248
3249 ExprResult ExprRes = ActOnFinishFullExpr(E, /*DiscardedValue*/ false);
3250 if (ExprRes.isInvalid())
3251 return StmtError();
3252 E = ExprRes.get();
3253
3255
3256 // If this goto is in a compute construct scope, we need to make sure we
3257 // check gotos in/out.
3258 if (getCurScope()->isInOpenACCComputeConstructScope())
3260
3261 return new (Context) IndirectGotoStmt(GotoLoc, StarLoc, E);
3262}
3263
3265 const Scope &DestScope) {
3266 if (!S.CurrentSEHFinally.empty() &&
3267 DestScope.Contains(*S.CurrentSEHFinally.back())) {
3268 S.Diag(Loc, diag::warn_jump_out_of_seh_finally);
3269 }
3270}
3271
3274 Scope *S = CurScope->getContinueParent();
3275 if (!S) {
3276 // C99 6.8.6.2p1: A break shall appear only in or as a loop body.
3277 return StmtError(Diag(ContinueLoc, diag::err_continue_not_in_loop));
3278 }
3279 if (S->isConditionVarScope()) {
3280 // We cannot 'continue;' from within a statement expression in the
3281 // initializer of a condition variable because we would jump past the
3282 // initialization of that variable.
3283 return StmtError(Diag(ContinueLoc, diag::err_continue_from_cond_var_init));
3284 }
3285
3286 // A 'continue' that would normally have execution continue on a block outside
3287 // of a compute construct counts as 'branching out of' the compute construct,
3288 // so diagnose here.
3289 if (S->isOpenACCComputeConstructScope())
3290 return StmtError(
3291 Diag(ContinueLoc, diag::err_acc_branch_in_out_compute_construct)
3292 << /*branch*/ 0 << /*out of */ 0);
3293
3294 CheckJumpOutOfSEHFinally(*this, ContinueLoc, *S);
3295
3296 return new (Context) ContinueStmt(ContinueLoc);
3297}
3298
3301 Scope *S = CurScope->getBreakParent();
3302 if (!S) {
3303 // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body.
3304 return StmtError(Diag(BreakLoc, diag::err_break_not_in_loop_or_switch));
3305 }
3306 if (S->isOpenMPLoopScope())
3307 return StmtError(Diag(BreakLoc, diag::err_omp_loop_cannot_use_stmt)
3308 << "break");
3309
3310 // OpenACC doesn't allow 'break'ing from a compute construct, so diagnose if
3311 // we are trying to do so. This can come in 2 flavors: 1-the break'able thing
3312 // (besides the compute construct) 'contains' the compute construct, at which
3313 // point the 'break' scope will be the compute construct. Else it could be a
3314 // loop of some sort that has a direct parent of the compute construct.
3315 // However, a 'break' in a 'switch' marked as a compute construct doesn't
3316 // count as 'branch out of' the compute construct.
3317 if (S->isOpenACCComputeConstructScope() ||
3318 (S->isLoopScope() && S->getParent() &&
3319 S->getParent()->isOpenACCComputeConstructScope()))
3320 return StmtError(
3321 Diag(BreakLoc, diag::err_acc_branch_in_out_compute_construct)
3322 << /*branch*/ 0 << /*out of */ 0);
3323
3324 CheckJumpOutOfSEHFinally(*this, BreakLoc, *S);
3325
3326 return new (Context) BreakStmt(BreakLoc);
3327}
3328
3331 if (!E)
3332 return NamedReturnInfo();
3333 // - in a return statement in a function [where] ...
3334 // ... the expression is the name of a non-volatile automatic object ...
3335 const auto *DR = dyn_cast<DeclRefExpr>(E->IgnoreParens());
3336 if (!DR || DR->refersToEnclosingVariableOrCapture())
3337 return NamedReturnInfo();
3338 const auto *VD = dyn_cast<VarDecl>(DR->getDecl());
3339 if (!VD)
3340 return NamedReturnInfo();
3341 if (VD->getInit() && VD->getInit()->containsErrors())
3342 return NamedReturnInfo();
3344 if (Res.Candidate && !E->isXValue() &&
3349 CK_NoOp, E, nullptr, VK_XValue,
3351 }
3352 return Res;
3353}
3354
3357
3358 // C++20 [class.copy.elision]p3:
3359 // - in a return statement in a function with ...
3360 // (other than a function ... parameter)
3361 if (VD->getKind() == Decl::ParmVar)
3363 else if (VD->getKind() != Decl::Var)
3364 return NamedReturnInfo();
3365
3366 // (other than ... a catch-clause parameter)
3367 if (VD->isExceptionVariable())
3369
3370 // ...automatic...
3371 if (!VD->hasLocalStorage())
3372 return NamedReturnInfo();
3373
3374 // We don't want to implicitly move out of a __block variable during a return
3375 // because we cannot assume the variable will no longer be used.
3376 if (VD->hasAttr<BlocksAttr>())
3377 return NamedReturnInfo();
3378
3379 QualType VDType = VD->getType();
3380 if (VDType->isObjectType()) {
3381 // C++17 [class.copy.elision]p3:
3382 // ...non-volatile automatic object...
3383 if (VDType.isVolatileQualified())
3384 return NamedReturnInfo();
3385 } else if (VDType->isRValueReferenceType()) {
3386 // C++20 [class.copy.elision]p3:
3387 // ...either a non-volatile object or an rvalue reference to a non-volatile
3388 // object type...
3389 QualType VDReferencedType = VDType.getNonReferenceType();
3390 if (VDReferencedType.isVolatileQualified() ||
3391 !VDReferencedType->isObjectType())
3392 return NamedReturnInfo();
3394 } else {
3395 return NamedReturnInfo();
3396 }
3397
3398 // Variables with higher required alignment than their type's ABI
3399 // alignment cannot use NRVO.
3400 if (!VD->hasDependentAlignment() && !VDType->isIncompleteType() &&
3403
3404 return Info;
3405}
3406
3408 QualType ReturnType) {
3409 if (!Info.Candidate)
3410 return nullptr;
3411
3412 auto invalidNRVO = [&] {
3413 Info = NamedReturnInfo();
3414 return nullptr;
3415 };
3416
3417 // If we got a non-deduced auto ReturnType, we are in a dependent context and
3418 // there is no point in allowing copy elision since we won't have it deduced
3419 // by the point the VardDecl is instantiated, which is the last chance we have
3420 // of deciding if the candidate is really copy elidable.
3421 if ((ReturnType->getTypeClass() == Type::TypeClass::Auto &&
3422 ReturnType->isCanonicalUnqualified()) ||
3423 ReturnType->isSpecificBuiltinType(BuiltinType::Dependent))
3424 return invalidNRVO();
3425
3426 if (!ReturnType->isDependentType()) {
3427 // - in a return statement in a function with ...
3428 // ... a class return type ...
3429 if (!ReturnType->isRecordType())
3430 return invalidNRVO();
3431
3432 QualType VDType = Info.Candidate->getType();
3433 // ... the same cv-unqualified type as the function return type ...
3434 // When considering moving this expression out, allow dissimilar types.
3435 if (!VDType->isDependentType() &&
3436 !Context.hasSameUnqualifiedType(ReturnType, VDType))
3438 }
3439 return Info.isCopyElidable() ? Info.Candidate : nullptr;
3440}
3441
3442/// Verify that the initialization sequence that was picked for the
3443/// first overload resolution is permissible under C++98.
3444///
3445/// Reject (possibly converting) constructors not taking an rvalue reference,
3446/// or user conversion operators which are not ref-qualified.
3447static bool
3449 const InitializationSequence &Seq) {
3450 const auto *Step = llvm::find_if(Seq.steps(), [](const auto &Step) {
3451 return Step.Kind == InitializationSequence::SK_ConstructorInitialization ||
3452 Step.Kind == InitializationSequence::SK_UserConversion;
3453 });
3454 if (Step != Seq.step_end()) {
3455 const auto *FD = Step->Function.Function;
3456 if (isa<CXXConstructorDecl>(FD)
3458 : cast<CXXMethodDecl>(FD)->getRefQualifier() == RQ_None)
3459 return false;
3460 }
3461 return true;
3462}
3463
3465 const InitializedEntity &Entity, const NamedReturnInfo &NRInfo, Expr *Value,
3466 bool SupressSimplerImplicitMoves) {
3467 if (getLangOpts().CPlusPlus &&
3468 (!getLangOpts().CPlusPlus23 || SupressSimplerImplicitMoves) &&
3469 NRInfo.isMoveEligible()) {
3471 CK_NoOp, Value, VK_XValue, FPOptionsOverride());
3472 Expr *InitExpr = &AsRvalue;
3473 auto Kind = InitializationKind::CreateCopy(Value->getBeginLoc(),
3474 Value->getBeginLoc());
3475 InitializationSequence Seq(*this, Entity, Kind, InitExpr);
3476 auto Res = Seq.getFailedOverloadResult();
3477 if ((Res == OR_Success || Res == OR_Deleted) &&
3480 // Promote "AsRvalue" to the heap, since we now need this
3481 // expression node to persist.
3482 Value =
3484 nullptr, VK_XValue, FPOptionsOverride());
3485 // Complete type-checking the initialization of the return type
3486 // using the constructor we found.
3487 return Seq.Perform(*this, Entity, Kind, Value);
3488 }
3489 }
3490 // Either we didn't meet the criteria for treating an lvalue as an rvalue,
3491 // above, or overload resolution failed. Either way, we need to try
3492 // (again) now with the return value expression as written.
3494}
3495
3496/// Determine whether the declared return type of the specified function
3497/// contains 'auto'.
3499 const FunctionProtoType *FPT =
3501 return FPT->getReturnType()->isUndeducedType();
3502}
3503
3505 Expr *RetValExp,
3506 NamedReturnInfo &NRInfo,
3507 bool SupressSimplerImplicitMoves) {
3508 // If this is the first return we've seen, infer the return type.
3509 // [expr.prim.lambda]p4 in C++11; block literals follow the same rules.
3510 CapturingScopeInfo *CurCap = cast<CapturingScopeInfo>(getCurFunction());
3511 QualType FnRetType = CurCap->ReturnType;
3512 LambdaScopeInfo *CurLambda = dyn_cast<LambdaScopeInfo>(CurCap);
3513 if (CurLambda && CurLambda->CallOperator->getType().isNull())
3514 return StmtError();
3515 bool HasDeducedReturnType =
3516 CurLambda && hasDeducedReturnType(CurLambda->CallOperator);
3517
3518 if (ExprEvalContexts.back().isDiscardedStatementContext() &&
3519 (HasDeducedReturnType || CurCap->HasImplicitReturnType)) {
3520 if (RetValExp) {
3521 ExprResult ER =
3522 ActOnFinishFullExpr(RetValExp, ReturnLoc, /*DiscardedValue*/ false);
3523 if (ER.isInvalid())
3524 return StmtError();
3525 RetValExp = ER.get();
3526 }
3527 return ReturnStmt::Create(Context, ReturnLoc, RetValExp,
3528 /* NRVOCandidate=*/nullptr);
3529 }
3530
3531 if (HasDeducedReturnType) {
3532 FunctionDecl *FD = CurLambda->CallOperator;
3533 // If we've already decided this lambda is invalid, e.g. because
3534 // we saw a `return` whose expression had an error, don't keep
3535 // trying to deduce its return type.
3536 if (FD->isInvalidDecl())
3537 return StmtError();
3538 // In C++1y, the return type may involve 'auto'.
3539 // FIXME: Blocks might have a return type of 'auto' explicitly specified.
3540 if (CurCap->ReturnType.isNull())
3541 CurCap->ReturnType = FD->getReturnType();
3542
3543 AutoType *AT = CurCap->ReturnType->getContainedAutoType();
3544 assert(AT && "lost auto type from lambda return type");
3545 if (DeduceFunctionTypeFromReturnExpr(FD, ReturnLoc, RetValExp, AT)) {
3546 FD->setInvalidDecl();
3547 // FIXME: preserve the ill-formed return expression.
3548 return StmtError();
3549 }
3550 CurCap->ReturnType = FnRetType = FD->getReturnType();
3551 } else if (CurCap->HasImplicitReturnType) {
3552 // For blocks/lambdas with implicit return types, we check each return
3553 // statement individually, and deduce the common return type when the block
3554 // or lambda is completed.
3555 // FIXME: Fold this into the 'auto' codepath above.
3556 if (RetValExp && !isa<InitListExpr>(RetValExp)) {
3558 if (Result.isInvalid())
3559 return StmtError();
3560 RetValExp = Result.get();
3561
3562 // DR1048: even prior to C++14, we should use the 'auto' deduction rules
3563 // when deducing a return type for a lambda-expression (or by extension
3564 // for a block). These rules differ from the stated C++11 rules only in
3565 // that they remove top-level cv-qualifiers.
3567 FnRetType = RetValExp->getType().getUnqualifiedType();
3568 else
3569 FnRetType = CurCap->ReturnType = Context.DependentTy;
3570 } else {
3571 if (RetValExp) {
3572 // C++11 [expr.lambda.prim]p4 bans inferring the result from an
3573 // initializer list, because it is not an expression (even
3574 // though we represent it as one). We still deduce 'void'.
3575 Diag(ReturnLoc, diag::err_lambda_return_init_list)
3576 << RetValExp->getSourceRange();
3577 }
3578
3579 FnRetType = Context.VoidTy;
3580 }
3581
3582 // Although we'll properly infer the type of the block once it's completed,
3583 // make sure we provide a return type now for better error recovery.
3584 if (CurCap->ReturnType.isNull())
3585 CurCap->ReturnType = FnRetType;
3586 }
3587 const VarDecl *NRVOCandidate = getCopyElisionCandidate(NRInfo, FnRetType);
3588
3589 if (auto *CurBlock = dyn_cast<BlockScopeInfo>(CurCap)) {
3590 if (CurBlock->FunctionType->castAs<FunctionType>()->getNoReturnAttr()) {
3591 Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr);
3592 return StmtError();
3593 }
3594 } else if (auto *CurRegion = dyn_cast<CapturedRegionScopeInfo>(CurCap)) {
3595 Diag(ReturnLoc, diag::err_return_in_captured_stmt) << CurRegion->getRegionName();
3596 return StmtError();
3597 } else {
3598 assert(CurLambda && "unknown kind of captured scope");
3599 if (CurLambda->CallOperator->getType()
3600 ->castAs<FunctionType>()
3601 ->getNoReturnAttr()) {
3602 Diag(ReturnLoc, diag::err_noreturn_lambda_has_return_expr);
3603 return StmtError();
3604 }
3605 }
3606
3607 // Otherwise, verify that this result type matches the previous one. We are
3608 // pickier with blocks than for normal functions because we don't have GCC
3609 // compatibility to worry about here.
3610 if (FnRetType->isDependentType()) {
3611 // Delay processing for now. TODO: there are lots of dependent
3612 // types we can conclusively prove aren't void.
3613 } else if (FnRetType->isVoidType()) {
3614 if (RetValExp && !isa<InitListExpr>(RetValExp) &&
3615 !(getLangOpts().CPlusPlus &&
3616 (RetValExp->isTypeDependent() ||
3617 RetValExp->getType()->isVoidType()))) {
3618 if (!getLangOpts().CPlusPlus &&
3619 RetValExp->getType()->isVoidType())
3620 Diag(ReturnLoc, diag::ext_return_has_void_expr) << "literal" << 2;
3621 else {
3622 Diag(ReturnLoc, diag::err_return_block_has_expr);
3623 RetValExp = nullptr;
3624 }
3625 }
3626 } else if (!RetValExp) {
3627 return StmtError(Diag(ReturnLoc, diag::err_block_return_missing_expr));
3628 } else if (!RetValExp->isTypeDependent()) {
3629 // we have a non-void block with an expression, continue checking
3630
3631 // C99 6.8.6.4p3(136): The return statement is not an assignment. The
3632 // overlap restriction of subclause 6.5.16.1 does not apply to the case of
3633 // function return.
3634
3635 // In C++ the return statement is handled via a copy initialization.
3636 // the C version of which boils down to CheckSingleAssignmentConstraints.
3637 InitializedEntity Entity =
3638 InitializedEntity::InitializeResult(ReturnLoc, FnRetType);
3640 Entity, NRInfo, RetValExp, SupressSimplerImplicitMoves);
3641 if (Res.isInvalid()) {
3642 // FIXME: Cleanup temporaries here, anyway?
3643 return StmtError();
3644 }
3645 RetValExp = Res.get();
3646 CheckReturnValExpr(RetValExp, FnRetType, ReturnLoc);
3647 }
3648
3649 if (RetValExp) {
3650 ExprResult ER =
3651 ActOnFinishFullExpr(RetValExp, ReturnLoc, /*DiscardedValue*/ false);
3652 if (ER.isInvalid())
3653 return StmtError();
3654 RetValExp = ER.get();
3655 }
3656 auto *Result =
3657 ReturnStmt::Create(Context, ReturnLoc, RetValExp, NRVOCandidate);
3658
3659 // If we need to check for the named return value optimization,
3660 // or if we need to infer the return type,
3661 // save the return statement in our scope for later processing.
3662 if (CurCap->HasImplicitReturnType || NRVOCandidate)
3663 FunctionScopes.back()->Returns.push_back(Result);
3664
3665 if (FunctionScopes.back()->FirstReturnLoc.isInvalid())
3666 FunctionScopes.back()->FirstReturnLoc = ReturnLoc;
3667
3668 if (auto *CurBlock = dyn_cast<BlockScopeInfo>(CurCap);
3669 CurBlock && CurCap->HasImplicitReturnType && RetValExp &&
3670 RetValExp->containsErrors())
3671 CurBlock->TheDecl->setInvalidDecl();
3672
3673 return Result;
3674}
3675
3676namespace {
3677/// Marks all typedefs in all local classes in a type referenced.
3678///
3679/// In a function like
3680/// auto f() {
3681/// struct S { typedef int a; };
3682/// return S();
3683/// }
3684///
3685/// the local type escapes and could be referenced in some TUs but not in
3686/// others. Pretend that all local typedefs are always referenced, to not warn
3687/// on this. This isn't necessary if f has internal linkage, or the typedef
3688/// is private.
3689class LocalTypedefNameReferencer : public DynamicRecursiveASTVisitor {
3690public:
3691 LocalTypedefNameReferencer(Sema &S) : S(S) {}
3692 bool VisitRecordType(RecordType *RT) override;
3693
3694private:
3695 Sema &S;
3696};
3697bool LocalTypedefNameReferencer::VisitRecordType(RecordType *RT) {
3698 auto *R = dyn_cast<CXXRecordDecl>(RT->getDecl());
3699 if (!R || !R->isLocalClass() || !R->isLocalClass()->isExternallyVisible() ||
3700 R->isDependentType())
3701 return true;
3702 for (auto *TmpD : R->decls())
3703 if (auto *T = dyn_cast<TypedefNameDecl>(TmpD))
3704 if (T->getAccess() != AS_private || R->hasFriends())
3705 S.MarkAnyDeclReferenced(T->getLocation(), T, /*OdrUse=*/false);
3706 return true;
3707}
3708}
3709
3711 return FD->getTypeSourceInfo()
3712 ->getTypeLoc()
3714 .getReturnLoc();
3715}
3716
3718 SourceLocation ReturnLoc,
3719 Expr *RetExpr, const AutoType *AT) {
3720 // If this is the conversion function for a lambda, we choose to deduce its
3721 // type from the corresponding call operator, not from the synthesized return
3722 // statement within it. See Sema::DeduceReturnType.
3724 return false;
3725
3726 if (isa_and_nonnull<InitListExpr>(RetExpr)) {
3727 // If the deduction is for a return statement and the initializer is
3728 // a braced-init-list, the program is ill-formed.
3729 Diag(RetExpr->getExprLoc(),
3730 getCurLambda() ? diag::err_lambda_return_init_list
3731 : diag::err_auto_fn_return_init_list)
3732 << RetExpr->getSourceRange();
3733 return true;
3734 }
3735
3736 if (FD->isDependentContext()) {
3737 // C++1y [dcl.spec.auto]p12:
3738 // Return type deduction [...] occurs when the definition is
3739 // instantiated even if the function body contains a return
3740 // statement with a non-type-dependent operand.
3741 assert(AT->isDeduced() && "should have deduced to dependent type");
3742 return false;
3743 }
3744
3745 TypeLoc OrigResultType = getReturnTypeLoc(FD);
3746 // In the case of a return with no operand, the initializer is considered
3747 // to be void().
3749 if (!RetExpr) {
3750 // For a function with a deduced result type to return with omitted
3751 // expression, the result type as written must be 'auto' or
3752 // 'decltype(auto)', possibly cv-qualified or constrained, but not
3753 // ref-qualified.
3754 if (!OrigResultType.getType()->getAs<AutoType>()) {
3755 Diag(ReturnLoc, diag::err_auto_fn_return_void_but_not_auto)
3756 << OrigResultType.getType();
3757 return true;
3758 }
3759 RetExpr = &VoidVal;
3760 }
3761
3762 QualType Deduced = AT->getDeducedType();
3763 {
3764 // Otherwise, [...] deduce a value for U using the rules of template
3765 // argument deduction.
3766 auto RetExprLoc = RetExpr->getExprLoc();
3767 TemplateDeductionInfo Info(RetExprLoc);
3768 SourceLocation TemplateSpecLoc;
3769 if (RetExpr->getType() == Context.OverloadTy) {
3770 auto FindResult = OverloadExpr::find(RetExpr);
3771 if (FindResult.Expression)
3772 TemplateSpecLoc = FindResult.Expression->getNameLoc();
3773 }
3774 TemplateSpecCandidateSet FailedTSC(TemplateSpecLoc);
3776 OrigResultType, RetExpr, Deduced, Info, /*DependentDeduction=*/false,
3777 /*IgnoreConstraints=*/false, &FailedTSC);
3779 return true;
3780 switch (Res) {
3782 break;
3784 return true;
3786 // If a function with a declared return type that contains a placeholder
3787 // type has multiple return statements, the return type is deduced for
3788 // each return statement. [...] if the type deduced is not the same in
3789 // each deduction, the program is ill-formed.
3790 const LambdaScopeInfo *LambdaSI = getCurLambda();
3791 if (LambdaSI && LambdaSI->HasImplicitReturnType)
3792 Diag(ReturnLoc, diag::err_typecheck_missing_return_type_incompatible)
3793 << Info.SecondArg << Info.FirstArg << true /*IsLambda*/;
3794 else
3795 Diag(ReturnLoc, diag::err_auto_fn_different_deductions)
3796 << (AT->isDecltypeAuto() ? 1 : 0) << Info.SecondArg
3797 << Info.FirstArg;
3798 return true;
3799 }
3800 default:
3801 Diag(RetExpr->getExprLoc(), diag::err_auto_fn_deduction_failure)
3802 << OrigResultType.getType() << RetExpr->getType();
3803 FailedTSC.NoteCandidates(*this, RetExprLoc);
3804 return true;
3805 }
3806 }
3807
3808 // If a local type is part of the returned type, mark its fields as
3809 // referenced.
3810 LocalTypedefNameReferencer(*this).TraverseType(RetExpr->getType());
3811
3812 // CUDA: Kernel function must have 'void' return type.
3813 if (getLangOpts().CUDA && FD->hasAttr<CUDAGlobalAttr>() &&
3814 !Deduced->isVoidType()) {
3815 Diag(FD->getLocation(), diag::err_kern_type_not_void_return)
3816 << FD->getType() << FD->getSourceRange();
3817 return true;
3818 }
3819
3820 if (!FD->isInvalidDecl() && AT->getDeducedType() != Deduced)
3821 // Update all declarations of the function to have the deduced return type.
3823
3824 return false;
3825}
3826
3829 Scope *CurScope) {
3830 // Correct typos, in case the containing function returns 'auto' and
3831 // RetValExp should determine the deduced type.
3833 RetValExp, nullptr, /*RecoverUncorrectedTypos=*/true);
3834 if (RetVal.isInvalid())
3835 return StmtError();
3836
3837 if (getCurScope()->isInOpenACCComputeConstructScope())
3838 return StmtError(
3839 Diag(ReturnLoc, diag::err_acc_branch_in_out_compute_construct)
3840 << /*return*/ 1 << /*out of */ 0);
3841
3842 // using plain return in a coroutine is not allowed.
3844 if (FSI->FirstReturnLoc.isInvalid() && FSI->isCoroutine()) {
3845 assert(FSI->FirstCoroutineStmtLoc.isValid() &&
3846 "first coroutine location not set");
3847 Diag(ReturnLoc, diag::err_return_in_coroutine);
3848 Diag(FSI->FirstCoroutineStmtLoc, diag::note_declared_coroutine_here)
3850 }
3851
3852 CheckInvalidBuiltinCountedByRef(RetVal.get(), ReturnArgKind);
3853
3854 StmtResult R =
3855 BuildReturnStmt(ReturnLoc, RetVal.get(), /*AllowRecovery=*/true);
3856 if (R.isInvalid() || ExprEvalContexts.back().isDiscardedStatementContext())
3857 return R;
3858
3859 VarDecl *VD =
3860 const_cast<VarDecl *>(cast<ReturnStmt>(R.get())->getNRVOCandidate());
3861
3862 CurScope->updateNRVOCandidate(VD);
3863
3864 CheckJumpOutOfSEHFinally(*this, ReturnLoc, *CurScope->getFnParent());
3865
3866 return R;
3867}
3868
3870 const Expr *E) {
3871 if (!E || !S.getLangOpts().CPlusPlus23 || !S.getLangOpts().MSVCCompat)
3872 return false;
3873 const Decl *D = E->getReferencedDeclOfCallee();
3874 if (!D || !S.SourceMgr.isInSystemHeader(D->getLocation()))
3875 return false;
3876 for (const DeclContext *DC = D->getDeclContext(); DC; DC = DC->getParent()) {
3877 if (DC->isStdNamespace())
3878 return true;
3879 }
3880 return false;
3881}
3882
3884 bool AllowRecovery) {
3885 // Check for unexpanded parameter packs.
3886 if (RetValExp && DiagnoseUnexpandedParameterPack(RetValExp))
3887 return StmtError();
3888
3889 // HACK: We suppress simpler implicit move here in msvc compatibility mode
3890 // just as a temporary work around, as the MSVC STL has issues with
3891 // this change.
3892 bool SupressSimplerImplicitMoves =
3895 RetValExp, SupressSimplerImplicitMoves ? SimplerImplicitMoveMode::ForceOff
3897
3898 if (isa<CapturingScopeInfo>(getCurFunction()))
3899 return ActOnCapScopeReturnStmt(ReturnLoc, RetValExp, NRInfo,
3900 SupressSimplerImplicitMoves);
3901
3902 QualType FnRetType;
3903 QualType RelatedRetType;
3904 const AttrVec *Attrs = nullptr;
3905 bool isObjCMethod = false;
3906
3907 if (const FunctionDecl *FD = getCurFunctionDecl()) {
3908 FnRetType = FD->getReturnType();
3909 if (FD->hasAttrs())
3910 Attrs = &FD->getAttrs();
3911 if (FD->isNoReturn())
3912 Diag(ReturnLoc, diag::warn_noreturn_function_has_return_expr) << FD;
3913 if (FD->isMain() && RetValExp)
3914 if (isa<CXXBoolLiteralExpr>(RetValExp))
3915 Diag(ReturnLoc, diag::warn_main_returns_bool_literal)
3916 << RetValExp->getSourceRange();
3917 if (FD->hasAttr<CmseNSEntryAttr>() && RetValExp) {
3918 if (const auto *RT = dyn_cast<RecordType>(FnRetType.getCanonicalType())) {
3919 if (RT->getDecl()->isOrContainsUnion())
3920 Diag(RetValExp->getBeginLoc(), diag::warn_cmse_nonsecure_union) << 1;
3921 }
3922 }
3923 } else if (ObjCMethodDecl *MD = getCurMethodDecl()) {
3924 FnRetType = MD->getReturnType();
3925 isObjCMethod = true;
3926 if (MD->hasAttrs())
3927 Attrs = &MD->getAttrs();
3928 if (MD->hasRelatedResultType() && MD->getClassInterface()) {
3929 // In the implementation of a method with a related return type, the
3930 // type used to type-check the validity of return statements within the
3931 // method body is a pointer to the type of the class being implemented.
3932 RelatedRetType = Context.getObjCInterfaceType(MD->getClassInterface());
3933 RelatedRetType = Context.getObjCObjectPointerType(RelatedRetType);
3934 }
3935 } else // If we don't have a function/method context, bail.
3936 return StmtError();
3937
3938 if (RetValExp) {
3939 const auto *ATy = dyn_cast<ArrayType>(RetValExp->getType());
3940 if (ATy && ATy->getElementType().isWebAssemblyReferenceType()) {
3941 Diag(ReturnLoc, diag::err_wasm_table_art) << 1;
3942 return StmtError();
3943 }
3944 }
3945
3946 // C++1z: discarded return statements are not considered when deducing a
3947 // return type.
3948 if (ExprEvalContexts.back().isDiscardedStatementContext() &&
3949 FnRetType->getContainedAutoType()) {
3950 if (RetValExp) {
3951 ExprResult ER =
3952 ActOnFinishFullExpr(RetValExp, ReturnLoc, /*DiscardedValue*/ false);
3953 if (ER.isInvalid())
3954 return StmtError();
3955 RetValExp = ER.get();
3956 }
3957 return ReturnStmt::Create(Context, ReturnLoc, RetValExp,
3958 /* NRVOCandidate=*/nullptr);
3959 }
3960
3961 // FIXME: Add a flag to the ScopeInfo to indicate whether we're performing
3962 // deduction.
3963 if (getLangOpts().CPlusPlus14) {
3964 if (AutoType *AT = FnRetType->getContainedAutoType()) {
3965 FunctionDecl *FD = cast<FunctionDecl>(CurContext);
3966 // If we've already decided this function is invalid, e.g. because
3967 // we saw a `return` whose expression had an error, don't keep
3968 // trying to deduce its return type.
3969 // (Some return values may be needlessly wrapped in RecoveryExpr).
3970 if (FD->isInvalidDecl() ||
3971 DeduceFunctionTypeFromReturnExpr(FD, ReturnLoc, RetValExp, AT)) {
3972 FD->setInvalidDecl();
3973 if (!AllowRecovery)
3974 return StmtError();
3975 // The deduction failure is diagnosed and marked, try to recover.
3976 if (RetValExp) {
3977 // Wrap return value with a recovery expression of the previous type.
3978 // If no deduction yet, use DependentTy.
3979 auto Recovery = CreateRecoveryExpr(
3980 RetValExp->getBeginLoc(), RetValExp->getEndLoc(), RetValExp,
3981 AT->isDeduced() ? FnRetType : QualType());
3982 if (Recovery.isInvalid())
3983 return StmtError();
3984 RetValExp = Recovery.get();
3985 } else {
3986 // Nothing to do: a ReturnStmt with no value is fine recovery.
3987 }
3988 } else {
3989 FnRetType = FD->getReturnType();
3990 }
3991 }
3992 }
3993 const VarDecl *NRVOCandidate = getCopyElisionCandidate(NRInfo, FnRetType);
3994
3995 bool HasDependentReturnType = FnRetType->isDependentType();
3996
3997 ReturnStmt *Result = nullptr;
3998 if (FnRetType->isVoidType()) {
3999 if (RetValExp) {
4000 if (auto *ILE = dyn_cast<InitListExpr>(RetValExp)) {
4001 // We simply never allow init lists as the return value of void
4002 // functions. This is compatible because this was never allowed before,
4003 // so there's no legacy code to deal with.
4005 int FunctionKind = 0;
4006 if (isa<ObjCMethodDecl>(CurDecl))
4007 FunctionKind = 1;
4008 else if (isa<CXXConstructorDecl>(CurDecl))
4009 FunctionKind = 2;
4010 else if (isa<CXXDestructorDecl>(CurDecl))
4011 FunctionKind = 3;
4012
4013 Diag(ReturnLoc, diag::err_return_init_list)
4014 << CurDecl << FunctionKind << RetValExp->getSourceRange();
4015
4016 // Preserve the initializers in the AST.
4017 RetValExp = AllowRecovery
4018 ? CreateRecoveryExpr(ILE->getLBraceLoc(),
4019 ILE->getRBraceLoc(), ILE->inits())
4020 .get()
4021 : nullptr;
4022 } else if (!RetValExp->isTypeDependent()) {
4023 // C99 6.8.6.4p1 (ext_ since GCC warns)
4024 unsigned D = diag::ext_return_has_expr;
4025 if (RetValExp->getType()->isVoidType()) {
4027 if (isa<CXXConstructorDecl>(CurDecl) ||
4028 isa<CXXDestructorDecl>(CurDecl))
4029 D = diag::err_ctor_dtor_returns_void;
4030 else
4031 D = diag::ext_return_has_void_expr;
4032 }
4033 else {
4034 ExprResult Result = RetValExp;
4036 if (Result.isInvalid())
4037 return StmtError();
4038 RetValExp = Result.get();
4039 RetValExp = ImpCastExprToType(RetValExp,
4040 Context.VoidTy, CK_ToVoid).get();
4041 }
4042 // return of void in constructor/destructor is illegal in C++.
4043 if (D == diag::err_ctor_dtor_returns_void) {
4045 Diag(ReturnLoc, D) << CurDecl << isa<CXXDestructorDecl>(CurDecl)
4046 << RetValExp->getSourceRange();
4047 }
4048 // return (some void expression); is legal in C++.
4049 else if (D != diag::ext_return_has_void_expr ||
4052
4053 int FunctionKind = 0;
4054 if (isa<ObjCMethodDecl>(CurDecl))
4055 FunctionKind = 1;
4056 else if (isa<CXXConstructorDecl>(CurDecl))
4057 FunctionKind = 2;
4058 else if (isa<CXXDestructorDecl>(CurDecl))
4059 FunctionKind = 3;
4060
4061 Diag(ReturnLoc, D)
4062 << CurDecl << FunctionKind << RetValExp->getSourceRange();
4063 }
4064 }
4065
4066 if (RetValExp) {
4067 ExprResult ER =
4068 ActOnFinishFullExpr(RetValExp, ReturnLoc, /*DiscardedValue*/ false);
4069 if (ER.isInvalid())
4070 return StmtError();
4071 RetValExp = ER.get();
4072 }
4073 }
4074
4075 Result = ReturnStmt::Create(Context, ReturnLoc, RetValExp,
4076 /* NRVOCandidate=*/nullptr);
4077 } else if (!RetValExp && !HasDependentReturnType) {
4079
4080 if ((FD && FD->isInvalidDecl()) || FnRetType->containsErrors()) {
4081 // The intended return type might have been "void", so don't warn.
4082 } else if (getLangOpts().CPlusPlus11 && FD && FD->isConstexpr()) {
4083 // C++11 [stmt.return]p2
4084 Diag(ReturnLoc, diag::err_constexpr_return_missing_expr)
4085 << FD << FD->isConsteval();
4086 FD->setInvalidDecl();
4087 } else {
4088 // C99 6.8.6.4p1 (ext_ since GCC warns)
4089 // C90 6.6.6.4p4
4090 unsigned DiagID = getLangOpts().C99 ? diag::ext_return_missing_expr
4091 : diag::warn_return_missing_expr;
4092 // Note that at this point one of getCurFunctionDecl() or
4093 // getCurMethodDecl() must be non-null (see above).
4094 assert((getCurFunctionDecl() || getCurMethodDecl()) &&
4095 "Not in a FunctionDecl or ObjCMethodDecl?");
4096 bool IsMethod = FD == nullptr;
4097 const NamedDecl *ND =
4098 IsMethod ? cast<NamedDecl>(getCurMethodDecl()) : cast<NamedDecl>(FD);
4099 Diag(ReturnLoc, DiagID) << ND << IsMethod;
4100 }
4101
4102 Result = ReturnStmt::Create(Context, ReturnLoc, /* RetExpr=*/nullptr,
4103 /* NRVOCandidate=*/nullptr);
4104 } else {
4105 assert(RetValExp || HasDependentReturnType);
4106 QualType RetType = RelatedRetType.isNull() ? FnRetType : RelatedRetType;
4107
4108 // C99 6.8.6.4p3(136): The return statement is not an assignment. The
4109 // overlap restriction of subclause 6.5.16.1 does not apply to the case of
4110 // function return.
4111
4112 // In C++ the return statement is handled via a copy initialization,
4113 // the C version of which boils down to CheckSingleAssignmentConstraints.
4114 if (!HasDependentReturnType && !RetValExp->isTypeDependent()) {
4115 // we have a non-void function with an expression, continue checking
4116 InitializedEntity Entity =
4117 InitializedEntity::InitializeResult(ReturnLoc, RetType);
4119 Entity, NRInfo, RetValExp, SupressSimplerImplicitMoves);
4120 if (Res.isInvalid() && AllowRecovery)
4121 Res = CreateRecoveryExpr(RetValExp->getBeginLoc(),
4122 RetValExp->getEndLoc(), RetValExp, RetType);
4123 if (Res.isInvalid()) {
4124 // FIXME: Clean up temporaries here anyway?
4125 return StmtError();
4126 }
4127 RetValExp = Res.getAs<Expr>();
4128
4129 // If we have a related result type, we need to implicitly
4130 // convert back to the formal result type. We can't pretend to
4131 // initialize the result again --- we might end double-retaining
4132 // --- so instead we initialize a notional temporary.
4133 if (!RelatedRetType.isNull()) {
4135 FnRetType);
4136 Res = PerformCopyInitialization(Entity, ReturnLoc, RetValExp);
4137 if (Res.isInvalid()) {
4138 // FIXME: Clean up temporaries here anyway?
4139 return StmtError();
4140 }
4141 RetValExp = Res.getAs<Expr>();
4142 }
4143
4144 CheckReturnValExpr(RetValExp, FnRetType, ReturnLoc, isObjCMethod, Attrs,
4146 }
4147
4148 if (RetValExp) {
4149 ExprResult ER =
4150 ActOnFinishFullExpr(RetValExp, ReturnLoc, /*DiscardedValue*/ false);
4151 if (ER.isInvalid())
4152 return StmtError();
4153 RetValExp = ER.get();
4154 }
4155 Result = ReturnStmt::Create(Context, ReturnLoc, RetValExp, NRVOCandidate);
4156 }
4157
4158 // If we need to check for the named return value optimization, save the
4159 // return statement in our scope for later processing.
4160 if (Result->getNRVOCandidate())
4161 FunctionScopes.back()->Returns.push_back(Result);
4162
4163 if (FunctionScopes.back()->FirstReturnLoc.isInvalid())
4164 FunctionScopes.back()->FirstReturnLoc = ReturnLoc;
4165
4166 return Result;
4167}
4168
4171 Stmt *HandlerBlock) {
4172 // There's nothing to test that ActOnExceptionDecl didn't already test.
4173 return new (Context)
4174 CXXCatchStmt(CatchLoc, cast_or_null<VarDecl>(ExDecl), HandlerBlock);
4175}
4176
4177namespace {
4178class CatchHandlerType {
4179 QualType QT;
4180 LLVM_PREFERRED_TYPE(bool)
4181 unsigned IsPointer : 1;
4182
4183 // This is a special constructor to be used only with DenseMapInfo's
4184 // getEmptyKey() and getTombstoneKey() functions.
4185 friend struct llvm::DenseMapInfo<CatchHandlerType>;
4186 enum Unique { ForDenseMap };
4187 CatchHandlerType(QualType QT, Unique) : QT(QT), IsPointer(false) {}
4188
4189public:
4190 /// Used when creating a CatchHandlerType from a handler type; will determine
4191 /// whether the type is a pointer or reference and will strip off the top
4192 /// level pointer and cv-qualifiers.
4193 CatchHandlerType(QualType Q) : QT(Q), IsPointer(false) {
4194 if (QT->isPointerType())
4195 IsPointer = true;
4196
4197 QT = QT.getUnqualifiedType();
4198 if (IsPointer || QT->isReferenceType())
4199 QT = QT->getPointeeType();
4200 }
4201
4202 /// Used when creating a CatchHandlerType from a base class type; pretends the
4203 /// type passed in had the pointer qualifier, does not need to get an
4204 /// unqualified type.
4205 CatchHandlerType(QualType QT, bool IsPointer)
4206 : QT(QT), IsPointer(IsPointer) {}
4207
4208 QualType underlying() const { return QT; }
4209 bool isPointer() const { return IsPointer; }
4210
4211 friend bool operator==(const CatchHandlerType &LHS,
4212 const CatchHandlerType &RHS) {
4213 // If the pointer qualification does not match, we can return early.
4214 if (LHS.IsPointer != RHS.IsPointer)
4215 return false;
4216 // Otherwise, check the underlying type without cv-qualifiers.
4217 return LHS.QT == RHS.QT;
4218 }
4219};
4220} // namespace
4221
4222namespace llvm {
4223template <> struct DenseMapInfo<CatchHandlerType> {
4224 static CatchHandlerType getEmptyKey() {
4225 return CatchHandlerType(DenseMapInfo<QualType>::getEmptyKey(),
4226 CatchHandlerType::ForDenseMap);
4227 }
4228
4229 static CatchHandlerType getTombstoneKey() {
4230 return CatchHandlerType(DenseMapInfo<QualType>::getTombstoneKey(),
4231 CatchHandlerType::ForDenseMap);
4232 }
4233
4234 static unsigned getHashValue(const CatchHandlerType &Base) {
4235 return DenseMapInfo<QualType>::getHashValue(Base.underlying());
4236 }
4237
4238 static bool isEqual(const CatchHandlerType &LHS,
4239 const CatchHandlerType &RHS) {
4240 return LHS == RHS;
4241 }
4242};
4243}
4244
4245namespace {
4246class CatchTypePublicBases {
4247 const llvm::DenseMap<QualType, CXXCatchStmt *> &TypesToCheck;
4248
4249 CXXCatchStmt *FoundHandler;
4250 QualType FoundHandlerType;
4251 QualType TestAgainstType;
4252
4253public:
4254 CatchTypePublicBases(const llvm::DenseMap<QualType, CXXCatchStmt *> &T,
4255 QualType QT)
4256 : TypesToCheck(T), FoundHandler(nullptr), TestAgainstType(QT) {}
4257
4258 CXXCatchStmt *getFoundHandler() const { return FoundHandler; }
4259 QualType getFoundHandlerType() const { return FoundHandlerType; }
4260
4261 bool operator()(const CXXBaseSpecifier *S, CXXBasePath &) {
4262 if (S->getAccessSpecifier() == AccessSpecifier::AS_public) {
4263 QualType Check = S->getType().getCanonicalType();
4264 const auto &M = TypesToCheck;
4265 auto I = M.find(Check);
4266 if (I != M.end()) {
4267 // We're pretty sure we found what we need to find. However, we still
4268 // need to make sure that we properly compare for pointers and
4269 // references, to handle cases like:
4270 //
4271 // } catch (Base *b) {
4272 // } catch (Derived &d) {
4273 // }
4274 //
4275 // where there is a qualification mismatch that disqualifies this
4276 // handler as a potential problem.
4277 if (I->second->getCaughtType()->isPointerType() ==
4278 TestAgainstType->isPointerType()) {
4279 FoundHandler = I->second;
4280 FoundHandlerType = Check;
4281 return true;
4282 }
4283 }
4284 }
4285 return false;
4286 }
4287};
4288}
4289
4291 ArrayRef<Stmt *> Handlers) {
4292 const llvm::Triple &T = Context.getTargetInfo().getTriple();
4293 const bool IsOpenMPGPUTarget =
4294 getLangOpts().OpenMPIsTargetDevice && (T.isNVPTX() || T.isAMDGCN());
4295 // Don't report an error if 'try' is used in system headers or in an OpenMP
4296 // target region compiled for a GPU architecture.
4297 if (!IsOpenMPGPUTarget && !getLangOpts().CXXExceptions &&
4298 !getSourceManager().isInSystemHeader(TryLoc) && !getLangOpts().CUDA) {
4299 // Delay error emission for the OpenMP device code.
4300 targetDiag(TryLoc, diag::err_exceptions_disabled) << "try";
4301 }
4302
4303 // In OpenMP target regions, we assume that catch is never reached on GPU
4304 // targets.
4305 if (IsOpenMPGPUTarget)
4306 targetDiag(TryLoc, diag::warn_try_not_valid_on_target) << T.str();
4307
4308 // Exceptions aren't allowed in CUDA device code.
4309 if (getLangOpts().CUDA)
4310 CUDA().DiagIfDeviceCode(TryLoc, diag::err_cuda_device_exceptions)
4311 << "try" << llvm::to_underlying(CUDA().CurrentTarget());
4312
4313 if (getCurScope() && getCurScope()->isOpenMPSimdDirectiveScope())
4314 Diag(TryLoc, diag::err_omp_simd_region_cannot_use_stmt) << "try";
4315
4317
4318 // C++ try is incompatible with SEH __try.
4319 if (!getLangOpts().Borland && FSI->FirstSEHTryLoc.isValid()) {
4320 Diag(TryLoc, diag::err_mixing_cxx_try_seh_try) << 0;
4321 Diag(FSI->FirstSEHTryLoc, diag::note_conflicting_try_here) << "'__try'";
4322 }
4323
4324 const unsigned NumHandlers = Handlers.size();
4325 assert(!Handlers.empty() &&
4326 "The parser shouldn't call this if there are no handlers.");
4327
4328 llvm::DenseMap<QualType, CXXCatchStmt *> HandledBaseTypes;
4329 llvm::DenseMap<CatchHandlerType, CXXCatchStmt *> HandledTypes;
4330 for (unsigned i = 0; i < NumHandlers; ++i) {
4331 CXXCatchStmt *H = cast<CXXCatchStmt>(Handlers[i]);
4332
4333 // Diagnose when the handler is a catch-all handler, but it isn't the last
4334 // handler for the try block. [except.handle]p5. Also, skip exception
4335 // declarations that are invalid, since we can't usefully report on them.
4336 if (!H->getExceptionDecl()) {
4337 if (i < NumHandlers - 1)
4338 return StmtError(Diag(H->getBeginLoc(), diag::err_early_catch_all));
4339 continue;
4340 } else if (H->getExceptionDecl()->isInvalidDecl())
4341 continue;
4342
4343 // Walk the type hierarchy to diagnose when this type has already been
4344 // handled (duplication), or cannot be handled (derivation inversion). We
4345 // ignore top-level cv-qualifiers, per [except.handle]p3
4346 CatchHandlerType HandlerCHT = H->getCaughtType().getCanonicalType();
4347
4348 // We can ignore whether the type is a reference or a pointer; we need the
4349 // underlying declaration type in order to get at the underlying record
4350 // decl, if there is one.
4351 QualType Underlying = HandlerCHT.underlying();
4352 if (auto *RD = Underlying->getAsCXXRecordDecl()) {
4353 if (!RD->hasDefinition())
4354 continue;
4355 // Check that none of the public, unambiguous base classes are in the
4356 // map ([except.handle]p1). Give the base classes the same pointer
4357 // qualification as the original type we are basing off of. This allows
4358 // comparison against the handler type using the same top-level pointer
4359 // as the original type.
4360 CXXBasePaths Paths;
4361 Paths.setOrigin(RD);
4362 CatchTypePublicBases CTPB(HandledBaseTypes,
4364 if (RD->lookupInBases(CTPB, Paths)) {
4365 const CXXCatchStmt *Problem = CTPB.getFoundHandler();
4366 if (!Paths.isAmbiguous(
4367 CanQualType::CreateUnsafe(CTPB.getFoundHandlerType()))) {
4369 diag::warn_exception_caught_by_earlier_handler)
4370 << H->getCaughtType();
4372 diag::note_previous_exception_handler)
4373 << Problem->getCaughtType();
4374 }
4375 }
4376 // Strip the qualifiers here because we're going to be comparing this
4377 // type to the base type specifiers of a class, which are ignored in a
4378 // base specifier per [class.derived.general]p2.
4379 HandledBaseTypes[Underlying.getUnqualifiedType()] = H;
4380 }
4381
4382 // Add the type the list of ones we have handled; diagnose if we've already
4383 // handled it.
4384 auto R = HandledTypes.insert(
4385 std::make_pair(H->getCaughtType().getCanonicalType(), H));
4386 if (!R.second) {
4387 const CXXCatchStmt *Problem = R.first->second;
4389 diag::warn_exception_caught_by_earlier_handler)
4390 << H->getCaughtType();
4392 diag::note_previous_exception_handler)
4393 << Problem->getCaughtType();
4394 }
4395 }
4396
4397 FSI->setHasCXXTry(TryLoc);
4398
4399 return CXXTryStmt::Create(Context, TryLoc, cast<CompoundStmt>(TryBlock),
4400 Handlers);
4401}
4402
4404 Stmt *TryBlock, Stmt *Handler) {
4405 assert(TryBlock && Handler);
4406
4408
4409 // SEH __try is incompatible with C++ try. Borland appears to support this,
4410 // however.
4411 if (!getLangOpts().Borland) {
4412 if (FSI->FirstCXXOrObjCTryLoc.isValid()) {
4413 Diag(TryLoc, diag::err_mixing_cxx_try_seh_try) << FSI->FirstTryType;
4414 Diag(FSI->FirstCXXOrObjCTryLoc, diag::note_conflicting_try_here)
4416 ? "'try'"
4417 : "'@try'");
4418 }
4419 }
4420
4421 FSI->setHasSEHTry(TryLoc);
4422
4423 // Reject __try in Obj-C methods, blocks, and captured decls, since we don't
4424 // track if they use SEH.
4425 DeclContext *DC = CurContext;
4426 while (DC && !DC->isFunctionOrMethod())
4427 DC = DC->getParent();
4428 FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(DC);
4429 if (FD)
4430 FD->setUsesSEHTry(true);
4431 else
4432 Diag(TryLoc, diag::err_seh_try_outside_functions);
4433
4434 // Reject __try on unsupported targets.
4436 Diag(TryLoc, diag::err_seh_try_unsupported);
4437
4438 return SEHTryStmt::Create(Context, IsCXXTry, TryLoc, TryBlock, Handler);
4439}
4440
4442 Stmt *Block) {
4443 assert(FilterExpr && Block);
4444 QualType FTy = FilterExpr->getType();
4445 if (!FTy->isIntegerType() && !FTy->isDependentType()) {
4446 return StmtError(
4447 Diag(FilterExpr->getExprLoc(), diag::err_filter_expression_integral)
4448 << FTy);
4449 }
4450 return SEHExceptStmt::Create(Context, Loc, FilterExpr, Block);
4451}
4452
4454 CurrentSEHFinally.push_back(CurScope);
4455}
4456
4458 CurrentSEHFinally.pop_back();
4459}
4460
4462 assert(Block);
4463 CurrentSEHFinally.pop_back();
4465}
4466
4469 Scope *SEHTryParent = CurScope;
4470 while (SEHTryParent && !SEHTryParent->isSEHTryScope())
4471 SEHTryParent = SEHTryParent->getParent();
4472 if (!SEHTryParent)
4473 return StmtError(Diag(Loc, diag::err_ms___leave_not_in___try));
4474 CheckJumpOutOfSEHFinally(*this, Loc, *SEHTryParent);
4475
4476 return new (Context) SEHLeaveStmt(Loc);
4477}
4478
4480 bool IsIfExists,
4481 NestedNameSpecifierLoc QualifierLoc,
4482 DeclarationNameInfo NameInfo,
4483 Stmt *Nested)
4484{
4485 return new (Context) MSDependentExistsStmt(KeywordLoc, IsIfExists,
4486 QualifierLoc, NameInfo,
4487 cast<CompoundStmt>(Nested));
4488}
4489
4490
4492 bool IsIfExists,
4493 CXXScopeSpec &SS,
4494 UnqualifiedId &Name,
4495 Stmt *Nested) {
4496 return BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
4499 Nested);
4500}
4501
4504 unsigned NumParams) {
4505 DeclContext *DC = CurContext;
4506 while (!(DC->isFunctionOrMethod() || DC->isRecord() || DC->isFileContext()))
4507 DC = DC->getParent();
4508
4509 RecordDecl *RD = nullptr;
4510 if (getLangOpts().CPlusPlus)
4512 /*Id=*/nullptr);
4513 else
4515 /*Id=*/nullptr);
4516
4517 RD->setCapturedRecord();
4518 DC->addDecl(RD);
4519 RD->setImplicit();
4520 RD->startDefinition();
4521
4522 assert(NumParams > 0 && "CapturedStmt requires context parameter");
4523 CD = CapturedDecl::Create(Context, CurContext, NumParams);
4524 DC->addDecl(CD);
4525 return RD;
4526}
4527
4528static bool
4531 SmallVectorImpl<Expr *> &CaptureInits) {
4532 for (const sema::Capture &Cap : RSI->Captures) {
4533 if (Cap.isInvalid())
4534 continue;
4535
4536 // Form the initializer for the capture.
4538 RSI->CapRegionKind == CR_OpenMP);
4539
4540 // FIXME: Bail out now if the capture is not used and the initializer has
4541 // no side-effects.
4542
4543 // Create a field for this capture.
4544 FieldDecl *Field = S.BuildCaptureField(RSI->TheRecordDecl, Cap);
4545
4546 // Add the capture to our list of captures.
4547 if (Cap.isThisCapture()) {
4548 Captures.push_back(CapturedStmt::Capture(Cap.getLocation(),
4550 } else if (Cap.isVLATypeCapture()) {
4551 Captures.push_back(
4553 } else {
4554 assert(Cap.isVariableCapture() && "unknown kind of capture");
4555
4556 if (S.getLangOpts().OpenMP && RSI->CapRegionKind == CR_OpenMP)
4557 S.OpenMP().setOpenMPCaptureKind(Field, Cap.getVariable(),
4558 RSI->OpenMPLevel);
4559
4560 Captures.push_back(CapturedStmt::Capture(
4561 Cap.getLocation(),
4564 cast<VarDecl>(Cap.getVariable())));
4565 }
4566 CaptureInits.push_back(Init.get());
4567 }
4568 return false;
4569}
4570
4572 CapturedRegionKind Kind,
4573 unsigned NumParams) {
4574 CapturedDecl *CD = nullptr;
4575 RecordDecl *RD = CreateCapturedStmtRecordDecl(CD, Loc, NumParams);
4576
4577 // Build the context parameter
4579 IdentifierInfo *ParamName = &Context.Idents.get("__context");
4581 auto *Param =
4582 ImplicitParamDecl::Create(Context, DC, Loc, ParamName, ParamType,
4584 DC->addDecl(Param);
4585
4586 CD->setContextParam(0, Param);
4587
4588 // Enter the capturing scope for this captured region.
4589 PushCapturedRegionScope(CurScope, CD, RD, Kind);
4590
4591 if (CurScope)
4592 PushDeclContext(CurScope, CD);
4593 else
4594 CurContext = CD;
4595
4598 ExprEvalContexts.back().InImmediateEscalatingFunctionContext = false;
4599}
4600
4602 CapturedRegionKind Kind,
4604 unsigned OpenMPCaptureLevel) {
4605 CapturedDecl *CD = nullptr;
4606 RecordDecl *RD = CreateCapturedStmtRecordDecl(CD, Loc, Params.size());
4607
4608 // Build the context parameter
4610 bool ContextIsFound = false;
4611 unsigned ParamNum = 0;
4612 for (ArrayRef<CapturedParamNameType>::iterator I = Params.begin(),
4613 E = Params.end();
4614 I != E; ++I, ++ParamNum) {
4615 if (I->second.isNull()) {
4616 assert(!ContextIsFound &&
4617 "null type has been found already for '__context' parameter");
4618 IdentifierInfo *ParamName = &Context.Idents.get("__context");
4620 .withConst()
4621 .withRestrict();
4622 auto *Param =
4623 ImplicitParamDecl::Create(Context, DC, Loc, ParamName, ParamType,
4625 DC->addDecl(Param);
4626 CD->setContextParam(ParamNum, Param);
4627 ContextIsFound = true;
4628 } else {
4629 IdentifierInfo *ParamName = &Context.Idents.get(I->first);
4630 auto *Param =
4631 ImplicitParamDecl::Create(Context, DC, Loc, ParamName, I->second,
4633 DC->addDecl(Param);
4634 CD->setParam(ParamNum, Param);
4635 }
4636 }
4637 assert(ContextIsFound && "no null type for '__context' parameter");
4638 if (!ContextIsFound) {
4639 // Add __context implicitly if it is not specified.
4640 IdentifierInfo *ParamName = &Context.Idents.get("__context");
4642 auto *Param =
4643 ImplicitParamDecl::Create(Context, DC, Loc, ParamName, ParamType,
4645 DC->addDecl(Param);
4646 CD->setContextParam(ParamNum, Param);
4647 }
4648 // Enter the capturing scope for this captured region.
4649 PushCapturedRegionScope(CurScope, CD, RD, Kind, OpenMPCaptureLevel);
4650
4651 if (CurScope)
4652 PushDeclContext(CurScope, CD);
4653 else
4654 CurContext = CD;
4655
4658}
4659
4665 CapturedRegionScopeInfo *RSI = cast<CapturedRegionScopeInfo>(ScopeRAII.get());
4666
4669
4670 SmallVector<Decl*, 4> Fields(Record->fields());
4671 ActOnFields(/*Scope=*/nullptr, Record->getLocation(), Record, Fields,
4673}
4674
4676 // Leave the captured scope before we start creating captures in the
4677 // enclosing scope.
4682 CapturedRegionScopeInfo *RSI = cast<CapturedRegionScopeInfo>(ScopeRAII.get());
4683
4685 SmallVector<Expr *, 4> CaptureInits;
4686 if (buildCapturedStmtCaptureList(*this, RSI, Captures, CaptureInits))
4687 return StmtError();
4688
4689 CapturedDecl *CD = RSI->TheCapturedDecl;
4690 RecordDecl *RD = RSI->TheRecordDecl;
4691
4693 getASTContext(), S, static_cast<CapturedRegionKind>(RSI->CapRegionKind),
4694 Captures, CaptureInits, CD, RD);
4695
4696 CD->setBody(Res->getCapturedStmt());
4697 RD->completeDefinition();
4698
4699 return Res;
4700}
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
const Decl * D
Expr * E
Defines the clang::Expr interface and subclasses for C++ expressions.
llvm::MachO::Record Record
Definition: MachO.h:31
Defines the clang::Preprocessor interface.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
This file declares semantic analysis for CUDA constructs.
SourceRange Range
Definition: SemaObjC.cpp:758
SourceLocation Loc
Definition: SemaObjC.cpp:759
This file declares semantic analysis for Objective-C.
This file declares semantic analysis for OpenMP constructs and clauses.
@ ft_different_class
@ ft_parameter_mismatch
@ ft_return_type
@ ft_parameter_arity
static bool CmpEnumVals(const std::pair< llvm::APSInt, EnumConstantDecl * > &lhs, const std::pair< llvm::APSInt, EnumConstantDecl * > &rhs)
CmpEnumVals - Comparison predicate for sorting enumeration values.
Definition: SemaStmt.cpp:1094
static bool FinishForRangeVarDecl(Sema &SemaRef, VarDecl *Decl, Expr *Init, SourceLocation Loc, int DiagID)
Finish building a variable declaration for a for-range statement.
Definition: SemaStmt.cpp:2328
static bool CmpCaseVals(const std::pair< llvm::APSInt, CaseStmt * > &lhs, const std::pair< llvm::APSInt, CaseStmt * > &rhs)
CmpCaseVals - Comparison predicate for sorting case values.
Definition: SemaStmt.cpp:1081
SmallVector< std::pair< llvm::APSInt, EnumConstantDecl * >, 64 > EnumValsTy
Definition: SemaStmt.cpp:1245
static bool ShouldDiagnoseSwitchCaseNotInEnum(const Sema &S, const EnumDecl *ED, const Expr *CaseExpr, EnumValsTy::iterator &EI, EnumValsTy::iterator &EIEnd, const llvm::APSInt &Val)
Returns true if we should emit a diagnostic about this case expression not being a part of the enum u...
Definition: SemaStmt.cpp:1249
static bool DiagnoseUnusedComparison(Sema &S, const Expr *E)
Diagnose unused comparisons, both builtin and overloaded operators.
Definition: SemaStmt.cpp:132
static bool EqEnumVals(const std::pair< llvm::APSInt, EnumConstantDecl * > &lhs, const std::pair< llvm::APSInt, EnumConstantDecl * > &rhs)
EqEnumVals - Comparison preficate for uniqing enumeration values.
Definition: SemaStmt.cpp:1102
static bool hasDeducedReturnType(FunctionDecl *FD)
Determine whether the declared return type of the specified function contains 'auto'.
Definition: SemaStmt.cpp:3498
static bool ObjCEnumerationCollection(Expr *Collection)
Definition: SemaStmt.cpp:2420
static void DiagnoseForRangeConstVariableCopies(Sema &SemaRef, const VarDecl *VD)
Definition: SemaStmt.cpp:3115
static StmtResult RebuildForRangeWithDereference(Sema &SemaRef, Scope *S, SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *InitStmt, Stmt *LoopVarDecl, SourceLocation ColonLoc, Expr *Range, SourceLocation RangeLoc, SourceLocation RParenLoc)
Speculatively attempt to dereference an invalid range expression.
Definition: SemaStmt.cpp:2647
static void checkEnumTypesInSwitchStmt(Sema &S, const Expr *Cond, const Expr *Case)
Definition: SemaStmt.cpp:1281
static void DiagnoseForRangeReferenceVariableCopies(Sema &SemaRef, const VarDecl *VD, QualType RangeInitType)
Definition: SemaStmt.cpp:3026
static void DiagnoseForRangeVariableCopies(Sema &SemaRef, const CXXForRangeStmt *ForStmt)
DiagnoseForRangeVariableCopies - Diagnose three cases and fixes for them.
Definition: SemaStmt.cpp:3160
static bool CheckSimplerImplicitMovesMSVCWorkaround(const Sema &S, const Expr *E)
Definition: SemaStmt.cpp:3869
static bool VerifyInitializationSequenceCXX98(const Sema &S, const InitializationSequence &Seq)
Verify that the initialization sequence that was picked for the first overload resolution is permissi...
Definition: SemaStmt.cpp:3448
static QualType GetTypeBeforeIntegralPromotion(const Expr *&E)
GetTypeBeforeIntegralPromotion - Returns the pre-promotion type of potentially integral-promoted expr...
Definition: SemaStmt.cpp:1110
static Sema::ForRangeStatus BuildNonArrayForRange(Sema &SemaRef, Expr *BeginRange, Expr *EndRange, QualType RangeType, VarDecl *BeginVar, VarDecl *EndVar, SourceLocation ColonLoc, SourceLocation CoawaitLoc, OverloadCandidateSet *CandidateSet, ExprResult *BeginExpr, ExprResult *EndExpr, BeginEndFunction *BEF)
Create the initialization, compare, and increment steps for the range-based for loop expression.
Definition: SemaStmt.cpp:2513
static bool hasTrivialABIAttr(QualType VariableType)
Determines whether the VariableType's declaration is a record with the clang::trivial_abi attribute.
Definition: SemaStmt.cpp:3105
static void AdjustAPSInt(llvm::APSInt &Val, unsigned BitWidth, bool IsSigned)
Definition: SemaStmt.cpp:1216
static bool buildCapturedStmtCaptureList(Sema &S, CapturedRegionScopeInfo *RSI, SmallVectorImpl< CapturedStmt::Capture > &Captures, SmallVectorImpl< Expr * > &CaptureInits)
Definition: SemaStmt.cpp:4529
static bool DiagnoseNoDiscard(Sema &S, const NamedDecl *OffendingDecl, const WarnUnusedResultAttr *A, SourceLocation Loc, SourceRange R1, SourceRange R2, bool IsCtor)
Definition: SemaStmt.cpp:203
static void checkCaseValue(Sema &S, SourceLocation Loc, const llvm::APSInt &Val, unsigned UnpromotedWidth, bool UnpromotedSign)
Check the specified case value is in range for the given unpromoted switch type.
Definition: SemaStmt.cpp:1223
static void CheckJumpOutOfSEHFinally(Sema &S, SourceLocation Loc, const Scope &DestScope)
Definition: SemaStmt.cpp:3264
Defines the Objective-C statement AST node classes.
enum clang::format::@1335::AnnotatingParser::Context::@351 ContextType
Defines the clang::TypeLoc interface and its subclasses.
Allows QualTypes to be sorted and hence used in maps and sets.
SourceLocation Begin
std::string Label
__device__ int
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:188
SourceManager & getSourceManager()
Definition: ASTContext.h:741
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
unsigned getIntWidth(QualType T) const
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl.
QualType getAutoRRefDeductType() const
C++11 deduction pattern for 'auto &&' type.
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2732
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
CanQualType VoidPtrTy
Definition: ASTContext.h:1187
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
CanQualType DependentTy
Definition: ASTContext.h:1188
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1703
IdentifierTable & Idents
Definition: ASTContext.h:680
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
CanQualType OverloadTy
Definition: ASTContext.h:1188
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2763
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2482
CanQualType VoidTy
Definition: ASTContext.h:1160
bool hasSimilarType(QualType T1, QualType T2) const
Determine if two types are similar, according to the C++ rules.
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:799
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
bool isUnset() const
Definition: Ownership.h:167
PtrTy get() const
Definition: Ownership.h:170
bool isInvalid() const
Definition: Ownership.h:166
bool isUsable() const
Definition: Ownership.h:168
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:3577
Attr - This represents one attribute.
Definition: Attr.h:43
SourceLocation getLocation() const
Definition: Attr.h:96
static AttributedStmt * Create(const ASTContext &C, SourceLocation Loc, ArrayRef< const Attr * > Attrs, Stmt *SubStmt)
Definition: Stmt.cpp:432
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
Definition: Type.h:6556
bool isDecltypeAuto() const
Definition: Type.h:6579
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:4324
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3909
BreakStmt - This represents a break.
Definition: Stmt.h:3007
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....
Definition: Expr.h:3840
Represents a path from a specific derived class (which is not represented as part of the path) to a p...
BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases...
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1491
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:720
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:28
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: StmtCXX.h:43
VarDecl * getExceptionDecl() const
Definition: StmtCXX.h:49
QualType getCaughtType() const
Definition: StmtCXX.cpp:19
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1546
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2553
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2880
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
Definition: StmtCXX.h:135
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....
Definition: ExprCXX.h:1817
Represents a call to a member function that may be written either with member call syntax (e....
Definition: ExprCXX.h:176
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2078
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:81
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
Definition: DeclCXX.cpp:131
An expression "T()" which creates an rvalue of a non-class type T.
Definition: ExprCXX.h:2182
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:74
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context.
Definition: DeclSpec.cpp:149
static CXXTryStmt * Create(const ASTContext &C, SourceLocation tryLoc, CompoundStmt *tryBlock, ArrayRef< Stmt * > handlers)
Definition: StmtCXX.cpp:25
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2874
Decl * getCalleeDecl()
Definition: Expr.h:3041
static CanQual< Type > CreateUnsafe(QualType Other)
Builds a canonical type from a QualType.
QualType withConst() const
Retrieves a version of this type with const applied.
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4673
void setBody(Stmt *B)
Definition: Decl.cpp:5464
static DeclContext * castToDeclContext(const CapturedDecl *D)
Definition: Decl.h:4757
void setContextParam(unsigned i, ImplicitParamDecl *P)
Definition: Decl.h:4739
void setParam(unsigned i, ImplicitParamDecl *P)
Definition: Decl.h:4721
static CapturedDecl * Create(ASTContext &C, DeclContext *DC, unsigned NumParams)
Definition: Decl.cpp:5451
Describes the capture of either a variable, or 'this', or variable-length array type.
Definition: Stmt.h:3797
This captures a statement into a function.
Definition: Stmt.h:3784
Stmt * getCapturedStmt()
Retrieve the statement being captured.
Definition: Stmt.h:3888
static CapturedStmt * Create(const ASTContext &Context, Stmt *S, CapturedRegionKind Kind, ArrayRef< Capture > Captures, ArrayRef< Expr * > CaptureInits, CapturedDecl *CD, RecordDecl *RD)
Definition: Stmt.cpp:1364
CaseStmt - Represent a case statement.
Definition: Stmt.h:1828
Expr * getLHS()
Definition: Stmt.h:1915
static CaseStmt * Create(const ASTContext &Ctx, Expr *lhs, Expr *rhs, SourceLocation caseLoc, SourceLocation ellipsisLoc, SourceLocation colonLoc)
Build a case statement.
Definition: Stmt.cpp:1227
Expr * getRHS()
Definition: Stmt.h:1927
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:3547
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1628
bool body_empty() const
Definition: Stmt.h:1672
static CompoundStmt * Create(const ASTContext &C, ArrayRef< Stmt * > Stmts, FPOptionsOverride FPFeatures, SourceLocation LB, SourceLocation RB)
Definition: Stmt.cpp:390
Stmt * body_back()
Definition: Stmt.h:1696
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:4262
ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:3615
ContinueStmt - This represents a continue.
Definition: Stmt.h:2977
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1435
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:2089
bool isFileContext() const
Definition: DeclBase.h:2160
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1334
bool isRecord() const
Definition: DeclBase.h:2169
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1768
bool isStdNamespace() const
Definition: DeclBase.cpp:1318
bool isFunctionOrMethod() const
Definition: DeclBase.h:2141
void addHiddenDecl(Decl *D)
Add the declaration D to this context without modifying any lookup tables.
Definition: DeclBase.cpp:1742
Decl * getSingleDecl()
Definition: DeclGroup.h:83
bool isSingleDecl() const
Definition: DeclGroup.h:80
bool isNull() const
Definition: DeclGroup.h:79
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1265
ValueDecl * getDecl()
Definition: Expr.h:1333
SourceLocation getLocation() const
Definition: Expr.h:1341
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
Definition: Stmt.h:1519
bool isSingleDecl() const
isSingleDecl - This method returns true if this DeclStmt refers to a single Decl.
Definition: Stmt.h:1532
const Decl * getSingleDecl() const
Definition: Stmt.h:1534
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.h:1545
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
T * getAttr() const
Definition: DeclBase.h:576
bool hasAttrs() const
Definition: DeclBase.h:521
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:151
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
Definition: DeclBase.cpp:564
static Decl * castFromDeclContext(const DeclContext *)
Definition: DeclBase.cpp:1038
bool isInvalidDecl() const
Definition: DeclBase.h:591
SourceLocation getLocation() const
Definition: DeclBase.h:442
void setImplicit(bool I=true)
Definition: DeclBase.h:597
void setLocation(SourceLocation L)
Definition: DeclBase.h:443
DeclContext * getDeclContext()
Definition: DeclBase.h:451
AttrVec & getAttrs()
Definition: DeclBase.h:527
bool hasAttr() const
Definition: DeclBase.h:580
Kind getKind() const
Definition: DeclBase.h:445
SourceLocation getTypeSpecEndLoc() const
Definition: Decl.cpp:1983
SourceLocation getTypeSpecStartLoc() const
Definition: Decl.cpp:1977
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:786
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:764
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it has not been deduced.
Definition: Type.h:6543
bool isDeduced() const
Definition: Type.h:6544
SourceLocation getDefaultLoc() const
Definition: Stmt.h:1997
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1493
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:939
DoStmt - This represents a 'do/while' stmt.
Definition: Stmt.h:2752
Recursive AST visitor that supports extension via dynamic dispatch.
Represents an enum.
Definition: Decl.h:3847
enumerator_range enumerators() const
Definition: Decl.h:3980
bool isClosed() const
Returns true if this enum is either annotated with enum_extensibility(closed) or isn't annotated with...
Definition: Decl.cpp:4914
bool isClosedNonFlag() const
Returns true if this enum is annotated with neither flag_enum nor enum_extensibility(open).
Definition: Decl.cpp:4924
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
Definition: Type.h:6098
EnumDecl * getDecl() const
Definition: Type.h:6105
EvaluatedExprVisitor - This class visits 'Expr *'s.
This represents one expression.
Definition: Expr.h:110
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...
bool isXValue() const
Definition: Expr.h:279
bool isGLValue() const
Definition: Expr.h:280
@ SE_AllowSideEffects
Allow any unmodeled side effect.
Definition: Expr.h:671
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:3095
bool isUnusedResultAWarning(const Expr *&WarnExpr, SourceLocation &Loc, SourceRange &R1, SourceRange &R2, ASTContext &Ctx) const
isUnusedResultAWarning - Return true if this immediate expression should be warned about if the resul...
Definition: Expr.cpp:2617
bool isValueDependent() const
Determines whether the value of this expression depends on.
Definition: Expr.h:175
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Definition: Expr.h:192
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:3090
bool containsErrors() const
Whether this expression contains subexpressions which had errors, e.g.
Definition: Expr.h:245
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:3086
Decl * getReferencedDeclOfCallee()
Definition: Expr.cpp:1543
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
Definition: Expr.h:221
bool isIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:3070
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:277
QualType getType() const
Definition: Expr.h:142
bool isKnownToHaveBooleanValue(bool Semantic=true) const
isKnownToHaveBooleanValue - Return true if this is an integer expression that is known to return 0 or...
Definition: Expr.cpp:136
Represents difference between two FPOptions values.
Definition: LangOptions.h:978
FPOptionsOverride getChangesFrom(const FPOptions &Base) const
Return difference with the given option set.
Definition: LangOptions.h:1085
Represents a member of a struct/union/class.
Definition: Decl.h:3033
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
Definition: Diagnostic.h:138
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:127
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:101
ForStmt - This represents a 'for (init;cond;inc)' stmt.
Definition: Stmt.h:2808
void setBody(Stmt *S)
Definition: Stmt.h:2862
SourceLocation getRParenLoc() const
Definition: Stmt.h:2868
SourceLocation getBeginLoc() const
Definition: Stmt.h:2871
FullExpr - Represents a "full-expression" node.
Definition: Expr.h:1044
Represents a function declaration or definition.
Definition: Decl.h:1935
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2672
void setUsesSEHTry(bool UST)
Definition: Decl.h:2447
bool isNoReturn() const
Determines whether this function is known to be 'noreturn', through an attribute on its declaration o...
Definition: Decl.cpp:3531
QualType getReturnType() const
Definition: Decl.h:2720
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:2398
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program.
Definition: Decl.cpp:3313
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:4405
bool isOverloadedOperator() const
Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".
Definition: Decl.h:2808
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
Definition: Decl.cpp:3989
bool isConsteval() const
Definition: Decl.h:2410
Represents a prototype with parameter type info, e.g.
Definition: Type.h:5102
Declaration of a template function.
Definition: DeclTemplate.h:959
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:4321
static StringRef getNameForCallConv(CallingConv CC)
Definition: Type.cpp:3537
bool getNoReturnAttr() const
Determine whether this function type includes the GNU noreturn attribute.
Definition: Type.h:4651
QualType getReturnType() const
Definition: Type.h:4643
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
Definition: Expr.h:4716
GotoStmt - This represents a direct goto.
Definition: Stmt.h:2889
One of these records is kept for each identifier that is lexed.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
static IfStmt * Create(const ASTContext &Ctx, SourceLocation IL, IfStatementKind Kind, Stmt *Init, VarDecl *Var, Expr *Cond, SourceLocation LPL, SourceLocation RPL, Stmt *Then, SourceLocation EL=SourceLocation(), Stmt *Else=nullptr)
Create an IfStmt.
Definition: Stmt.cpp:965
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
Definition: Expr.h:1717
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3724
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
Definition: Expr.cpp:2082
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)
Create implicit parameter.
Definition: Decl.cpp:5402
IndirectGotoStmt - This represents an indirect goto.
Definition: Stmt.h:2928
static InitializationKind CreateCopy(SourceLocation InitLoc, SourceLocation EqualLoc, bool AllowExplicitConvs=false)
Create a copy initialization.
Describes the sequence of initializations required to initialize a given object or reference with a s...
Describes an entity that is being initialized.
static InitializedEntity InitializeResult(SourceLocation ReturnLoc, QualType Type)
Create the initialization entity for the result of a function.
static InitializedEntity InitializeRelatedResult(ObjCMethodDecl *MD, QualType Type)
Create the initialization entity for a related result.
unsigned allocateManglingNumber() const
static InitializedEntity InitializeVariable(VarDecl *Var)
Create the initialization entity for a variable.
static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)
Create the initialization entity for a parameter.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Definition: Expr.cpp:973
Represents the declaration of a label.
Definition: Decl.h:503
bool isGnuLocal() const
Definition: Decl.h:530
void setLocStart(SourceLocation L)
Definition: Decl.h:531
LabelStmt * getStmt() const
Definition: Decl.h:527
void setStmt(LabelStmt *T)
Definition: Decl.h:528
bool isMSAsmLabel() const
Definition: Decl.h:537
LabelStmt - Represents a label, which has a substatement.
Definition: Stmt.h:2058
Represents the results of name lookup.
Definition: Lookup.h:46
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:362
bool isAmbiguous() const
Definition: Lookup.h:324
Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name.
Definition: StmtCXX.h:253
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Definition: ExprCXX.h:4734
Expr * getSubExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.
Definition: ExprCXX.h:4751
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:3236
Expr * getBase() const
Definition: Expr.h:3313
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:3519
This represents a decl that may have a name.
Definition: Decl.h:253
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:274
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:319
ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const
Determine if the declaration obeys the reserved identifier rules of the given language.
Definition: Decl.cpp:1126
A C++ nested-name-specifier augmented with source location information.
NullStmt - This is the null statement ";": C99 6.8.3p3.
Definition: Stmt.h:1591
Represents Objective-C's collection statement.
Definition: StmtObjC.h:23
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:941
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:140
bool hasRelatedResultType() const
Determine whether this method has a result type that is related to the message receiver's type.
Definition: DeclObjC.h:256
QualType getReturnType() const
Definition: DeclObjC.h:329
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1209
Represents a pointer to an Objective C object.
Definition: Type.h:7580
Wrapper for void* pointer.
Definition: Ownership.h:50
void * getAsOpaquePtr() const
Definition: Ownership.h:90
PtrTy get() const
Definition: Ownership.h:80
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13....
Definition: Overload.h:1008
@ CSK_Normal
Normal lookup.
Definition: Overload.h:1012
void NoteCandidates(PartialDiagnosticAt PA, Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef< Expr * > Args, StringRef Opc="", SourceLocation Loc=SourceLocation(), llvm::function_ref< bool(OverloadCandidate &)> Filter=[](OverloadCandidate &) { return true;})
When overload resolution fails, prints diagnostic messages containing the candidates in the candidate...
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:3044
ParenExpr - This represents a parenthesized expression, e.g.
Definition: Expr.h:2170
Represents a parameter to a function.
Definition: Decl.h:1725
ParsedAttributes - A collection of parsed attributes.
Definition: ParsedAttr.h:956
Wrapper for source info for pointers.
Definition: TypeLoc.h:1332
SourceLocation getStarLoc() const
Definition: TypeLoc.h:1334
IdentifierTable & getIdentifierTable()
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:6546
ArrayRef< Expr * > semantics()
Definition: Expr.h:6625
A (possibly-)qualified type.
Definition: Type.h:929
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:8015
QualType withRestrict() const
Definition: Type.h:1170
QualType withConst() const
Definition: Type.h:1154
bool isTriviallyCopyConstructibleType(const ASTContext &Context) const
Return true if this is a trivially copyable type.
Definition: Type.cpp:2838
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:996
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:8134
QualType getCanonicalType() const
Definition: Type.h:7983
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:8025
void removeLocalConst()
Definition: Type.h:8039
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:8004
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
Definition: Type.h:354
Represents a struct/union/class.
Definition: Decl.h:4148
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
Definition: Decl.cpp:5038
bool isOrContainsUnion() const
Returns whether this record is a union, or contains (at any nesting level) a union member.
Definition: Decl.cpp:5077
virtual void completeDefinition()
Note that the definition of this type is now complete.
Definition: Decl.cpp:5104
void setCapturedRecord()
Mark the record as a record for captured variables in CapturedStmt construct.
Definition: Decl.cpp:5073
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:6072
RecordDecl * getDecl() const
Definition: Type.h:6082
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
Definition: Stmt.h:3046
void setRetValue(Expr *E)
Definition: Stmt.h:3079
static ReturnStmt * Create(const ASTContext &Ctx, SourceLocation RL, Expr *E, const VarDecl *NRVOCandidate)
Create a return statement.
Definition: Stmt.cpp:1211
Expr * getRetValue()
Definition: Stmt.h:3077
static SEHExceptStmt * Create(const ASTContext &C, SourceLocation ExceptLoc, Expr *FilterExpr, Stmt *Block)
Definition: Stmt.cpp:1274
static SEHFinallyStmt * Create(const ASTContext &C, SourceLocation FinallyLoc, Stmt *Block)
Definition: Stmt.cpp:1282
Represents a __leave statement.
Definition: Stmt.h:3745
static SEHTryStmt * Create(const ASTContext &C, bool isCXXTry, SourceLocation TryLoc, Stmt *TryBlock, Stmt *Handler)
Definition: Stmt.cpp:1254
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:41
const Scope * getFnParent() const
getFnParent - Return the closest scope that is a function body.
Definition: Scope.h:275
bool Contains(const Scope &rhs) const
Returns if rhs has a higher scope depth than this.
Definition: Scope.h:600
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:263
Scope * getContinueParent()
getContinueParent - Return the closest scope that a continue statement would be affected by.
Definition: Scope.h:285
bool isSEHTryScope() const
Determine whether this scope is a SEH '__try' block.
Definition: Scope.h:576
Scope * getBreakParent()
getBreakParent - Return the closest scope that a break statement would be affected by.
Definition: Scope.h:306
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:271
void updateNRVOCandidate(VarDecl *VD)
Definition: Scope.cpp:136
@ SwitchScope
This is a scope that corresponds to a switch statement.
Definition: Scope.h:102
A generic diagnostic builder for errors which may or may not be deferred.
Definition: SemaBase.h:110
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
Definition: SemaBase.cpp:60
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaBase.cpp:32
SemaDiagnosticBuilder DiagIfDeviceCode(SourceLocation Loc, unsigned DiagID)
Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as device c...
Definition: SemaCUDA.cpp:817
StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc, Stmt *First, Expr *collection, SourceLocation RParenLoc)
Definition: SemaObjC.cpp:36
StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body)
FinishObjCForCollectionStmt - Attach the body to a objective-C foreach statement.
Definition: SemaObjC.cpp:198
bool inferObjCARCLifetime(ValueDecl *decl)
void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init)
Check if the current region is an OpenMP loop region and if it is, mark loop control variable,...
void setOpenMPCaptureKind(FieldDecl *FD, const ValueDecl *D, unsigned Level)
Sets OpenMP capture kind (OMPC_private, OMPC_firstprivate, OMPC_map etc.) for FD based on DSA for the...
std::pair< VarDecl *, Expr * > get() const
Definition: Sema.h:7332
bool isInvalid() const
Definition: Sema.h:7331
ExprResult release()
Definition: Sema.h:7278
Expr * get() const
Definition: Sema.h:7280
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
Definition: Sema.h:12086
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:464
ParsedType CreateParsedType(QualType T, TypeSourceInfo *TInfo)
Package the given type and TSI into a ParsedType.
Definition: SemaType.cpp:6394
SmallVector< Scope *, 2 > CurrentSEHFinally
Stack of active SEH __finally scopes. Can be empty.
Definition: Sema.h:10657
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:12643
Scope * getCurScope() const
Retrieve the parser's current scope.
Definition: Sema.h:732
void DiagnoseDiscardedExprMarkedNodiscard(const Expr *E)
DiagnoseDiscardedExprMarkedNodiscard - Given an expression that is semantically a discarded-value exp...
Definition: SemaStmt.cpp:416
void ProcessStmtAttributes(Stmt *Stmt, const ParsedAttributes &InAttrs, SmallVectorImpl< const Attr * > &OutAttrs)
Process the attributes before creating an attributed statement.
ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Op, Expr *Input, bool IsAfterAmp=false)
Unary Operators. 'Tok' is the token for the operator.
Definition: SemaExpr.cpp:15821
StmtResult BuildMSDependentExistsStmt(SourceLocation KeywordLoc, bool IsIfExists, NestedNameSpecifierLoc QualifierLoc, DeclarationNameInfo NameInfo, Stmt *Nested)
Definition: SemaStmt.cpp:4479
ExprResult IgnoredValueConversions(Expr *E)
IgnoredValueConversions - Given that an expression's result is syntactically ignored,...
@ LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:8998
bool ActOnCoroutineBodyStart(Scope *S, SourceLocation KwLoc, StringRef Keyword)
StmtResult BuildAttributedStmt(SourceLocation AttrsLoc, ArrayRef< const Attr * > Attrs, Stmt *SubStmt)
Definition: SemaStmt.cpp:651
SemaOpenMP & OpenMP()
Definition: Sema.h:1126
StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope)
Definition: SemaStmt.cpp:4468
StmtResult ActOnForEachLValueExpr(Expr *E)
In an Objective C collection iteration statement: for (x in y) x can be an arbitrary l-value expressi...
Definition: SemaStmt.cpp:2313
void ActOnForEachDeclStmt(DeclGroupPtrTy Decl)
Definition: SemaStmt.cpp:86
SemaCUDA & CUDA()
Definition: Sema.h:1071
void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl=nullptr, ExpressionEvaluationContextRecord::ExpressionKind Type=ExpressionEvaluationContextRecord::EK_Other)
Definition: SemaExpr.cpp:17394
ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)
CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...
Definition: SemaExpr.cpp:20387
@ Switch
An integral condition for a 'switch' statement.
SmallVector< sema::FunctionScopeInfo *, 4 > FunctionScopes
Stack containing information about each of the nested function, block, and method scopes that are cur...
Definition: Sema.h:849
PoppedFunctionScopePtr PopFunctionScopeInfo(const sema::AnalysisBasedWarnings::Policy *WP=nullptr, const Decl *D=nullptr, QualType BlockType=QualType())
Pop a function (or block or lambda or captured region) scope from the stack.
Definition: Sema.cpp:2292
bool checkAndRewriteMustTailAttr(Stmt *St, const Attr &MTA)
Check whether the given statement can have musttail applied to it, issuing a diagnostic and returning...
Definition: SemaStmt.cpp:680
StmtResult ActOnGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc, LabelDecl *TheDecl)
Definition: SemaStmt.cpp:3217
StmtResult ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, Scope *CurScope)
Definition: SemaStmt.cpp:3828
void setFunctionHasBranchIntoScope()
Definition: Sema.cpp:2341
ExprResult ActOnCaseExpr(SourceLocation CaseLoc, ExprResult Val)
Definition: SemaStmt.cpp:500
ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)
VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...
Definition: SemaExpr.cpp:17152
SimplerImplicitMoveMode
Definition: Sema.h:10817
StmtResult ActOnExprStmt(ExprResult Arg, bool DiscardedValue=true)
Definition: SemaStmt.cpp:49
FieldDecl * BuildCaptureField(RecordDecl *RD, const sema::Capture &Capture)
Build a FieldDecl suitable to hold the given capture.
StmtResult BuildIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal)
Definition: SemaStmt.cpp:1044
FunctionDecl * getCurFunctionDecl(bool AllowLambda=false) const
Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...
Definition: Sema.cpp:1570
ExprResult PerformContextualImplicitConversion(SourceLocation Loc, Expr *FromE, ContextualImplicitConverter &Converter)
Perform a contextual implicit conversion.
ExprResult UsualUnaryConversions(Expr *E)
UsualUnaryConversions - Performs various conversions that are common to most operators (C99 6....
Definition: SemaExpr.cpp:784
void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc)
Look for instances where it is likely the comma operator is confused with another operator.
Definition: SemaExpr.cpp:13879
ExprResult CheckSwitchCondition(SourceLocation SwitchLoc, Expr *Cond)
Definition: SemaStmt.cpp:1120
ASTContext & Context
Definition: Sema.h:909
bool DiagIfReachable(SourceLocation Loc, ArrayRef< const Stmt * > Stmts, const PartialDiagnostic &PD)
Conditionally issue a diagnostic based on the statements's reachability analysis.
Definition: SemaExpr.cpp:20182
void FinalizeDeclaration(Decl *D)
FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...
Definition: SemaDecl.cpp:14677
void ActOnCapturedRegionError()
Definition: SemaStmt.cpp:4660
SemaObjC & ObjC()
Definition: Sema.h:1111
DeclGroupPtrTy ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType=nullptr)
Definition: SemaDecl.cpp:70
@ AllowFold
Definition: Sema.h:7245
ExprResult DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose=true)
Definition: SemaExpr.cpp:752
ASTContext & getASTContext() const
Definition: Sema.h:532
ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *Input, bool IsAfterAmp=false)
Definition: SemaExpr.cpp:15777
void PopExpressionEvaluationContext()
Definition: SemaExpr.cpp:17827
StmtResult ActOnSEHTryBlock(bool IsCXXTry, SourceLocation TryLoc, Stmt *TryBlock, Stmt *Handler)
Definition: SemaStmt.cpp:4403
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)
ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
Definition: Sema.cpp:692
ForRangeStatus
Definition: Sema.h:10479
@ FRS_Success
Definition: Sema.h:10480
@ FRS_DiagnosticIssued
Definition: Sema.h:10482
@ FRS_NoViableFunction
Definition: Sema.h:10481
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition: Sema.cpp:1575
DeclRefExpr * BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, SourceLocation Loc, const CXXScopeSpec *SS=nullptr)
Definition: SemaExpr.cpp:2204
ExprResult CheckConvertedConstantExpression(Expr *From, QualType T, llvm::APSInt &Value, CCEKind CCE)
void setFunctionHasIndirectGoto()
Definition: Sema.cpp:2351
ExprResult BuildCaptureInit(const sema::Capture &Capture, SourceLocation ImplicitCaptureLoc, bool IsOpenMPMapping=false)
Initialize the given capture with a suitable expression.
StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch, Stmt *Body)
Definition: SemaStmt.cpp:1308
NamedReturnInfo getNamedReturnInfo(Expr *&E, SimplerImplicitMoveMode Mode=SimplerImplicitMoveMode::Normal)
Determine whether the given expression might be move-eligible or copy-elidable in either a (co_)retur...
Definition: SemaStmt.cpp:3329
std::unique_ptr< sema::FunctionScopeInfo, PoppedFunctionScopeDeleter > PoppedFunctionScopePtr
Definition: Sema.h:672
void DiagnoseUnusedExprResult(const Stmt *S, unsigned DiagID)
DiagnoseUnusedExprResult - If the statement passed in is an expression whose result is unused,...
Definition: SemaStmt.cpp:420
FPOptions & getCurFPFeatures()
Definition: Sema.h:527
void PopCompoundScope()
Definition: Sema.cpp:2330
@ UPPC_Expression
An arbitrary expression.
Definition: Sema.h:13909
const LangOptions & getLangOpts() const
Definition: Sema.h:525
StmtResult ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc, ConditionResult Cond, SourceLocation RParenLoc, Stmt *Body)
Definition: SemaStmt.cpp:1792
Preprocessor & PP
Definition: Sema.h:908
bool DiagnoseUnexpandedParameterPack(SourceLocation Loc, TypeSourceInfo *T, UnexpandedParameterPackContext UPPC)
If the given type contains an unexpanded parameter pack, diagnose the error.
const LangOptions & LangOpts
Definition: Sema.h:907
sema::LambdaScopeInfo * getCurLambda(bool IgnoreNonLambdaCapturingScope=false)
Retrieve the current lambda scope info, if any.
Definition: Sema.cpp:2406
void ActOnStartOfCompoundStmt(bool IsStmtExpr)
Definition: SemaStmt.cpp:431
bool DeduceFunctionTypeFromReturnExpr(FunctionDecl *FD, SourceLocation ReturnLoc, Expr *RetExpr, const AutoType *AT)
Deduce the return type for a function from a returned expression, per C++1y [dcl.spec....
Definition: SemaStmt.cpp:3717
void MarkAnyDeclReferenced(SourceLocation Loc, Decl *D, bool MightBeOdrUse)
Perform marking for a reference to an arbitrary declaration.
Definition: SemaExpr.cpp:20066
TypeLoc getReturnTypeLoc(FunctionDecl *FD) const
Definition: SemaStmt.cpp:3710
StmtResult ActOnExprStmtError()
Definition: SemaStmt.cpp:66
const VarDecl * getCopyElisionCandidate(NamedReturnInfo &Info, QualType ReturnType)
Updates given NamedReturnInfo's move-eligible and copy-elidable statuses, considering the function re...
Definition: SemaStmt.cpp:3407
NamedDecl * getCurFunctionOrMethodDecl() const
getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method or C function we're in,...
Definition: Sema.cpp:1582
StmtResult ActOnNullStmt(SourceLocation SemiLoc, bool HasLeadingEmptyMacro=false)
Definition: SemaStmt.cpp:71
RecordDecl * CreateCapturedStmtRecordDecl(CapturedDecl *&CD, SourceLocation Loc, unsigned NumParams)
Definition: SemaStmt.cpp:4503
void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope, CapturedRegionKind Kind, unsigned NumParams)
Definition: SemaStmt.cpp:4571
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:940
void PushCompoundScope(bool IsStmtExpr)
Definition: Sema.cpp:2325
DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl * > Group)
BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...
Definition: SemaDecl.cpp:14909
AssignConvertType CheckSingleAssignmentConstraints(QualType LHSType, ExprResult &RHS, bool Diagnose=true, bool DiagnoseCFAudited=false, bool ConvertRHS=true)
Check assignment constraints for an assignment of RHS to LHSType.
Definition: SemaExpr.cpp:9628
void DiagnoseAssignmentEnum(QualType DstType, QualType SrcType, Expr *SrcExpr)
DiagnoseAssignmentEnum - Warn if assignment to enum is a constant integer not in the range of enum va...
Definition: SemaStmt.cpp:1736
ExprResult ActOnCoawaitExpr(Scope *S, SourceLocation KwLoc, Expr *E)
std::optional< sema::TemplateDeductionInfo * > isSFINAEContext() const
Determines whether we are currently in a context where template argument substitution failures are no...
bool findMacroSpelling(SourceLocation &loc, StringRef name)
Looks through the macro-expansion chain for the given location, looking for a macro expansion with th...
Definition: Sema.cpp:2144
void DiagnoseEmptyStmtBody(SourceLocation StmtLoc, const Stmt *Body, unsigned DiagID)
Emit DiagID if statement located on StmtLoc has a suspicious null statement as a Body,...
void DiagnoseEmptyLoopBody(const Stmt *S, const Stmt *PossibleBody)
Warn if a for/while loop statement S, which is followed by PossibleBody, has a suspicious null statem...
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:640
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:1044
DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)
Retrieves the declaration name from a parsed unqualified-id.
Definition: SemaDecl.cpp:5787
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5.
Definition: Sema.h:7777
StmtResult ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, NamedReturnInfo &NRInfo, bool SupressSimplerImplicitMoves)
ActOnCapScopeReturnStmt - Utility routine to type-check return statements for capturing scopes.
Definition: SemaStmt.cpp:3504
AssignConvertType
AssignConvertType - All of the 'assignment' semantic checks return this enum to indicate whether the ...
Definition: Sema.h:7580
StmtResult ActOnCapturedRegionEnd(Stmt *S)
Definition: SemaStmt.cpp:4675
StmtResult ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, Stmt *First, ConditionResult Second, FullExprArg Third, SourceLocation RParenLoc, Stmt *Body)
Definition: SemaStmt.cpp:2255
StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc, Expr *DestExp)
Definition: SemaStmt.cpp:3232
ExprResult CheckPlaceholderExpr(Expr *E)
Check for operands with placeholder types and complain if found.
Definition: SemaExpr.cpp:20971
bool inTemplateInstantiation() const
Determine whether we are currently performing template instantiation.
Definition: Sema.h:13502
SourceManager & getSourceManager() const
Definition: Sema.h:530
ExprResult PerformMoveOrCopyInitialization(const InitializedEntity &Entity, const NamedReturnInfo &NRInfo, Expr *Value, bool SupressSimplerImplicitMoves=false)
Perform the initialization of a potentially-movable value, which is the result of return value.
Definition: SemaStmt.cpp:3464
void ActOnInitializerError(Decl *Dcl)
ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...
Definition: SemaDecl.cpp:13903
StmtResult ActOnCXXForRangeStmt(Scope *S, SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *InitStmt, Stmt *LoopVar, SourceLocation ColonLoc, Expr *Collection, SourceLocation RParenLoc, BuildForRangeKind Kind, ArrayRef< MaterializeTemporaryExpr * > LifetimeExtendTemps={})
ActOnCXXForRangeStmt - Check and build a C++11 for-range statement.
Definition: SemaStmt.cpp:2425
StmtResult BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, bool AllowRecovery=false)
Definition: SemaStmt.cpp:3883
ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc, tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr)
Binary Operators. 'Tok' is the token for the operator.
Definition: SemaExpr.cpp:15271
void PushCapturedRegionScope(Scope *RegionScope, CapturedDecl *CD, RecordDecl *RD, CapturedRegionKind K, unsigned OpenMPCaptureLevel=0)
Definition: Sema.cpp:2721
void setFunctionHasMustTail()
Definition: Sema.cpp:2356
void setFunctionHasBranchProtectedScope()
Definition: Sema.cpp:2346
StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block)
Definition: SemaStmt.cpp:4461
StmtResult ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope)
Definition: SemaStmt.cpp:3273
@ CCEK_CaseValue
Expression in a case label.
Definition: Sema.h:9999
StmtResult BuildCXXForRangeStmt(SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *InitStmt, SourceLocation ColonLoc, Stmt *RangeDecl, Stmt *Begin, Stmt *End, Expr *Cond, Expr *Inc, Stmt *LoopVarDecl, SourceLocation RParenLoc, BuildForRangeKind Kind, ArrayRef< MaterializeTemporaryExpr * > LifetimeExtendTemps={})
BuildCXXForRangeStmt - Build or instantiate a C++11 for-range statement.
Definition: SemaStmt.cpp:2683
StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body, SourceLocation WhileLoc, SourceLocation CondLParen, Expr *Cond, SourceLocation CondRParen)
Definition: SemaStmt.cpp:1822
StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc)
Definition: SemaStmt.cpp:1184
StmtResult ActOnMSDependentExistsStmt(SourceLocation KeywordLoc, bool IsIfExists, CXXScopeSpec &SS, UnqualifiedId &Name, Stmt *Nested)
Definition: SemaStmt.cpp:4491
@ PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
@ ImmediateFunctionContext
In addition of being constant evaluated, the current expression occurs in an immediate function conte...
StmtResult ActOnSEHExceptBlock(SourceLocation Loc, Expr *FilterExpr, Stmt *Block)
Definition: SemaStmt.cpp:4441
void ActOnAfterCompoundStatementLeadingPragmas()
Definition: SemaStmt.cpp:435
StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, SourceLocation StartLoc, SourceLocation EndLoc)
Definition: SemaStmt.cpp:76
bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:9068
void ActOnFields(Scope *S, SourceLocation RecLoc, Decl *TagDecl, ArrayRef< Decl * > Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList)
Definition: SemaDecl.cpp:18992
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
void DiscardCleanupsInEvaluationContext()
Definition: SemaExpr.cpp:17904
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:7917
void PushDeclContext(Scope *S, DeclContext *DC)
Set the current declaration context until it gets popped.
Definition: SemaDecl.cpp:1308
StmtResult ActOnAttributedStmt(const ParsedAttributes &AttrList, Stmt *SubStmt)
Definition: SemaStmt.cpp:668
SourceManager & SourceMgr
Definition: Sema.h:912
DiagnosticsEngine & Diags
Definition: Sema.h:911
StmtResult ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope)
Definition: SemaStmt.cpp:3300
void ActOnStartSEHFinallyBlock()
Definition: SemaStmt.cpp:4453
ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)
Definition: SemaInit.cpp:9713
void ActOnAbortSEHFinallyBlock()
Definition: SemaStmt.cpp:4457
void PopDeclContext()
Definition: SemaDecl.cpp:1315
QualType SubstAutoTypeDependent(QualType TypeWithAuto)
BuildForRangeKind
Definition: Sema.h:10752
@ BFRK_Check
Determining whether a for-range statement could be built.
Definition: Sema.h:10760
@ BFRK_Build
Initial building of a for-range statement.
Definition: Sema.h:10754
@ BFRK_Rebuild
Instantiation or recovery rebuild of a for-range statement.
Definition: Sema.h:10757
StmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc, Decl *ExDecl, Stmt *HandlerBlock)
ActOnCXXCatchBlock - Takes an exception declaration and a handler block and creates a proper catch ha...
Definition: SemaStmt.cpp:4170
void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt)
ActOnCaseStmtBody - This installs a statement as the body of a case.
Definition: SemaStmt.cpp:583
void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)
AddInitializerToDecl - Adds the initializer Init to the declaration dcl.
Definition: SemaDecl.cpp:13386
bool DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained=nullptr)
DiagnoseAssignmentResult - Emit a diagnostic, if required, for the assignment conversion type specifi...
Definition: SemaExpr.cpp:16819
SemaDiagnosticBuilder targetDiag(SourceLocation Loc, unsigned DiagID, const FunctionDecl *FD=nullptr)
Definition: Sema.cpp:1963
ExprResult CreateRecoveryExpr(SourceLocation Begin, SourceLocation End, ArrayRef< Expr * > SubExprs, QualType T=QualType())
Attempts to produce a RecoveryExpr after some AST node cannot be created.
Definition: SemaExpr.cpp:21168
StmtResult ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal)
Definition: SemaStmt.cpp:962
std::string getTemplateArgumentBindingsText(const TemplateParameterList *Params, const TemplateArgumentList &Args)
Produces a formatted string that describes the binding of template parameters to template arguments.
ExprResult ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc, UnaryExprOrTypeTrait ExprKind, bool IsType, void *TyOrEx, SourceRange ArgRange)
ActOnUnaryExprOrTypeTraitExpr - Handle sizeof(type) and sizeof expr and the same for alignof and __al...
Definition: SemaExpr.cpp:4686
ForRangeStatus BuildForRangeBeginEndCall(SourceLocation Loc, SourceLocation RangeLoc, const DeclarationNameInfo &NameInfo, LookupResult &MemberLookup, OverloadCandidateSet *CandidateSet, Expr *Range, ExprResult *CallExpr)
Build a call to 'begin' or 'end' for a C++11 for-range statement.
sema::CompoundScopeInfo & getCurCompoundScope() const
Definition: SemaStmt.cpp:447
TemplateDeductionResult DeduceAutoType(TypeLoc AutoTypeLoc, Expr *Initializer, QualType &Result, sema::TemplateDeductionInfo &Info, bool DependentDeduction=false, bool IgnoreConstraints=false, TemplateSpecCandidateSet *FailedTSC=nullptr)
Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6)
void ActOnFinishOfCompoundStmt()
Definition: SemaStmt.cpp:443
StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R, ArrayRef< Stmt * > Elts, bool isStmtExpr)
Definition: SemaStmt.cpp:451
bool IsValueInFlagEnum(const EnumDecl *ED, const llvm::APInt &Val, bool AllowMask) const
IsValueInFlagEnum - Determine if a value is allowed as part of a flag enum.
Definition: SemaDecl.cpp:19982
StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl, SourceLocation ColonLoc, Stmt *SubStmt)
Definition: SemaStmt.cpp:608
StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock, ArrayRef< Stmt * > Handlers)
ActOnCXXTryBlock - Takes a try compound-statement and a number of handlers and creates a try statemen...
Definition: SemaStmt.cpp:4290
StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc, Stmt *SubStmt, Scope *CurScope)
Definition: SemaStmt.cpp:588
StmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprResult LHS, SourceLocation DotDotDotLoc, ExprResult RHS, SourceLocation ColonLoc)
Definition: SemaStmt.cpp:552
StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body)
FinishCXXForRangeStmt - Attach the body to a C++0x for-range statement.
Definition: SemaStmt.cpp:3199
ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})
Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...
ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)
Definition: Sema.h:8268
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
SourceLocation getLocWithOffset(IntTy Offset) const
Return a source location with the specified offset from this SourceLocation.
bool isMacroBodyExpansion(SourceLocation Loc) const
Tests whether the given source location represents the expansion of a macro body.
bool isInSystemMacro(SourceLocation loc) const
Returns whether Loc is expanded from a macro in a system header.
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
A trivial tuple used to represent a source range.
SourceLocation getBegin() const
Stmt - This represents one statement.
Definition: Stmt.h:84
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:357
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:333
static std::tuple< bool, const Attr *, const Attr * > determineLikelihoodConflict(const Stmt *Then, const Stmt *Else)
Definition: Stmt.cpp:192
static const Attr * getLikelihoodAttr(const Stmt *S)
Definition: Stmt.cpp:170
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:345
const SwitchCase * getNextSwitchCase() const
Definition: Stmt.h:1801
SwitchStmt - This represents a 'switch' stmt.
Definition: Stmt.h:2415
void setBody(Stmt *Body)
Definition: Stmt.h:2495
static SwitchStmt * Create(const ASTContext &Ctx, Stmt *Init, VarDecl *Var, Expr *Cond, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a switch statement.
Definition: Stmt.cpp:1088
Expr * getCond()
Definition: Stmt.h:2478
SwitchCase * getSwitchCaseList()
Definition: Stmt.h:2552
void setAllEnumCasesCovered()
Set a flag in the SwitchStmt indicating that if the 'switch (X)' is a switch over an enum value then ...
Definition: Stmt.h:2577
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3564
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3667
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:3792
void startDefinition()
Starts the definition of this tag declaration.
Definition: Decl.cpp:4760
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:1262
bool isSEHTrySupported() const
Whether the target supports SEH __try.
Definition: TargetInfo.h:1597
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
void NoteCandidates(Sema &S, SourceLocation Loc)
NoteCandidates - When no template specialization match is found, prints diagnostic messages containin...
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:59
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:133
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type.
Definition: TypeLoc.h:78
T getAsAdjusted() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:2715
A container of type source information.
Definition: Type.h:7902
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:256
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:7913
The base class of the type hierarchy.
Definition: Type.h:1828
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1916
bool isVoidType() const
Definition: Type.h:8510
bool isSignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is signed or an enumeration types whose underlying ty...
Definition: Type.cpp:2201
bool isRValueReferenceType() const
Definition: Type.h:8212
bool isArrayType() const
Definition: Type.h:8258
bool isPointerType() const
Definition: Type.h:8186
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:8550
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:8800
bool isReferenceType() const
Definition: Type.h:8204
bool isEnumeralType() const
Definition: Type.h:8290
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition: Type.cpp:738
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:8625
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
Definition: Type.h:2811
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: Type.h:8479
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2706
bool containsErrors() const
Whether this type is an error type.
Definition: Type.h:2700
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
Definition: Type.h:8786
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
Definition: Type.h:8644
bool isObjectType() const
Determine whether this type is an object type.
Definition: Type.h:2446
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
Definition: Type.cpp:2396
TypeClass getTypeClass() const
Definition: Type.h:2341
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
Definition: Type.h:2367
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:8731
bool isRecordType() const
Definition: Type.h:8286
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Definition: Expr.h:2232
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:1028
void setType(QualType newType)
Definition: Decl.h:683
QualType getType() const
Definition: Decl.h:682
QualType getType() const
Definition: Value.cpp:234
Represents a variable declaration or definition.
Definition: Decl.h:882
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:2140
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2179
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition: Decl.h:1177
bool isExceptionVariable() const
Determine whether this variable is the exception variable in a C++ catch statememt or an Objective-C ...
Definition: Decl.h:1438
const Expr * getInit() const
Definition: Decl.h:1319
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
Definition: Decl.h:1135
bool isLocalVarDecl() const
Returns true for local variable declarations other than parameters.
Definition: Decl.h:1204
bool hasDependentAlignment() const
Determines if this variable's alignment is dependent.
Definition: Decl.cpp:2682
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3808
WhileStmt - This represents a 'while' stmt.
Definition: Stmt.h:2611
static WhileStmt * Create(const ASTContext &Ctx, VarDecl *Var, Expr *Cond, Stmt *Body, SourceLocation WL, SourceLocation LParenLoc, SourceLocation RParenLoc)
Create a while statement.
Definition: Stmt.cpp:1150
ValueDecl * getVariable() const
Definition: ScopeInfo.h:675
bool isVariableCapture() const
Definition: ScopeInfo.h:650
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
Definition: ScopeInfo.h:686
bool isInvalid() const
Definition: ScopeInfo.h:661
bool isVLATypeCapture() const
Definition: ScopeInfo.h:657
bool isThisCapture() const
Definition: ScopeInfo.h:649
bool isReferenceCapture() const
Definition: ScopeInfo.h:655
Retains information about a captured region.
Definition: ScopeInfo.h:816
unsigned short CapRegionKind
The kind of captured region.
Definition: ScopeInfo.h:831
RecordDecl * TheRecordDecl
The captured record type.
Definition: ScopeInfo.h:822
CapturedDecl * TheCapturedDecl
The CapturedDecl for this statement.
Definition: ScopeInfo.h:819
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
Definition: ScopeInfo.h:732
SmallVector< Capture, 4 > Captures
Captures - The captures.
Definition: ScopeInfo.h:721
Contains information about the compound statement currently being parsed.
Definition: ScopeInfo.h:67
FPOptions InitialFPFeatures
FP options at the beginning of the compound statement, prior to any pragma.
Definition: ScopeInfo.h:79
Retains information about a function, method, or block that is currently being parsed.
Definition: ScopeInfo.h:104
llvm::PointerIntPair< SwitchStmt *, 1, bool > SwitchInfo
A SwitchStmt, along with a flag indicating if its list of case statements is incomplete (because we d...
Definition: ScopeInfo.h:205
SourceLocation FirstCXXOrObjCTryLoc
First C++ 'try' or ObjC @try statement in the current function.
Definition: ScopeInfo.h:189
SourceLocation FirstCoroutineStmtLoc
First coroutine statement in the current function.
Definition: ScopeInfo.h:183
StringRef getFirstCoroutineStmtKeyword() const
Definition: ScopeInfo.h:518
SourceLocation FirstReturnLoc
First 'return' statement in the current function.
Definition: ScopeInfo.h:186
enum clang::sema::FunctionScopeInfo::@245 FirstTryType
SourceLocation FirstSEHTryLoc
First SEH '__try' statement in the current function.
Definition: ScopeInfo.h:193
void setHasCXXTry(SourceLocation TryLoc)
Definition: ScopeInfo.h:465
SmallVector< CompoundScopeInfo, 4 > CompoundScopes
The stack of currently active compound statement scopes in the function.
Definition: ScopeInfo.h:228
void setHasSEHTry(SourceLocation TryLoc)
Definition: ScopeInfo.h:477
SmallVector< SwitchInfo, 8 > SwitchStack
SwitchStack - This is the current set of active switch statements in the block.
Definition: ScopeInfo.h:209
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
Definition: ScopeInfo.h:874
Provides information about an attempted template argument deduction, whose success or failure was des...
TemplateArgument SecondArg
The second template argument to which the template argument deduction failure refers.
TemplateArgument FirstArg
The first template argument to which the template argument deduction failure refers.
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
bool This(InterpState &S, CodePtr OpPC)
Definition: Interp.h:2392
bool Cast(InterpState &S, CodePtr OpPC)
Definition: Interp.h:2128
void checkExprLifetimeMustTailArg(Sema &SemaRef, const InitializedEntity &Entity, Expr *Init)
Check that the lifetime of the given expr (and its subobjects) is sufficient, assuming that it is pas...
The JSON file list parser is used to communicate input to InstallAPI.
@ CPlusPlus23
Definition: LangStandard.h:60
@ CPlusPlus
Definition: LangStandard.h:55
@ CPlusPlus11
Definition: LangStandard.h:56
@ CPlusPlus14
Definition: LangStandard.h:57
@ CPlusPlus17
Definition: LangStandard.h:58
Expr * IgnoreElidableImplicitConstructorSingleStep(Expr *E)
Definition: IgnoreExpr.h:125
@ OR_Deleted
Succeeded, but refers to a deleted function.
Definition: Overload.h:61
@ OR_Success
Overload resolution succeeded.
Definition: Overload.h:52
bool isReservedInAllContexts(ReservedIdentifierStatus Status)
Determine whether an identifier is reserved in all contexts.
IfStatementKind
In an if statement, this denotes whether the statement is a constexpr or consteval if statement.
Definition: Specifiers.h:39
Expr * IgnoreExprNodes(Expr *E, FnTys &&... Fns)
Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *, Recursively apply each of the f...
Definition: IgnoreExpr.h:34
@ RQ_None
No ref-qualifier was provided.
Definition: Type.h:1768
@ OCD_AllCandidates
Requests that all candidates be shown.
Definition: Overload.h:67
@ Seq
'seq' clause, allowed on 'loop' and 'routine' directives.
bool operator==(const CallGraphNode::CallRecord &LHS, const CallGraphNode::CallRecord &RHS)
Definition: CallGraph.h:204
CapturedRegionKind
The different kinds of captured statement.
Definition: CapturedStmt.h:16
@ CR_OpenMP
Definition: CapturedStmt.h:19
@ SC_None
Definition: Specifiers.h:250
StmtResult StmtError()
Definition: Ownership.h:265
@ Result
The result type of a method or function.
ActionResult< Expr * > ExprResult
Definition: Ownership.h:248
@ Struct
The "struct" keyword.
ExprResult ExprError()
Definition: Ownership.h:264
@ AR_NotYetIntroduced
Definition: DeclBase.h:74
@ AR_Available
Definition: DeclBase.h:73
@ AR_Deprecated
Definition: DeclBase.h:75
@ AR_Unavailable
Definition: DeclBase.h:76
bool isLambdaConversionOperator(CXXConversionDecl *C)
Definition: ASTLambda.h:62
ActionResult< Stmt * > StmtResult
Definition: Ownership.h:249
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
Definition: Specifiers.h:144
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:139
Expr * IgnoreParensSingleStep(Expr *E)
Definition: IgnoreExpr.h:150
const FunctionProtoType * T
Expr * IgnoreImplicitAsWrittenSingleStep(Expr *E)
Definition: IgnoreExpr.h:137
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
TemplateDeductionResult
Describes the result of template argument deduction.
Definition: Sema.h:365
@ Success
Template argument deduction was successful.
@ Inconsistent
Template argument deduction produced inconsistent deduced values for the given template parameter.
@ AlreadyDiagnosed
Some error which was already diagnosed.
ReservedIdentifierStatus
@ CapturedContext
Parameter for captured context.
@ AS_private
Definition: Specifiers.h:126
Diagnostic wrappers for TextAPI types for error reporting.
Definition: Dominators.h:30
#define true
Definition: stdbool.h:25
#define false
Definition: stdbool.h:26
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:642
bool isMoveEligible() const
Definition: Sema.h:10814
bool isCopyElidable() const
Definition: Sema.h:10815
const VarDecl * Candidate
Definition: Sema.h:10809
static CatchHandlerType getEmptyKey()
Definition: SemaStmt.cpp:4224
static CatchHandlerType getTombstoneKey()
Definition: SemaStmt.cpp:4229
static unsigned getHashValue(const CatchHandlerType &Base)
Definition: SemaStmt.cpp:4234
static bool isEqual(const CatchHandlerType &LHS, const CatchHandlerType &RHS)
Definition: SemaStmt.cpp:4238