[clang] [clang] Reject array comparisons in C++26 for unknown/dependent types in templates (PR #191101)
via cfe-commits
cfe-commits at lists.llvm.org
Sat Apr 18 09:21:04 PDT 2026
https://github.com/PrabbyDD updated https://github.com/llvm/llvm-project/pull/191101
>From 9747c53e1c391f06d027d105fe87c741fd2db37a Mon Sep 17 00:00:00 2001
From: PrabbyDD <dhaliprabh at gmail.com>
Date: Wed, 8 Apr 2026 19:52:35 -0700
Subject: [PATCH 1/6] [clang] Reject array comparisons in C++26 for
unknow/dependent types in templates. Fixes #190756. Clang was rejecting array
comparisons where types are known correctly, but not for dependent types like
inside function templates or anything that wraps a template. Fix by not
skipping the array comparison check when our operands in the template are
arrays so we can send an error. Non array types in templates skip these
checks.
---
clang/lib/Sema/SemaExpr.cpp | 2528 +++++++++--------
clang/test/SemaCXX/array-compare-template.cpp | 8 +
2 files changed, 1318 insertions(+), 1218 deletions(-)
create mode 100644 clang/test/SemaCXX/array-compare-template.cpp
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 9fd8c6a0a5451..ef67a26a588ab 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -141,7 +141,7 @@ void Sema::NoteDeletedFunction(FunctionDecl *Decl) {
return NoteDeletedInheritingConstructor(Ctor);
Diag(Decl->getLocation(), diag::note_availability_specified_here)
- << Decl << 1;
+ << Decl << 1;
}
/// Determine whether a FunctionDecl was ever declared with an
@@ -219,7 +219,7 @@ void Sema::MaybeSuggestAddingStaticToDecl(const FunctionDecl *Cur) {
if (!hasAnyExplicitStorageClass(First)) {
SourceLocation DeclBegin = First->getSourceRange().getBegin();
Diag(DeclBegin, diag::note_convert_inline_to_static)
- << Cur << FixItHint::CreateInsertion(DeclBegin, "static ");
+ << Cur << FixItHint::CreateInsertion(DeclBegin, "static ");
}
}
@@ -258,7 +258,7 @@ bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
if (ParsingInitForAutoVars.count(D)) {
if (isa<BindingDecl>(D)) {
Diag(Loc, diag::err_binding_cannot_appear_in_own_initializer)
- << D->getDeclName();
+ << D->getDeclName();
} else {
Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer)
<< diag::ParsingInitFor::Var << D->getDeclName()
@@ -300,8 +300,7 @@ bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
// constraint expression, for example)
return true;
if (!Satisfaction.IsSatisfied) {
- Diag(Loc,
- diag::err_reference_to_function_with_unsatisfied_constraints)
+ Diag(Loc, diag::err_reference_to_function_with_unsatisfied_constraints)
<< D;
DiagnoseUnsatisfiedConstraint(Satisfaction);
return true;
@@ -316,7 +315,6 @@ bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
if (getLangOpts().CUDA && !CUDA().CheckCall(Loc, FD))
return true;
-
}
if (auto *Concept = dyn_cast<ConceptDecl>(D);
@@ -330,12 +328,12 @@ bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
cast<CXXConstructorDecl>(MD)->isDefaultConstructor()) ||
MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())) {
Diag(Loc, diag::warn_cxx17_compat_lambda_def_ctor_assign)
- << !isa<CXXConstructorDecl>(MD);
+ << !isa<CXXConstructorDecl>(MD);
}
}
- auto getReferencedObjCProp = [](const NamedDecl *D) ->
- const ObjCPropertyDecl * {
+ auto getReferencedObjCProp =
+ [](const NamedDecl *D) -> const ObjCPropertyDecl * {
if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
return MD->findPropertyDecl();
return nullptr;
@@ -344,7 +342,7 @@ bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
if (diagnoseArgIndependentDiagnoseIfAttrs(ObjCPDecl, Loc))
return true;
} else if (diagnoseArgIndependentDiagnoseIfAttrs(D, Loc)) {
- return true;
+ return true;
}
// [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions
@@ -521,7 +519,8 @@ ExprResult Sema::DefaultFunctionArrayConversion(Expr *E, bool Diagnose) {
// Handle any placeholder expressions which made it here.
if (E->hasPlaceholderType()) {
ExprResult result = CheckPlaceholderExpr(E);
- if (result.isInvalid()) return ExprError();
+ if (result.isInvalid())
+ return ExprError();
E = result.get();
}
@@ -535,7 +534,8 @@ ExprResult Sema::DefaultFunctionArrayConversion(Expr *E, bool Diagnose) {
return ExprError();
E = ImpCastExprToType(E, Context.getPointerType(Ty),
- CK_FunctionToPointerDecay).get();
+ CK_FunctionToPointerDecay)
+ .get();
} else if (Ty->isArrayType()) {
// In C90 mode, arrays only promote to pointers if the array expression is
// an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has
@@ -585,8 +585,7 @@ static void CheckForNullPointerDereference(Sema &S, Expr *E) {
}
static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE,
- SourceLocation AssignLoc,
- const Expr* RHS) {
+ SourceLocation AssignLoc, const Expr *RHS) {
const ObjCIvarDecl *IV = OIRE->getDecl();
if (!IV)
return;
@@ -604,13 +603,12 @@ static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE,
if (ObjCInterfaceDecl *IDecl = OTy->getInterface()) {
ObjCInterfaceDecl *ClassDeclared = nullptr;
ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
- if (!ClassDeclared->getSuperClass()
- && (*ClassDeclared->ivar_begin()) == IV) {
+ if (!ClassDeclared->getSuperClass() &&
+ (*ClassDeclared->ivar_begin()) == IV) {
if (RHS) {
- NamedDecl *ObjectSetClass =
- S.LookupSingleName(S.TUScope,
- &S.Context.Idents.get("object_setClass"),
- SourceLocation(), S.LookupOrdinaryName);
+ NamedDecl *ObjectSetClass = S.LookupSingleName(
+ S.TUScope, &S.Context.Idents.get("object_setClass"),
+ SourceLocation(), S.LookupOrdinaryName);
if (ObjectSetClass) {
SourceLocation RHSLocEnd = S.getLocForEndOfToken(RHS->getEndLoc());
S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_assign)
@@ -619,14 +617,12 @@ static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE,
<< FixItHint::CreateReplacement(
SourceRange(OIRE->getOpLoc(), AssignLoc), ",")
<< FixItHint::CreateInsertion(RHSLocEnd, ")");
- }
- else
+ } else
S.Diag(OIRE->getLocation(), diag::warn_objc_isa_assign);
} else {
- NamedDecl *ObjectGetClass =
- S.LookupSingleName(S.TUScope,
- &S.Context.Idents.get("object_getClass"),
- SourceLocation(), S.LookupOrdinaryName);
+ NamedDecl *ObjectGetClass = S.LookupSingleName(
+ S.TUScope, &S.Context.Idents.get("object_getClass"),
+ SourceLocation(), S.LookupOrdinaryName);
if (ObjectGetClass)
S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_use)
<< FixItHint::CreateInsertion(OIRE->getBeginLoc(),
@@ -645,14 +641,16 @@ ExprResult Sema::DefaultLvalueConversion(Expr *E) {
// Handle any placeholder expressions which made it here.
if (E->hasPlaceholderType()) {
ExprResult result = CheckPlaceholderExpr(E);
- if (result.isInvalid()) return ExprError();
+ if (result.isInvalid())
+ return ExprError();
E = result.get();
}
// C++ [conv.lval]p1:
// A glvalue of a non-function, non-array type T can be
// converted to a prvalue.
- if (!E->isGLValue()) return E;
+ if (!E->isGLValue())
+ return E;
QualType T = E->getType();
assert(!T.isNull() && "r-value conversion on typeless expression?");
@@ -683,16 +681,15 @@ ExprResult Sema::DefaultLvalueConversion(Expr *E) {
if (getLangOpts().OpenCL &&
!getOpenCLOptions().isAvailableOption("cl_khr_fp16", getLangOpts()) &&
T->isHalfType()) {
- Diag(E->getExprLoc(), diag::err_opencl_half_load_store)
- << 0 << T;
+ Diag(E->getExprLoc(), diag::err_opencl_half_load_store) << 0 << T;
return ExprError();
}
CheckForNullPointerDereference(*this, E);
if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(E->IgnoreParenCasts())) {
- NamedDecl *ObjectGetClass = LookupSingleName(TUScope,
- &Context.Idents.get("object_getClass"),
- SourceLocation(), LookupOrdinaryName);
+ NamedDecl *ObjectGetClass =
+ LookupSingleName(TUScope, &Context.Idents.get("object_getClass"),
+ SourceLocation(), LookupOrdinaryName);
if (ObjectGetClass)
Diag(E->getExprLoc(), diag::warn_objc_isa_use)
<< FixItHint::CreateInsertion(OISA->getBeginLoc(), "object_getClass(")
@@ -700,10 +697,9 @@ ExprResult Sema::DefaultLvalueConversion(Expr *E) {
SourceRange(OISA->getOpLoc(), OISA->getIsaMemberLoc()), ")");
else
Diag(E->getExprLoc(), diag::warn_objc_isa_use);
- }
- else if (const ObjCIvarRefExpr *OIRE =
- dyn_cast<ObjCIvarRefExpr>(E->IgnoreParenCasts()))
- DiagnoseDirectIsaAccess(*this, OIRE, SourceLocation(), /* Expr*/nullptr);
+ } else if (const ObjCIvarRefExpr *OIRE =
+ dyn_cast<ObjCIvarRefExpr>(E->IgnoreParenCasts()))
+ DiagnoseDirectIsaAccess(*this, OIRE, SourceLocation(), /* Expr*/ nullptr);
// C++ [conv.lval]p1:
// [...] If T is a non-class type, the type of the prvalue is the
@@ -727,8 +723,8 @@ ExprResult Sema::DefaultLvalueConversion(Expr *E) {
return Res;
E = Res.get();
- // Loading a __weak object implicitly retains the value, so we need a cleanup to
- // balance that.
+ // Loading a __weak object implicitly retains the value, so we need a cleanup
+ // to balance that.
if (E->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
Cleanup.setExprNeedsCleanups(true);
@@ -937,8 +933,8 @@ ExprResult Sema::DefaultArgumentPromotion(Expr *E) {
// potentially potentially evaluated contexts.
if (getLangOpts().CPlusPlus && E->isGLValue() && !isUnevaluatedContext()) {
ExprResult Temp = PerformCopyInitialization(
- InitializedEntity::InitializeTemporary(E->getType()),
- E->getExprLoc(), E);
+ InitializedEntity::InitializeTemporary(E->getType()), E->getExprLoc(),
+ E);
if (Temp.isInvalid())
return ExprError();
E = Temp.get();
@@ -1134,8 +1130,10 @@ static bool handleComplexIntegerToFloatConversion(Sema &S, ExprResult &IntExpr,
QualType IntTy,
QualType ComplexTy,
bool SkipCast) {
- if (IntTy->isComplexType() || IntTy->isRealFloatingType()) return true;
- if (SkipCast) return false;
+ if (IntTy->isComplexType() || IntTy->isRealFloatingType())
+ return true;
+ if (SkipCast)
+ return false;
if (IntTy->isIntegerType()) {
QualType fpTy = ComplexTy->castAs<ComplexType>()->getElementType();
IntExpr = S.ImpCastExprToType(IntExpr.get(), fpTy, CK_IntegralToFloating);
@@ -1211,8 +1209,8 @@ static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr,
if (IntTy->isIntegerType()) {
if (ConvertInt)
// Convert intExpr to the lhs floating point type.
- IntExpr = S.ImpCastExprToType(IntExpr.get(), FloatTy,
- CK_IntegralToFloating);
+ IntExpr =
+ S.ImpCastExprToType(IntExpr.get(), FloatTy, CK_IntegralToFloating);
return FloatTy;
}
@@ -1227,17 +1225,17 @@ static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr,
// float -> _Complex float
if (ConvertFloat)
- FloatExpr = S.ImpCastExprToType(FloatExpr.get(), result,
- CK_FloatingRealToComplex);
+ FloatExpr =
+ S.ImpCastExprToType(FloatExpr.get(), result, CK_FloatingRealToComplex);
return result;
}
/// Handle arithmethic conversion with floating point types. Helper
/// function of UsualArithmeticConversions()
-static QualType handleFloatConversion(Sema &S, ExprResult &LHS,
- ExprResult &RHS, QualType LHSType,
- QualType RHSType, bool IsCompAssign) {
+static QualType handleFloatConversion(Sema &S, ExprResult &LHS, ExprResult &RHS,
+ QualType LHSType, QualType RHSType,
+ bool IsCompAssign) {
bool LHSFloat = LHSType->isRealFloatingType();
bool RHSFloat = RHSType->isRealFloatingType();
@@ -1274,11 +1272,11 @@ static QualType handleFloatConversion(Sema &S, ExprResult &LHS,
return handleIntToFloatConversion(S, LHS, RHS, LHSType, RHSType,
/*ConvertFloat=*/!IsCompAssign,
- /*ConvertInt=*/ true);
+ /*ConvertInt=*/true);
}
assert(RHSFloat);
return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType,
- /*ConvertFloat=*/ true,
+ /*ConvertFloat=*/true,
/*ConvertInt=*/!IsCompAssign);
}
@@ -1323,7 +1321,7 @@ ExprResult doComplexIntegralCast(Sema &S, Expr *op, QualType toType) {
return S.ImpCastExprToType(op, S.Context.getComplexType(toType),
CK_IntegralComplexCast);
}
-}
+} // namespace
/// Handle integer arithmetic conversions. Helper function of
/// UsualArithmeticConversions()
@@ -1368,7 +1366,7 @@ static QualType handleIntegerConversion(Sema &S, ExprResult &LHS,
// on most 32-bit systems). Use the unsigned type corresponding
// to the signed type.
QualType result =
- S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType);
+ S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType);
RHS = (*doRHSCast)(S, RHS.get(), result);
if (!IsCompAssign)
LHS = (*doLHSCast)(S, LHS.get(), result);
@@ -1389,8 +1387,8 @@ static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS,
QualType LHSEltType = LHSComplexInt->getElementType();
QualType RHSEltType = RHSComplexInt->getElementType();
QualType ScalarType =
- handleIntegerConversion<doComplexIntegralCast, doComplexIntegralCast>
- (S, LHS, RHS, LHSEltType, RHSEltType, IsCompAssign);
+ handleIntegerConversion<doComplexIntegralCast, doComplexIntegralCast>(
+ S, LHS, RHS, LHSEltType, RHSEltType, IsCompAssign);
return S.Context.getComplexType(ScalarType);
}
@@ -1398,11 +1396,10 @@ static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS,
if (LHSComplexInt) {
QualType LHSEltType = LHSComplexInt->getElementType();
QualType ScalarType =
- handleIntegerConversion<doComplexIntegralCast, doIntegralCast>
- (S, LHS, RHS, LHSEltType, RHSType, IsCompAssign);
+ handleIntegerConversion<doComplexIntegralCast, doIntegralCast>(
+ S, LHS, RHS, LHSEltType, RHSType, IsCompAssign);
QualType ComplexType = S.Context.getComplexType(ScalarType);
- RHS = S.ImpCastExprToType(RHS.get(), ComplexType,
- CK_IntegralRealToComplex);
+ RHS = S.ImpCastExprToType(RHS.get(), ComplexType, CK_IntegralRealToComplex);
return ComplexType;
}
@@ -1411,13 +1408,12 @@ static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS,
QualType RHSEltType = RHSComplexInt->getElementType();
QualType ScalarType =
- handleIntegerConversion<doIntegralCast, doComplexIntegralCast>
- (S, LHS, RHS, LHSType, RHSEltType, IsCompAssign);
+ handleIntegerConversion<doIntegralCast, doComplexIntegralCast>(
+ S, LHS, RHS, LHSType, RHSEltType, IsCompAssign);
QualType ComplexType = S.Context.getComplexType(ScalarType);
if (!IsCompAssign)
- LHS = S.ImpCastExprToType(LHS.get(), ComplexType,
- CK_IntegralRealToComplex);
+ LHS = S.ImpCastExprToType(LHS.get(), ComplexType, CK_IntegralRealToComplex);
return ComplexType;
}
@@ -1788,7 +1784,6 @@ QualType Sema::UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS,
// Semantic Analysis for various Expression Types
//===----------------------------------------------------------------------===//
-
ExprResult Sema::ActOnGenericSelectionExpr(
SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc,
bool PredicateIsExpr, void *ControllingExprOrType,
@@ -1796,10 +1791,10 @@ ExprResult Sema::ActOnGenericSelectionExpr(
unsigned NumAssocs = ArgTypes.size();
assert(NumAssocs == ArgExprs.size());
- TypeSourceInfo **Types = new TypeSourceInfo*[NumAssocs];
+ TypeSourceInfo **Types = new TypeSourceInfo *[NumAssocs];
for (unsigned i = 0; i < NumAssocs; ++i) {
if (ArgTypes[i])
- (void) GetTypeFromParser(ArgTypes[i], &Types[i]);
+ (void)GetTypeFromParser(ArgTypes[i], &Types[i]);
else
Types[i] = nullptr;
}
@@ -1817,7 +1812,7 @@ ExprResult Sema::ActOnGenericSelectionExpr(
ExprResult ER = CreateGenericSelectionExpr(
KeyLoc, DefaultLoc, RParenLoc, PredicateIsExpr, ControllingExprOrType,
llvm::ArrayRef(Types, NumAssocs), ArgExprs);
- delete [] Types;
+ delete[] Types;
return ER;
}
@@ -1966,19 +1961,17 @@ ExprResult Sema::CreateGenericSelectionExpr(
// C11 6.5.1.1p2 "No two generic associations in the same generic
// selection shall specify compatible types."
- for (unsigned j = i+1; j < NumAssocs; ++j)
+ for (unsigned j = i + 1; j < NumAssocs; ++j)
if (Types[j] && !Types[j]->getType()->isDependentType() &&
areTypesCompatibleForGeneric(Context, Types[i]->getType(),
Types[j]->getType())) {
Diag(Types[j]->getTypeLoc().getBeginLoc(),
diag::err_assoc_compatible_types)
- << Types[j]->getTypeLoc().getSourceRange()
- << Types[j]->getType()
- << Types[i]->getType();
- Diag(Types[i]->getTypeLoc().getBeginLoc(),
- diag::note_compat_assoc)
- << Types[i]->getTypeLoc().getSourceRange()
- << Types[i]->getType();
+ << Types[j]->getTypeLoc().getSourceRange()
+ << Types[j]->getType() << Types[i]->getType();
+ Diag(Types[i]->getTypeLoc().getBeginLoc(), diag::note_compat_assoc)
+ << Types[i]->getTypeLoc().getSourceRange()
+ << Types[i]->getType();
TypeErrorFound = true;
}
}
@@ -2047,10 +2040,8 @@ ExprResult Sema::CreateGenericSelectionExpr(
Diag(SR.getBegin(), diag::err_generic_sel_multi_match)
<< SR << P.second << (unsigned)CompatIndices.size();
for (unsigned I : CompatIndices) {
- Diag(Types[I]->getTypeLoc().getBeginLoc(),
- diag::note_compat_assoc)
- << Types[I]->getTypeLoc().getSourceRange()
- << Types[I]->getType();
+ Diag(Types[I]->getTypeLoc().getBeginLoc(), diag::note_compat_assoc)
+ << Types[I]->getTypeLoc().getSourceRange() << Types[I]->getType();
}
return ExprError();
}
@@ -2071,8 +2062,7 @@ ExprResult Sema::CreateGenericSelectionExpr(
// then the result expression of the generic selection is the expression
// in that generic association. Otherwise, the result expression of the
// generic selection is the expression in the default generic association."
- unsigned ResultIndex =
- CompatIndices.size() ? CompatIndices[0] : DefaultIndex;
+ unsigned ResultIndex = CompatIndices.size() ? CompatIndices[0] : DefaultIndex;
if (ControllingExpr) {
return GenericSelectionExpr::Create(
@@ -2127,7 +2117,7 @@ static SourceLocation getUDSuffixLoc(Sema &S, SourceLocation TokLoc,
static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope,
IdentifierInfo *UDSuffix,
SourceLocation UDSuffixLoc,
- ArrayRef<Expr*> Args,
+ ArrayRef<Expr *> Args,
SourceLocation LitEndLoc) {
assert(Args.size() <= 2 && "too many arguments for literal operator");
@@ -2139,7 +2129,7 @@ static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope,
}
DeclarationName OpName =
- S.Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
+ S.Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
@@ -2231,8 +2221,8 @@ Sema::ExpandFunctionLocalPredefinedMacros(ArrayRef<Token> Toks) {
return ExpandedToks;
}
-ExprResult
-Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) {
+ExprResult Sema::ActOnStringLiteral(ArrayRef<Token> StringToks,
+ Scope *UDLScope) {
assert(!StringToks.empty() && "Must have at least one string!");
// StringToks needs backing storage as it doesn't hold array elements itself
@@ -2312,8 +2302,8 @@ Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) {
// We're building a user-defined literal.
IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
SourceLocation UDSuffixLoc =
- getUDSuffixLoc(*this, StringTokLocs[Literal.getUDSuffixToken()],
- Literal.getUDSuffixOffset());
+ getUDSuffixLoc(*this, StringTokLocs[Literal.getUDSuffixToken()],
+ Literal.getUDSuffixOffset());
// Make sure we're allowed user-defined literals here.
if (!UDLScope)
@@ -2324,13 +2314,11 @@ Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) {
QualType SizeType = Context.getSizeType();
DeclarationName OpName =
- Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
+ Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
- QualType ArgTy[] = {
- Context.getArrayDecayedType(StrTy), SizeType
- };
+ QualType ArgTy[] = {Context.getArrayDecayedType(StrTy), SizeType};
LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName);
switch (LookupLiteralOperator(UDLScope, R, ArgTy,
@@ -2340,9 +2328,9 @@ Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) {
case LOLR_Cooked: {
llvm::APInt Len(Context.getIntWidth(SizeType), Literal.GetNumStringChars());
- IntegerLiteral *LenArg = IntegerLiteral::Create(Context, Len, SizeType,
- StringTokLocs[0]);
- Expr *Args[] = { Lit, LenArg };
+ IntegerLiteral *LenArg =
+ IntegerLiteral::Create(Context, Len, SizeType, StringTokLocs[0]);
+ Expr *Args[] = {Lit, LenArg};
return BuildLiteralOperatorCall(R, OpNameInfo, Args, StringTokLocs.back());
}
@@ -2364,7 +2352,8 @@ Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) {
llvm::APSInt Value(CharBits, CharIsUnsigned);
TemplateArgument TypeArg(CharTy);
- TemplateArgumentLocInfo TypeArgInfo(Context.getTrivialTypeSourceInfo(CharTy));
+ TemplateArgumentLocInfo TypeArgInfo(
+ Context.getTrivialTypeSourceInfo(CharTy));
ExplicitArgs.addArgument(TemplateArgumentLoc(TypeArg, TypeArgInfo));
SourceLocation Loc = StringTokLocs.back();
@@ -2385,10 +2374,9 @@ Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) {
llvm_unreachable("unexpected literal operator lookup result");
}
-DeclRefExpr *
-Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
- SourceLocation Loc,
- const CXXScopeSpec *SS) {
+DeclRefExpr *Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
+ SourceLocation Loc,
+ const CXXScopeSpec *SS) {
DeclarationNameInfo NameInfo(D->getDeclName(), Loc);
return BuildDeclRefExpr(D, Ty, VK, NameInfo, SS);
}
@@ -2519,11 +2507,10 @@ Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
return E;
}
-void
-Sema::DecomposeUnqualifiedId(const UnqualifiedId &Id,
- TemplateArgumentListInfo &Buffer,
- DeclarationNameInfo &NameInfo,
- const TemplateArgumentListInfo *&TemplateArgs) {
+void Sema::DecomposeUnqualifiedId(
+ const UnqualifiedId &Id, TemplateArgumentListInfo &Buffer,
+ DeclarationNameInfo &NameInfo,
+ const TemplateArgumentListInfo *&TemplateArgs) {
if (Id.getKind() == UnqualifiedIdKind::IK_TemplateId) {
Buffer.setLAngleLoc(Id.TemplateId->LAngleLoc);
Buffer.setRAngleLoc(Id.TemplateId->RAngleLoc);
@@ -2680,15 +2667,14 @@ bool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
OverloadCandidateSet::CSK_Normal);
OverloadCandidateSet::iterator Best;
for (NamedDecl *CD : Corrected) {
- if (FunctionTemplateDecl *FTD =
- dyn_cast<FunctionTemplateDecl>(CD))
- AddTemplateOverloadCandidate(
- FTD, DeclAccessPair::make(FTD, AS_none), ExplicitTemplateArgs,
- Args, OCS);
+ if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(CD))
+ AddTemplateOverloadCandidate(FTD,
+ DeclAccessPair::make(FTD, AS_none),
+ ExplicitTemplateArgs, Args, OCS);
else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(CD))
if (!ExplicitTemplateArgs || ExplicitTemplateArgs->size() == 0)
- AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none),
- Args, OCS);
+ AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none), Args,
+ OCS);
}
switch (OCS.BestViableFunction(*this, R.getNameLoc(), Best)) {
case OR_Success:
@@ -2706,8 +2692,8 @@ bool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
CXXRecordDecl *Record =
Corrected.getCorrectionSpecifier().getAsRecordDecl();
if (!Record)
- Record = cast<CXXRecordDecl>(
- ND->getDeclContext()->getRedeclContext());
+ Record =
+ cast<CXXRecordDecl>(ND->getDeclContext()->getRedeclContext());
R.setNamingClass(Record);
}
@@ -2814,12 +2800,13 @@ recoverFromMSUnqualifiedLookup(Sema &S, ASTContext &Context,
TemplateArgs);
}
-ExprResult
-Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
- SourceLocation TemplateKWLoc, UnqualifiedId &Id,
- bool HasTrailingLParen, bool IsAddressOfOperand,
- CorrectionCandidateCallback *CCC,
- bool IsInlineAsmIdentifier, Token *KeywordReplacement) {
+ExprResult Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
+ SourceLocation TemplateKWLoc,
+ UnqualifiedId &Id, bool HasTrailingLParen,
+ bool IsAddressOfOperand,
+ CorrectionCandidateCallback *CCC,
+ bool IsInlineAsmIdentifier,
+ Token *KeywordReplacement) {
assert(!(IsAddressOfOperand && HasTrailingLParen) &&
"cannot be direct & operand and have a trailing lparen");
if (SS.isInvalid())
@@ -2910,7 +2897,8 @@ Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
if (R.empty() && HasTrailingLParen && II &&
getLangOpts().implicitFunctionsAllowed()) {
NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S);
- if (D) R.addDecl(D);
+ if (D)
+ R.addDecl(D);
}
// Determine whether this name might be a candidate for
@@ -3036,7 +3024,7 @@ ExprResult Sema::BuildQualifiedDeclarationNameExpr(
if (CD->isInvalidDecl() || CD->isBeingDefined())
return ExprError();
Diag(NameInfo.getLoc(), diag::err_no_member)
- << NameInfo.getName() << DC << SS.getRange();
+ << NameInfo.getName() << DC << SS.getRange();
return ExprError();
}
@@ -3201,14 +3189,15 @@ ExprResult Sema::PerformObjectMemberConversion(Expr *From,
// Otherwise build the appropriate casts.
if (IsDerivedFrom(FromLoc, FromRecordType, QRecordType)) {
CXXCastPath BasePath;
- if (CheckDerivedToBaseConversion(FromRecordType, QRecordType,
- FromLoc, FromRange, &BasePath))
+ if (CheckDerivedToBaseConversion(FromRecordType, QRecordType, FromLoc,
+ FromRange, &BasePath))
return ExprError();
if (PointerConversions)
QType = Context.getPointerType(QType);
- From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase,
- VK, &BasePath).get();
+ From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase, VK,
+ &BasePath)
+ .get();
FromType = QType;
FromRecordType = QRecordType;
@@ -3221,8 +3210,8 @@ ExprResult Sema::PerformObjectMemberConversion(Expr *From,
}
CXXCastPath BasePath;
- if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType,
- FromLoc, FromRange, &BasePath,
+ if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType, FromLoc,
+ FromRange, &BasePath,
/*IgnoreAccess=*/true))
return ExprError();
@@ -3288,7 +3277,6 @@ bool Sema::UseArgumentDependentLookup(const CXXScopeSpec &SS,
return true;
}
-
/// Diagnoses obvious problems with the use of the given declaration
/// as an expression. This is only actually called for lookups that
/// were not overloaded, and it doesn't promise that the declaration
@@ -3694,7 +3682,7 @@ ExprResult Sema::ActOnCharacterConstant(const Token &Tok, Scope *UDLScope) {
else if (Literal.isUTF32())
Ty = Context.Char32Ty; // U'x' -> char32_t in C11 and C++11.
else if (!getLangOpts().CPlusPlus || Literal.isMultiChar())
- Ty = Context.IntTy; // 'x' -> int in C, 'wxyz' -> int in C++.
+ Ty = Context.IntTy; // 'x' -> int in C, 'wxyz' -> int in C++.
else
Ty = Context.CharTy; // 'x' -> char in C++;
// u8'x' -> char in C11-C17 and in C++ without char8_t.
@@ -3709,8 +3697,8 @@ ExprResult Sema::ActOnCharacterConstant(const Token &Tok, Scope *UDLScope) {
else if (Literal.isUTF8())
Kind = CharacterLiteralKind::UTF8;
- Expr *Lit = new (Context) CharacterLiteral(Literal.getValue(), Kind, Ty,
- Tok.getLocation());
+ Expr *Lit = new (Context)
+ CharacterLiteral(Literal.getValue(), Kind, Ty, Tok.getLocation());
if (Literal.getUDSuffix().empty())
return Lit;
@@ -3718,7 +3706,7 @@ ExprResult Sema::ActOnCharacterConstant(const Token &Tok, Scope *UDLScope) {
// We're building a user-defined literal.
IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
SourceLocation UDSuffixLoc =
- getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());
+ getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());
// Make sure we're allowed user-defined literals here.
if (!UDLScope)
@@ -3835,7 +3823,7 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
// We're building a user-defined literal.
const IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
SourceLocation UDSuffixLoc =
- getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());
+ getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());
// Make sure we're allowed user-defined literals here.
if (!UDLScope)
@@ -3855,7 +3843,7 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
}
DeclarationName OpName =
- Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
+ Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
@@ -3949,7 +3937,8 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
}
}
- if (Literal.isUnsigned) Ty = Context.getCorrespondingUnsignedType(Ty);
+ if (Literal.isUnsigned)
+ Ty = Context.getCorrespondingUnsignedType(Ty);
bool isSigned = !Literal.isUnsigned;
unsigned scale = Context.getFixedPointScale(Ty);
@@ -3973,7 +3962,7 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
Tok.getLocation(), scale);
} else if (Literal.isFloatingLiteral()) {
QualType Ty;
- if (Literal.isHalf){
+ if (Literal.isHalf) {
if (getLangOpts().HLSL ||
getOpenCLOptions().isAvailableOption("cl_khr_fp16", getLangOpts()))
Ty = Context.HalfTy;
@@ -4145,7 +4134,7 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
// Does it fit in a unsigned int?
if (ResultVal.isIntN(IntSize)) {
// Does it fit in a signed int?
- if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
+ if (!Literal.isUnsigned && ResultVal[IntSize - 1] == 0)
Ty = Context.IntTy;
else if (AllowUnsigned)
Ty = Context.UnsignedIntTy;
@@ -4160,7 +4149,7 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
// Does it fit in a unsigned long?
if (ResultVal.isIntN(LongSize)) {
// Does it fit in a signed long?
- if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
+ if (!Literal.isUnsigned && ResultVal[LongSize - 1] == 0)
Ty = Context.LongTy;
else if (AllowUnsigned)
Ty = Context.UnsignedLongTy;
@@ -4193,8 +4182,9 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
// Does it fit in a signed long long?
// To be compatible with MSVC, hex integer literals ending with the
// LL or i64 suffix are always signed in Microsoft mode.
- if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 ||
- (getLangOpts().MSVCCompat && Literal.isLongLong)))
+ if (!Literal.isUnsigned &&
+ (ResultVal[LongLongSize - 1] == 0 ||
+ (getLangOpts().MSVCCompat && Literal.isLongLong)))
Ty = Context.LongLongTy;
else if (AllowUnsigned)
Ty = Context.UnsignedLongLongTy;
@@ -4233,8 +4223,8 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
// If this is an imaginary literal, create the ImaginaryLiteral wrapper.
if (Literal.isImaginary) {
- Res = new (Context) ImaginaryLiteral(Res,
- Context.getComplexType(Res->getType()));
+ Res = new (Context)
+ ImaginaryLiteral(Res, Context.getComplexType(Res->getType()));
// In C++, this is a GNU extension. In C, it's a C2y extension.
unsigned DiagId;
@@ -4266,8 +4256,7 @@ static bool CheckVecStepTraitOperandType(Sema &S, QualType T,
// Every built-in scalar type (OpenCL 1.1 6.1.1) is either an arithmetic
// type (C99 6.2.5p18) or void.
if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) {
- S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type)
- << T << ArgRange;
+ S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type) << T << ArgRange;
return true;
}
@@ -4350,8 +4339,7 @@ static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T,
// runtime doesn't allow it.
if (!S.LangOpts.ObjCRuntime.allowsSizeofAlignof() && T->isObjCObjectType()) {
S.Diag(Loc, diag::err_sizeof_nonfragile_interface)
- << T << (TraitKind == UETT_SizeOf)
- << ArgRange;
+ << T << (TraitKind == UETT_SizeOf) << ArgRange;
return true;
}
@@ -4371,9 +4359,9 @@ static void warnOnSizeofOnArrayDecay(Sema &S, SourceLocation Loc, QualType T,
if (!ICE || ICE->getCastKind() != CK_ArrayToPointerDecay)
return;
- S.Diag(Loc, diag::warn_sizeof_array_decay) << ICE->getSourceRange()
- << ICE->getType()
- << ICE->getSubExpr()->getType();
+ S.Diag(Loc, diag::warn_sizeof_array_decay)
+ << ICE->getSourceRange() << ICE->getType()
+ << ICE->getSubExpr()->getType();
}
bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E,
@@ -4398,8 +4386,7 @@ bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E,
// used to build SFINAE gadgets.
// FIXME: Should we consider instantiation-dependent operands to 'alignof'?
if (IsUnevaluatedOperand && !inTemplateInstantiation() &&
- !E->isInstantiationDependent() &&
- !E->getType()->isVariableArrayType() &&
+ !E->isInstantiationDependent() && !E->getType()->isVariableArrayType() &&
E->HasSideEffects(Context, false))
Diag(E->getExprLoc(), diag::warn_side_effects_unevaluated_context);
@@ -4477,8 +4464,7 @@ bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E,
QualType OType = PVD->getOriginalType();
QualType Type = PVD->getType();
if (Type->isPointerType() && OType->isArrayType()) {
- Diag(E->getExprLoc(), diag::warn_sizeof_array_param)
- << Type << OType;
+ Diag(E->getExprLoc(), diag::warn_sizeof_array_param) << Type << OType;
Diag(PVD->getLocation(), diag::note_declared_at);
}
}
@@ -4505,7 +4491,7 @@ static bool CheckAlignOfExpr(Sema &S, Expr *E, UnaryExprOrTypeTrait ExprKind) {
if (E->getObjectKind() == OK_BitField) {
S.Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield)
- << 1 << E->getSourceRange();
+ << 1 << E->getSourceRange();
return true;
}
@@ -4539,7 +4525,7 @@ static bool CheckAlignOfExpr(Sema &S, Expr *E, UnaryExprOrTypeTrait ExprKind) {
// definition if we can find a member of it.
if (!FD->getParent()->isCompleteDefinition()) {
S.Diag(E->getExprLoc(), diag::err_alignof_member_of_incomplete_type)
- << E->getSourceRange();
+ << E->getSourceRange();
return true;
}
@@ -4823,9 +4809,8 @@ ExprResult Sema::CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,
ExprKind, TInfo, Context.getSizeType(), OpLoc, R.getEnd());
}
-ExprResult
-Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
- UnaryExprOrTypeTrait ExprKind) {
+ExprResult Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
+ UnaryExprOrTypeTrait ExprKind) {
ExprResult PE = CheckPlaceholderExpr(E);
if (PE.isInvalid())
return ExprError();
@@ -4841,9 +4826,9 @@ Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
} else if (ExprKind == UETT_VecStep) {
isInvalid = CheckVecStepExpr(E);
} else if (ExprKind == UETT_OpenMPRequiredSimdAlign) {
- Diag(E->getExprLoc(), diag::err_openmp_default_simd_align_expr);
- isInvalid = true;
- } else if (E->refersToBitField()) { // C99 6.5.3.4p1.
+ Diag(E->getExprLoc(), diag::err_openmp_default_simd_align_expr);
+ isInvalid = true;
+ } else if (E->refersToBitField()) { // C99 6.5.3.4p1.
Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 0;
isInvalid = true;
} else if (ExprKind == UETT_VectorElements || ExprKind == UETT_SizeOf ||
@@ -4857,7 +4842,8 @@ Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
if ((ExprKind == UETT_SizeOf || ExprKind == UETT_CountOf) &&
E->getType()->isVariableArrayType()) {
PE = TransformToPotentiallyEvaluated(E);
- if (PE.isInvalid()) return ExprError();
+ if (PE.isInvalid())
+ return ExprError();
E = PE.get();
}
@@ -4866,16 +4852,17 @@ Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
ExprKind, E, Context.getSizeType(), OpLoc, E->getSourceRange().getEnd());
}
-ExprResult
-Sema::ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,
- UnaryExprOrTypeTrait ExprKind, bool IsType,
- void *TyOrEx, SourceRange ArgRange) {
+ExprResult Sema::ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,
+ UnaryExprOrTypeTrait ExprKind,
+ bool IsType, void *TyOrEx,
+ SourceRange ArgRange) {
// If error parsing type, ignore.
- if (!TyOrEx) return ExprError();
+ if (!TyOrEx)
+ return ExprError();
if (IsType) {
TypeSourceInfo *TInfo;
- (void) GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo);
+ (void)GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo);
return CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, ArgRange);
}
@@ -4922,33 +4909,37 @@ static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc,
// Test for placeholders.
ExprResult PR = S.CheckPlaceholderExpr(V.get());
- if (PR.isInvalid()) return QualType();
+ if (PR.isInvalid())
+ return QualType();
if (PR.get() != V.get()) {
V = PR;
return CheckRealImagOperand(S, V, Loc, IsReal);
}
// Reject anything else.
- S.Diag(Loc, diag::err_realimag_invalid_type) << V.get()->getType()
- << (IsReal ? "__real" : "__imag");
+ S.Diag(Loc, diag::err_realimag_invalid_type)
+ << V.get()->getType() << (IsReal ? "__real" : "__imag");
return QualType();
}
-
-
-ExprResult
-Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
- tok::TokenKind Kind, Expr *Input) {
+ExprResult Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
+ tok::TokenKind Kind, Expr *Input) {
UnaryOperatorKind Opc;
switch (Kind) {
- default: llvm_unreachable("Unknown unary op!");
- case tok::plusplus: Opc = UO_PostInc; break;
- case tok::minusminus: Opc = UO_PostDec; break;
+ default:
+ llvm_unreachable("Unknown unary op!");
+ case tok::plusplus:
+ Opc = UO_PostInc;
+ break;
+ case tok::minusminus:
+ Opc = UO_PostDec;
+ break;
}
// Since this might is a postfix expression, get rid of ParenListExprs.
ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Input);
- if (Result.isInvalid()) return ExprError();
+ if (Result.isInvalid())
+ return ExprError();
Input = Result.get();
return BuildUnaryOp(S, OpLoc, Opc, Input);
@@ -4957,8 +4948,7 @@ Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
/// Diagnose if arithmetic on the given ObjC pointer is illegal.
///
/// \return true on error
-static bool checkArithmeticOnObjCPointer(Sema &S,
- SourceLocation opLoc,
+static bool checkArithmeticOnObjCPointer(Sema &S, SourceLocation opLoc,
Expr *op) {
assert(op->getType()->isObjCObjectPointerType());
if (S.LangOpts.ObjCRuntime.allowsPointerArithmetic() &&
@@ -4966,8 +4956,8 @@ static bool checkArithmeticOnObjCPointer(Sema &S,
return false;
S.Diag(opLoc, diag::err_arithmetic_nonfragile_interface)
- << op->getType()->castAs<ObjCObjectPointerType>()->getPointeeType()
- << op->getSourceRange();
+ << op->getType()->castAs<ObjCObjectPointerType>()->getPointeeType()
+ << op->getSourceRange();
return true;
}
@@ -5375,9 +5365,9 @@ void Sema::CheckSubscriptAccessOfNoDeref(const ArraySubscriptExpr *E) {
}
}
-ExprResult
-Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
- Expr *Idx, SourceLocation RLoc) {
+ExprResult Sema::CreateBuiltinArraySubscriptExpr(Expr *Base,
+ SourceLocation LLoc, Expr *Idx,
+ SourceLocation RLoc) {
Expr *LHSExp = Base;
Expr *RHSExp = Idx;
@@ -5424,7 +5414,7 @@ Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
IndexExpr = RHSExp;
ResultType = PTy->getPointeeType();
} else if (const ObjCObjectPointerType *PTy =
- LHSTy->getAs<ObjCObjectPointerType>()) {
+ LHSTy->getAs<ObjCObjectPointerType>()) {
BaseExpr = LHSExp;
IndexExpr = RHSExp;
@@ -5436,19 +5426,19 @@ Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
ResultType = PTy->getPointeeType();
} else if (const PointerType *PTy = RHSTy->getAs<PointerType>()) {
- // Handle the uncommon case of "123[Ptr]".
+ // Handle the uncommon case of "123[Ptr]".
BaseExpr = RHSExp;
IndexExpr = LHSExp;
ResultType = PTy->getPointeeType();
} else if (const ObjCObjectPointerType *PTy =
- RHSTy->getAs<ObjCObjectPointerType>()) {
- // Handle the uncommon case of "123[Ptr]".
+ RHSTy->getAs<ObjCObjectPointerType>()) {
+ // Handle the uncommon case of "123[Ptr]".
BaseExpr = RHSExp;
IndexExpr = LHSExp;
ResultType = PTy->getPointeeType();
if (!LangOpts.isSubscriptPointerArithmetic()) {
Diag(LLoc, diag::err_subscript_nonfragile_interface)
- << ResultType << BaseExpr->getSourceRange();
+ << ResultType << BaseExpr->getSourceRange();
return ExprError();
}
} else if (LHSTy->isSubscriptableVectorType()) {
@@ -5492,7 +5482,8 @@ Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
Diag(LHSExp->getBeginLoc(), diag::ext_subscript_non_lvalue)
<< LHSExp->getSourceRange();
LHSExp = ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy),
- CK_ArrayToPointerDecay).get();
+ CK_ArrayToPointerDecay)
+ .get();
LHSTy = LHSExp->getType();
BaseExpr = LHSExp;
@@ -5503,7 +5494,8 @@ Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
Diag(RHSExp->getBeginLoc(), diag::ext_subscript_non_lvalue)
<< RHSExp->getSourceRange();
RHSExp = ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy),
- CK_ArrayToPointerDecay).get();
+ CK_ArrayToPointerDecay)
+ .get();
RHSTy = RHSExp->getType();
BaseExpr = RHSExp;
@@ -5511,7 +5503,7 @@ Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
ResultType = RHSTy->castAs<PointerType>()->getPointeeType();
} else {
return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value)
- << LHSExp->getSourceRange() << RHSExp->getSourceRange());
+ << LHSExp->getSourceRange() << RHSExp->getSourceRange());
}
// C99 6.5.2.1p1
if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent())
@@ -5540,8 +5532,7 @@ Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
if (ResultType->isVoidType() && !getLangOpts().CPlusPlus) {
// GNU extension: subscripting on pointer to void
- Diag(LLoc, diag::ext_gnu_subscript_void_type)
- << BaseExpr->getSourceRange();
+ Diag(LLoc, diag::ext_gnu_subscript_void_type) << BaseExpr->getSourceRange();
// C forbids expressions of unqualified void type from being l-values.
// See IsCForbiddenLValueType.
@@ -6008,7 +5999,7 @@ class FunctionCallCCC final : public FunctionCallFilterCCC {
private:
const IdentifierInfo *const FunctionName;
};
-}
+} // namespace
static TypoCorrection TryTypoCorrectionForCall(Sema &S, Expr *Fn,
FunctionDecl *FDecl,
@@ -6068,13 +6059,12 @@ static bool isParenthetizedAndQualifiedAddressOfExpr(Expr *Fn) {
return false;
}
-bool
-Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
- FunctionDecl *FDecl,
- const FunctionProtoType *Proto,
- ArrayRef<Expr *> Args,
- SourceLocation RParenLoc,
- bool IsExecConfig) {
+bool Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
+ FunctionDecl *FDecl,
+ const FunctionProtoType *Proto,
+ ArrayRef<Expr *> Args,
+ SourceLocation RParenLoc,
+ bool IsExecConfig) {
// Bail out early if calling a builtin with custom typechecking.
if (FDecl)
if (unsigned ID = FDecl->getBuiltinID())
@@ -6092,9 +6082,9 @@ Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
bool Invalid = false;
unsigned MinArgs = FDecl ? FDecl->getMinRequiredArguments() : NumParams;
unsigned FnKind = Fn->getType()->isBlockPointerType()
- ? 1 /* block */
- : (IsExecConfig ? 3 /* kernel function (exec config) */
- : 0 /* function */);
+ ? 1 /* block */
+ : (IsExecConfig ? 3 /* kernel function (exec config) */
+ : 0 /* function */);
// If too few arguments are available (and we don't have default
// arguments for the remaining parameters), don't make the call.
@@ -6233,12 +6223,12 @@ bool Sema::GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
// Strip the unbridged-cast placeholder expression off, if applicable.
bool CFAudited = false;
- if (Arg->getType() == Context.ARCUnbridgedCastTy &&
- FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() &&
+ if (Arg->getType() == Context.ARCUnbridgedCastTy && FDecl &&
+ FDecl->hasAttr<CFAuditedTransferAttr>() &&
(!Param || !Param->hasAttr<CFConsumedAttr>()))
Arg = ObjC().stripARCUnbridgedCast(Arg);
- else if (getLangOpts().ObjCAutoRefCount &&
- FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() &&
+ else if (getLangOpts().ObjCAutoRefCount && FDecl &&
+ FDecl->hasAttr<CFAuditedTransferAttr>() &&
(!Param || !Param->hasAttr<CFConsumedAttr>()))
CFAudited = true;
@@ -6316,7 +6306,7 @@ bool Sema::GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
AllArgs.push_back(arg.get());
}
- // Otherwise do argument promotion, (C99 6.5.2.2p7).
+ // Otherwise do argument promotion, (C99 6.5.2.2p7).
} else {
for (Expr *A : Args.slice(ArgIx)) {
ExprResult Arg = DefaultVariadicArgumentPromotion(A, CallType, FDecl);
@@ -6338,13 +6328,11 @@ static void DiagnoseCalleeStaticArrayParam(Sema &S, ParmVarDecl *PVD) {
TL = DTL.getOriginalLoc();
if (ArrayTypeLoc ATL = TL.getAs<ArrayTypeLoc>())
S.Diag(PVD->getLocation(), diag::note_callee_static_array)
- << ATL.getLocalSourceRange();
+ << ATL.getLocalSourceRange();
}
-void
-Sema::CheckStaticArrayArgument(SourceLocation CallLoc,
- ParmVarDecl *Param,
- const Expr *ArgExpr) {
+void Sema::CheckStaticArrayArgument(SourceLocation CallLoc, ParmVarDecl *Param,
+ const Expr *ArgExpr) {
// Static array parameters are not supported in C++.
if (!Param || getLangOpts().CPlusPlus)
return;
@@ -6355,8 +6343,7 @@ Sema::CheckStaticArrayArgument(SourceLocation CallLoc,
if (!AT || AT->getSizeModifier() != ArraySizeModifier::Static)
return;
- if (ArgExpr->isNullPointerConstant(Context,
- Expr::NPC_NeverValueDependent)) {
+ if (ArgExpr->isNullPointerConstant(Context, Expr::NPC_NeverValueDependent)) {
Diag(CallLoc, diag::warn_null_arg) << ArgExpr->getSourceRange();
DiagnoseCalleeStaticArrayParam(*this, Param);
return;
@@ -6367,7 +6354,7 @@ Sema::CheckStaticArrayArgument(SourceLocation CallLoc,
return;
const ConstantArrayType *ArgCAT =
- Context.getAsConstantArrayType(ArgExpr->IgnoreParenCasts()->getType());
+ Context.getAsConstantArrayType(ArgExpr->IgnoreParenCasts()->getType());
if (!ArgCAT)
return;
@@ -6403,23 +6390,21 @@ static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn);
static bool isPlaceholderToRemoveAsArg(QualType type) {
// Placeholders are never sugared.
const BuiltinType *placeholder = dyn_cast<BuiltinType>(type);
- if (!placeholder) return false;
+ if (!placeholder)
+ return false;
switch (placeholder->getKind()) {
- // Ignore all the non-placeholder types.
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ // Ignore all the non-placeholder types.
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id:
#include "clang/Basic/OpenCLImageTypes.def"
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
- case BuiltinType::Id:
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
#include "clang/Basic/OpenCLExtensionTypes.def"
- // In practice we'll never use this, since all SVE types are sugared
- // via TypedefTypes rather than exposed directly as BuiltinTypes.
-#define SVE_TYPE(Name, Id, SingletonId) \
- case BuiltinType::Id:
+ // In practice we'll never use this, since all SVE types are sugared
+ // via TypedefTypes rather than exposed directly as BuiltinTypes.
+#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
#include "clang/Basic/AArch64ACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) \
- case BuiltinType::Id:
+#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
#include "clang/Basic/PPCTypes.def"
#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
#include "clang/Basic/RISCVVTypes.def"
@@ -6462,7 +6447,6 @@ static bool isPlaceholderToRemoveAsArg(QualType type) {
case BuiltinType::OMPArrayShaping:
case BuiltinType::OMPIterator:
return true;
-
}
llvm_unreachable("bad builtin type kind");
}
@@ -6474,8 +6458,10 @@ bool Sema::CheckArgsForPlaceholders(MultiExprArg args) {
for (size_t i = 0, e = args.size(); i != e; i++) {
if (isPlaceholderToRemoveAsArg(args[i]->getType())) {
ExprResult result = CheckPlaceholderExpr(args[i]);
- if (result.isInvalid()) hasInvalid = true;
- else args[i] = result.get();
+ if (result.isInvalid())
+ hasInvalid = true;
+ else
+ args[i] = result.get();
}
}
return hasInvalid;
@@ -6546,8 +6532,8 @@ static FunctionDecl *rewriteBuiltinFunctionDecl(Sema *Sema, ASTContext &Context,
FunctionProtoType::ExtProtoInfo EPI;
EPI.Variadic = FT->isVariadic();
- QualType OverloadTy = Context.getFunctionType(FT->getReturnType(),
- OverloadParams, EPI);
+ QualType OverloadTy =
+ Context.getFunctionType(FT->getReturnType(), OverloadParams, EPI);
DeclContext *Parent = FDecl->getParent();
FunctionDecl *OverloadDecl = FunctionDecl::Create(
Context, Parent, FDecl->getLocation(), FDecl->getLocation(),
@@ -6555,14 +6541,14 @@ static FunctionDecl *rewriteBuiltinFunctionDecl(Sema *Sema, ASTContext &Context,
/*TInfo=*/nullptr, SC_Extern, Sema->getCurFPFeatures().isFPConstrained(),
false,
/*hasPrototype=*/true);
- SmallVector<ParmVarDecl*, 16> Params;
+ SmallVector<ParmVarDecl *, 16> Params;
FT = cast<FunctionProtoType>(OverloadTy);
for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
QualType ParamType = FT->getParamType(i);
ParmVarDecl *Parm =
ParmVarDecl::Create(Context, OverloadDecl, SourceLocation(),
- SourceLocation(), nullptr, ParamType,
- /*TInfo=*/nullptr, SC_None, nullptr);
+ SourceLocation(), nullptr, ParamType,
+ /*TInfo=*/nullptr, SC_None, nullptr);
Parm->setScopeInfo(0, i);
Params.push_back(Parm);
}
@@ -6668,7 +6654,6 @@ tryImplicitlyCaptureThisIfImplicitMemberFunctionAccessWithDependentArgs(
if (!enclosingClassIsRelatedToClassInWhichMembersWereFound(UME, S))
return;
-
DeclContext *EnclosingFunctionCtx = S.CurContext->getParent()->getParent();
// If the enclosing function is not dependent, then this lambda is
// capture ready, so if we can capture this, do so.
@@ -6777,7 +6762,8 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
bool AllowRecovery) {
// Since this might be a postfix expression, get rid of ParenListExprs.
ExprResult Result = MaybeConvertParenListExprToParenExpr(Scope, Fn);
- if (Result.isInvalid()) return ExprError();
+ if (Result.isInvalid())
+ return ExprError();
Fn = Result.get();
// The __builtin_amdgcn_is_invocable builtin is special, and will be resolved
@@ -6822,7 +6808,8 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
}
if (Fn->getType() == Context.PseudoObjectTy) {
ExprResult result = CheckPlaceholderExpr(Fn);
- if (result.isInvalid()) return ExprError();
+ if (result.isInvalid())
+ return ExprError();
Fn = result.get();
}
@@ -6860,7 +6847,8 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
if (Fn->getType() == Context.UnknownAnyTy) {
ExprResult result = rebuildUnknownAnyFunction(*this, Fn);
- if (result.isInvalid()) return ExprError();
+ if (result.isInvalid())
+ return ExprError();
Fn = result.get();
}
@@ -6894,7 +6882,8 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
// If we're directly calling a function, get the appropriate declaration.
if (Fn->getType() == Context.UnknownAnyTy) {
ExprResult result = rebuildUnknownAnyFunction(*this, Fn);
- if (result.isInvalid()) return ExprError();
+ if (result.isInvalid())
+ return ExprError();
Fn = result.get();
}
@@ -6953,7 +6942,7 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
// type.
if (getLangOpts().HIP && FD && FD->getBuiltinID()) {
for (unsigned Idx = 0; Idx < ArgExprs.size() && Idx < FD->param_size();
- ++Idx) {
+ ++Idx) {
ParmVarDecl *Param = FD->getParamDecl(Idx);
if (!ArgExprs[Idx] || !Param || !Param->getType()->isPointerType() ||
!ArgExprs[Idx]->getType()->isPointerType())
@@ -6966,10 +6955,14 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
// Add address space cast if target address spaces are different
bool NeedImplicitASC =
- ParamAS != LangAS::Default && // Pointer params in generic AS don't need special handling.
- ( ArgAS == LangAS::Default || // We do allow implicit conversion from generic AS
- // or from specific AS which has target AS matching that of Param.
- getASTContext().getTargetAddressSpace(ArgAS) == getASTContext().getTargetAddressSpace(ParamAS));
+ ParamAS != LangAS::Default && // Pointer params in generic AS don't
+ // need special handling.
+ (ArgAS ==
+ LangAS::Default || // We do allow implicit conversion from
+ // generic AS or from specific AS which has
+ // target AS matching that of Param.
+ getASTContext().getTargetAddressSpace(ArgAS) ==
+ getASTContext().getTargetAddressSpace(ParamAS));
if (!NeedImplicitASC)
continue;
@@ -6986,9 +6979,8 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
ArgPtQuals.setAddressSpace(ParamAS);
auto NewArgPtTy =
Context.getQualifiedType(ArgPtTy.getUnqualifiedType(), ArgPtQuals);
- auto NewArgTy =
- Context.getQualifiedType(Context.getPointerType(NewArgPtTy),
- ArgTy.getQualifiers());
+ auto NewArgTy = Context.getQualifiedType(
+ Context.getPointerType(NewArgPtTy), ArgTy.getQualifiers());
// Finally perform an implicit address space cast
ArgExprs[Idx] = ImpCastExprToType(ArgExprs[Idx], NewArgTy,
@@ -7215,7 +7207,8 @@ ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
if (Config) {
// CUDA: Kernel calls must be to global functions
if (FDecl && !FDecl->hasAttr<CUDAGlobalAttr>())
- return ExprError(Diag(LParenLoc,diag::err_kern_call_not_global_function)
+ return ExprError(
+ Diag(LParenLoc, diag::err_kern_call_not_global_function)
<< FDecl << Fn->getSourceRange());
// CUDA: Kernel function must have 'void' return type
@@ -7223,12 +7216,12 @@ ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
!FuncT->getReturnType()->getAs<AutoType>() &&
!FuncT->getReturnType()->isInstantiationDependentType())
return ExprError(Diag(LParenLoc, diag::err_kern_type_not_void_return)
- << Fn->getType() << Fn->getSourceRange());
+ << Fn->getType() << Fn->getSourceRange());
} else {
// CUDA: Calls to global functions must be configured
if (FDecl && FDecl->hasAttr<CUDAGlobalAttr>())
return ExprError(Diag(LParenLoc, diag::err_global_call_not_config)
- << FDecl << Fn->getSourceRange());
+ << FDecl << Fn->getSourceRange());
}
}
@@ -7264,9 +7257,11 @@ ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
const FunctionDecl *Def = nullptr;
if (FDecl->hasBody(Def) && Args.size() != Def->param_size()) {
Proto = Def->getType()->getAs<FunctionProtoType>();
- if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->param_size()))
+ if (!Proto ||
+ !(Proto->isVariadic() && Args.size() >= Def->param_size()))
Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
- << (Args.size() > Def->param_size()) << FDecl << Fn->getSourceRange();
+ << (Args.size() > Def->param_size()) << FDecl
+ << Fn->getSourceRange();
}
// If the function we're calling isn't a function prototype, but we have
@@ -7365,9 +7360,9 @@ ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), FDecl);
}
-ExprResult
-Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty,
- SourceLocation RParenLoc, Expr *InitExpr) {
+ExprResult Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty,
+ SourceLocation RParenLoc,
+ Expr *InitExpr) {
assert(Ty && "ActOnCompoundLiteral(): missing type");
assert(InitExpr && "ActOnCompoundLiteral(): missing expression");
@@ -7379,9 +7374,10 @@ Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty,
return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, InitExpr);
}
-ExprResult
-Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
- SourceLocation RParenLoc, Expr *LiteralExpr) {
+ExprResult Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc,
+ TypeSourceInfo *TInfo,
+ SourceLocation RParenLoc,
+ Expr *LiteralExpr) {
QualType literalType = TInfo->getType();
if (literalType->isArrayType()) {
@@ -7417,20 +7413,21 @@ Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
return ExprError();
}
} else if (!literalType->isDependentType() &&
- RequireCompleteType(LParenLoc, literalType,
- diag::err_typecheck_decl_incomplete_type,
- SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())))
+ RequireCompleteType(
+ LParenLoc, literalType,
+ diag::err_typecheck_decl_incomplete_type,
+ SourceRange(LParenLoc,
+ LiteralExpr->getSourceRange().getEnd())))
return ExprError();
- InitializedEntity Entity
- = InitializedEntity::InitializeCompoundLiteralInit(TInfo);
- InitializationKind Kind
- = InitializationKind::CreateCStyleCast(LParenLoc,
- SourceRange(LParenLoc, RParenLoc),
- /*InitList=*/true);
+ InitializedEntity Entity =
+ InitializedEntity::InitializeCompoundLiteralInit(TInfo);
+ InitializationKind Kind = InitializationKind::CreateCStyleCast(
+ LParenLoc, SourceRange(LParenLoc, RParenLoc),
+ /*InitList=*/true);
InitializationSequence InitSeq(*this, Entity, Kind, LiteralExpr);
- ExprResult Result = InitSeq.Perform(*this, Entity, Kind, LiteralExpr,
- &literalType);
+ ExprResult Result =
+ InitSeq.Perform(*this, Entity, Kind, LiteralExpr, &literalType);
if (Result.isInvalid())
return ExprError();
LiteralExpr = Result.get();
@@ -7487,8 +7484,7 @@ Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
auto *E = new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType, VK,
LiteralExpr, IsFileScope);
if (IsFileScope) {
- if (!LiteralExpr->isTypeDependent() &&
- !LiteralExpr->isValueDependent() &&
+ if (!LiteralExpr->isTypeDependent() && !LiteralExpr->isValueDependent() &&
!literalType->isDependentType()) // C99 6.5.2.5p3
if (CheckForConstantInitializer(LiteralExpr))
return ExprError();
@@ -7498,7 +7494,7 @@ Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
// "If the compound literal occurs inside the body of a function, the
// type name shall not be qualified by an address-space qualifier."
Diag(LParenLoc, diag::err_compound_literal_with_address_space)
- << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd());
+ << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd());
return ExprError();
}
@@ -7529,9 +7525,9 @@ Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
return MaybeBindToTemporary(E);
}
-ExprResult
-Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList,
- SourceLocation RBraceLoc) {
+ExprResult Sema::ActOnInitList(SourceLocation LBraceLoc,
+ MultiExprArg InitArgList,
+ SourceLocation RBraceLoc) {
// Only produce each kind of designated initialization diagnostic once.
SourceLocation FirstDesignator;
bool DiagnosedArrayDesignator = false;
@@ -7551,14 +7547,14 @@ Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList,
if (!DiagnosedNestedDesignator && DIE->size() > 1) {
DiagnosedNestedDesignator = true;
Diag(DIE->getBeginLoc(), diag::ext_designated_init_nested)
- << DIE->getDesignatorsSourceRange();
+ << DIE->getDesignatorsSourceRange();
}
for (auto &Desig : DIE->designators()) {
if (!Desig.isFieldDesignator() && !DiagnosedArrayDesignator) {
DiagnosedArrayDesignator = true;
Diag(Desig.getBeginLoc(), diag::ext_designated_init_array)
- << Desig.getSourceRange();
+ << Desig.getSourceRange();
}
}
@@ -7566,18 +7562,18 @@ Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList,
!isa<DesignatedInitExpr>(InitArgList[0])) {
DiagnosedMixedDesignator = true;
Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
- << DIE->getSourceRange();
+ << DIE->getSourceRange();
Diag(InitArgList[0]->getBeginLoc(), diag::note_designated_init_mixed)
- << InitArgList[0]->getSourceRange();
+ << InitArgList[0]->getSourceRange();
}
} else if (getLangOpts().CPlusPlus && !DiagnosedMixedDesignator &&
isa<DesignatedInitExpr>(InitArgList[0])) {
DiagnosedMixedDesignator = true;
auto *DIE = cast<DesignatedInitExpr>(InitArgList[0]);
Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
- << DIE->getSourceRange();
+ << DIE->getSourceRange();
Diag(InitArgList[I]->getBeginLoc(), diag::note_designated_init_mixed)
- << InitArgList[I]->getSourceRange();
+ << InitArgList[I]->getSourceRange();
}
}
@@ -7597,9 +7593,9 @@ Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList,
return BuildInitList(LBraceLoc, InitArgList, RBraceLoc);
}
-ExprResult
-Sema::BuildInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList,
- SourceLocation RBraceLoc) {
+ExprResult Sema::BuildInitList(SourceLocation LBraceLoc,
+ MultiExprArg InitArgList,
+ SourceLocation RBraceLoc) {
// Semantic analysis for initializers is done by ActOnDeclarator() and
// CheckInitializer() - it requires knowledge of the object being initialized.
@@ -7611,7 +7607,8 @@ Sema::BuildInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList,
// Ignore failures; dropping the entire initializer list because
// of one failure would be terrible for indexing/etc.
- if (result.isInvalid()) continue;
+ if (result.isInvalid())
+ continue;
InitArgList[I] = result.get();
}
@@ -7628,7 +7625,8 @@ void Sema::maybeExtendBlockObject(ExprResult &E) {
assert(E.get()->isPRValue());
// Only do this in an r-value context.
- if (!getLangOpts().ObjCAutoRefCount) return;
+ if (!getLangOpts().ObjCAutoRefCount)
+ return;
E = ImplicitCastExpr::Create(
Context, E.get()->getType(), CK_ARCExtendBlockObject, E.get(),
@@ -7664,7 +7662,8 @@ CastKind Sema::PrepareScalarCast(ExprResult &Src, QualType DestTy) {
}
case Type::STK_BlockPointer:
return (SrcKind == Type::STK_BlockPointer
- ? CK_BitCast : CK_AnyPointerToBlockPointerCast);
+ ? CK_BitCast
+ : CK_AnyPointerToBlockPointerCast);
case Type::STK_ObjCObjectPointer:
if (SrcKind == Type::STK_ObjCObjectPointer)
return CK_BitCast;
@@ -7727,13 +7726,13 @@ CastKind Sema::PrepareScalarCast(ExprResult &Src, QualType DestTy) {
return CK_IntegralToFloating;
case Type::STK_IntegralComplex:
Src = ImpCastExprToType(Src.get(),
- DestTy->castAs<ComplexType>()->getElementType(),
- CK_IntegralCast);
+ DestTy->castAs<ComplexType>()->getElementType(),
+ CK_IntegralCast);
return CK_IntegralRealToComplex;
case Type::STK_FloatingComplex:
Src = ImpCastExprToType(Src.get(),
- DestTy->castAs<ComplexType>()->getElementType(),
- CK_IntegralToFloating);
+ DestTy->castAs<ComplexType>()->getElementType(),
+ CK_IntegralToFloating);
return CK_FloatingRealToComplex;
case Type::STK_MemberPointer:
llvm_unreachable("member pointer type in C");
@@ -7855,7 +7854,8 @@ static bool breakDownVectorType(QualType type, uint64_t &len,
// We allow lax conversion to and from non-vector types, but only if
// they're real types (i.e. non-complex, non-pointer scalar types).
- if (!type->isRealType()) return false;
+ if (!type->isRealType())
+ return false;
len = 1;
eltType = type;
@@ -7938,8 +7938,10 @@ bool Sema::areLaxCompatibleVectorTypes(QualType srcTy, QualType destTy) {
// depend on them). Most scalar OP ExtVector cases are handled by the
// splat path anyway, which does what we want (convert, not bitcast).
// What this rules out for ExtVectors is crazy things like char4*float.
- if (srcTy->isScalarType() && destTy->isExtVectorType()) return false;
- if (destTy->isScalarType() && srcTy->isExtVectorType()) return false;
+ if (srcTy->isScalarType() && destTy->isExtVectorType())
+ return false;
+ if (destTy->isScalarType() && srcTy->isExtVectorType())
+ return false;
return areVectorTypesSameSize(srcTy, destTy);
}
@@ -7965,7 +7967,7 @@ bool Sema::isLaxVectorConversion(QualType srcTy, QualType destTy) {
// OK, integer (vector) -> integer (vector) bitcast.
break;
- case LangOptions::LaxVectorConversionKind::All:
+ case LangOptions::LaxVectorConversionKind::All:
break;
}
@@ -8000,14 +8002,14 @@ bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
if (Ty->isVectorType() || Ty->isIntegralType(Context)) {
if (!areLaxCompatibleVectorTypes(Ty, VectorTy))
return Diag(R.getBegin(),
- Ty->isVectorType() ?
- diag::err_invalid_conversion_between_vectors :
- diag::err_invalid_conversion_between_vector_and_integer)
- << VectorTy << Ty << R;
+ Ty->isVectorType()
+ ? diag::err_invalid_conversion_between_vectors
+ : diag::err_invalid_conversion_between_vector_and_integer)
+ << VectorTy << Ty << R;
} else
return Diag(R.getBegin(),
diag::err_invalid_conversion_between_vector_and_scalar)
- << VectorTy << Ty << R;
+ << VectorTy << Ty << R;
Kind = CK_BitCast;
return false;
@@ -8079,8 +8081,8 @@ ExprResult Sema::CheckExtVectorCast(SourceRange R, QualType DestTy,
(getLangOpts().OpenCL &&
!Context.hasSameUnqualifiedType(DestTy, SrcTy) &&
!Context.areCompatibleVectorTypes(DestTy, SrcTy))) {
- Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors)
- << DestTy << SrcTy << R;
+ Diag(R.getBegin(), diag::err_invalid_conversion_between_ext_vectors)
+ << DestTy << SrcTy << R;
return ExprError();
}
Kind = CK_BitCast;
@@ -8093,7 +8095,7 @@ ExprResult Sema::CheckExtVectorCast(SourceRange R, QualType DestTy,
if (SrcTy->isPointerType())
return Diag(R.getBegin(),
diag::err_invalid_conversion_between_vector_and_scalar)
- << DestTy << SrcTy << R;
+ << DestTy << SrcTy << R;
Kind = CK_VectorSplat;
return prepareVectorSplat(DestTy, CastExpr);
@@ -8134,10 +8136,9 @@ static void CheckSufficientAllocSize(Sema &S, QualType DestType,
<< Size.getQuantity() << TargetType << LhsSize->getQuantity();
}
-ExprResult
-Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
- Declarator &D, ParsedType &Ty,
- SourceLocation RParenLoc, Expr *CastExpr) {
+ExprResult Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
+ Declarator &D, ParsedType &Ty,
+ SourceLocation RParenLoc, Expr *CastExpr) {
assert(!D.isInvalidType() && (CastExpr != nullptr) &&
"ActOnCastExpr(): missing type or expr");
@@ -8161,8 +8162,9 @@ Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
// i.e. all the elements are integer constants.
ParenExpr *PE = dyn_cast<ParenExpr>(CastExpr);
ParenListExpr *PLE = dyn_cast<ParenListExpr>(CastExpr);
- if ((getLangOpts().AltiVec || getLangOpts().ZVector || getLangOpts().OpenCL)
- && castType->isVectorType() && (PE || PLE)) {
+ if ((getLangOpts().AltiVec || getLangOpts().ZVector ||
+ getLangOpts().OpenCL) &&
+ castType->isVectorType() && (PE || PLE)) {
if (PLE && PLE->getNumExprs() == 0) {
Diag(PLE->getExprLoc(), diag::err_altivec_empty_initializer);
return ExprError();
@@ -8171,8 +8173,7 @@ Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
Expr *E = (PE ? PE->getSubExpr() : PLE->getExpr(0));
if (!E->isTypeDependent() && !E->getType()->isVectorType())
isVectorLiteral = true;
- }
- else
+ } else
isVectorLiteral = true;
}
@@ -8186,7 +8187,8 @@ Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
// sequence of BinOp comma operators.
if (isa<ParenListExpr>(CastExpr)) {
ExprResult Result = MaybeConvertParenListExprToParenExpr(S, CastExpr);
- if (Result.isInvalid()) return ExprError();
+ if (Result.isInvalid())
+ return ExprError();
CastExpr = Result.get();
}
@@ -8253,16 +8255,12 @@ ExprResult Sema::BuildVectorLiteral(SourceLocation LParenLoc,
Literal = ImpCastExprToType(Literal.get(), ElemTy,
PrepareScalarCast(Literal, ElemTy));
return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get());
- }
- else if (numExprs < numElems) {
- Diag(E->getExprLoc(),
- diag::err_incorrect_number_of_vector_initializers);
+ } else if (numExprs < numElems) {
+ Diag(E->getExprLoc(), diag::err_incorrect_number_of_vector_initializers);
return ExprError();
- }
- else
+ } else
initExprs.append(exprs, exprs + numExprs);
- }
- else {
+ } else {
// For OpenCL, when the number of initializers is a single value,
// it will be replicated to all components of the vector.
if (getLangOpts().OpenCL && VTy->getVectorKind() == VectorKind::Generic &&
@@ -8287,14 +8285,14 @@ ExprResult Sema::BuildVectorLiteral(SourceLocation LParenLoc,
}
// FIXME: This means that pretty-printing the final AST will produce curly
// braces instead of the original commas.
- InitListExpr *initE = new (Context) InitListExpr(Context, LiteralLParenLoc,
- initExprs, LiteralRParenLoc);
+ InitListExpr *initE = new (Context)
+ InitListExpr(Context, LiteralLParenLoc, initExprs, LiteralRParenLoc);
initE->setType(Ty);
return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, initE);
}
-ExprResult
-Sema::MaybeConvertParenListExprToParenExpr(Scope *S, Expr *OrigExpr) {
+ExprResult Sema::MaybeConvertParenListExprToParenExpr(Scope *S,
+ Expr *OrigExpr) {
ParenListExpr *E = dyn_cast<ParenListExpr>(OrigExpr);
if (!E)
return OrigExpr;
@@ -8302,16 +8300,16 @@ Sema::MaybeConvertParenListExprToParenExpr(Scope *S, Expr *OrigExpr) {
ExprResult Result(E->getExpr(0));
for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i)
- Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(),
- E->getExpr(i));
+ Result =
+ ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(), E->getExpr(i));
- if (Result.isInvalid()) return ExprError();
+ if (Result.isInvalid())
+ return ExprError();
return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), Result.get());
}
-ExprResult Sema::ActOnParenListExpr(SourceLocation L,
- SourceLocation R,
+ExprResult Sema::ActOnParenListExpr(SourceLocation L, SourceLocation R,
MultiExprArg Val) {
return ParenListExpr::Create(Context, L, Val, R);
}
@@ -8329,16 +8327,14 @@ bool Sema::DiagnoseConditionalForNull(const Expr *LHSExpr, const Expr *RHSExpr,
SourceLocation QuestionLoc) {
const Expr *NullExpr = LHSExpr;
const Expr *NonPointerExpr = RHSExpr;
- Expr::NullPointerConstantKind NullKind =
- NullExpr->isNullPointerConstant(Context,
- Expr::NPC_ValueDependentIsNotNull);
+ Expr::NullPointerConstantKind NullKind = NullExpr->isNullPointerConstant(
+ Context, Expr::NPC_ValueDependentIsNotNull);
if (NullKind == Expr::NPCK_NotNull) {
NullExpr = RHSExpr;
NonPointerExpr = LHSExpr;
- NullKind =
- NullExpr->isNullPointerConstant(Context,
- Expr::NPC_ValueDependentIsNotNull);
+ NullKind = NullExpr->isNullPointerConstant(
+ Context, Expr::NPC_ValueDependentIsNotNull);
}
if (NullKind == Expr::NPCK_NotNull)
@@ -8371,15 +8367,16 @@ static bool checkCondition(Sema &S, const Expr *Cond,
// OpenCL v1.1 s6.3.i says the condition cannot be a floating point type.
if (S.getLangOpts().OpenCL && CondTy->isFloatingType()) {
S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
- << CondTy << Cond->getSourceRange();
+ << CondTy << Cond->getSourceRange();
return true;
}
// C99 6.5.15p2
- if (CondTy->isScalarType()) return false;
+ if (CondTy->isScalarType())
+ return false;
S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_scalar)
- << CondTy << Cond->getSourceRange();
+ << CondTy << Cond->getSourceRange();
return true;
}
@@ -8389,7 +8386,7 @@ static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr,
QualType PointerTy) {
if ((!PointerTy->isAnyPointerType() && !PointerTy->isBlockPointerType()) ||
!NullExpr.get()->isNullPointerConstant(S.Context,
- Expr::NPC_ValueDependentIsNull))
+ Expr::NPC_ValueDependentIsNull))
return true;
NullExpr = S.ImpCastExprToType(NullExpr.get(), PointerTy, CK_NullToPointer);
@@ -8451,7 +8448,8 @@ static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS,
return QualType();
}
- unsigned MergedCVRQual = lhQual.getCVRQualifiers() | rhQual.getCVRQualifiers();
+ unsigned MergedCVRQual =
+ lhQual.getCVRQualifiers() | rhQual.getCVRQualifiers();
auto LHSCastKind = CK_BitCast, RHSCastKind = CK_BitCast;
lhQual.removeCVRQualifiers();
rhQual.removeCVRQualifiers();
@@ -8551,8 +8549,8 @@ static QualType checkConditionalBlockPointerCompatibility(Sema &S,
return destType;
}
S.Diag(Loc, diag::err_typecheck_cond_incompatible_operands)
- << LHSTy << RHSTy << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ << LHSTy << RHSTy << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
return QualType();
}
@@ -8561,10 +8559,8 @@ static QualType checkConditionalBlockPointerCompatibility(Sema &S,
}
/// Return the resulting type when the operands are both pointers.
-static QualType
-checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS,
- ExprResult &RHS,
- SourceLocation Loc) {
+static QualType checkConditionalObjectPointersCompatibility(
+ Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc) {
// get the pointer types
QualType LHSTy = LHS.get()->getType();
QualType RHSTy = RHS.get()->getType();
@@ -8576,8 +8572,8 @@ checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS,
// ignore qualifiers on void (C99 6.5.15p3, clause 6)
if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) {
// Figure out necessary qualifiers (C99 6.5.15p6)
- QualType destPointee
- = S.Context.getQualifiedType(lhptee, rhptee.getQualifiers());
+ QualType destPointee =
+ S.Context.getQualifiedType(lhptee, rhptee.getQualifiers());
QualType destType = S.Context.getPointerType(destPointee);
// Add qualifiers if necessary.
LHS = S.ImpCastExprToType(LHS.get(), destType, CK_NoOp);
@@ -8586,8 +8582,8 @@ checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS,
return destType;
}
if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) {
- QualType destPointee
- = S.Context.getQualifiedType(rhptee, lhptee.getQualifiers());
+ QualType destPointee =
+ S.Context.getQualifiedType(rhptee, lhptee.getQualifiers());
QualType destType = S.Context.getPointerType(destPointee);
// Add qualifiers if necessary.
RHS = S.ImpCastExprToType(RHS.get(), destType, CK_NoOp);
@@ -8602,7 +8598,7 @@ checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS,
/// Return false if the first expression is not an integer and the second
/// expression is not a pointer, true otherwise.
static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int,
- Expr* PointerExpr, SourceLocation Loc,
+ Expr *PointerExpr, SourceLocation Loc,
bool IsIntFirstExpr) {
if (!PointerExpr->getType()->isPointerType() ||
!Int.get()->getType()->isIntegerType())
@@ -8612,8 +8608,8 @@ static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int,
Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get();
S.Diag(Loc, diag::ext_typecheck_cond_pointer_integer_mismatch)
- << Expr1->getType() << Expr2->getType()
- << Expr1->getSourceRange() << Expr2->getSourceRange();
+ << Expr1->getType() << Expr2->getType() << Expr1->getSourceRange()
+ << Expr2->getSourceRange();
Int = S.ImpCastExprToType(Int.get(), PointerExpr->getType(),
CK_IntegralToPointer);
return true;
@@ -8644,19 +8640,19 @@ static QualType OpenCLArithmeticConversions(Sema &S, ExprResult &LHS,
// For conversion purposes, we ignore any qualifiers.
// For example, "const float" and "float" are equivalent.
QualType LHSType =
- S.Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType();
+ S.Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType();
QualType RHSType =
- S.Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType();
+ S.Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType();
if (!LHSType->isIntegerType() && !LHSType->isRealFloatingType()) {
S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
- << LHSType << LHS.get()->getSourceRange();
+ << LHSType << LHS.get()->getSourceRange();
return QualType();
}
if (!RHSType->isIntegerType() && !RHSType->isRealFloatingType()) {
S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
- << RHSType << RHS.get()->getSourceRange();
+ << RHSType << RHS.get()->getSourceRange();
return QualType();
}
@@ -8670,8 +8666,8 @@ static QualType OpenCLArithmeticConversions(Sema &S, ExprResult &LHS,
/*IsCompAssign = */ false);
// Finally, we have two differing integer types.
- return handleIntegerConversion<doIntegralCast, doIntegralCast>
- (S, LHS, RHS, LHSType, RHSType, /*IsCompAssign = */ false);
+ return handleIntegerConversion<doIntegralCast, doIntegralCast>(
+ S, LHS, RHS, LHSType, RHSType, /*IsCompAssign = */ false);
}
/// Convert scalar operands to a vector that matches the
@@ -8685,11 +8681,12 @@ static QualType OpenCLArithmeticConversions(Sema &S, ExprResult &LHS,
/// into a vector of that type where the length matches the condition
/// vector type. s6.11.6 requires that the element types of the result
/// and the condition must have the same number of bits.
-static QualType
-OpenCLConvertScalarsToVectors(Sema &S, ExprResult &LHS, ExprResult &RHS,
- QualType CondTy, SourceLocation QuestionLoc) {
+static QualType OpenCLConvertScalarsToVectors(Sema &S, ExprResult &LHS,
+ ExprResult &RHS, QualType CondTy,
+ SourceLocation QuestionLoc) {
QualType ResTy = OpenCLArithmeticConversions(S, LHS, RHS, QuestionLoc);
- if (ResTy.isNull()) return QualType();
+ if (ResTy.isNull())
+ return QualType();
const VectorType *CV = CondTy->getAs<VectorType>();
assert(CV);
@@ -8699,8 +8696,8 @@ OpenCLConvertScalarsToVectors(Sema &S, ExprResult &LHS, ExprResult &RHS,
QualType VectorTy = S.Context.getExtVectorType(ResTy, NumElements);
// Ensure that all types have the same number of bits
- if (S.Context.getTypeSize(CV->getElementType())
- != S.Context.getTypeSize(ResTy)) {
+ if (S.Context.getTypeSize(CV->getElementType()) !=
+ S.Context.getTypeSize(ResTy)) {
// Since VectorTy is created internally, it does not pretty print
// with an OpenCL name. Instead, we just print a description.
std::string EleTyName = ResTy.getUnqualifiedType().getAsString();
@@ -8708,7 +8705,7 @@ OpenCLConvertScalarsToVectors(Sema &S, ExprResult &LHS, ExprResult &RHS,
llvm::raw_svector_ostream OS(Str);
OS << "(vector of " << NumElements << " '" << EleTyName << "' values)";
S.Diag(QuestionLoc, diag::err_conditional_vector_element_size)
- << CondTy << OS.str();
+ << CondTy << OS.str();
return QualType();
}
@@ -8727,10 +8724,11 @@ static bool checkOpenCLConditionVector(Sema &S, Expr *Cond,
const VectorType *CondTy = Cond->getType()->getAs<VectorType>();
assert(CondTy);
QualType EleTy = CondTy->getElementType();
- if (EleTy->isIntegerType()) return false;
+ if (EleTy->isIntegerType())
+ return false;
S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
- << Cond->getType() << Cond->getSourceRange();
+ << Cond->getType() << Cond->getSourceRange();
return true;
}
@@ -8748,7 +8746,7 @@ static bool checkVectorResult(Sema &S, QualType CondTy, QualType VecResTy,
if (CV->getNumElements() != RV->getNumElements()) {
S.Diag(QuestionLoc, diag::err_conditional_vector_size)
- << CondTy << VecResTy;
+ << CondTy << VecResTy;
return true;
}
@@ -8769,10 +8767,9 @@ static bool checkVectorResult(Sema &S, QualType CondTy, QualType VecResTy,
/// Return the resulting type for the conditional operator in
/// OpenCL (aka "ternary selection operator", OpenCL v1.1
/// s6.3.i) when the condition is a vector type.
-static QualType
-OpenCLCheckVectorConditional(Sema &S, ExprResult &Cond,
- ExprResult &LHS, ExprResult &RHS,
- SourceLocation QuestionLoc) {
+static QualType OpenCLCheckVectorConditional(Sema &S, ExprResult &Cond,
+ ExprResult &LHS, ExprResult &RHS,
+ SourceLocation QuestionLoc) {
Cond = S.DefaultFunctionArrayLvalueConversion(Cond.get());
if (Cond.isInvalid())
return QualType();
@@ -8833,11 +8830,13 @@ QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
SourceLocation QuestionLoc) {
ExprResult LHSResult = CheckPlaceholderExpr(LHS.get());
- if (!LHSResult.isUsable()) return QualType();
+ if (!LHSResult.isUsable())
+ return QualType();
LHS = LHSResult;
ExprResult RHSResult = CheckPlaceholderExpr(RHS.get());
- if (!RHSResult.isUsable()) return QualType();
+ if (!RHSResult.isUsable())
+ return QualType();
RHS = RHSResult;
// C++ is sufficiently different to merit its own checker.
@@ -8896,16 +8895,16 @@ QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
// Diagnose attempts to convert between __ibm128, __float128 and long double
// where such conversions currently can't be handled.
if (unsupportedTypeConversion(*this, LHSTy, RHSTy)) {
- Diag(QuestionLoc,
- diag::err_typecheck_cond_incompatible_operands) << LHSTy << RHSTy
- << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
+ Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
+ << LHSTy << RHSTy << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
return QualType();
}
// OpenCL v2.0 s6.12.5 - Blocks cannot be used as expressions of the ternary
// selection operator (?:).
- if (getLangOpts().OpenCL &&
- ((int)checkBlockType(*this, LHS.get()) | (int)checkBlockType(*this, RHS.get()))) {
+ if (getLangOpts().OpenCL && ((int)checkBlockType(*this, LHS.get()) |
+ (int)checkBlockType(*this, RHS.get()))) {
return QualType();
}
@@ -8964,8 +8963,10 @@ QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
// C99 6.5.15p6 - "if one operand is a null pointer constant, the result has
// the type of the other operand."
- if (!checkConditionalNullPointer(*this, RHS, LHSTy)) return LHSTy;
- if (!checkConditionalNullPointer(*this, LHS, RHSTy)) return RHSTy;
+ if (!checkConditionalNullPointer(*this, RHS, LHSTy))
+ return LHSTy;
+ if (!checkConditionalNullPointer(*this, LHS, RHSTy))
+ return RHSTy;
// All objective-c pointer type analysis is done here.
QualType compositeType =
@@ -8975,7 +8976,6 @@ QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
if (!compositeType.isNull())
return compositeType;
-
// Handle block pointer types.
if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType())
return checkConditionalBlockPointerCompatibility(*this, LHS, RHS,
@@ -8989,10 +8989,10 @@ QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
// GCC compatibility: soften pointer/integer mismatch. Note that
// null pointers have been filtered out by this point.
if (checkPointerIntegerMismatch(*this, LHS, RHS.get(), QuestionLoc,
- /*IsIntFirstExpr=*/true))
+ /*IsIntFirstExpr=*/true))
return RHSTy;
if (checkPointerIntegerMismatch(*this, RHS, LHS.get(), QuestionLoc,
- /*IsIntFirstExpr=*/false))
+ /*IsIntFirstExpr=*/false))
return LHSTy;
// Emit a better diagnostic if one of the expressions is a null pointer
@@ -9008,8 +9008,8 @@ QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
// Otherwise, the operands are not compatible.
Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
- << LHSTy << RHSTy << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ << LHSTy << RHSTy << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
return QualType();
}
@@ -9021,9 +9021,9 @@ static void SuggestParentheses(Sema &Self, SourceLocation Loc,
SourceLocation EndLoc = Self.getLocForEndOfToken(ParenRange.getEnd());
if (ParenRange.getBegin().isFileID() && ParenRange.getEnd().isFileID() &&
EndLoc.isValid()) {
- Self.Diag(Loc, Note)
- << FixItHint::CreateInsertion(ParenRange.getBegin(), "(")
- << FixItHint::CreateInsertion(EndLoc, ")");
+ Self.Diag(Loc, Note) << FixItHint::CreateInsertion(ParenRange.getBegin(),
+ "(")
+ << FixItHint::CreateInsertion(EndLoc, ")");
} else {
// We can't display the parentheses, so just show the bare note.
Self.Diag(Loc, Note) << ParenRange;
@@ -9072,8 +9072,8 @@ static bool IsArithmeticBinaryExpr(const Expr *E, BinaryOperatorKind *Opcode,
// Make sure this is really a binary operator that is safe to pass into
// BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op.
OverloadedOperatorKind OO = Call->getOperator();
- if (OO < OO_Plus || OO > OO_Arrow ||
- OO == OO_PlusPlus || OO == OO_MinusMinus)
+ if (OO < OO_Plus || OO > OO_Arrow || OO == OO_PlusPlus ||
+ OO == OO_MinusMinus)
return false;
BinaryOperatorKind OpKind = BinaryOperator::getOverloadedOpcode(OO);
@@ -9129,9 +9129,8 @@ static void DiagnoseConditionalPrecedence(Sema &Self, SourceLocation OpLoc,
? diag::warn_precedence_bitwise_conditional
: diag::warn_precedence_conditional;
- Self.Diag(OpLoc, DiagID)
- << Condition->getSourceRange()
- << BinaryOperator::getOpcodeStr(CondOpcode);
+ Self.Diag(OpLoc, DiagID) << Condition->getSourceRange()
+ << BinaryOperator::getOpcodeStr(CondOpcode);
SuggestParentheses(
Self, OpLoc,
@@ -9171,7 +9170,7 @@ static QualType computeConditionalNullability(QualType ResTy, bool IsBin,
MergedKind = NullabilityKind::NonNull;
else
MergedKind = RHSKind;
- // Compute nullability of a normal conditional expression.
+ // Compute nullability of a normal conditional expression.
} else {
if (LHSKind == NullabilityKind::Nullable ||
RHSKind == NullabilityKind::Nullable)
@@ -9197,9 +9196,8 @@ static QualType computeConditionalNullability(QualType ResTy, bool IsBin,
}
ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
- SourceLocation ColonLoc,
- Expr *CondExpr, Expr *LHSExpr,
- Expr *RHSExpr) {
+ SourceLocation ColonLoc, Expr *CondExpr,
+ Expr *LHSExpr, Expr *RHSExpr) {
// If this is the gnu "x ?: y" extension, analyze the types as though the LHS
// was the condition.
OpaqueValueExpr *opaqueValue = nullptr;
@@ -9211,18 +9209,17 @@ ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
// as Objective-C++'s dictionary subscripting syntax.
if (commonExpr->hasPlaceholderType()) {
ExprResult result = CheckPlaceholderExpr(commonExpr);
- if (!result.isUsable()) return ExprError();
+ if (!result.isUsable())
+ return ExprError();
commonExpr = result.get();
}
// We usually want to apply unary conversions *before* saving, except
// in the special case of a C++ l-value conditional.
- if (!(getLangOpts().CPlusPlus
- && !commonExpr->isTypeDependent()
- && commonExpr->getValueKind() == RHSExpr->getValueKind()
- && commonExpr->isGLValue()
- && commonExpr->isOrdinaryOrBitFieldObject()
- && RHSExpr->isOrdinaryOrBitFieldObject()
- && Context.hasSameType(commonExpr->getType(), RHSExpr->getType()))) {
+ if (!(getLangOpts().CPlusPlus && !commonExpr->isTypeDependent() &&
+ commonExpr->getValueKind() == RHSExpr->getValueKind() &&
+ commonExpr->isGLValue() && commonExpr->isOrdinaryOrBitFieldObject() &&
+ RHSExpr->isOrdinaryOrBitFieldObject() &&
+ Context.hasSameType(commonExpr->getType(), RHSExpr->getType()))) {
ExprResult commonRes = UsualUnaryConversions(commonExpr);
if (commonRes.isInvalid())
return ExprError();
@@ -9239,11 +9236,9 @@ ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
commonExpr = MatExpr.get();
}
- opaqueValue = new (Context) OpaqueValueExpr(commonExpr->getExprLoc(),
- commonExpr->getType(),
- commonExpr->getValueKind(),
- commonExpr->getObjectKind(),
- commonExpr);
+ opaqueValue = new (Context) OpaqueValueExpr(
+ commonExpr->getExprLoc(), commonExpr->getType(),
+ commonExpr->getValueKind(), commonExpr->getObjectKind(), commonExpr);
LHSExpr = CondExpr = opaqueValue;
}
@@ -9251,10 +9246,9 @@ ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
ExprValueKind VK = VK_PRValue;
ExprObjectKind OK = OK_Ordinary;
ExprResult Cond = CondExpr, LHS = LHSExpr, RHS = RHSExpr;
- QualType result = CheckConditionalOperands(Cond, LHS, RHS,
- VK, OK, QuestionLoc);
- if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() ||
- RHS.isInvalid())
+ QualType result =
+ CheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc);
+ if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() || RHS.isInvalid())
return ExprError();
DiagnoseConditionalPrecedence(*this, QuestionLoc, Cond.get(), LHS.get(),
@@ -9262,8 +9256,8 @@ ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
CheckBoolLikeConversion(Cond.get(), QuestionLoc);
- result = computeConditionalNullability(result, commonExpr, LHSTy, RHSTy,
- Context);
+ result =
+ computeConditionalNullability(result, commonExpr, LHSTy, RHSTy, Context);
if (!commonExpr)
return new (Context)
@@ -9437,9 +9431,9 @@ static AssignConvertType checkPointerTypesForAssignment(Sema &S,
if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) {
do {
std::tie(lhptee, lhq) =
- cast<PointerType>(lhptee)->getPointeeType().split().asPair();
+ cast<PointerType>(lhptee)->getPointeeType().split().asPair();
std::tie(rhptee, rhq) =
- cast<PointerType>(rhptee)->getPointeeType().split().asPair();
+ cast<PointerType>(rhptee)->getPointeeType().split().asPair();
// Inconsistent address spaces at this point is invalid, even if the
// address spaces would be compatible.
@@ -10045,8 +10039,8 @@ static void ConstructTransparentUnion(Sema &S, ASTContext &C,
// Build an initializer list that designates the appropriate member
// of the transparent union.
Expr *E = EResult.get();
- InitListExpr *Initializer = new (C) InitListExpr(C, SourceLocation(),
- E, SourceLocation());
+ InitListExpr *Initializer =
+ new (C) InitListExpr(C, SourceLocation(), E, SourceLocation());
Initializer->setType(UnionType);
Initializer->setInitializedFieldInUnion(Field);
@@ -10089,8 +10083,7 @@ Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType,
if (RHS.get()->isNullPointerConstant(Context,
Expr::NPC_ValueDependentIsNull)) {
- RHS = ImpCastExprToType(RHS.get(), it->getType(),
- CK_NullToPointer);
+ RHS = ImpCastExprToType(RHS.get(), it->getType(), CK_NullToPointer);
InitField = it;
break;
}
@@ -10148,13 +10141,12 @@ AssignConvertType Sema::CheckSingleAssignmentConstraints(QualType LHSType,
RHS = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
AssignmentAction::Assigning);
} else {
- ImplicitConversionSequence ICS =
- TryImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
- /*SuppressUserConversions=*/false,
- AllowedExplicit::None,
- /*InOverloadResolution=*/false,
- /*CStyle=*/false,
- /*AllowObjCWritebackConversion=*/false);
+ ImplicitConversionSequence ICS = TryImplicitConversion(
+ RHS.get(), LHSType.getUnqualifiedType(),
+ /*SuppressUserConversions=*/false, AllowedExplicit::None,
+ /*InOverloadResolution=*/false,
+ /*CStyle=*/false,
+ /*AllowObjCWritebackConversion=*/false);
if (ICS.isFailure())
return AssignConvertType::Incompatible;
RHS = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
@@ -10356,27 +10348,27 @@ struct OriginalOperand {
Expr *Orig;
NamedDecl *Conversion;
};
-}
+} // namespace
QualType Sema::InvalidOperands(SourceLocation Loc, ExprResult &LHS,
ExprResult &RHS) {
OriginalOperand OrigLHS(LHS.get()), OrigRHS(RHS.get());
Diag(Loc, diag::err_typecheck_invalid_operands)
- << OrigLHS.getType() << OrigRHS.getType()
- << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
+ << OrigLHS.getType() << OrigRHS.getType() << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
// If a user-defined conversion was applied to either of the operands prior
// to applying the built-in operator rules, tell the user about it.
if (OrigLHS.Conversion) {
Diag(OrigLHS.Conversion->getLocation(),
diag::note_typecheck_invalid_operands_converted)
- << 0 << LHS.get()->getType();
+ << 0 << LHS.get()->getType();
}
if (OrigRHS.Conversion) {
Diag(OrigRHS.Conversion->getLocation(),
diag::note_typecheck_invalid_operands_converted)
- << 1 << RHS.get()->getType();
+ << 1 << RHS.get()->getType();
}
return QualType();
@@ -10419,10 +10411,8 @@ QualType Sema::InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS,
/// \param scalar - if non-null, actually perform the conversions
/// \return true if the operation fails (but without diagnosing the failure)
static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar,
- QualType scalarTy,
- QualType vectorEltTy,
- QualType vectorTy,
- unsigned &DiagID) {
+ QualType scalarTy, QualType vectorEltTy,
+ QualType vectorTy, unsigned &DiagID) {
// The conversion to apply to the scalar before splatting it,
// if necessary.
CastKind scalarCast = CK_NoOp;
@@ -10430,9 +10420,10 @@ static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar,
if (vectorEltTy->isBooleanType() && scalarTy->isIntegralType(S.Context)) {
scalarCast = CK_IntegralToBoolean;
} else if (vectorEltTy->isIntegralType(S.Context)) {
- if (S.getLangOpts().OpenCL && (scalarTy->isRealFloatingType() ||
- (scalarTy->isIntegerType() &&
- S.Context.getIntegerTypeOrder(vectorEltTy, scalarTy) < 0))) {
+ if (S.getLangOpts().OpenCL &&
+ (scalarTy->isRealFloatingType() ||
+ (scalarTy->isIntegerType() &&
+ S.Context.getIntegerTypeOrder(vectorEltTy, scalarTy) < 0))) {
DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
return true;
}
@@ -10447,8 +10438,7 @@ static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar,
return true;
}
scalarCast = CK_FloatingCast;
- }
- else if (scalarTy->isIntegralType(S.Context))
+ } else if (scalarTy->isIntegralType(S.Context))
scalarCast = CK_IntegralToFloating;
else
return true;
@@ -10878,11 +10868,11 @@ QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
if (!IsCompAssign) {
*OtherExpr = ImpCastExprToType(OtherExpr->get(), VecType, CK_BitCast);
return VecType;
- // In a compound assignment, lhs += rhs, 'lhs' is a lvalue src, forbidding
- // any implicit cast. Here, the 'rhs' should be implicit casted to 'lhs'
- // type. Note that this is already done by non-compound assignments in
- // CheckAssignmentConstraints. If it's a scalar type, only bitcast for
- // <1 x T> -> T. The result is also a vector type.
+ // In a compound assignment, lhs += rhs, 'lhs' is a lvalue src, forbidding
+ // any implicit cast. Here, the 'rhs' should be implicit casted to 'lhs'
+ // type. Note that this is already done by non-compound assignments in
+ // CheckAssignmentConstraints. If it's a scalar type, only bitcast for
+ // <1 x T> -> T. The result is also a vector type.
} else if (OtherType->isExtVectorType() || OtherType->isVectorType() ||
(OtherType->isScalarType() && VT->getNumElements() == 1)) {
ExprResult *RHSExpr = &RHS;
@@ -10897,8 +10887,8 @@ QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
if ((!RHSVecType && !RHSType->isRealType()) ||
(!LHSVecType && !LHSType->isRealType())) {
Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
- << LHSType << RHSType
- << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
+ << LHSType << RHSType << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
return QualType();
}
@@ -10906,15 +10896,13 @@ QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
// If the operands are of more than one vector type, then an error shall
// occur. Implicit conversions between vector types are not permitted, per
// section 6.2.1.
- if (getLangOpts().OpenCL &&
- RHSVecType && isa<ExtVectorType>(RHSVecType) &&
+ if (getLangOpts().OpenCL && RHSVecType && isa<ExtVectorType>(RHSVecType) &&
LHSVecType && isa<ExtVectorType>(LHSVecType)) {
- Diag(Loc, diag::err_opencl_implicit_vector_conversion) << LHSType
- << RHSType;
+ Diag(Loc, diag::err_opencl_implicit_vector_conversion)
+ << LHSType << RHSType;
return QualType();
}
-
// If there is a vector type that is not a ExtVector and a scalar, we reach
// this point if scalar could not be converted to the vector's element type
// without truncation.
@@ -10923,17 +10911,15 @@ QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
QualType Scalar = LHSVecType ? RHSType : LHSType;
QualType Vector = LHSVecType ? LHSType : RHSType;
unsigned ScalarOrVector = LHSVecType && RHSVecType ? 1 : 0;
- Diag(Loc,
- diag::err_typecheck_vector_not_convertable_implict_truncation)
+ Diag(Loc, diag::err_typecheck_vector_not_convertable_implict_truncation)
<< ScalarOrVector << Scalar << Vector;
return QualType();
}
// Otherwise, use the generic diagnostic.
- Diag(Loc, DiagID)
- << LHSType << RHSType
- << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
+ Diag(Loc, DiagID) << LHSType << RHSType << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
return QualType();
}
@@ -11047,8 +11033,8 @@ static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS,
return;
S.Diag(Loc, diag::warn_null_in_comparison_operation)
- << LHSNull /* LHS is NULL */ << NonNullType
- << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
+ << LHSNull /* LHS is NULL */ << NonNullType << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
}
static void DetectPrecisionLossInComplexDivision(Sema &S, QualType DivisorTy,
@@ -11091,7 +11077,7 @@ static void DetectPrecisionLossInComplexDivision(Sema &S, QualType DivisorTy,
}
static void DiagnoseDivisionSizeofPointerOrArray(Sema &S, Expr *LHS, Expr *RHS,
- SourceLocation Loc) {
+ SourceLocation Loc) {
const auto *LUE = dyn_cast<UnaryExprOrTypeTraitExpr>(LHS);
const auto *RUE = dyn_cast<UnaryExprOrTypeTraitExpr>(RHS);
if (!LUE || !RUE)
@@ -11138,7 +11124,7 @@ static void DiagnoseDivisionSizeofPointerOrArray(Sema &S, Expr *LHS, Expr *RHS,
}
}
-static void DiagnoseBadDivideOrRemainderValues(Sema& S, ExprResult &LHS,
+static void DiagnoseBadDivideOrRemainderValues(Sema &S, ExprResult &LHS,
ExprResult &RHS,
SourceLocation Loc, bool IsDiv) {
// Check for division/remainder by zero.
@@ -11148,7 +11134,7 @@ static void DiagnoseBadDivideOrRemainderValues(Sema& S, ExprResult &LHS,
RHSValue.Val.getInt() == 0)
S.DiagRuntimeBehavior(Loc, RHS.get(),
S.PDiag(diag::warn_remainder_division_by_zero)
- << IsDiv << RHS.get()->getSourceRange());
+ << IsDiv << RHS.get()->getSourceRange());
}
static void diagnoseScopedEnums(Sema &S, const SourceLocation Loc,
@@ -11235,8 +11221,8 @@ QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS,
return compType;
}
-QualType Sema::CheckRemainderOperands(
- ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) {
+QualType Sema::CheckRemainderOperands(ExprResult &LHS, ExprResult &RHS,
+ SourceLocation Loc, bool IsCompAssign) {
checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
// Note: This check is here to simplify the double exclusions of
@@ -11303,19 +11289,19 @@ QualType Sema::CheckRemainderOperands(
static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc,
Expr *LHSExpr, Expr *RHSExpr) {
S.Diag(Loc, S.getLangOpts().CPlusPlus
- ? diag::err_typecheck_pointer_arith_void_type
- : diag::ext_gnu_void_ptr)
- << 1 /* two pointers */ << LHSExpr->getSourceRange()
- << RHSExpr->getSourceRange();
+ ? diag::err_typecheck_pointer_arith_void_type
+ : diag::ext_gnu_void_ptr)
+ << 1 /* two pointers */ << LHSExpr->getSourceRange()
+ << RHSExpr->getSourceRange();
}
/// Diagnose invalid arithmetic on a void pointer.
static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc,
Expr *Pointer) {
S.Diag(Loc, S.getLangOpts().CPlusPlus
- ? diag::err_typecheck_pointer_arith_void_type
- : diag::ext_gnu_void_ptr)
- << 0 /* one pointer */ << Pointer->getSourceRange();
+ ? diag::err_typecheck_pointer_arith_void_type
+ : diag::ext_gnu_void_ptr)
+ << 0 /* one pointer */ << Pointer->getSourceRange();
}
/// Diagnose invalid arithmetic on a null pointer.
@@ -11326,11 +11312,10 @@ static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc,
static void diagnoseArithmeticOnNullPointer(Sema &S, SourceLocation Loc,
Expr *Pointer, bool IsGNUIdiom) {
if (IsGNUIdiom)
- S.Diag(Loc, diag::warn_gnu_null_ptr_arith)
- << Pointer->getSourceRange();
+ S.Diag(Loc, diag::warn_gnu_null_ptr_arith) << Pointer->getSourceRange();
else
S.Diag(Loc, diag::warn_pointer_arith_null_ptr)
- << S.getLangOpts().CPlusPlus << Pointer->getSourceRange();
+ << S.getLangOpts().CPlusPlus << Pointer->getSourceRange();
}
/// Diagnose invalid subraction on a null pointer.
@@ -11357,14 +11342,15 @@ static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc,
assert(LHS->getType()->isAnyPointerType());
assert(RHS->getType()->isAnyPointerType());
S.Diag(Loc, S.getLangOpts().CPlusPlus
- ? diag::err_typecheck_pointer_arith_function_type
- : diag::ext_gnu_ptr_func_arith)
- << 1 /* two pointers */ << LHS->getType()->getPointeeType()
- // We only show the second type if it differs from the first.
- << (unsigned)!S.Context.hasSameUnqualifiedType(LHS->getType(),
- RHS->getType())
- << RHS->getType()->getPointeeType()
- << LHS->getSourceRange() << RHS->getSourceRange();
+ ? diag::err_typecheck_pointer_arith_function_type
+ : diag::ext_gnu_ptr_func_arith)
+ << 1 /* two pointers */
+ << LHS->getType()->getPointeeType()
+ // We only show the second type if it differs from the first.
+ << (unsigned)!S.Context.hasSameUnqualifiedType(LHS->getType(),
+ RHS->getType())
+ << RHS->getType()->getPointeeType() << LHS->getSourceRange()
+ << RHS->getSourceRange();
}
/// Diagnose invalid arithmetic on a function pointer.
@@ -11372,11 +11358,11 @@ static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc,
Expr *Pointer) {
assert(Pointer->getType()->isAnyPointerType());
S.Diag(Loc, S.getLangOpts().CPlusPlus
- ? diag::err_typecheck_pointer_arith_function_type
- : diag::ext_gnu_ptr_func_arith)
- << 0 /* one pointer */ << Pointer->getType()->getPointeeType()
- << 0 /* one pointer, so only one type */
- << Pointer->getSourceRange();
+ ? diag::err_typecheck_pointer_arith_function_type
+ : diag::ext_gnu_ptr_func_arith)
+ << 0 /* one pointer */ << Pointer->getType()->getPointeeType()
+ << 0 /* one pointer, so only one type */
+ << Pointer->getSourceRange();
}
/// Emit error if Operand is incomplete pointer type
@@ -11410,7 +11396,8 @@ static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc,
if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>())
ResType = ResAtomicType->getValueType();
- if (!ResType->isAnyPointerType()) return true;
+ if (!ResType->isAnyPointerType())
+ return true;
QualType PointeeTy = ResType->getPointeeType();
if (PointeeTy->isVoidType()) {
@@ -11422,7 +11409,8 @@ static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc,
return !S.getLangOpts().CPlusPlus;
}
- if (checkArithmeticIncompletePointerType(S, Loc, Operand)) return false;
+ if (checkArithmeticIncompletePointerType(S, Loc, Operand))
+ return false;
return true;
}
@@ -11440,11 +11428,14 @@ static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc,
Expr *LHSExpr, Expr *RHSExpr) {
bool isLHSPointer = LHSExpr->getType()->isAnyPointerType();
bool isRHSPointer = RHSExpr->getType()->isAnyPointerType();
- if (!isLHSPointer && !isRHSPointer) return true;
+ if (!isLHSPointer && !isRHSPointer)
+ return true;
QualType LHSPointeeTy, RHSPointeeTy;
- if (isLHSPointer) LHSPointeeTy = LHSExpr->getType()->getPointeeType();
- if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType();
+ if (isLHSPointer)
+ LHSPointeeTy = LHSExpr->getType()->getPointeeType();
+ if (isRHSPointer)
+ RHSPointeeTy = RHSExpr->getType()->getPointeeType();
// if both are pointers check if operation is valid wrt address spaces
if (isLHSPointer && isRHSPointer) {
@@ -11462,9 +11453,12 @@ static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc,
bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->isVoidType();
bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->isVoidType();
if (isLHSVoidPtr || isRHSVoidPtr) {
- if (!isRHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, LHSExpr);
- else if (!isLHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, RHSExpr);
- else diagnoseArithmeticOnTwoVoidPointers(S, Loc, LHSExpr, RHSExpr);
+ if (!isRHSVoidPtr)
+ diagnoseArithmeticOnVoidPointer(S, Loc, LHSExpr);
+ else if (!isLHSVoidPtr)
+ diagnoseArithmeticOnVoidPointer(S, Loc, RHSExpr);
+ else
+ diagnoseArithmeticOnTwoVoidPointers(S, Loc, LHSExpr, RHSExpr);
return !S.getLangOpts().CPlusPlus;
}
@@ -11472,10 +11466,12 @@ static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc,
bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->isFunctionType();
bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->isFunctionType();
if (isLHSFuncPtr || isRHSFuncPtr) {
- if (!isRHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, LHSExpr);
- else if (!isLHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc,
- RHSExpr);
- else diagnoseArithmeticOnTwoFunctionPointers(S, Loc, LHSExpr, RHSExpr);
+ if (!isRHSFuncPtr)
+ diagnoseArithmeticOnFunctionPointer(S, Loc, LHSExpr);
+ else if (!isLHSFuncPtr)
+ diagnoseArithmeticOnFunctionPointer(S, Loc, RHSExpr);
+ else
+ diagnoseArithmeticOnTwoFunctionPointers(S, Loc, LHSExpr, RHSExpr);
return !S.getLangOpts().CPlusPlus;
}
@@ -11492,15 +11488,15 @@ static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc,
/// literal.
static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc,
Expr *LHSExpr, Expr *RHSExpr) {
- StringLiteral* StrExpr = dyn_cast<StringLiteral>(LHSExpr->IgnoreImpCasts());
- Expr* IndexExpr = RHSExpr;
+ StringLiteral *StrExpr = dyn_cast<StringLiteral>(LHSExpr->IgnoreImpCasts());
+ Expr *IndexExpr = RHSExpr;
if (!StrExpr) {
StrExpr = dyn_cast<StringLiteral>(RHSExpr->IgnoreImpCasts());
IndexExpr = LHSExpr;
}
- bool IsStringPlusInt = StrExpr &&
- IndexExpr->getType()->isIntegralOrUnscopedEnumerationType();
+ bool IsStringPlusInt =
+ StrExpr && IndexExpr->getType()->isIntegralOrUnscopedEnumerationType();
if (!IsStringPlusInt || IndexExpr->isValueDependent())
return;
@@ -11548,11 +11544,9 @@ static void diagnoseStringPlusChar(Sema &Self, SourceLocation OpLoc,
SourceRange DiagRange(LHSExpr->getBeginLoc(), RHSExpr->getEndLoc());
const QualType CharType = CharExpr->getType();
- if (!CharType->isAnyCharacterType() &&
- CharType->isIntegerType() &&
+ if (!CharType->isAnyCharacterType() && CharType->isIntegerType() &&
llvm::isUIntN(Ctx.getCharWidth(), CharExpr->getValue())) {
- Self.Diag(OpLoc, diag::warn_string_plus_char)
- << DiagRange << Ctx.CharTy;
+ Self.Diag(OpLoc, diag::warn_string_plus_char) << DiagRange << Ctx.CharTy;
} else {
Self.Diag(OpLoc, diag::warn_string_plus_char)
<< DiagRange << CharExpr->getType();
@@ -11576,14 +11570,14 @@ static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc,
assert(LHSExpr->getType()->isAnyPointerType());
assert(RHSExpr->getType()->isAnyPointerType());
S.Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
- << LHSExpr->getType() << RHSExpr->getType() << LHSExpr->getSourceRange()
- << RHSExpr->getSourceRange();
+ << LHSExpr->getType() << RHSExpr->getType() << LHSExpr->getSourceRange()
+ << RHSExpr->getSourceRange();
}
// C99 6.5.6
QualType Sema::CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS,
SourceLocation Loc, BinaryOperatorKind Opc,
- QualType* CompLHSTy) {
+ QualType *CompLHSTy) {
checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
if (LHS.get()->getType()->isVectorType() ||
@@ -11594,7 +11588,8 @@ QualType Sema::CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS,
/*AllowBoolConversions*/ getLangOpts().ZVector,
/*AllowBooleanOperation*/ false,
/*ReportInvalid*/ true);
- if (CompLHSTy) *CompLHSTy = compType;
+ if (CompLHSTy)
+ *CompLHSTy = compType;
return compType;
}
@@ -11630,7 +11625,8 @@ QualType Sema::CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS,
// handle the common case first (both operands are arithmetic).
if (!compType.isNull() && compType->isArithmeticType()) {
- if (CompLHSTy) *CompLHSTy = compType;
+ if (CompLHSTy)
+ *CompLHSTy = compType;
return compType;
}
@@ -11665,10 +11661,9 @@ QualType Sema::CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS,
Context, Expr::NPC_ValueDependentIsNotNull)) {
// In C++ adding zero to a null pointer is defined.
Expr::EvalResult KnownVal;
- if (!getLangOpts().CPlusPlus ||
- (!IExp->isValueDependent() &&
- (!IExp->EvaluateAsInt(KnownVal, Context) ||
- KnownVal.Val.getInt() != 0))) {
+ if (!getLangOpts().CPlusPlus || (!IExp->isValueDependent() &&
+ (!IExp->EvaluateAsInt(KnownVal, Context) ||
+ KnownVal.Val.getInt() != 0))) {
// Check the conditions to see if this is the 'p = nullptr + n' idiom.
bool IsGNUIdiom = BinaryOperator::isNullPointerArithmeticExtension(
Context, BO_Add, PExp, IExp);
@@ -11721,7 +11716,8 @@ QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
/*AllowBoolConversions*/ getLangOpts().ZVector,
/*AllowBooleanOperation*/ false,
/*ReportInvalid*/ true);
- if (CompLHSTy) *CompLHSTy = compType;
+ if (CompLHSTy)
+ *CompLHSTy = compType;
return compType;
}
@@ -11753,7 +11749,8 @@ QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
// Handle the common case first (both operands are arithmetic).
if (!compType.isNull() && compType->isArithmeticType()) {
- if (CompLHSTy) *CompLHSTy = compType;
+ if (CompLHSTy)
+ *CompLHSTy = compType;
return compType;
}
@@ -11780,8 +11777,8 @@ QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
// Subtracting from a null pointer should produce a warning.
// The last argument to the diagnose call says this doesn't match the
// GNU int-to-pointer idiom.
- if (LHS.get()->IgnoreParenCasts()->isNullPointerConstant(Context,
- Expr::NPC_ValueDependentIsNotNull)) {
+ if (LHS.get()->IgnoreParenCasts()->isNullPointerConstant(
+ Context, Expr::NPC_ValueDependentIsNotNull)) {
// In C++ adding zero to a null pointer is defined.
Expr::EvalResult KnownVal;
if (!getLangOpts().CPlusPlus ||
@@ -11796,16 +11793,17 @@ QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
return QualType();
// Check array bounds for pointer arithemtic
- CheckArrayAccess(LHS.get(), RHS.get(), /*ArraySubscriptExpr*/nullptr,
- /*AllowOnePastEnd*/true, /*IndexNegated*/true);
+ CheckArrayAccess(LHS.get(), RHS.get(), /*ArraySubscriptExpr*/ nullptr,
+ /*AllowOnePastEnd*/ true, /*IndexNegated*/ true);
- if (CompLHSTy) *CompLHSTy = LHS.get()->getType();
+ if (CompLHSTy)
+ *CompLHSTy = LHS.get()->getType();
return LHS.get()->getType();
}
// Handle pointer-pointer subtractions.
- if (const PointerType *RHSPTy
- = RHS.get()->getType()->getAs<PointerType>()) {
+ if (const PointerType *RHSPTy =
+ RHS.get()->getType()->getAs<PointerType>()) {
QualType rpointee = RHSPTy->getPointeeType();
if (getLangOpts().CPlusPlus) {
@@ -11823,8 +11821,8 @@ QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
}
}
- if (!checkArithmeticBinOpPointerOperands(*this, Loc,
- LHS.get(), RHS.get()))
+ if (!checkArithmeticBinOpPointerOperands(*this, Loc, LHS.get(),
+ RHS.get()))
return QualType();
bool LHSIsNullPtr = LHS.get()->IgnoreParenCasts()->isNullPointerConstant(
@@ -11844,13 +11842,14 @@ QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
if (!rpointee->isVoidType() && !rpointee->isFunctionType()) {
CharUnits ElementSize = Context.getTypeSizeInChars(rpointee);
if (ElementSize.isZero()) {
- Diag(Loc,diag::warn_sub_ptr_zero_size_types)
- << rpointee.getUnqualifiedType()
- << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
+ Diag(Loc, diag::warn_sub_ptr_zero_size_types)
+ << rpointee.getUnqualifiedType() << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
}
}
- if (CompLHSTy) *CompLHSTy = LHS.get()->getType();
+ if (CompLHSTy)
+ *CompLHSTy = LHS.get()->getType();
return Context.getPointerDiffType();
}
}
@@ -11866,11 +11865,12 @@ static bool isScopedEnumerationType(QualType T) {
return false;
}
-static void DiagnoseBadShiftValues(Sema& S, ExprResult &LHS, ExprResult &RHS,
+static void DiagnoseBadShiftValues(Sema &S, ExprResult &LHS, ExprResult &RHS,
SourceLocation Loc, BinaryOperatorKind Opc,
QualType LHSType) {
- // OpenCL 6.3j: shift values are effectively % word size of LHS (more defined),
- // so skip remaining warnings as we don't want to modify values within Sema.
+ // OpenCL 6.3j: shift values are effectively % word size of LHS (more
+ // defined), so skip remaining warnings as we don't want to modify values
+ // within Sema.
if (S.getLangOpts().OpenCL)
return;
@@ -11958,8 +11958,8 @@ static void DiagnoseBadShiftValues(Sema& S, ExprResult &LHS, ExprResult &RHS,
// turned off separately if needed.
if (ResultBits - 1 == LeftSize) {
S.Diag(Loc, diag::warn_shift_result_sets_sign_bit)
- << HexResult << LHSType
- << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
+ << HexResult << LHSType << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
return;
}
@@ -11977,18 +11977,20 @@ static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS,
if ((S.LangOpts.OpenCL || S.LangOpts.ZVector) &&
!LHS.get()->getType()->isVectorType()) {
S.Diag(Loc, diag::err_shift_rhs_only_vector)
- << RHS.get()->getType() << LHS.get()->getType()
- << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
+ << RHS.get()->getType() << LHS.get()->getType()
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
return QualType();
}
if (!IsCompAssign) {
LHS = S.UsualUnaryConversions(LHS.get());
- if (LHS.isInvalid()) return QualType();
+ if (LHS.isInvalid())
+ return QualType();
}
RHS = S.UsualUnaryConversions(RHS.get());
- if (RHS.isInvalid()) return QualType();
+ if (RHS.isInvalid())
+ return QualType();
QualType LHSType = LHS.get()->getType();
// Note that LHS might be a scalar because the routine calls not only in
@@ -12013,13 +12015,13 @@ static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS,
// The operands need to be integers.
if (!LHSEleType->isIntegerType()) {
S.Diag(Loc, diag::err_typecheck_expect_int)
- << LHS.get()->getType() << LHS.get()->getSourceRange();
+ << LHS.get()->getType() << LHS.get()->getSourceRange();
return QualType();
}
if (!RHSEleType->isIntegerType()) {
S.Diag(Loc, diag::err_typecheck_expect_int)
- << RHS.get()->getType() << RHS.get()->getSourceRange();
+ << RHS.get()->getType() << RHS.get()->getSourceRange();
return QualType();
}
@@ -12028,7 +12030,7 @@ static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS,
if (IsCompAssign)
return RHSType;
if (LHSEleType != RHSEleType) {
- LHS = S.ImpCastExprToType(LHS.get(),RHSEleType, CK_IntegralCast);
+ LHS = S.ImpCastExprToType(LHS.get(), RHSEleType, CK_IntegralCast);
LHSEleType = RHSEleType;
}
QualType VecTy =
@@ -12041,8 +12043,8 @@ static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS,
// that the number of elements is the same as LHS...
if (RHSVecTy->getNumElements() != LHSVecTy->getNumElements()) {
S.Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
- << LHS.get()->getType() << RHS.get()->getType()
- << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
+ << LHS.get()->getType() << RHS.get()->getType()
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
return QualType();
}
if (!S.LangOpts.OpenCL && !S.LangOpts.ZVector) {
@@ -12058,7 +12060,7 @@ static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS,
} else {
// ...else expand RHS to match the number of elements in LHS.
QualType VecTy =
- S.Context.getExtVectorType(RHSEleType, LHSVecTy->getNumElements());
+ S.Context.getExtVectorType(RHSEleType, LHSVecTy->getNumElements());
RHS = S.ImpCastExprToType(RHS.get(), VecTy, CK_VectorSplat);
}
@@ -12193,7 +12195,8 @@ QualType Sema::CheckShiftOperands(ExprResult &LHS, ExprResult &RHS,
if (LHS.isInvalid())
return QualType();
QualType LHSType = LHS.get()->getType();
- if (IsCompAssign) LHS = OldLHS;
+ if (IsCompAssign)
+ LHS = OldLHS;
// The RHS is simpler.
RHS = UsualUnaryConversions(RHS.get());
@@ -12223,8 +12226,8 @@ static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc,
bool IsError) {
S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers
: diag::ext_typecheck_comparison_of_distinct_pointers)
- << LHS.get()->getType() << RHS.get()->getType()
- << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
+ << LHS.get()->getType() << RHS.get()->getType()
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
}
/// Returns false if the pointers are converted to a composite type,
@@ -12249,7 +12252,7 @@ static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc,
if (T.isNull()) {
if ((LHSType->isAnyPointerType() || LHSType->isMemberPointerType()) &&
(RHSType->isAnyPointerType() || RHSType->isMemberPointerType()))
- diagnoseDistinctPointerComparison(S, Loc, LHS, RHS, /*isError*/true);
+ diagnoseDistinctPointerComparison(S, Loc, LHS, RHS, /*isError*/ true);
else
S.InvalidOperands(Loc, LHS, RHS);
return true;
@@ -12264,8 +12267,8 @@ static void diagnoseFunctionPointerToVoidComparison(Sema &S, SourceLocation Loc,
bool IsError) {
S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void
: diag::ext_typecheck_comparison_of_fptr_to_void)
- << LHS.get()->getType() << RHS.get()->getType()
- << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
+ << LHS.get()->getType() << RHS.get()->getType()
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
}
static bool isObjCObjectLiteral(ExprResult &E) {
@@ -12283,7 +12286,7 @@ static bool isObjCObjectLiteral(ExprResult &E) {
static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS) {
const ObjCObjectPointerType *Type =
- LHS->getType()->getAs<ObjCObjectPointerType>();
+ LHS->getType()->getAs<ObjCObjectPointerType>();
// If this is not actually an Objective-C object, bail out.
if (!Type)
@@ -12330,7 +12333,7 @@ static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS) {
static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc,
ExprResult &LHS, ExprResult &RHS,
- BinaryOperator::Opcode Opc){
+ BinaryOperator::Opcode Opc) {
Expr *Literal;
Expr *Other;
if (isObjCObjectLiteral(LHS)) {
@@ -12358,22 +12361,22 @@ static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc,
if (LiteralKind == SemaObjC::LK_String)
S.Diag(Loc, diag::warn_objc_string_literal_comparison)
- << Literal->getSourceRange();
+ << Literal->getSourceRange();
else
S.Diag(Loc, diag::warn_objc_literal_comparison)
- << LiteralKind << Literal->getSourceRange();
+ << LiteralKind << Literal->getSourceRange();
if (BinaryOperator::isEqualityOp(Opc) &&
hasIsEqualMethod(S, LHS.get(), RHS.get())) {
SourceLocation Start = LHS.get()->getBeginLoc();
SourceLocation End = S.getLocForEndOfToken(RHS.get()->getEndLoc());
CharSourceRange OpRange =
- CharSourceRange::getCharRange(Loc, S.getLocForEndOfToken(Loc));
+ CharSourceRange::getCharRange(Loc, S.getLocForEndOfToken(Loc));
S.Diag(Loc, diag::note_objc_literal_comparison_isequal)
- << FixItHint::CreateInsertion(Start, Opc == BO_EQ ? "[" : "![")
- << FixItHint::CreateReplacement(OpRange, " isEqual:")
- << FixItHint::CreateInsertion(End, "]");
+ << FixItHint::CreateInsertion(Start, Opc == BO_EQ ? "[" : "![")
+ << FixItHint::CreateReplacement(OpRange, " isEqual:")
+ << FixItHint::CreateInsertion(End, "]");
}
}
@@ -12383,14 +12386,17 @@ static void diagnoseLogicalNotOnLHSofCheck(Sema &S, ExprResult &LHS,
BinaryOperatorKind Opc) {
// Check that left hand side is !something.
UnaryOperator *UO = dyn_cast<UnaryOperator>(LHS.get()->IgnoreImpCasts());
- if (!UO || UO->getOpcode() != UO_LNot) return;
+ if (!UO || UO->getOpcode() != UO_LNot)
+ return;
// Only check if the right hand side is non-bool arithmetic type.
- if (RHS.get()->isKnownToHaveBooleanValue()) return;
+ if (RHS.get()->isKnownToHaveBooleanValue())
+ return;
// Make sure that the something in !something is not bool.
Expr *SubExpr = UO->getSubExpr()->IgnoreImpCasts();
- if (SubExpr->isKnownToHaveBooleanValue()) return;
+ if (SubExpr->isKnownToHaveBooleanValue())
+ return;
// Emit warning.
bool IsBitwiseOp = Opc == BO_And || Opc == BO_Or || Opc == BO_Xor;
@@ -12404,8 +12410,7 @@ static void diagnoseLogicalNotOnLHSofCheck(Sema &S, ExprResult &LHS,
if (FirstClose.isInvalid())
FirstOpen = SourceLocation();
S.Diag(UO->getOperatorLoc(), diag::note_logical_not_fix)
- << IsBitwiseOp
- << FixItHint::CreateInsertion(FirstOpen, "(")
+ << IsBitwiseOp << FixItHint::CreateInsertion(FirstOpen, "(")
<< FixItHint::CreateInsertion(FirstClose, ")");
// Second note suggests (!x) < y
@@ -12488,8 +12493,7 @@ static void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc,
QualType LHSType = LHS->getType();
QualType RHSType = RHS->getType();
if (LHSType->hasFloatingRepresentation() ||
- (LHSType->isBlockPointerType() && !BinaryOperator::isEqualityOp(Opc)) ||
- S.inTemplateInstantiation())
+ (LHSType->isBlockPointerType() && !BinaryOperator::isEqualityOp(Opc)))
return;
// WebAssembly Tables cannot be compared, therefore shouldn't emit
@@ -12612,8 +12616,8 @@ static void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc,
LiteralStringStripped = LHSStripped;
} else if ((isa<StringLiteral>(RHSStripped) ||
isa<ObjCEncodeExpr>(RHSStripped)) &&
- !LHSStripped->isNullPointerConstant(S.Context,
- Expr::NPC_ValueDependentIsNull)) {
+ !LHSStripped->isNullPointerConstant(
+ S.Context, Expr::NPC_ValueDependentIsNull)) {
LiteralString = RHS;
LiteralStringStripped = RHSStripped;
}
@@ -12829,7 +12833,7 @@ void Sema::CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE) {
if (!E.get()->getType()->isAnyPointerType() &&
E.get()->isNullPointerConstant(Context,
Expr::NPC_ValueDependentIsNotNull) ==
- Expr::NPCK_ZeroExpression) {
+ Expr::NPCK_ZeroExpression) {
if (const auto *CL = dyn_cast<CharacterLiteral>(E.get())) {
if (CL->getValue() == 0)
Diag(E.get()->getExprLoc(), diag::warn_pointer_compare)
@@ -12837,14 +12841,14 @@ void Sema::CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE) {
<< FixItHint::CreateReplacement(E.get()->getExprLoc(),
NullValue ? "NULL" : "(void *)0");
} else if (const auto *CE = dyn_cast<CStyleCastExpr>(E.get())) {
- TypeSourceInfo *TI = CE->getTypeInfoAsWritten();
- QualType T = Context.getCanonicalType(TI->getType()).getUnqualifiedType();
- if (T == Context.CharTy)
- Diag(E.get()->getExprLoc(), diag::warn_pointer_compare)
- << NullValue
- << FixItHint::CreateReplacement(E.get()->getExprLoc(),
- NullValue ? "NULL" : "(void *)0");
- }
+ TypeSourceInfo *TI = CE->getTypeInfoAsWritten();
+ QualType T = Context.getCanonicalType(TI->getType()).getUnqualifiedType();
+ if (T == Context.CharTy)
+ Diag(E.get()->getExprLoc(), diag::warn_pointer_compare)
+ << NullValue
+ << FixItHint::CreateReplacement(E.get()->getExprLoc(),
+ NullValue ? "NULL" : "(void *)0");
+ }
}
}
@@ -12860,6 +12864,14 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
return Ty->isPointerType() || Ty->isMemberPointerType();
};
+ // Skip comparison check if we are using templates until types are known.
+ if (this->inTemplateInstantiation()) {
+ QualType LHSType = LHS.get()->getType();
+ QualType RHSType = RHS.get()->getType();
+ if (!LHSType->isArrayType() && !RHSType->isArrayType())
+ return QualType();
+ }
+
// C++2a [expr.spaceship]p6: If at least one of the operands is of pointer
// type, array-to-pointer, ..., conversions are performed on both operands to
// bring them to their composite type.
@@ -13021,9 +13033,9 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
// All of the following pointer-related warnings are GCC extensions, except
// when handling null pointer constants.
QualType LCanPointeeTy =
- LHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
+ LHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
QualType RCanPointeeTy =
- RHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
+ RHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
// C99 6.5.9p2 and C99 6.5.8p2
if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(),
@@ -13042,13 +13054,15 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
} else if (!IsRelational &&
(LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) {
// Valid unless comparison between non-null pointer and function pointer
- if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType())
- && !LHSIsNull && !RHSIsNull)
+ if ((LCanPointeeTy->isFunctionType() ||
+ RCanPointeeTy->isFunctionType()) &&
+ !LHSIsNull && !RHSIsNull)
diagnoseFunctionPointerToVoidComparison(*this, Loc, LHS, RHS,
- /*isError*/false);
+ /*isError*/ false);
} else {
// Invalid
- diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, /*isError*/false);
+ diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS,
+ /*isError*/ false);
}
if (LCanPointeeTy != RCanPointeeTy) {
// Treat NULL constant as a special case in OpenCL.
@@ -13063,8 +13077,8 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
}
LangAS AddrSpaceL = LCanPointeeTy.getAddressSpace();
LangAS AddrSpaceR = RCanPointeeTy.getAddressSpace();
- CastKind Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion
- : CK_BitCast;
+ CastKind Kind =
+ AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
const FunctionType *LFn = LCanPointeeTy->getAs<FunctionType>();
const FunctionType *RFn = RCanPointeeTy->getAs<FunctionType>();
@@ -13081,7 +13095,6 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
return computeResultTy();
}
-
// C++ [expr.eq]p4:
// Two operands of type std::nullptr_t or one operand of type
// std::nullptr_t and the other a null pointer constant compare
@@ -13176,34 +13189,36 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
if (!LHSIsNull && !RHSIsNull &&
!Context.typesAreCompatible(lpointee, rpointee)) {
Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
- << LHSType << RHSType << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ << LHSType << RHSType << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
}
RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
return computeResultTy();
}
// Allow block pointers to be compared with null pointer constants.
- if (!IsOrdered
- && ((LHSType->isBlockPointerType() && RHSType->isPointerType())
- || (LHSType->isPointerType() && RHSType->isBlockPointerType()))) {
+ if (!IsOrdered &&
+ ((LHSType->isBlockPointerType() && RHSType->isPointerType()) ||
+ (LHSType->isPointerType() && RHSType->isBlockPointerType()))) {
if (!LHSIsNull && !RHSIsNull) {
- if (!((RHSType->isPointerType() && RHSType->castAs<PointerType>()
- ->getPointeeType()->isVoidType())
- || (LHSType->isPointerType() && LHSType->castAs<PointerType>()
- ->getPointeeType()->isVoidType())))
+ if (!((RHSType->isPointerType() &&
+ RHSType->castAs<PointerType>()->getPointeeType()->isVoidType()) ||
+ (LHSType->isPointerType() &&
+ LHSType->castAs<PointerType>()->getPointeeType()->isVoidType())))
Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
- << LHSType << RHSType << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ << LHSType << RHSType << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
}
if (LHSIsNull && !RHSIsNull)
LHS = ImpCastExprToType(LHS.get(), RHSType,
- RHSType->isPointerType() ? CK_BitCast
- : CK_AnyPointerToBlockPointerCast);
+ RHSType->isPointerType()
+ ? CK_BitCast
+ : CK_AnyPointerToBlockPointerCast);
else
RHS = ImpCastExprToType(RHS.get(), LHSType,
- LHSType->isPointerType() ? CK_BitCast
- : CK_AnyPointerToBlockPointerCast);
+ LHSType->isPointerType()
+ ? CK_BitCast
+ : CK_AnyPointerToBlockPointerCast);
return computeResultTy();
}
@@ -13218,7 +13233,7 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
if (!LPtrToVoid && !RPtrToVoid &&
!Context.typesAreCompatible(LHSType, RHSType)) {
diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS,
- /*isError*/false);
+ /*isError*/ false);
}
// FIXME: If LPtrToVoid, we should presumably convert the LHS rather than
// the RHS, but we have test coverage for this behavior.
@@ -13228,18 +13243,17 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
if (getLangOpts().ObjCAutoRefCount)
ObjC().CheckObjCConversion(SourceRange(), RHSType, E,
CheckedConversionKind::Implicit);
- LHS = ImpCastExprToType(E, RHSType,
- RPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
- }
- else {
+ LHS = ImpCastExprToType(
+ E, RHSType, RPT ? CK_BitCast : CK_CPointerToObjCPointerCast);
+ } else {
Expr *E = RHS.get();
if (getLangOpts().ObjCAutoRefCount)
ObjC().CheckObjCConversion(SourceRange(), LHSType, E,
CheckedConversionKind::Implicit,
/*Diagnose=*/true,
/*DiagnoseCFAudited=*/false, Opc);
- RHS = ImpCastExprToType(E, LHSType,
- LPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
+ RHS = ImpCastExprToType(
+ E, LHSType, LPT ? CK_BitCast : CK_CPointerToObjCPointerCast);
}
return computeResultTy();
}
@@ -13247,7 +13261,7 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
RHSType->isObjCObjectPointerType()) {
if (!Context.areComparableObjCPointerTypes(LHSType, RHSType))
diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS,
- /*isError*/false);
+ /*isError*/ false);
if (isObjCObjectLiteral(LHS) || isObjCObjectLiteral(RHS))
diagnoseObjCLiteralComparison(*this, Loc, LHS, RHS, Opc);
@@ -13283,8 +13297,9 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
if (IsOrdered) {
isError = getLangOpts().CPlusPlus;
DiagID =
- isError ? diag::err_typecheck_ordered_comparison_of_pointer_and_zero
- : diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
+ isError
+ ? diag::err_typecheck_ordered_comparison_of_pointer_and_zero
+ : diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
}
} else if (getLangOpts().CPlusPlus) {
DiagID = diag::err_typecheck_comparison_of_pointer_integer;
@@ -13295,30 +13310,31 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
DiagID = diag::ext_typecheck_comparison_of_pointer_integer;
if (DiagID) {
- Diag(Loc, DiagID)
- << LHSType << RHSType << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ Diag(Loc, DiagID) << LHSType << RHSType << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
if (isError)
return QualType();
}
if (LHSType->isIntegerType())
LHS = ImpCastExprToType(LHS.get(), RHSType,
- LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
+ LHSIsNull ? CK_NullToPointer
+ : CK_IntegralToPointer);
else
RHS = ImpCastExprToType(RHS.get(), LHSType,
- RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
+ RHSIsNull ? CK_NullToPointer
+ : CK_IntegralToPointer);
return computeResultTy();
}
// Handle block pointers.
- if (!IsOrdered && RHSIsNull
- && LHSType->isBlockPointerType() && RHSType->isIntegerType()) {
+ if (!IsOrdered && RHSIsNull && LHSType->isBlockPointerType() &&
+ RHSType->isIntegerType()) {
RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
return computeResultTy();
}
- if (!IsOrdered && LHSIsNull
- && LHSType->isIntegerType() && RHSType->isBlockPointerType()) {
+ if (!IsOrdered && LHSIsNull && LHSType->isIntegerType() &&
+ RHSType->isBlockPointerType()) {
LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
return computeResultTy();
}
@@ -13973,11 +13989,14 @@ inline QualType Sema::CheckLogicalOperands(ExprResult &LHS, ExprResult &RHS,
static bool IsReadonlyMessage(Expr *E, Sema &S) {
const MemberExpr *ME = dyn_cast<MemberExpr>(E);
- if (!ME) return false;
- if (!isa<FieldDecl>(ME->getMemberDecl())) return false;
+ if (!ME)
+ return false;
+ if (!isa<FieldDecl>(ME->getMemberDecl()))
+ return false;
ObjCMessageExpr *Base = dyn_cast<ObjCMessageExpr>(
ME->getBase()->IgnoreImplicit()->IgnoreParenImpCasts());
- if (!Base) return false;
+ if (!Base)
+ return false;
return Base->getMethodDecl() != nullptr;
}
@@ -13991,8 +14010,10 @@ static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E) {
// Must be a reference to a declaration from an enclosing scope.
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
- if (!DRE) return NCCK_None;
- if (!DRE->refersToEnclosingVariableOrCapture()) return NCCK_None;
+ if (!DRE)
+ return NCCK_None;
+ if (!DRE->refersToEnclosingVariableOrCapture())
+ return NCCK_None;
ValueDecl *Value = DRE->getDecl();
@@ -14131,8 +14152,8 @@ static void DiagnoseConstAssignment(Sema &S, const Expr *E,
const FunctionDecl *FD = CE->getDirectCallee();
if (FD && !IsTypeModifiable(FD->getReturnType(), IsDereference)) {
if (!DiagnosticEmitted) {
- S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
- << ConstFunction << FD;
+ S.Diag(Loc, diag::err_typecheck_assign_const)
+ << ExprRange << ConstFunction << FD;
DiagnosticEmitted = true;
}
S.Diag(FD->getReturnTypeSourceRange().getBegin(),
@@ -14176,11 +14197,7 @@ static void DiagnoseConstAssignment(Sema &S, const Expr *E,
S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange << ConstUnknown;
}
-enum OriginalExprKind {
- OEK_Variable,
- OEK_Member,
- OEK_LValue
-};
+enum OriginalExprKind { OEK_Variable, OEK_Member, OEK_LValue };
static void DiagnoseRecursiveConstFields(Sema &S, const ValueDecl *VD,
const RecordType *Ty,
@@ -14203,13 +14220,12 @@ static void DiagnoseRecursiveConstFields(Sema &S, const ValueDecl *VD,
if (FieldTy.isConstQualified()) {
if (!DiagnosticEmitted) {
S.Diag(Loc, diag::err_typecheck_assign_const)
- << Range << NestedConstMember << OEK << VD
- << IsNested << Field;
+ << Range << NestedConstMember << OEK << VD << IsNested << Field;
DiagnosticEmitted = true;
}
S.Diag(Field->getLocation(), diag::note_typecheck_assign_const)
- << NestedConstMember << IsNested << Field
- << FieldTy << Field->getSourceRange();
+ << NestedConstMember << IsNested << Field << FieldTy
+ << Field->getSourceRange();
}
// Then we append it to the list to check next in order.
@@ -14234,14 +14250,14 @@ static void DiagnoseRecursiveConstFields(Sema &S, const Expr *E,
bool DiagEmitted = false;
if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
- DiagnoseRecursiveConstFields(S, ME->getMemberDecl(), RTy, Loc,
- Range, OEK_Member, DiagEmitted);
+ DiagnoseRecursiveConstFields(S, ME->getMemberDecl(), RTy, Loc, Range,
+ OEK_Member, DiagEmitted);
else if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
- DiagnoseRecursiveConstFields(S, DRE->getDecl(), RTy, Loc,
- Range, OEK_Variable, DiagEmitted);
+ DiagnoseRecursiveConstFields(S, DRE->getDecl(), RTy, Loc, Range,
+ OEK_Variable, DiagEmitted);
else
- DiagnoseRecursiveConstFields(S, nullptr, RTy, Loc,
- Range, OEK_LValue, DiagEmitted);
+ DiagnoseRecursiveConstFields(S, nullptr, RTy, Loc, Range, OEK_LValue,
+ DiagEmitted);
if (!DiagEmitted)
DiagnoseConstAssignment(S, E, Loc);
}
@@ -14254,8 +14270,7 @@ static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
S.CheckShadowingDeclModification(E, Loc);
SourceLocation OrigLoc = Loc;
- Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context,
- &Loc);
+ Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context, &Loc);
if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S))
IsLV = Expr::MLV_InvalidMessageExpression;
if (IsLV == Expr::MLV_Valid)
@@ -14292,15 +14307,15 @@ static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
ObjCMethodDecl *method = S.getCurMethodDecl();
if (method && var == method->getSelfDecl()) {
DiagID = method->isClassMethod()
- ? diag::err_typecheck_arc_assign_self_class_method
- : diag::err_typecheck_arc_assign_self;
+ ? diag::err_typecheck_arc_assign_self_class_method
+ : diag::err_typecheck_arc_assign_self;
- // - Objective-C externally_retained attribute.
+ // - Objective-C externally_retained attribute.
} else if (var->hasAttr<ObjCExternallyRetainedAttr>() ||
isa<ParmVarDecl>(var)) {
DiagID = diag::err_typecheck_arc_assign_externally_retained;
- // - fast enumeration variables
+ // - fast enumeration variables
} else {
DiagID = diag::err_typecheck_arr_assign_enumeration;
}
@@ -14351,8 +14366,9 @@ static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
break;
case Expr::MLV_IncompleteType:
case Expr::MLV_IncompleteVoidType:
- return S.RequireCompleteType(Loc, E->getType(),
- diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E);
+ return S.RequireCompleteType(
+ Loc, E->getType(),
+ diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E);
case Expr::MLV_DuplicateVectorComponents:
DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
break;
@@ -14380,8 +14396,7 @@ static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
}
static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr,
- SourceLocation Loc,
- Sema &Sema) {
+ SourceLocation Loc, Sema &Sema) {
if (Sema.inTemplateInstantiation())
return;
if (Sema.isUnevaluatedContext())
@@ -14435,8 +14450,8 @@ QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS,
return QualType();
QualType LHSType = LHSExpr->getType();
- QualType RHSType = CompoundType.isNull() ? RHS.get()->getType() :
- CompoundType;
+ QualType RHSType =
+ CompoundType.isNull() ? RHS.get()->getType() : CompoundType;
if (RHS.isUsable()) {
// Even if this check fails don't return early to allow the best
@@ -14463,8 +14478,8 @@ QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS,
if (getLangOpts().OpenCL &&
!getOpenCLOptions().isAvailableOption("cl_khr_fp16", getLangOpts()) &&
LHSType->isHalfType()) {
- Diag(Loc, diag::err_opencl_half_load_store) << 1
- << LHSType.getUnqualifiedType();
+ Diag(Loc, diag::err_opencl_half_load_store)
+ << 1 << LHSType.getUnqualifiedType();
return QualType();
}
@@ -14510,8 +14525,8 @@ QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS,
Loc.getLocWithOffset(2) != UO->getSubExpr()->getBeginLoc() &&
UO->getSubExpr()->getBeginLoc().isFileID()) {
Diag(Loc, diag::warn_not_compound_assign)
- << (UO->getOpcode() == UO_Plus ? "+" : "-")
- << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
+ << (UO->getOpcode() == UO_Plus ? "+" : "-")
+ << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
}
}
@@ -14711,7 +14726,7 @@ static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op,
// Increment of bool sets it to true, but is deprecated.
S.Diag(OpLoc, S.getLangOpts().CPlusPlus17 ? diag::ext_increment_bool
: diag::warn_increment_bool)
- << Op->getSourceRange();
+ << Op->getSourceRange();
} else if (S.getLangOpts().CPlusPlus && ResType->isEnumeralType()) {
// Error on enum increments and decrements in C++ mode
S.Diag(OpLoc, diag::err_increment_decrement_enum) << IsInc << ResType;
@@ -14737,9 +14752,10 @@ static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op,
<< IsInc << Op->getSourceRange();
} else if (ResType->isPlaceholderType()) {
ExprResult PR = S.CheckPlaceholderExpr(Op);
- if (PR.isInvalid()) return QualType();
- return CheckIncrementDecrementOperand(S, PR.get(), VK, OK, OpLoc,
- IsInc, IsPrefix);
+ if (PR.isInvalid())
+ return QualType();
+ return CheckIncrementDecrementOperand(S, PR.get(), VK, OK, OpLoc, IsInc,
+ IsPrefix);
} else if (S.getLangOpts().AltiVec && ResType->isVectorType()) {
// OK! ( C/C++ Language Extensions for CBEA(Version 2.6) 10.3 )
} else if (S.getLangOpts().ZVector && ResType->isVectorType() &&
@@ -14751,7 +14767,7 @@ static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op,
// OpenCL V1.2 6.3 says dec/inc ops operate on integer vector types.
} else {
S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
- << ResType << int(IsInc) << Op->getSourceRange();
+ << ResType << int(IsInc) << Op->getSourceRange();
return QualType();
}
// At this point, we know we have a real, complex or pointer type.
@@ -14807,8 +14823,8 @@ static ValueDecl *getPrimaryDecl(Expr *E) {
case Stmt::ArraySubscriptExprClass: {
// FIXME: This code shouldn't be necessary! We should catch the implicit
// promotion of register arrays earlier.
- Expr* Base = cast<ArraySubscriptExpr>(E)->getBase();
- if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) {
+ Expr *Base = cast<ArraySubscriptExpr>(E)->getBase();
+ if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Base)) {
if (ICE->getSubExpr()->getType()->isArrayType())
return getPrimaryDecl(ICE->getSubExpr());
}
@@ -14817,7 +14833,7 @@ static ValueDecl *getPrimaryDecl(Expr *E) {
case Stmt::UnaryOperatorClass: {
UnaryOperator *UO = cast<UnaryOperator>(E);
- switch(UO->getOpcode()) {
+ switch (UO->getOpcode()) {
case UO_Real:
case UO_Imag:
case UO_Extension:
@@ -14852,8 +14868,8 @@ enum {
/// Diagnose invalid operand for address of operations.
///
/// \param Type The type of operand which cannot have its address taken.
-static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc,
- Expr *E, unsigned Type) {
+static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc, Expr *E,
+ unsigned Type) {
S.Diag(Loc, diag::err_typecheck_address_of) << Type << E->getSourceRange();
}
@@ -14886,13 +14902,14 @@ bool Sema::CheckUseOfCXXMethodAsAddressOfOperand(SourceLocation OpLoc,
}
QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
- if (const BuiltinType *PTy = OrigOp.get()->getType()->getAsPlaceholderType()){
+ if (const BuiltinType *PTy =
+ OrigOp.get()->getType()->getAsPlaceholderType()) {
if (PTy->getKind() == BuiltinType::Overload) {
Expr *E = OrigOp.get()->IgnoreParens();
if (!isa<OverloadExpr>(E)) {
assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function)
- << OrigOp.get()->getSourceRange();
+ << OrigOp.get()->getSourceRange();
return QualType();
}
@@ -14900,7 +14917,7 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
if (isa<UnresolvedMemberExpr>(Ovl))
if (!ResolveSingleFunctionTemplateSpecialization(Ovl)) {
Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
- << OrigOp.get()->getSourceRange();
+ << OrigOp.get()->getSourceRange();
return QualType();
}
@@ -14912,12 +14929,13 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
if (PTy->getKind() == BuiltinType::BoundMember) {
Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
- << OrigOp.get()->getSourceRange();
+ << OrigOp.get()->getSourceRange();
return QualType();
}
OrigOp = CheckPlaceholderExpr(OrigOp.get());
- if (OrigOp.isInvalid()) return QualType();
+ if (OrigOp.isInvalid())
+ return QualType();
}
if (OrigOp.get()->isTypeDependent())
@@ -14934,7 +14952,7 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
// depending on a vendor implementation. Thus preventing
// taking an address of the capture to avoid invalid AS casts.
if (LangOpts.OpenCL) {
- auto* VarRef = dyn_cast<DeclRefExpr>(op);
+ auto *VarRef = dyn_cast<DeclRefExpr>(op);
if (VarRef && VarRef->refersToEnclosingVariableOrCapture()) {
Diag(op->getExprLoc(), diag::err_opencl_taking_address_capture);
return QualType();
@@ -14943,7 +14961,7 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
if (getLangOpts().C99) {
// Implement C99-only parts of addressof rules.
- if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) {
+ if (UnaryOperator *uOp = dyn_cast<UnaryOperator>(op)) {
if (uOp->getOpcode() == UO_Deref)
// Per C99 6.5.3.2, the address of a deref always returns a valid result
// (assuming the deref expression is valid).
@@ -14981,7 +14999,7 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
// If the underlying expression isn't a decl ref, give up.
if (!isa<DeclRefExpr>(op)) {
Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
- << OrigOp.get()->getSourceRange();
+ << OrigOp.get()->getSourceRange();
return QualType();
}
DeclRefExpr *DRE = cast<DeclRefExpr>(op);
@@ -15036,7 +15054,7 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
AddressOfError = AO_Property_Expansion;
} else {
Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
- << op->getType() << op->getSourceRange();
+ << op->getType() << op->getSourceRange();
return QualType();
}
} else if (const auto *DRE = dyn_cast<DeclRefExpr>(op)) {
@@ -15059,8 +15077,7 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
// in C++ it is not error to take address of a register
// variable (c++03 7.1.1P3)
- if (vd->getStorageClass() == SC_Register &&
- !getLangOpts().CPlusPlus) {
+ if (vd->getStorageClass() == SC_Register && !getLangOpts().CPlusPlus) {
AddressOfError = AO_Register_Variable;
}
} else if (isa<MSPropertyDecl>(dcl)) {
@@ -15084,7 +15101,7 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
if (dcl->getType()->isReferenceType()) {
Diag(OpLoc,
diag::err_cannot_form_pointer_to_member_of_reference_type)
- << dcl->getDeclName() << dcl->getType();
+ << dcl->getDeclName() << dcl->getType();
return QualType();
}
@@ -15151,7 +15168,7 @@ static void RecordModifiableNonNullParam(Sema &S, const Expr *Exp) {
const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D);
if (!Param)
return;
- if (const FunctionDecl* FD = dyn_cast<FunctionDecl>(Param->getDeclContext()))
+ if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Param->getDeclContext()))
if (!FD->hasAttr<NonNullAttr>() && !Param->hasAttr<NonNullAttr>())
return;
if (FunctionScopeInfo *FD = S.getCurFunction())
@@ -15171,27 +15188,26 @@ static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
if (isa<CXXReinterpretCastExpr>(Op->IgnoreParens())) {
QualType OpOrigType = Op->IgnoreParenCasts()->getType();
- S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/true,
+ S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/ true,
Op->getSourceRange());
}
- if (const PointerType *PT = OpTy->getAs<PointerType>())
- {
+ if (const PointerType *PT = OpTy->getAs<PointerType>()) {
Result = PT->getPointeeType();
- }
- else if (const ObjCObjectPointerType *OPT =
- OpTy->getAs<ObjCObjectPointerType>())
+ } else if (const ObjCObjectPointerType *OPT =
+ OpTy->getAs<ObjCObjectPointerType>())
Result = OPT->getPointeeType();
else {
ExprResult PR = S.CheckPlaceholderExpr(Op);
- if (PR.isInvalid()) return QualType();
+ if (PR.isInvalid())
+ return QualType();
if (PR.get() != Op)
return CheckIndirectionOperand(S, PR.get(), VK, OpLoc);
}
if (Result.isNull()) {
S.Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
- << OpTy << Op->getSourceRange();
+ << OpTy << Op->getSourceRange();
return QualType();
}
@@ -15221,60 +15237,150 @@ static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
BinaryOperatorKind Sema::ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind) {
BinaryOperatorKind Opc;
switch (Kind) {
- default: llvm_unreachable("Unknown binop!");
- case tok::periodstar: Opc = BO_PtrMemD; break;
- case tok::arrowstar: Opc = BO_PtrMemI; break;
- case tok::star: Opc = BO_Mul; break;
- case tok::slash: Opc = BO_Div; break;
- case tok::percent: Opc = BO_Rem; break;
- case tok::plus: Opc = BO_Add; break;
- case tok::minus: Opc = BO_Sub; break;
- case tok::lessless: Opc = BO_Shl; break;
- case tok::greatergreater: Opc = BO_Shr; break;
- case tok::lessequal: Opc = BO_LE; break;
- case tok::less: Opc = BO_LT; break;
- case tok::greaterequal: Opc = BO_GE; break;
- case tok::greater: Opc = BO_GT; break;
- case tok::exclaimequal: Opc = BO_NE; break;
- case tok::equalequal: Opc = BO_EQ; break;
- case tok::spaceship: Opc = BO_Cmp; break;
- case tok::amp: Opc = BO_And; break;
- case tok::caret: Opc = BO_Xor; break;
- case tok::pipe: Opc = BO_Or; break;
- case tok::ampamp: Opc = BO_LAnd; break;
- case tok::pipepipe: Opc = BO_LOr; break;
- case tok::equal: Opc = BO_Assign; break;
- case tok::starequal: Opc = BO_MulAssign; break;
- case tok::slashequal: Opc = BO_DivAssign; break;
- case tok::percentequal: Opc = BO_RemAssign; break;
- case tok::plusequal: Opc = BO_AddAssign; break;
- case tok::minusequal: Opc = BO_SubAssign; break;
- case tok::lesslessequal: Opc = BO_ShlAssign; break;
- case tok::greatergreaterequal: Opc = BO_ShrAssign; break;
- case tok::ampequal: Opc = BO_AndAssign; break;
- case tok::caretequal: Opc = BO_XorAssign; break;
- case tok::pipeequal: Opc = BO_OrAssign; break;
- case tok::comma: Opc = BO_Comma; break;
+ default:
+ llvm_unreachable("Unknown binop!");
+ case tok::periodstar:
+ Opc = BO_PtrMemD;
+ break;
+ case tok::arrowstar:
+ Opc = BO_PtrMemI;
+ break;
+ case tok::star:
+ Opc = BO_Mul;
+ break;
+ case tok::slash:
+ Opc = BO_Div;
+ break;
+ case tok::percent:
+ Opc = BO_Rem;
+ break;
+ case tok::plus:
+ Opc = BO_Add;
+ break;
+ case tok::minus:
+ Opc = BO_Sub;
+ break;
+ case tok::lessless:
+ Opc = BO_Shl;
+ break;
+ case tok::greatergreater:
+ Opc = BO_Shr;
+ break;
+ case tok::lessequal:
+ Opc = BO_LE;
+ break;
+ case tok::less:
+ Opc = BO_LT;
+ break;
+ case tok::greaterequal:
+ Opc = BO_GE;
+ break;
+ case tok::greater:
+ Opc = BO_GT;
+ break;
+ case tok::exclaimequal:
+ Opc = BO_NE;
+ break;
+ case tok::equalequal:
+ Opc = BO_EQ;
+ break;
+ case tok::spaceship:
+ Opc = BO_Cmp;
+ break;
+ case tok::amp:
+ Opc = BO_And;
+ break;
+ case tok::caret:
+ Opc = BO_Xor;
+ break;
+ case tok::pipe:
+ Opc = BO_Or;
+ break;
+ case tok::ampamp:
+ Opc = BO_LAnd;
+ break;
+ case tok::pipepipe:
+ Opc = BO_LOr;
+ break;
+ case tok::equal:
+ Opc = BO_Assign;
+ break;
+ case tok::starequal:
+ Opc = BO_MulAssign;
+ break;
+ case tok::slashequal:
+ Opc = BO_DivAssign;
+ break;
+ case tok::percentequal:
+ Opc = BO_RemAssign;
+ break;
+ case tok::plusequal:
+ Opc = BO_AddAssign;
+ break;
+ case tok::minusequal:
+ Opc = BO_SubAssign;
+ break;
+ case tok::lesslessequal:
+ Opc = BO_ShlAssign;
+ break;
+ case tok::greatergreaterequal:
+ Opc = BO_ShrAssign;
+ break;
+ case tok::ampequal:
+ Opc = BO_AndAssign;
+ break;
+ case tok::caretequal:
+ Opc = BO_XorAssign;
+ break;
+ case tok::pipeequal:
+ Opc = BO_OrAssign;
+ break;
+ case tok::comma:
+ Opc = BO_Comma;
+ break;
}
return Opc;
}
-static inline UnaryOperatorKind ConvertTokenKindToUnaryOpcode(
- tok::TokenKind Kind) {
+static inline UnaryOperatorKind
+ConvertTokenKindToUnaryOpcode(tok::TokenKind Kind) {
UnaryOperatorKind Opc;
switch (Kind) {
- default: llvm_unreachable("Unknown unary op!");
- case tok::plusplus: Opc = UO_PreInc; break;
- case tok::minusminus: Opc = UO_PreDec; break;
- case tok::amp: Opc = UO_AddrOf; break;
- case tok::star: Opc = UO_Deref; break;
- case tok::plus: Opc = UO_Plus; break;
- case tok::minus: Opc = UO_Minus; break;
- case tok::tilde: Opc = UO_Not; break;
- case tok::exclaim: Opc = UO_LNot; break;
- case tok::kw___real: Opc = UO_Real; break;
- case tok::kw___imag: Opc = UO_Imag; break;
- case tok::kw___extension__: Opc = UO_Extension; break;
+ default:
+ llvm_unreachable("Unknown unary op!");
+ case tok::plusplus:
+ Opc = UO_PreInc;
+ break;
+ case tok::minusminus:
+ Opc = UO_PreDec;
+ break;
+ case tok::amp:
+ Opc = UO_AddrOf;
+ break;
+ case tok::star:
+ Opc = UO_Deref;
+ break;
+ case tok::plus:
+ Opc = UO_Plus;
+ break;
+ case tok::minus:
+ Opc = UO_Minus;
+ break;
+ case tok::tilde:
+ Opc = UO_Not;
+ break;
+ case tok::exclaim:
+ Opc = UO_LNot;
+ break;
+ case tok::kw___real:
+ Opc = UO_Real;
+ break;
+ case tok::kw___imag:
+ Opc = UO_Imag;
+ break;
+ case tok::kw___extension__:
+ Opc = UO_Extension;
+ break;
}
return Opc;
}
@@ -15327,14 +15433,13 @@ static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr,
RHSExpr = RHSExpr->IgnoreParenImpCasts();
const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
- if (!LHSDeclRef || !RHSDeclRef ||
- LHSDeclRef->getLocation().isMacroID() ||
+ if (!LHSDeclRef || !RHSDeclRef || LHSDeclRef->getLocation().isMacroID() ||
RHSDeclRef->getLocation().isMacroID())
return;
const ValueDecl *LHSDecl =
- cast<ValueDecl>(LHSDeclRef->getDecl()->getCanonicalDecl());
+ cast<ValueDecl>(LHSDeclRef->getDecl()->getCanonicalDecl());
const ValueDecl *RHSDecl =
- cast<ValueDecl>(RHSDeclRef->getDecl()->getCanonicalDecl());
+ cast<ValueDecl>(RHSDeclRef->getDecl()->getCanonicalDecl());
if (LHSDecl != RHSDecl)
return;
if (LHSDecl->getType().isVolatileQualified())
@@ -15369,8 +15474,7 @@ static void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R,
if (LHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) {
ObjCPointerExpr = LHS;
OtherExpr = RHS;
- }
- else if (RHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) {
+ } else if (RHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) {
ObjCPointerExpr = RHS;
OtherExpr = LHS;
}
@@ -15393,8 +15497,7 @@ static void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R,
Diag = diag::warn_objc_pointer_masking_performSelector;
}
- S.Diag(OpLoc, Diag)
- << ObjCPointerExpr->getSourceRange();
+ S.Diag(OpLoc, Diag) << ObjCPointerExpr->getSourceRange();
}
}
@@ -15481,7 +15584,7 @@ ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
}
ExprResult LHS = LHSExpr, RHS = RHSExpr;
- QualType ResultTy; // Result type of the binary operator.
+ QualType ResultTy; // Result type of the binary operator.
// The following two variables are used for compound assignment operators
QualType CompLHSTy; // Type of LHS after promotions for computation
QualType CompResultTy; // Type of computation result
@@ -15508,9 +15611,8 @@ ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
// OpenCL special types - image, sampler, pipe, and blocks are to be used
// only with a builtin functions and therefore should be disallowed here.
- if (LHSTy->isImageType() || RHSTy->isImageType() ||
- LHSTy->isSamplerT() || RHSTy->isSamplerT() ||
- LHSTy->isPipeType() || RHSTy->isPipeType() ||
+ if (LHSTy->isImageType() || RHSTy->isImageType() || LHSTy->isSamplerT() ||
+ RHSTy->isSamplerT() || LHSTy->isPipeType() || RHSTy->isPipeType() ||
LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType()) {
ResultTy = InvalidOperands(OpLoc, LHS, RHS);
return ExprError();
@@ -15559,8 +15661,8 @@ ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
break;
case BO_PtrMemD:
case BO_PtrMemI:
- ResultTy = CheckPointerToMemberOperands(LHS, RHS, VK, OpLoc,
- Opc == BO_PtrMemI);
+ ResultTy =
+ CheckPointerToMemberOperands(LHS, RHS, VK, OpLoc, Opc == BO_PtrMemI);
break;
case BO_Mul:
case BO_Div:
@@ -15692,10 +15794,11 @@ ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
CheckArrayAccess(LHS.get());
CheckArrayAccess(RHS.get());
- if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(LHS.get()->IgnoreParenCasts())) {
- NamedDecl *ObjectSetClass = LookupSingleName(TUScope,
- &Context.Idents.get("object_setClass"),
- SourceLocation(), LookupOrdinaryName);
+ if (const ObjCIsaExpr *OISA =
+ dyn_cast<ObjCIsaExpr>(LHS.get()->IgnoreParenCasts())) {
+ NamedDecl *ObjectSetClass =
+ LookupSingleName(TUScope, &Context.Idents.get("object_setClass"),
+ SourceLocation(), LookupOrdinaryName);
if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.get())) {
SourceLocation RHSLocEnd = getLocForEndOfToken(RHS.get()->getEndLoc());
Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign)
@@ -15704,12 +15807,10 @@ ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
<< FixItHint::CreateReplacement(SourceRange(OISA->getOpLoc(), OpLoc),
",")
<< FixItHint::CreateInsertion(RHSLocEnd, ")");
- }
- else
+ } else
Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign);
- }
- else if (const ObjCIvarRefExpr *OIRE =
- dyn_cast<ObjCIvarRefExpr>(LHS.get()->IgnoreParenCasts()))
+ } else if (const ObjCIvarRefExpr *OIRE =
+ dyn_cast<ObjCIvarRefExpr>(LHS.get()->IgnoreParenCasts()))
DiagnoseDirectIsaAccess(*this, OIRE, OpLoc, RHS.get());
// Opc is not a compound assignment if CompResultTy is null.
@@ -15722,8 +15823,8 @@ ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
}
// Handle compound assignments.
- if (getLangOpts().CPlusPlus && LHS.get()->getObjectKind() !=
- OK_ObjCProperty) {
+ if (getLangOpts().CPlusPlus &&
+ LHS.get()->getObjectKind() != OK_ObjCProperty) {
VK = VK_LValue;
OK = LHS.get()->getObjectKind();
}
@@ -15776,29 +15877,29 @@ static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc,
: SourceRange(LHSExpr->getBeginLoc(), RHSBO->getLHS()->getEndLoc());
Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel)
- << DiagRange << BinaryOperator::getOpcodeStr(Opc) << OpStr;
+ << DiagRange << BinaryOperator::getOpcodeStr(Opc) << OpStr;
SuggestParentheses(Self, OpLoc,
- Self.PDiag(diag::note_precedence_silence) << OpStr,
- (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());
+ Self.PDiag(diag::note_precedence_silence) << OpStr,
+ (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());
SuggestParentheses(Self, OpLoc,
- Self.PDiag(diag::note_precedence_bitwise_first)
- << BinaryOperator::getOpcodeStr(Opc),
- ParensRange);
+ Self.PDiag(diag::note_precedence_bitwise_first)
+ << BinaryOperator::getOpcodeStr(Opc),
+ ParensRange);
}
/// It accepts a '&&' expr that is inside a '||' one.
/// Emit a diagnostic together with a fixit hint that wraps the '&&' expression
/// in parentheses.
-static void
-EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc,
- BinaryOperator *Bop) {
+static void EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self,
+ SourceLocation OpLoc,
+ BinaryOperator *Bop) {
assert(Bop->getOpcode() == BO_LAnd);
Self.Diag(Bop->getOperatorLoc(), diag::warn_logical_and_in_logical_or)
<< Bop->getSourceRange() << OpLoc;
SuggestParentheses(Self, Bop->getOperatorLoc(),
- Self.PDiag(diag::note_precedence_silence)
- << Bop->getOpcodeStr(),
- Bop->getSourceRange());
+ Self.PDiag(diag::note_precedence_silence)
+ << Bop->getOpcodeStr(),
+ Bop->getSourceRange());
}
/// Look for '&&' in the left hand of a '||' expr.
@@ -15843,12 +15944,12 @@ static void DiagnoseBitwiseOpInBitwiseOp(Sema &S, BinaryOperatorKind Opc,
if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(SubExpr)) {
if (Bop->isBitwiseOp() && Bop->getOpcode() < Opc) {
S.Diag(Bop->getOperatorLoc(), diag::warn_bitwise_op_in_bitwise_op)
- << Bop->getOpcodeStr() << BinaryOperator::getOpcodeStr(Opc)
- << Bop->getSourceRange() << OpLoc;
+ << Bop->getOpcodeStr() << BinaryOperator::getOpcodeStr(Opc)
+ << Bop->getSourceRange() << OpLoc;
SuggestParentheses(S, Bop->getOperatorLoc(),
- S.PDiag(diag::note_precedence_silence)
- << Bop->getOpcodeStr(),
- Bop->getSourceRange());
+ S.PDiag(diag::note_precedence_silence)
+ << Bop->getOpcodeStr(),
+ Bop->getSourceRange());
}
}
}
@@ -15861,14 +15962,14 @@ static void DiagnoseAdditionInShift(Sema &S, SourceLocation OpLoc,
S.Diag(Bop->getOperatorLoc(), diag::warn_addition_in_bitshift)
<< Bop->getSourceRange() << OpLoc << Shift << Op;
SuggestParentheses(S, Bop->getOperatorLoc(),
- S.PDiag(diag::note_precedence_silence) << Op,
- Bop->getSourceRange());
+ S.PDiag(diag::note_precedence_silence) << Op,
+ Bop->getSourceRange());
}
}
}
-static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc,
- Expr *LHSExpr, Expr *RHSExpr) {
+static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc, Expr *LHSExpr,
+ Expr *RHSExpr) {
CXXOperatorCallExpr *OCE = dyn_cast<CXXOperatorCallExpr>(LHSExpr);
if (!OCE)
return;
@@ -15897,27 +15998,28 @@ static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc,
/// precedence.
static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc,
SourceLocation OpLoc, Expr *LHSExpr,
- Expr *RHSExpr){
+ Expr *RHSExpr) {
// Diagnose "arg1 'bitwise' arg2 'eq' arg3".
if (BinaryOperator::isBitwiseOp(Opc))
DiagnoseBitwisePrecedence(Self, Opc, OpLoc, LHSExpr, RHSExpr);
// Diagnose "arg1 & arg2 | arg3"
if ((Opc == BO_Or || Opc == BO_Xor) &&
- !OpLoc.isMacroID()/* Don't warn in macros. */) {
+ !OpLoc.isMacroID() /* Don't warn in macros. */) {
DiagnoseBitwiseOpInBitwiseOp(Self, Opc, OpLoc, LHSExpr);
DiagnoseBitwiseOpInBitwiseOp(Self, Opc, OpLoc, RHSExpr);
}
// Warn about arg1 || arg2 && arg3, as GCC 4.3+ does.
// We don't warn for 'assert(a || b && "bad")' since this is safe.
- if (Opc == BO_LOr && !OpLoc.isMacroID()/* Don't warn in macros. */) {
+ if (Opc == BO_LOr && !OpLoc.isMacroID() /* Don't warn in macros. */) {
DiagnoseLogicalAndInLogicalOrLHS(Self, OpLoc, LHSExpr, RHSExpr);
DiagnoseLogicalAndInLogicalOrRHS(Self, OpLoc, LHSExpr, RHSExpr);
}
- if ((Opc == BO_Shl && LHSExpr->getType()->isIntegralType(Self.getASTContext()))
- || Opc == BO_Shr) {
+ if ((Opc == BO_Shl &&
+ LHSExpr->getType()->isIntegralType(Self.getASTContext())) ||
+ Opc == BO_Shr) {
StringRef Shift = BinaryOperator::getOpcodeStr(Opc);
DiagnoseAdditionInShift(Self, OpLoc, LHSExpr, Shift);
DiagnoseAdditionInShift(Self, OpLoc, RHSExpr, Shift);
@@ -15930,8 +16032,7 @@ static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc,
}
ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc,
- tok::TokenKind Kind,
- Expr *LHSExpr, Expr *RHSExpr) {
+ tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr) {
BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Kind);
assert(LHSExpr && "ActOnBinOp(): missing left expression");
assert(RHSExpr && "ActOnBinOp(): missing right expression");
@@ -15964,8 +16065,8 @@ void Sema::LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc,
/// Build an overloaded binary operator expression in the given scope.
static ExprResult BuildOverloadedBinOp(Sema &S, Scope *Sc, SourceLocation OpLoc,
- BinaryOperatorKind Opc,
- Expr *LHS, Expr *RHS) {
+ BinaryOperatorKind Opc, Expr *LHS,
+ Expr *RHS) {
switch (Opc) {
case BO_Assign:
// In the non-overloaded case, we warn about self-assignment (x = x) for
@@ -16026,7 +16127,8 @@ ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc,
// that an overload set can be dependently-typed, but it never
// instantiates to having an overloadable type.
ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr);
- if (resolvedRHS.isInvalid()) return ExprError();
+ if (resolvedRHS.isInvalid())
+ return ExprError();
RHSExpr = resolvedRHS.get();
if (RHSExpr->isTypeDependent() ||
@@ -16057,7 +16159,8 @@ ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc,
}
ExprResult LHS = CheckPlaceholderExpr(LHSExpr);
- if (LHS.isInvalid()) return ExprError();
+ if (LHS.isInvalid())
+ return ExprError();
LHSExpr = LHS.get();
}
@@ -16081,7 +16184,8 @@ ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc,
return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr);
- if (!resolvedRHS.isUsable()) return ExprError();
+ if (!resolvedRHS.isUsable())
+ return ExprError();
RHSExpr = resolvedRHS.get();
}
@@ -16169,10 +16273,11 @@ ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc,
QualType Ty = InputExpr->getType();
// The only legal unary operation for atomics is '&'.
if ((Opc != UO_AddrOf && Ty->isAtomicType()) ||
- // OpenCL special types - image, sampler, pipe, and blocks are to be used
- // only with a builtin functions and therefore should be disallowed here.
- (Ty->isImageType() || Ty->isSamplerT() || Ty->isPipeType()
- || Ty->isBlockPointerType())) {
+ // OpenCL special types - image, sampler, pipe, and blocks are to be
+ // used only with a builtin functions and therefore should be disallowed
+ // here.
+ (Ty->isImageType() || Ty->isSamplerT() || Ty->isPipeType() ||
+ Ty->isBlockPointerType())) {
return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
<< InputExpr->getType()
<< Input.get()->getSourceRange());
@@ -16469,15 +16574,15 @@ ExprResult Sema::BuildUnaryOp(Scope *S, SourceLocation OpLoc,
// & gets special logic for several kinds of placeholder.
// The builtin code knows what to do.
- if (Opc == UO_AddrOf &&
- (pty->getKind() == BuiltinType::Overload ||
- pty->getKind() == BuiltinType::UnknownAny ||
- pty->getKind() == BuiltinType::BoundMember))
+ if (Opc == UO_AddrOf && (pty->getKind() == BuiltinType::Overload ||
+ pty->getKind() == BuiltinType::UnknownAny ||
+ pty->getKind() == BuiltinType::BoundMember))
return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
// Anything else needs to be handled now.
ExprResult Result = CheckPlaceholderExpr(Input);
- if (Result.isInvalid()) return ExprError();
+ if (Result.isInvalid())
+ return ExprError();
Input = Result.get();
}
@@ -16615,32 +16720,32 @@ ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
// a struct/union/class.
if (!Dependent && !ArgTy->isRecordType())
return ExprError(Diag(BuiltinLoc, diag::err_offsetof_record_type)
- << ArgTy << TypeRange);
+ << ArgTy << TypeRange);
// Type must be complete per C99 7.17p3 because a declaring a variable
// with an incomplete type would be ill-formed.
- if (!Dependent
- && RequireCompleteType(BuiltinLoc, ArgTy,
- diag::err_offsetof_incomplete_type, TypeRange))
+ if (!Dependent &&
+ RequireCompleteType(BuiltinLoc, ArgTy, diag::err_offsetof_incomplete_type,
+ TypeRange))
return ExprError();
bool DidWarnAboutNonPOD = false;
QualType CurrentType = ArgTy;
SmallVector<OffsetOfNode, 4> Comps;
- SmallVector<Expr*, 4> Exprs;
+ SmallVector<Expr *, 4> Exprs;
for (const OffsetOfComponent &OC : Components) {
if (OC.isBrackets) {
// Offset of an array sub-field. TODO: Should we allow vector elements?
if (!CurrentType->isDependentType()) {
const ArrayType *AT = Context.getAsArrayType(CurrentType);
- if(!AT)
+ if (!AT)
return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type)
<< CurrentType);
CurrentType = AT->getElementType();
} else
CurrentType = Context.DependentTy;
- ExprResult IdxRval = DefaultLvalueConversion(static_cast<Expr*>(OC.U.E));
+ ExprResult IdxRval = DefaultLvalueConversion(static_cast<Expr *>(OC.U.E));
if (IdxRval.isInvalid())
return ExprError();
Expr *Idx = IdxRval.get();
@@ -16687,9 +16792,10 @@ ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
// If type is not a standard-layout class (Clause 9), the results are
// undefined.
if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
- bool IsSafe = LangOpts.CPlusPlus11? CRD->isStandardLayout() : CRD->isPOD();
- unsigned DiagID =
- LangOpts.CPlusPlus11? diag::ext_offsetof_non_standardlayout_type
+ bool IsSafe =
+ LangOpts.CPlusPlus11 ? CRD->isStandardLayout() : CRD->isPOD();
+ unsigned DiagID = LangOpts.CPlusPlus11
+ ? diag::ext_offsetof_non_standardlayout_type
: diag::ext_offsetof_non_pod_type;
if (!IsSafe && !DidWarnAboutNonPOD && !isUnevaluatedContext()) {
@@ -16725,8 +16831,7 @@ ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
// We diagnose this as an error.
if (MemberDecl->isBitField()) {
Diag(OC.LocEnd, diag::err_offsetof_bitfield)
- << MemberDecl->getDeclName()
- << SourceRange(BuiltinLoc, RParenLoc);
+ << MemberDecl->getDeclName() << SourceRange(BuiltinLoc, RParenLoc);
Diag(MemberDecl->getLocation(), diag::note_bitfield_decl);
return ExprError();
}
@@ -16742,8 +16847,7 @@ ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
Context.getCanonicalTagType(Parent), Paths)) {
if (Paths.getDetectedVirtual()) {
Diag(OC.LocEnd, diag::err_offsetof_field_of_virtual_base)
- << MemberDecl->getDeclName()
- << SourceRange(BuiltinLoc, RParenLoc);
+ << MemberDecl->getDeclName() << SourceRange(BuiltinLoc, RParenLoc);
return ExprError();
}
@@ -16755,8 +16859,8 @@ ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
if (IndirectMemberDecl) {
for (auto *FI : IndirectMemberDecl->chain()) {
assert(isa<FieldDecl>(FI));
- Comps.push_back(OffsetOfNode(OC.LocStart,
- cast<FieldDecl>(FI), OC.LocEnd));
+ Comps.push_back(
+ OffsetOfNode(OC.LocStart, cast<FieldDecl>(FI), OC.LocEnd));
}
} else
Comps.push_back(OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd));
@@ -16768,8 +16872,7 @@ ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
Comps, Exprs, RParenLoc);
}
-ExprResult Sema::ActOnBuiltinOffsetOf(Scope *S,
- SourceLocation BuiltinLoc,
+ExprResult Sema::ActOnBuiltinOffsetOf(Scope *S, SourceLocation BuiltinLoc,
SourceLocation TypeLoc,
ParsedType ParsedArgTy,
ArrayRef<OffsetOfComponent> Components,
@@ -16786,9 +16889,7 @@ ExprResult Sema::ActOnBuiltinOffsetOf(Scope *S,
return BuildBuiltinOffsetOf(BuiltinLoc, ArgTInfo, Components, RParenLoc);
}
-
-ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc,
- Expr *CondExpr,
+ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc, Expr *CondExpr,
Expr *LHSExpr, Expr *RHSExpr,
SourceLocation RPLoc) {
assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)");
@@ -16874,8 +16975,8 @@ void Sema::ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
// Look for an explicit signature in that function type.
FunctionProtoTypeLoc ExplicitSignature;
- if ((ExplicitSignature = Sig->getTypeLoc()
- .getAsAdjusted<FunctionProtoTypeLoc>())) {
+ if ((ExplicitSignature =
+ Sig->getTypeLoc().getAsAdjusted<FunctionProtoTypeLoc>())) {
// Check whether that explicit signature was synthesized by
// GetTypeForDeclarator. If so, don't save that as part of the
@@ -16914,7 +17015,7 @@ void Sema::ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
}
// Push block parameters from the declarator if we had them.
- SmallVector<ParmVarDecl*, 8> Params;
+ SmallVector<ParmVarDecl *, 8> Params;
if (ExplicitSignature) {
for (unsigned I = 0, E = ExplicitSignature.getNumParams(); I != E; ++I) {
ParmVarDecl *Param = ExplicitSignature.getParam(I);
@@ -16927,8 +17028,8 @@ void Sema::ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
Params.push_back(Param);
}
- // Fake up parameter variables if we have a typedef, like
- // ^ fntype { ... }
+ // Fake up parameter variables if we have a typedef, like
+ // ^ fntype { ... }
} else if (const FunctionProtoType *Fn = T->getAs<FunctionProtoType>()) {
for (const auto &I : Fn->param_types()) {
ParmVarDecl *Param = BuildParmVarDeclForTypedef(
@@ -16973,8 +17074,8 @@ void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {
PopFunctionScopeInfo();
}
-ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
- Stmt *Body, Scope *CurScope) {
+ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
+ Scope *CurScope) {
// If blocks are disabled, emit an error.
if (!LangOpts.Blocks)
Diag(CaretLoc, diag::err_blocks_disable) << LangOpts.OpenCL;
@@ -17006,7 +17107,8 @@ ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
const FunctionType *FTy = BSI->FunctionType->castAs<FunctionType>();
FunctionType::ExtInfo Ext = FTy->getExtInfo();
- if (NoReturn && !Ext.getNoReturn()) Ext = Ext.withNoReturn(true);
+ if (NoReturn && !Ext.getNoReturn())
+ Ext = Ext.withNoReturn(true);
// Turn protoless block types into nullary block types.
if (isa<FunctionNoProtoType>(FTy)) {
@@ -17020,7 +17122,7 @@ ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
(!NoReturn || FTy->getNoReturnAttr())) {
BlockTy = BSI->FunctionType;
- // Otherwise, make the minimal modifications to the function type.
+ // Otherwise, make the minimal modifications to the function type.
} else {
const FunctionProtoType *FPT = cast<FunctionProtoType>(FTy);
FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
@@ -17029,7 +17131,7 @@ ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
BlockTy = Context.getFunctionType(RetTy, FPT->getParamTypes(), EPI);
}
- // If we don't have a function type, just build one from nothing.
+ // If we don't have a function type, just build one from nothing.
} else {
FunctionProtoType::ExtProtoInfo EPI;
EPI.ExtInfo = FunctionType::ExtInfo().withNoReturn(NoReturn);
@@ -17040,8 +17142,7 @@ ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
BlockTy = Context.getBlockPointerType(BlockTy);
// If needed, diagnose invalid gotos and switches in the block.
- if (getCurFunction()->NeedsScopeChecking() &&
- !PP.isCodeCompletionEnabled())
+ if (getCurFunction()->NeedsScopeChecking() && !PP.isCodeCompletionEnabled())
DiagnoseInvalidJumps(cast<CompoundStmt>(Body));
BD->setBody(cast<CompoundStmt>(Body));
@@ -17116,9 +17217,9 @@ ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
// Build a full-expression copy expression if initialization
// succeeded and used a non-trivial constructor. Recover from
// errors by pretending that the copy isn't necessary.
- if (!Result.isInvalid() &&
- !cast<CXXConstructExpr>(Result.get())->getConstructor()
- ->isTrivial()) {
+ if (!Result.isInvalid() && !cast<CXXConstructExpr>(Result.get())
+ ->getConstructor()
+ ->isTrivial()) {
Result = MaybeCreateExprWithCleanups(Result);
CopyExpr = Result.get();
}
@@ -17175,9 +17276,8 @@ ExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,
return BuildVAArgExpr(BuiltinLoc, E, TInfo, RPLoc);
}
-ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc,
- Expr *E, TypeSourceInfo *TInfo,
- SourceLocation RPLoc) {
+ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,
+ TypeSourceInfo *TInfo, SourceLocation RPLoc) {
Expr *OrigExpr = E;
bool IsMS = false;
@@ -17199,7 +17299,8 @@ ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc,
// as Microsoft ABI on an actual Microsoft platform, where
// __builtin_ms_va_list and __builtin_va_list are the same.)
if (!E->isTypeDependent() && Context.getTargetInfo().hasBuiltinMSVaList() &&
- Context.getTargetInfo().getBuiltinVaListKind() != TargetInfo::CharPtrBuiltinVaList) {
+ Context.getTargetInfo().getBuiltinVaListKind() !=
+ TargetInfo::CharPtrBuiltinVaList) {
QualType MSVaListType = Context.getBuiltinMSVaListType();
if (Context.hasSameType(MSVaListType, E->getType())) {
if (CheckForModifiableLvalue(E, BuiltinLoc, *this))
@@ -17252,19 +17353,17 @@ ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc,
TInfo->getTypeLoc()))
return ExprError();
- if (RequireNonAbstractType(TInfo->getTypeLoc().getBeginLoc(),
- TInfo->getType(),
- diag::err_second_parameter_to_va_arg_abstract,
- TInfo->getTypeLoc()))
+ if (RequireNonAbstractType(
+ TInfo->getTypeLoc().getBeginLoc(), TInfo->getType(),
+ diag::err_second_parameter_to_va_arg_abstract, TInfo->getTypeLoc()))
return ExprError();
if (!TInfo->getType().isPODType(Context)) {
Diag(TInfo->getTypeLoc().getBeginLoc(),
TInfo->getType()->isObjCLifetimeType()
- ? diag::warn_second_parameter_to_va_arg_ownership_qualified
- : diag::warn_second_parameter_to_va_arg_not_pod)
- << TInfo->getType()
- << TInfo->getTypeLoc().getSourceRange();
+ ? diag::warn_second_parameter_to_va_arg_ownership_qualified
+ : diag::warn_second_parameter_to_va_arg_not_pod)
+ << TInfo->getType() << TInfo->getTypeLoc().getSourceRange();
}
if (TInfo->getType()->isArrayType()) {
@@ -17326,11 +17425,11 @@ ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc,
if (TInfo->getType()->isSpecificBuiltinType(BuiltinType::Float))
PromoteType = Context.DoubleTy;
if (!PromoteType.isNull())
- DiagRuntimeBehavior(TInfo->getTypeLoc().getBeginLoc(), E,
- PDiag(diag::warn_second_parameter_to_va_arg_never_compatible)
- << TInfo->getType()
- << PromoteType
- << TInfo->getTypeLoc().getSourceRange());
+ DiagRuntimeBehavior(
+ TInfo->getTypeLoc().getBeginLoc(), E,
+ PDiag(diag::warn_second_parameter_to_va_arg_never_compatible)
+ << TInfo->getType() << PromoteType
+ << TInfo->getTypeLoc().getSourceRange());
}
QualType T = TInfo->getType().getNonLValueExprType(Context);
@@ -17493,10 +17592,9 @@ static bool maybeDiagnoseAssignmentToFunction(Sema &S, QualType DstType,
}
bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
- SourceLocation Loc,
- QualType DstType, QualType SrcType,
- Expr *SrcExpr, AssignmentAction Action,
- bool *Complained) {
+ SourceLocation Loc, QualType DstType,
+ QualType SrcType, Expr *SrcExpr,
+ AssignmentAction Action, bool *Complained) {
if (Complained)
*Complained = false;
@@ -17565,7 +17663,7 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
}
CheckInferredResultType = DstType->isObjCObjectPointerType() &&
- SrcType->isObjCObjectPointerType();
+ SrcType->isObjCObjectPointerType();
if (CheckInferredResultType) {
SrcType = SrcType.getUnqualifiedType();
DstType = DstType.getUnqualifiedType();
@@ -17592,7 +17690,8 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
break;
case AssignConvertType::IncompatiblePointerDiscardsQualifiers: {
// Perform array-to-pointer decay if necessary.
- if (SrcType->isArrayType()) SrcType = Context.getArrayDecayedType(SrcType);
+ if (SrcType->isArrayType())
+ SrcType = Context.getArrayDecayedType(SrcType);
isInvalid = true;
@@ -17632,10 +17731,10 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType))
return false;
if (getLangOpts().CPlusPlus) {
- DiagKind = diag::err_typecheck_convert_discards_qualifiers;
+ DiagKind = diag::err_typecheck_convert_discards_qualifiers;
isInvalid = true;
} else {
- DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
+ DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
}
break;
@@ -17662,24 +17761,23 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
case AssignConvertType::IncompatibleObjCQualifiedId: {
if (SrcType->isObjCQualifiedIdType()) {
const ObjCObjectPointerType *srcOPT =
- SrcType->castAs<ObjCObjectPointerType>();
+ SrcType->castAs<ObjCObjectPointerType>();
for (auto *srcProto : srcOPT->quals()) {
PDecl = srcProto;
break;
}
if (const ObjCInterfaceType *IFaceT =
- DstType->castAs<ObjCObjectPointerType>()->getInterfaceType())
+ DstType->castAs<ObjCObjectPointerType>()->getInterfaceType())
IFace = IFaceT->getDecl();
- }
- else if (DstType->isObjCQualifiedIdType()) {
+ } else if (DstType->isObjCQualifiedIdType()) {
const ObjCObjectPointerType *dstOPT =
- DstType->castAs<ObjCObjectPointerType>();
+ DstType->castAs<ObjCObjectPointerType>();
for (auto *dstProto : dstOPT->quals()) {
PDecl = dstProto;
break;
}
if (const ObjCInterfaceType *IFaceT =
- SrcType->castAs<ObjCObjectPointerType>()->getInterfaceType())
+ SrcType->castAs<ObjCObjectPointerType>()->getInterfaceType())
IFace = IFaceT->getDecl();
}
if (getLangOpts().CPlusPlus) {
@@ -17783,7 +17881,9 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
FDiag << H;
}
- if (MayHaveConvFixit) { FDiag << (unsigned) (ConvHints.Kind); }
+ if (MayHaveConvFixit) {
+ FDiag << (unsigned)(ConvHints.Kind);
+ }
if (MayHaveFunctionDiff)
HandleFunctionTypeMismatch(FDiag, SecondType, FirstType);
@@ -17796,8 +17896,8 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
<< IFace << PDecl;
if (SecondType == Context.OverloadTy)
- NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression,
- FirstType, /*TakingAddress=*/true);
+ NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression, FirstType,
+ /*TakingAddress=*/true);
if (CheckInferredResultType)
ObjC().EmitRelatedResultTypeNote(SrcExpr);
@@ -17811,8 +17911,7 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
return isInvalid;
}
-ExprResult Sema::VerifyIntegerConstantExpression(Expr *E,
- llvm::APSInt *Result,
+ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
AllowFoldKind CanFold) {
class SimpleICEDiagnoser : public VerifyICEDiagnoser {
public:
@@ -17829,8 +17928,7 @@ ExprResult Sema::VerifyIntegerConstantExpression(Expr *E,
return VerifyIntegerConstantExpression(E, Result, Diagnoser, CanFold);
}
-ExprResult Sema::VerifyIntegerConstantExpression(Expr *E,
- llvm::APSInt *Result,
+ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
unsigned DiagID,
AllowFoldKind CanFold) {
class IDDiagnoser : public VerifyICEDiagnoser {
@@ -17838,7 +17936,7 @@ ExprResult Sema::VerifyIntegerConstantExpression(Expr *E,
public:
IDDiagnoser(unsigned DiagID)
- : VerifyICEDiagnoser(DiagID == 0), DiagID(DiagID) { }
+ : VerifyICEDiagnoser(DiagID == 0), DiagID(DiagID) {}
SemaDiagnosticBuilder diagnoseNotICE(Sema &S, SourceLocation Loc) override {
return S.Diag(Loc, DiagID);
@@ -17859,10 +17957,9 @@ Sema::VerifyICEDiagnoser::diagnoseFold(Sema &S, SourceLocation Loc) {
return S.Diag(Loc, diag::ext_expr_not_ice) << S.LangOpts.CPlusPlus;
}
-ExprResult
-Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
- VerifyICEDiagnoser &Diagnoser,
- AllowFoldKind CanFold) {
+ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
+ VerifyICEDiagnoser &Diagnoser,
+ AllowFoldKind CanFold) {
SourceLocation DiagLoc = E->getBeginLoc();
if (getLangOpts().CPlusPlus11) {
@@ -17874,6 +17971,7 @@ Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
ExprResult Converted;
class CXX11ConvertDiagnoser : public ICEConvertDiagnoser {
VerifyICEDiagnoser &BaseDiagnoser;
+
public:
CXX11ConvertDiagnoser(VerifyICEDiagnoser &BaseDiagnoser)
: ICEConvertDiagnoser(/*AllowScopedEnumerations*/ false,
@@ -17885,41 +17983,43 @@ Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
return BaseDiagnoser.diagnoseNotICEType(S, Loc, T);
}
- SemaDiagnosticBuilder diagnoseIncomplete(
- Sema &S, SourceLocation Loc, QualType T) override {
+ SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
+ QualType T) override {
return S.Diag(Loc, diag::err_ice_incomplete_type) << T;
}
- SemaDiagnosticBuilder diagnoseExplicitConv(
- Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
+ SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
+ QualType T,
+ QualType ConvTy) override {
return S.Diag(Loc, diag::err_ice_explicit_conversion) << T << ConvTy;
}
- SemaDiagnosticBuilder noteExplicitConv(
- Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
+ SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv,
+ QualType ConvTy) override {
return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here)
- << ConvTy->isEnumeralType() << ConvTy;
+ << ConvTy->isEnumeralType() << ConvTy;
}
- SemaDiagnosticBuilder diagnoseAmbiguous(
- Sema &S, SourceLocation Loc, QualType T) override {
+ SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
+ QualType T) override {
return S.Diag(Loc, diag::err_ice_ambiguous_conversion) << T;
}
- SemaDiagnosticBuilder noteAmbiguous(
- Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
+ SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
+ QualType ConvTy) override {
return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here)
- << ConvTy->isEnumeralType() << ConvTy;
+ << ConvTy->isEnumeralType() << ConvTy;
}
- SemaDiagnosticBuilder diagnoseConversion(
- Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
+ SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
+ QualType T,
+ QualType ConvTy) override {
llvm_unreachable("conversion functions are permitted");
}
} ConvertDiagnoser(Diagnoser);
- Converted = PerformContextualImplicitConversion(DiagLoc, E,
- ConvertDiagnoser);
+ Converted =
+ PerformContextualImplicitConversion(DiagLoc, E, ConvertDiagnoser);
if (Converted.isInvalid())
return Converted;
E = Converted.get();
@@ -17962,7 +18062,7 @@ Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
// the caret at its location rather than producing an essentially
// redundant note.
if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
- diag::note_invalid_subexpr_in_const_expr) {
+ diag::note_invalid_subexpr_in_const_expr) {
DiagLoc = Notes[0].first;
Notes.clear();
}
@@ -18009,8 +18109,8 @@ Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
// If our only note is the usual "invalid subexpression" note, just point
// the caret at its location rather than producing an essentially
// redundant note.
- if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
- diag::note_invalid_subexpr_in_const_expr) {
+ if (Notes.size() == 1 &&
+ Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr) {
DiagLoc = Notes[0].first;
Notes.clear();
}
@@ -18035,58 +18135,57 @@ Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
}
namespace {
- // Handle the case where we conclude a expression which we speculatively
- // considered to be unevaluated is actually evaluated.
- class TransformToPE : public TreeTransform<TransformToPE> {
- typedef TreeTransform<TransformToPE> BaseTransform;
+// Handle the case where we conclude a expression which we speculatively
+// considered to be unevaluated is actually evaluated.
+class TransformToPE : public TreeTransform<TransformToPE> {
+ typedef TreeTransform<TransformToPE> BaseTransform;
- public:
- TransformToPE(Sema &SemaRef) : BaseTransform(SemaRef) { }
+public:
+ TransformToPE(Sema &SemaRef) : BaseTransform(SemaRef) {}
- // Make sure we redo semantic analysis
- bool AlwaysRebuild() { return true; }
- bool ReplacingOriginal() { return true; }
+ // Make sure we redo semantic analysis
+ bool AlwaysRebuild() { return true; }
+ bool ReplacingOriginal() { return true; }
- // We need to special-case DeclRefExprs referring to FieldDecls which
- // are not part of a member pointer formation; normal TreeTransforming
- // doesn't catch this case because of the way we represent them in the AST.
- // FIXME: This is a bit ugly; is it really the best way to handle this
- // case?
- //
- // Error on DeclRefExprs referring to FieldDecls.
- ExprResult TransformDeclRefExpr(DeclRefExpr *E) {
- if (isa<FieldDecl>(E->getDecl()) &&
- !SemaRef.isUnevaluatedContext())
- return SemaRef.Diag(E->getLocation(),
- diag::err_invalid_non_static_member_use)
- << E->getDecl() << E->getSourceRange();
+ // We need to special-case DeclRefExprs referring to FieldDecls which
+ // are not part of a member pointer formation; normal TreeTransforming
+ // doesn't catch this case because of the way we represent them in the AST.
+ // FIXME: This is a bit ugly; is it really the best way to handle this
+ // case?
+ //
+ // Error on DeclRefExprs referring to FieldDecls.
+ ExprResult TransformDeclRefExpr(DeclRefExpr *E) {
+ if (isa<FieldDecl>(E->getDecl()) && !SemaRef.isUnevaluatedContext())
+ return SemaRef.Diag(E->getLocation(),
+ diag::err_invalid_non_static_member_use)
+ << E->getDecl() << E->getSourceRange();
- return BaseTransform::TransformDeclRefExpr(E);
- }
+ return BaseTransform::TransformDeclRefExpr(E);
+ }
- // Exception: filter out member pointer formation
- ExprResult TransformUnaryOperator(UnaryOperator *E) {
- if (E->getOpcode() == UO_AddrOf && E->getType()->isMemberPointerType())
- return E;
+ // Exception: filter out member pointer formation
+ ExprResult TransformUnaryOperator(UnaryOperator *E) {
+ if (E->getOpcode() == UO_AddrOf && E->getType()->isMemberPointerType())
+ return E;
- return BaseTransform::TransformUnaryOperator(E);
- }
+ return BaseTransform::TransformUnaryOperator(E);
+ }
- // The body of a lambda-expression is in a separate expression evaluation
- // context so never needs to be transformed.
- // FIXME: Ideally we wouldn't transform the closure type either, and would
- // just recreate the capture expressions and lambda expression.
- StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body) {
- return SkipLambdaBody(E, Body);
- }
- };
-}
+ // The body of a lambda-expression is in a separate expression evaluation
+ // context so never needs to be transformed.
+ // FIXME: Ideally we wouldn't transform the closure type either, and would
+ // just recreate the capture expressions and lambda expression.
+ StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body) {
+ return SkipLambdaBody(E, Body);
+ }
+};
+} // namespace
ExprResult Sema::TransformToPotentiallyEvaluated(Expr *E) {
assert(isUnevaluatedContext() &&
"Should only transform unevaluated expressions");
ExprEvalContexts.back().Context =
- ExprEvalContexts[ExprEvalContexts.size()-2].Context;
+ ExprEvalContexts[ExprEvalContexts.size() - 2].Context;
if (isUnevaluatedContext())
return E;
return TransformToPE(*this).TransformExpr(E);
@@ -18101,8 +18200,7 @@ TypeSourceInfo *Sema::TransformToPotentiallyEvaluated(TypeSourceInfo *TInfo) {
return TransformToPE(*this).TransformType(TInfo);
}
-void
-Sema::PushExpressionEvaluationContext(
+void Sema::PushExpressionEvaluationContext(
ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl,
ExpressionEvaluationContextRecord::ExpressionKind ExprContext) {
ExprEvalContexts.emplace_back(NewContext, ExprCleanupObjects.size(), Cleanup,
@@ -18130,8 +18228,7 @@ Sema::PushExpressionEvaluationContext(
std::swap(MaybeODRUseExprs, ExprEvalContexts.back().SavedMaybeODRUseExprs);
}
-void
-Sema::PushExpressionEvaluationContext(
+void Sema::PushExpressionEvaluationContext(
ExpressionEvaluationContext NewContext, ReuseLambdaContextDecl_t,
ExpressionEvaluationContextRecord::ExpressionKind ExprContext) {
Decl *ClosureContextDecl = ExprEvalContexts.back().ManglingContextDecl;
@@ -18400,7 +18497,7 @@ static void RemoveNestedImmediateInvocation(
SmallVector<Sema::ImmediateInvocationCandidate,
4>::reverse_iterator Current)
: Base(SemaRef), DRSet(DR), IISet(II), CurrentII(Current) {}
- void RemoveImmediateInvocation(ConstantExpr* E) {
+ void RemoveImmediateInvocation(ConstantExpr *E) {
auto It = std::find_if(CurrentII, IISet.rend(),
[E](Sema::ImmediateInvocationCandidate Elem) {
return Elem.getPointer() == E;
@@ -18604,7 +18701,7 @@ HandleImmediateInvocations(Sema &SemaRef,
}
void Sema::PopExpressionEvaluationContext() {
- ExpressionEvaluationContextRecord& Rec = ExprEvalContexts.back();
+ ExpressionEvaluationContextRecord &Rec = ExprEvalContexts.back();
if (!Rec.Lambdas.empty()) {
using ExpressionKind = ExpressionEvaluationContextRecord::ExpressionKind;
if (!getLangOpts().CPlusPlus20 &&
@@ -18664,7 +18761,7 @@ void Sema::PopExpressionEvaluationContext() {
Cleanup = Rec.ParentCleanup;
CleanupVarDeclMarking();
std::swap(MaybeODRUseExprs, Rec.SavedMaybeODRUseExprs);
- // Otherwise, merge the contexts together.
+ // Otherwise, merge the contexts together.
} else {
Cleanup.mergeFrom(Rec.ParentCleanup);
MaybeODRUseExprs.insert_range(Rec.SavedMaybeODRUseExprs);
@@ -18677,9 +18774,9 @@ void Sema::PopExpressionEvaluationContext() {
}
void Sema::DiscardCleanupsInEvaluationContext() {
- ExprCleanupObjects.erase(
- ExprCleanupObjects.begin() + ExprEvalContexts.back().NumCleanupObjects,
- ExprCleanupObjects.end());
+ ExprCleanupObjects.erase(ExprCleanupObjects.begin() +
+ ExprEvalContexts.back().NumCleanupObjects,
+ ExprCleanupObjects.end());
Cleanup.reset();
MaybeODRUseExprs.clear();
}
@@ -18700,27 +18797,27 @@ static bool isPotentiallyConstantEvaluatedContext(Sema &SemaRef) {
/// C++2a [expr.const]p12:
// An expression or conversion is potentially constant evaluated if it is
switch (SemaRef.ExprEvalContexts.back().Context) {
- case Sema::ExpressionEvaluationContext::ConstantEvaluated:
- case Sema::ExpressionEvaluationContext::ImmediateFunctionContext:
-
- // -- a manifestly constant-evaluated expression,
- case Sema::ExpressionEvaluationContext::PotentiallyEvaluated:
- case Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
- case Sema::ExpressionEvaluationContext::DiscardedStatement:
- // -- a potentially-evaluated expression,
- case Sema::ExpressionEvaluationContext::UnevaluatedList:
- // -- an immediate subexpression of a braced-init-list,
-
- // -- [FIXME] an expression of the form & cast-expression that occurs
- // within a templated entity
- // -- a subexpression of one of the above that is not a subexpression of
- // a nested unevaluated operand.
- return true;
+ case Sema::ExpressionEvaluationContext::ConstantEvaluated:
+ case Sema::ExpressionEvaluationContext::ImmediateFunctionContext:
+
+ // -- a manifestly constant-evaluated expression,
+ case Sema::ExpressionEvaluationContext::PotentiallyEvaluated:
+ case Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
+ case Sema::ExpressionEvaluationContext::DiscardedStatement:
+ // -- a potentially-evaluated expression,
+ case Sema::ExpressionEvaluationContext::UnevaluatedList:
+ // -- an immediate subexpression of a braced-init-list,
+
+ // -- [FIXME] an expression of the form & cast-expression that occurs
+ // within a templated entity
+ // -- a subexpression of one of the above that is not a subexpression of
+ // a nested unevaluated operand.
+ return true;
- case Sema::ExpressionEvaluationContext::Unevaluated:
- case Sema::ExpressionEvaluationContext::UnevaluatedAbstract:
- // Expressions in this context are never evaluated.
- return false;
+ case Sema::ExpressionEvaluationContext::Unevaluated:
+ case Sema::ExpressionEvaluationContext::UnevaluatedAbstract:
+ // Expressions in this context are never evaluated.
+ return false;
}
llvm_unreachable("Invalid context");
}
@@ -18998,7 +19095,7 @@ void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
PointOfInstantiation = Loc;
if (auto *MSI = Func->getMemberSpecializationInfo())
MSI->setPointOfInstantiation(Loc);
- // FIXME: Notify listener.
+ // FIXME: Notify listener.
else
Func->setTemplateSpecializationKind(TSK, PointOfInstantiation);
} else if (TSK != TSK_ImplicitInstantiation) {
@@ -19091,8 +19188,7 @@ void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
if (!Func->isDefined() && !Func->isInAnotherModuleUnit()) {
if (mightHaveNonExternalLinkage(Func))
UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
- else if (Func->getMostRecentDecl()->isInlined() &&
- !LangOpts.GNUInline &&
+ else if (Func->getMostRecentDecl()->isInlined() && !LangOpts.GNUInline &&
!Func->getMostRecentDecl()->hasAttr<GNUInlineAttr>())
UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
else if (isExternalWithNoLinkageType(Func))
@@ -19222,8 +19318,7 @@ static void diagnoseUncapturableValueReferenceOrBinding(Sema &S,
// If the parameter still belongs to the translation unit, then
// we're actually just using one parameter in the declaration of
// the next.
- if (isa<ParmVarDecl>(var) &&
- isa<TranslationUnitDecl>(VarDC))
+ if (isa<ParmVarDecl>(var) && isa<TranslationUnitDecl>(VarDC))
return;
// For C code, don't diagnose about capture if we're not actually in code
@@ -19248,9 +19343,8 @@ static void diagnoseUncapturableValueReferenceOrBinding(Sema &S,
}
S.Diag(loc, diag::err_reference_to_local_in_enclosing_context)
- << var << ValueKind << ContextKind << VarDC;
- S.Diag(var->getLocation(), diag::note_entity_declared_at)
- << var;
+ << var << ValueKind << ContextKind << VarDC;
+ S.Diag(var->getLocation(), diag::note_entity_declared_at) << var;
// FIXME: Add additional diagnostic info about class etc. which prevents
// capture.
@@ -19414,8 +19508,7 @@ static bool captureInBlock(BlockScopeInfo *BSI, ValueDecl *Var,
if (!Invalid &&
CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) {
if (BuildAndDiagnose) {
- S.Diag(Loc, diag::err_arc_autoreleasing_capture)
- << /*block*/ 0;
+ S.Diag(Loc, diag::err_arc_autoreleasing_capture) << /*block*/ 0;
S.Diag(Var->getLocation(), diag::note_previous_decl) << Var;
Invalid = true;
} else {
@@ -19546,7 +19639,7 @@ static bool captureInLambda(LambdaScopeInfo *LSI, ValueDecl *Var,
// captured entity is a reference to a function, the
// corresponding data member is also a reference to a
// function. - end note ]
- if (const ReferenceType *RefType = CaptureType->getAs<ReferenceType>()){
+ if (const ReferenceType *RefType = CaptureType->getAs<ReferenceType>()) {
if (!RefType->getPointeeType()->isFunctionType())
CaptureType = RefType->getPointeeType();
}
@@ -19557,7 +19650,7 @@ static bool captureInLambda(LambdaScopeInfo *LSI, ValueDecl *Var,
if (BuildAndDiagnose) {
S.Diag(Loc, diag::err_arc_autoreleasing_capture) << /*lambda*/ 1;
S.Diag(Var->getLocation(), diag::note_previous_decl)
- << Var->getDeclName();
+ << Var->getDeclName();
Invalid = true;
} else {
return false;
@@ -19744,7 +19837,8 @@ bool Sema::tryCaptureVariable(
assert(VD && "Cannot capture a null variable");
const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
- ? *FunctionScopeIndexToStopAt : FunctionScopes.size() - 1;
+ ? *FunctionScopeIndexToStopAt
+ : FunctionScopes.size() - 1;
// We need to sync up the Declaration Context with the
// FunctionScopeIndexToStopAt
if (FunctionScopeIndexToStopAt) {
@@ -19829,7 +19923,7 @@ bool Sema::tryCaptureVariable(
return true;
}
- FunctionScopeInfo *FSI = FunctionScopes[FunctionScopesIndex];
+ FunctionScopeInfo *FSI = FunctionScopes[FunctionScopesIndex];
CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FSI);
// Check whether we've already captured it.
@@ -19977,13 +20071,13 @@ bool Sema::tryCaptureVariable(
// If the variable had already been captured previously, we start capturing
// at the lambda nested within that one.
bool Invalid = false;
- for (unsigned I = ++FunctionScopesIndex, N = MaxFunctionScopesIndex + 1; I != N;
- ++I) {
+ for (unsigned I = ++FunctionScopesIndex, N = MaxFunctionScopesIndex + 1;
+ I != N; ++I) {
CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FunctionScopes[I]);
- // Certain capturing entities (lambdas, blocks etc.) are not allowed to capture
- // certain types of variables (unnamed, variably modified types etc.)
- // so check for eligibility.
+ // Certain capturing entities (lambdas, blocks etc.) are not allowed to
+ // capture certain types of variables (unnamed, variably modified types
+ // etc.) so check for eligibility.
if (!Invalid)
Invalid =
!isVariableCapturable(CSI, Var, ExprLoc, BuildAndDiagnose, *this);
@@ -19994,10 +20088,12 @@ bool Sema::tryCaptureVariable(
return true;
if (BlockScopeInfo *BSI = dyn_cast<BlockScopeInfo>(CSI)) {
- Invalid = !captureInBlock(BSI, Var, ExprLoc, BuildAndDiagnose, CaptureType,
- DeclRefType, Nested, *this, Invalid);
+ Invalid =
+ !captureInBlock(BSI, Var, ExprLoc, BuildAndDiagnose, CaptureType,
+ DeclRefType, Nested, *this, Invalid);
Nested = true;
- } else if (CapturedRegionScopeInfo *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
+ } else if (CapturedRegionScopeInfo *RSI =
+ dyn_cast<CapturedRegionScopeInfo>(CSI)) {
Invalid = !captureInCapturedRegion(
RSI, Var, ExprLoc, BuildAndDiagnose, CaptureType, DeclRefType, Nested,
Kind, /*IsTopScope*/ I == N - 1, *this, Invalid);
@@ -20022,8 +20118,8 @@ bool Sema::tryCaptureVariable(ValueDecl *Var, SourceLocation Loc,
QualType CaptureType;
QualType DeclRefType;
return tryCaptureVariable(Var, Loc, Kind, EllipsisLoc,
- /*BuildAndDiagnose=*/true, CaptureType,
- DeclRefType, nullptr);
+ /*BuildAndDiagnose=*/true, CaptureType, DeclRefType,
+ nullptr);
}
bool Sema::NeedToCaptureVariable(ValueDecl *Var, SourceLocation Loc) {
@@ -20057,23 +20153,24 @@ namespace {
class CopiedTemplateArgs {
bool HasArgs;
TemplateArgumentListInfo TemplateArgStorage;
+
public:
- template<typename RefExpr>
+ template <typename RefExpr>
CopiedTemplateArgs(RefExpr *E) : HasArgs(E->hasExplicitTemplateArgs()) {
if (HasArgs)
E->copyTemplateArgumentsInto(TemplateArgStorage);
}
- operator TemplateArgumentListInfo*()
+ operator TemplateArgumentListInfo *()
#ifdef __has_cpp_attribute
#if __has_cpp_attribute(clang::lifetimebound)
- [[clang::lifetimebound]]
+ [[clang::lifetimebound]]
#endif
#endif
{
return HasArgs ? &TemplateArgStorage : nullptr;
}
};
-}
+} // namespace
/// Walk the set of potential results of an expression and mark them all as
/// non-odr-uses if they satisfy the side-conditions of the NonOdrUseReason.
@@ -20265,7 +20362,7 @@ static ExprResult rebuildPotentialResultsAsNonOdrUsed(Sema &S, Expr *E,
if (!Sub.isUsable())
return Sub;
BO->setLHS(Sub.get());
- // -- If e is a comma expression, ...
+ // -- If e is a comma expression, ...
} else if (BO->getOpcode() == BO_Comma) {
ExprResult Sub = Rebuild(RHS);
if (!Sub.isUsable())
@@ -20462,8 +20559,8 @@ void Sema::CleanupVarDeclMarking() {
for (Expr *E : LocalMaybeODRUseExprs) {
if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
- MarkVarDeclODRUsed(cast<VarDecl>(DRE->getDecl()),
- DRE->getLocation(), *this);
+ MarkVarDeclODRUsed(cast<VarDecl>(DRE->getDecl()), DRE->getLocation(),
+ *this);
} else if (auto *ME = dyn_cast<MemberExpr>(E)) {
MarkVarDeclODRUsed(cast<VarDecl>(ME->getMemberDecl()), ME->getMemberLoc(),
*this);
@@ -20584,7 +20681,7 @@ static void DoMarkVarDeclReferenced(
PointOfInstantiation = Loc;
if (MSI)
MSI->setPointOfInstantiation(PointOfInstantiation);
- // FIXME: Notify listener.
+ // FIXME: Notify listener.
else
Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
}
@@ -20610,8 +20707,8 @@ static void DoMarkVarDeclReferenced(
else if (auto *ME = dyn_cast_or_null<MemberExpr>(E))
ME->setMemberDecl(ME->getMemberDecl());
} else if (FirstInstantiation) {
- SemaRef.PendingInstantiations
- .push_back(std::make_pair(Var, PointOfInstantiation));
+ SemaRef.PendingInstantiations.push_back(
+ std::make_pair(Var, PointOfInstantiation));
} else {
bool Inserted = false;
for (auto &I : SemaRef.SavedPendingInstantiations) {
@@ -20633,8 +20730,8 @@ static void DoMarkVarDeclReferenced(
// no direct way to avoid enqueueing the pending instantiation
// multiple times.
if (isa<VarTemplateSpecializationDecl>(Var) && !Inserted)
- SemaRef.PendingInstantiations
- .push_back(std::make_pair(Var, PointOfInstantiation));
+ SemaRef.PendingInstantiations.push_back(
+ std::make_pair(Var, PointOfInstantiation));
}
}
}
@@ -20808,8 +20905,8 @@ MarkExprReferenced(Sema &SemaRef, SourceLocation Loc, Decl *D, Expr *E,
if (!MD)
return;
// Only attempt to devirtualize if this is truly a virtual call.
- bool IsVirtualCall = MD->isVirtual() &&
- ME->performsVirtualDispatch(SemaRef.getLangOpts());
+ bool IsVirtualCall =
+ MD->isVirtual() && ME->performsVirtualDispatch(SemaRef.getLangOpts());
if (!IsVirtualCall)
return;
@@ -20890,13 +20987,13 @@ void Sema::MarkAnyDeclReferenced(SourceLocation Loc, Decl *D,
}
namespace {
- // Mark all of the declarations used by a type as referenced.
- // FIXME: Not fully implemented yet! We need to have a better understanding
- // of when we're entering a context we should not recurse into.
- // FIXME: This is and EvaluatedExprMarker are more-or-less equivalent to
- // TreeTransforms rebuilding the type in a new context. Rather than
- // duplicating the TreeTransform logic, we should consider reusing it here.
- // Currently that causes problems when rebuilding LambdaExprs.
+// Mark all of the declarations used by a type as referenced.
+// FIXME: Not fully implemented yet! We need to have a better understanding
+// of when we're entering a context we should not recurse into.
+// FIXME: This is and EvaluatedExprMarker are more-or-less equivalent to
+// TreeTransforms rebuilding the type in a new context. Rather than
+// duplicating the TreeTransform logic, we should consider reusing it here.
+// Currently that causes problems when rebuilding LambdaExprs.
class MarkReferencedDecls : public DynamicRecursiveASTVisitor {
Sema &S;
SourceLocation Loc;
@@ -20906,7 +21003,7 @@ class MarkReferencedDecls : public DynamicRecursiveASTVisitor {
bool TraverseTemplateArgument(const TemplateArgument &Arg) override;
};
-}
+} // namespace
bool MarkReferencedDecls::TraverseTemplateArgument(
const TemplateArgument &Arg) {
@@ -20979,9 +21076,8 @@ class EvaluatedExprMarker : public UsedDeclVisitor<EvaluatedExprMarker> {
};
} // namespace
-void Sema::MarkDeclarationsReferencedInExpr(Expr *E,
- bool SkipLocalVariables,
- ArrayRef<const Expr*> StopAt) {
+void Sema::MarkDeclarationsReferencedInExpr(Expr *E, bool SkipLocalVariables,
+ ArrayRef<const Expr *> StopAt) {
EvaluatedExprMarker(*this, SkipLocalVariables, StopAt).Visit(E);
}
@@ -21038,7 +21134,7 @@ bool Sema::DiagIfReachable(SourceLocation Loc, ArrayRef<const Stmt *> Stmts,
/// behavior of a program, such as passing a non-POD value through an ellipsis.
/// Failure to do so will likely result in spurious diagnostics or failures
/// during overload resolution or within sizeof/alignof/typeof/typeid.
-bool Sema::DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt*> Stmts,
+bool Sema::DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt *> Stmts,
const PartialDiagnostic &PD) {
if (ExprEvalContexts.back().isDiscardedStatementContext())
@@ -21091,12 +21187,12 @@ bool Sema::CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
public:
CallReturnIncompleteDiagnoser(FunctionDecl *FD, CallExpr *CE)
- : FD(FD), CE(CE) { }
+ : FD(FD), CE(CE) {}
void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
if (!FD) {
S.Diag(Loc, diag::err_call_incomplete_return)
- << T << CE->getSourceRange();
+ << T << CE->getSourceRange();
return;
}
@@ -21128,8 +21224,8 @@ void Sema::DiagnoseAssignmentAsCondition(Expr *E) {
IsOrAssign = Op->getOpcode() == BO_OrAssign;
// Greylist some idioms by putting them into a warning subcategory.
- if (ObjCMessageExpr *ME
- = dyn_cast<ObjCMessageExpr>(Op->getRHS()->IgnoreParenCasts())) {
+ if (ObjCMessageExpr *ME =
+ dyn_cast<ObjCMessageExpr>(Op->getRHS()->IgnoreParenCasts())) {
Selector Sel = ME->getSelector();
// self = [<foo> init...]
@@ -21160,15 +21256,15 @@ void Sema::DiagnoseAssignmentAsCondition(Expr *E) {
SourceLocation Open = E->getBeginLoc();
SourceLocation Close = getLocForEndOfToken(E->getSourceRange().getEnd());
Diag(Loc, diag::note_condition_assign_silence)
- << FixItHint::CreateInsertion(Open, "(")
- << FixItHint::CreateInsertion(Close, ")");
+ << FixItHint::CreateInsertion(Open, "(")
+ << FixItHint::CreateInsertion(Close, ")");
if (IsOrAssign)
Diag(Loc, diag::note_condition_or_assign_to_comparison)
- << FixItHint::CreateReplacement(Loc, "!=");
+ << FixItHint::CreateReplacement(Loc, "!=");
else
Diag(Loc, diag::note_condition_assign_to_comparison)
- << FixItHint::CreateReplacement(Loc, "==");
+ << FixItHint::CreateReplacement(Loc, "==");
}
void Sema::DiagnoseEqualityWithExtraParens(ParenExpr *ParenE) {
@@ -21186,17 +21282,17 @@ void Sema::DiagnoseEqualityWithExtraParens(ParenExpr *ParenE) {
if (BinaryOperator *opE = dyn_cast<BinaryOperator>(E))
if (opE->getOpcode() == BO_EQ &&
- opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(Context)
- == Expr::MLV_Valid) {
+ opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(Context) ==
+ Expr::MLV_Valid) {
SourceLocation Loc = opE->getOperatorLoc();
Diag(Loc, diag::warn_equality_with_extra_parens) << E->getSourceRange();
SourceRange ParenERange = ParenE->getSourceRange();
Diag(Loc, diag::note_equality_comparison_silence)
- << FixItHint::CreateRemoval(ParenERange.getBegin())
- << FixItHint::CreateRemoval(ParenERange.getEnd());
+ << FixItHint::CreateRemoval(ParenERange.getBegin())
+ << FixItHint::CreateRemoval(ParenERange.getEnd());
Diag(Loc, diag::note_equality_comparison_to_assign)
- << FixItHint::CreateReplacement(Loc, "=");
+ << FixItHint::CreateReplacement(Loc, "=");
}
}
@@ -21207,7 +21303,8 @@ ExprResult Sema::CheckBooleanCondition(SourceLocation Loc, Expr *E,
DiagnoseEqualityWithExtraParens(parenE);
ExprResult result = CheckPlaceholderExpr(E);
- if (result.isInvalid()) return ExprError();
+ if (result.isInvalid())
+ return ExprError();
E = result.get();
if (!E->isTypeDependent()) {
@@ -21225,7 +21322,7 @@ ExprResult Sema::CheckBooleanCondition(SourceLocation Loc, Expr *E,
QualType T = E->getType();
if (!T->isScalarType()) { // C99 6.8.4.1p1
Diag(Loc, diag::err_typecheck_statement_requires_scalar)
- << T << E->getSourceRange();
+ << T << E->getSourceRange();
return ExprError();
}
CheckBoolLikeConversion(E, Loc);
@@ -21273,190 +21370,182 @@ Sema::ConditionResult Sema::ActOnCondition(Scope *S, SourceLocation Loc,
}
namespace {
- /// A visitor for rebuilding a call to an __unknown_any expression
- /// to have an appropriate type.
- struct RebuildUnknownAnyFunction
+/// A visitor for rebuilding a call to an __unknown_any expression
+/// to have an appropriate type.
+struct RebuildUnknownAnyFunction
: StmtVisitor<RebuildUnknownAnyFunction, ExprResult> {
- Sema &S;
+ Sema &S;
- RebuildUnknownAnyFunction(Sema &S) : S(S) {}
+ RebuildUnknownAnyFunction(Sema &S) : S(S) {}
- ExprResult VisitStmt(Stmt *S) {
- llvm_unreachable("unexpected statement!");
- }
+ ExprResult VisitStmt(Stmt *S) { llvm_unreachable("unexpected statement!"); }
- ExprResult VisitExpr(Expr *E) {
- S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_call)
+ ExprResult VisitExpr(Expr *E) {
+ S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_call)
<< E->getSourceRange();
- return ExprError();
- }
+ return ExprError();
+ }
- /// Rebuild an expression which simply semantically wraps another
- /// expression which it shares the type and value kind of.
- template <class T> ExprResult rebuildSugarExpr(T *E) {
- ExprResult SubResult = Visit(E->getSubExpr());
- if (SubResult.isInvalid()) return ExprError();
+ /// Rebuild an expression which simply semantically wraps another
+ /// expression which it shares the type and value kind of.
+ template <class T> ExprResult rebuildSugarExpr(T *E) {
+ ExprResult SubResult = Visit(E->getSubExpr());
+ if (SubResult.isInvalid())
+ return ExprError();
- Expr *SubExpr = SubResult.get();
- E->setSubExpr(SubExpr);
- E->setType(SubExpr->getType());
- E->setValueKind(SubExpr->getValueKind());
- assert(E->getObjectKind() == OK_Ordinary);
- return E;
- }
+ Expr *SubExpr = SubResult.get();
+ E->setSubExpr(SubExpr);
+ E->setType(SubExpr->getType());
+ E->setValueKind(SubExpr->getValueKind());
+ assert(E->getObjectKind() == OK_Ordinary);
+ return E;
+ }
- ExprResult VisitParenExpr(ParenExpr *E) {
- return rebuildSugarExpr(E);
- }
+ ExprResult VisitParenExpr(ParenExpr *E) { return rebuildSugarExpr(E); }
- ExprResult VisitUnaryExtension(UnaryOperator *E) {
- return rebuildSugarExpr(E);
- }
+ ExprResult VisitUnaryExtension(UnaryOperator *E) {
+ return rebuildSugarExpr(E);
+ }
- ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
- ExprResult SubResult = Visit(E->getSubExpr());
- if (SubResult.isInvalid()) return ExprError();
+ ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
+ ExprResult SubResult = Visit(E->getSubExpr());
+ if (SubResult.isInvalid())
+ return ExprError();
- Expr *SubExpr = SubResult.get();
- E->setSubExpr(SubExpr);
- E->setType(S.Context.getPointerType(SubExpr->getType()));
- assert(E->isPRValue());
- assert(E->getObjectKind() == OK_Ordinary);
- return E;
- }
+ Expr *SubExpr = SubResult.get();
+ E->setSubExpr(SubExpr);
+ E->setType(S.Context.getPointerType(SubExpr->getType()));
+ assert(E->isPRValue());
+ assert(E->getObjectKind() == OK_Ordinary);
+ return E;
+ }
- ExprResult resolveDecl(Expr *E, ValueDecl *VD) {
- if (!isa<FunctionDecl>(VD)) return VisitExpr(E);
+ ExprResult resolveDecl(Expr *E, ValueDecl *VD) {
+ if (!isa<FunctionDecl>(VD))
+ return VisitExpr(E);
- E->setType(VD->getType());
+ E->setType(VD->getType());
- assert(E->isPRValue());
- if (S.getLangOpts().CPlusPlus &&
- !(isa<CXXMethodDecl>(VD) &&
- cast<CXXMethodDecl>(VD)->isInstance()))
- E->setValueKind(VK_LValue);
+ assert(E->isPRValue());
+ if (S.getLangOpts().CPlusPlus &&
+ !(isa<CXXMethodDecl>(VD) && cast<CXXMethodDecl>(VD)->isInstance()))
+ E->setValueKind(VK_LValue);
- return E;
- }
+ return E;
+ }
- ExprResult VisitMemberExpr(MemberExpr *E) {
- return resolveDecl(E, E->getMemberDecl());
- }
+ ExprResult VisitMemberExpr(MemberExpr *E) {
+ return resolveDecl(E, E->getMemberDecl());
+ }
- ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
- return resolveDecl(E, E->getDecl());
- }
- };
-}
+ ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
+ return resolveDecl(E, E->getDecl());
+ }
+};
+} // namespace
/// Given a function expression of unknown-any type, try to rebuild it
/// to have a function type.
static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *FunctionExpr) {
ExprResult Result = RebuildUnknownAnyFunction(S).Visit(FunctionExpr);
- if (Result.isInvalid()) return ExprError();
+ if (Result.isInvalid())
+ return ExprError();
return S.DefaultFunctionArrayConversion(Result.get());
}
namespace {
- /// A visitor for rebuilding an expression of type __unknown_anytype
- /// into one which resolves the type directly on the referring
- /// expression. Strict preservation of the original source
- /// structure is not a goal.
- struct RebuildUnknownAnyExpr
- : StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {
+/// A visitor for rebuilding an expression of type __unknown_anytype
+/// into one which resolves the type directly on the referring
+/// expression. Strict preservation of the original source
+/// structure is not a goal.
+struct RebuildUnknownAnyExpr : StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {
- Sema &S;
+ Sema &S;
- /// The current destination type.
- QualType DestType;
+ /// The current destination type.
+ QualType DestType;
- RebuildUnknownAnyExpr(Sema &S, QualType CastType)
+ RebuildUnknownAnyExpr(Sema &S, QualType CastType)
: S(S), DestType(CastType) {}
- ExprResult VisitStmt(Stmt *S) {
- llvm_unreachable("unexpected statement!");
- }
+ ExprResult VisitStmt(Stmt *S) { llvm_unreachable("unexpected statement!"); }
- ExprResult VisitExpr(Expr *E) {
- S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr)
+ ExprResult VisitExpr(Expr *E) {
+ S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr)
<< E->getSourceRange();
- return ExprError();
- }
+ return ExprError();
+ }
- ExprResult VisitCallExpr(CallExpr *E);
- ExprResult VisitObjCMessageExpr(ObjCMessageExpr *E);
+ ExprResult VisitCallExpr(CallExpr *E);
+ ExprResult VisitObjCMessageExpr(ObjCMessageExpr *E);
- /// Rebuild an expression which simply semantically wraps another
- /// expression which it shares the type and value kind of.
- template <class T> ExprResult rebuildSugarExpr(T *E) {
- ExprResult SubResult = Visit(E->getSubExpr());
- if (SubResult.isInvalid()) return ExprError();
- Expr *SubExpr = SubResult.get();
- E->setSubExpr(SubExpr);
- E->setType(SubExpr->getType());
- E->setValueKind(SubExpr->getValueKind());
- assert(E->getObjectKind() == OK_Ordinary);
- return E;
- }
+ /// Rebuild an expression which simply semantically wraps another
+ /// expression which it shares the type and value kind of.
+ template <class T> ExprResult rebuildSugarExpr(T *E) {
+ ExprResult SubResult = Visit(E->getSubExpr());
+ if (SubResult.isInvalid())
+ return ExprError();
+ Expr *SubExpr = SubResult.get();
+ E->setSubExpr(SubExpr);
+ E->setType(SubExpr->getType());
+ E->setValueKind(SubExpr->getValueKind());
+ assert(E->getObjectKind() == OK_Ordinary);
+ return E;
+ }
- ExprResult VisitParenExpr(ParenExpr *E) {
- return rebuildSugarExpr(E);
- }
+ ExprResult VisitParenExpr(ParenExpr *E) { return rebuildSugarExpr(E); }
- ExprResult VisitUnaryExtension(UnaryOperator *E) {
- return rebuildSugarExpr(E);
- }
+ ExprResult VisitUnaryExtension(UnaryOperator *E) {
+ return rebuildSugarExpr(E);
+ }
- ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
- const PointerType *Ptr = DestType->getAs<PointerType>();
- if (!Ptr) {
- S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof)
+ ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
+ const PointerType *Ptr = DestType->getAs<PointerType>();
+ if (!Ptr) {
+ S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof)
<< E->getSourceRange();
- return ExprError();
- }
+ return ExprError();
+ }
- if (isa<CallExpr>(E->getSubExpr())) {
- S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof_call)
+ if (isa<CallExpr>(E->getSubExpr())) {
+ S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof_call)
<< E->getSourceRange();
- return ExprError();
- }
+ return ExprError();
+ }
- assert(E->isPRValue());
- assert(E->getObjectKind() == OK_Ordinary);
- E->setType(DestType);
+ assert(E->isPRValue());
+ assert(E->getObjectKind() == OK_Ordinary);
+ E->setType(DestType);
- // Build the sub-expression as if it were an object of the pointee type.
- DestType = Ptr->getPointeeType();
- ExprResult SubResult = Visit(E->getSubExpr());
- if (SubResult.isInvalid()) return ExprError();
- E->setSubExpr(SubResult.get());
- return E;
- }
+ // Build the sub-expression as if it were an object of the pointee type.
+ DestType = Ptr->getPointeeType();
+ ExprResult SubResult = Visit(E->getSubExpr());
+ if (SubResult.isInvalid())
+ return ExprError();
+ E->setSubExpr(SubResult.get());
+ return E;
+ }
- ExprResult VisitImplicitCastExpr(ImplicitCastExpr *E);
+ ExprResult VisitImplicitCastExpr(ImplicitCastExpr *E);
- ExprResult resolveDecl(Expr *E, ValueDecl *VD);
+ ExprResult resolveDecl(Expr *E, ValueDecl *VD);
- ExprResult VisitMemberExpr(MemberExpr *E) {
- return resolveDecl(E, E->getMemberDecl());
- }
+ ExprResult VisitMemberExpr(MemberExpr *E) {
+ return resolveDecl(E, E->getMemberDecl());
+ }
- ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
- return resolveDecl(E, E->getDecl());
- }
- };
-}
+ ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
+ return resolveDecl(E, E->getDecl());
+ }
+};
+} // namespace
/// Rebuilds a call expression which yielded __unknown_anytype.
ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *E) {
Expr *CalleeExpr = E->getCallee();
- enum FnKind {
- FK_MemberFunction,
- FK_FunctionPointer,
- FK_BlockPointer
- };
+ enum FnKind { FK_MemberFunction, FK_FunctionPointer, FK_BlockPointer };
FnKind Kind;
QualType CalleeType = CalleeExpr->getType();
@@ -21480,8 +21569,7 @@ ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *E) {
if (Kind == FK_BlockPointer)
diagID = diag::err_block_returning_array_function;
- S.Diag(E->getExprLoc(), diagID)
- << DestType->isFunctionType() << DestType;
+ S.Diag(E->getExprLoc(), diagID) << DestType->isFunctionType() << DestType;
return ExprError();
}
@@ -21524,8 +21612,7 @@ ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *E) {
DestType = S.Context.getFunctionType(DestType, ParamTypes,
Proto->getExtProtoInfo());
} else {
- DestType = S.Context.getFunctionNoProtoType(DestType,
- FnType->getExtInfo());
+ DestType = S.Context.getFunctionNoProtoType(DestType, FnType->getExtInfo());
}
// Rebuild the appropriate pointer-to-function type.
@@ -21545,7 +21632,8 @@ ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *E) {
// Finally, we can recurse.
ExprResult CalleeResult = Visit(CalleeExpr);
- if (!CalleeResult.isUsable()) return ExprError();
+ if (!CalleeResult.isUsable())
+ return ExprError();
E->setCallee(CalleeResult.get());
// Bind a temporary if necessary.
@@ -21556,7 +21644,7 @@ ExprResult RebuildUnknownAnyExpr::VisitObjCMessageExpr(ObjCMessageExpr *E) {
// Verify that this is a legal result type of a call.
if (DestType->isArrayType() || DestType->isFunctionType()) {
S.Diag(E->getExprLoc(), diag::err_func_returning_array_function)
- << DestType->isFunctionType() << DestType;
+ << DestType->isFunctionType() << DestType;
return ExprError();
}
@@ -21585,7 +21673,8 @@ ExprResult RebuildUnknownAnyExpr::VisitImplicitCastExpr(ImplicitCastExpr *E) {
DestType = DestType->castAs<PointerType>()->getPointeeType();
ExprResult Result = Visit(E->getSubExpr());
- if (!Result.isUsable()) return ExprError();
+ if (!Result.isUsable())
+ return ExprError();
E->setSubExpr(Result.get());
return E;
@@ -21601,7 +21690,8 @@ ExprResult RebuildUnknownAnyExpr::VisitImplicitCastExpr(ImplicitCastExpr *E) {
DestType = S.Context.getLValueReferenceType(DestType);
ExprResult Result = Visit(E->getSubExpr());
- if (!Result.isUsable()) return ExprError();
+ if (!Result.isUsable())
+ return ExprError();
E->setSubExpr(Result.get());
return E;
@@ -21621,14 +21711,15 @@ ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {
if (const PointerType *Ptr = Type->getAs<PointerType>()) {
DestType = Ptr->getPointeeType();
ExprResult Result = resolveDecl(E, VD);
- if (Result.isInvalid()) return ExprError();
+ if (Result.isInvalid())
+ return ExprError();
return S.ImpCastExprToType(Result.get(), Type, CK_FunctionToPointerDecay,
VK_PRValue);
}
if (!Type->isFunctionType()) {
S.Diag(E->getExprLoc(), diag::err_unknown_any_function)
- << VD << E->getSourceRange();
+ << VD << E->getSourceRange();
return ExprError();
}
if (const FunctionProtoType *FT = Type->getAs<FunctionProtoType>()) {
@@ -21637,9 +21728,11 @@ ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {
// type. See the lengthy commentary in that routine.
QualType FDT = FD->getType();
const FunctionType *FnType = FDT->castAs<FunctionType>();
- const FunctionProtoType *Proto = dyn_cast_or_null<FunctionProtoType>(FnType);
+ const FunctionProtoType *Proto =
+ dyn_cast_or_null<FunctionProtoType>(FnType);
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
- if (DRE && Proto && Proto->getParamTypes().empty() && Proto->isVariadic()) {
+ if (DRE && Proto && Proto->getParamTypes().empty() &&
+ Proto->isVariadic()) {
SourceLocation Loc = FD->getLocation();
FunctionDecl *NewFD = FunctionDecl::Create(
S.Context, FD->getDeclContext(), Loc, Loc,
@@ -21651,10 +21744,9 @@ ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {
if (FD->getQualifier())
NewFD->setQualifierInfo(FD->getQualifierLoc());
- SmallVector<ParmVarDecl*, 16> Params;
+ SmallVector<ParmVarDecl *, 16> Params;
for (const auto &AI : FT->param_types()) {
- ParmVarDecl *Param =
- S.BuildParmVarDeclForTypedef(FD, Loc, AI);
+ ParmVarDecl *Param = S.BuildParmVarDeclForTypedef(FD, Loc, AI);
Param->setScopeInfo(0, Params.size());
Params.push_back(Param);
}
@@ -21674,20 +21766,20 @@ ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {
if (!S.getLangOpts().CPlusPlus)
ValueKind = VK_PRValue;
- // - variables
+ // - variables
} else if (isa<VarDecl>(VD)) {
if (const ReferenceType *RefTy = Type->getAs<ReferenceType>()) {
Type = RefTy->getPointeeType();
} else if (Type->isFunctionType()) {
S.Diag(E->getExprLoc(), diag::err_unknown_any_var_function_type)
- << VD << E->getSourceRange();
+ << VD << E->getSourceRange();
return ExprError();
}
- // - nothing else
+ // - nothing else
} else {
S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_decl)
- << VD << E->getSourceRange();
+ << VD << E->getSourceRange();
return ExprError();
}
@@ -21710,7 +21802,8 @@ ExprResult Sema::checkUnknownAnyCast(SourceRange TypeRange, QualType CastType,
// Rewrite the casted expression from scratch.
ExprResult result = RebuildUnknownAnyExpr(*this, CastType).Visit(CastExpr);
- if (!result.isUsable()) return ExprError();
+ if (!result.isUsable())
+ return ExprError();
CastExpr = result.get();
VK = CastExpr->getValueKind();
@@ -21723,14 +21816,15 @@ ExprResult Sema::forceUnknownAnyToType(Expr *E, QualType ToType) {
return RebuildUnknownAnyExpr(*this, ToType).Visit(E);
}
-ExprResult Sema::checkUnknownAnyArg(SourceLocation callLoc,
- Expr *arg, QualType ¶mType) {
+ExprResult Sema::checkUnknownAnyArg(SourceLocation callLoc, Expr *arg,
+ QualType ¶mType) {
// If the syntactic form of the argument is not an explicit cast of
// any sort, just do default argument promotion.
ExplicitCastExpr *castArg = dyn_cast<ExplicitCastExpr>(arg->IgnoreParens());
if (!castArg) {
ExprResult result = DefaultArgumentPromotion(arg);
- if (result.isInvalid()) return ExprError();
+ if (result.isInvalid())
+ return ExprError();
paramType = result.get()->getType();
return result;
}
@@ -21741,8 +21835,8 @@ ExprResult Sema::checkUnknownAnyArg(SourceLocation callLoc,
// Copy-initialize a parameter of that type.
InitializedEntity entity =
- InitializedEntity::InitializeParameter(Context, paramType,
- /*consumed*/ false);
+ InitializedEntity::InitializeParameter(Context, paramType,
+ /*consumed*/ false);
return PerformCopyInitialization(entity, callLoc, arg);
}
@@ -21773,13 +21867,13 @@ static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E) {
d = msg->getMethodDecl();
if (!d) {
S.Diag(loc, diag::err_uncasted_send_to_unknown_any_method)
- << static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector()
- << orig->getSourceRange();
+ << static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector()
+ << orig->getSourceRange();
return ExprError();
}
} else {
S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr)
- << E->getSourceRange();
+ << E->getSourceRange();
return ExprError();
}
@@ -21791,7 +21885,8 @@ static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E) {
ExprResult Sema::CheckPlaceholderExpr(Expr *E) {
const BuiltinType *placeholderType = E->getType()->getAsPlaceholderType();
- if (!placeholderType) return E;
+ if (!placeholderType)
+ return E;
switch (placeholderType->getKind()) {
case BuiltinType::UnresolvedTemplate: {
@@ -21972,18 +22067,15 @@ ExprResult Sema::CheckPlaceholderExpr(Expr *E) {
case BuiltinType::OMPIterator:
return ExprError(Diag(E->getBeginLoc(), diag::err_omp_iterator_use));
- // Everything else should be impossible.
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ // Everything else should be impossible.
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id:
#include "clang/Basic/OpenCLImageTypes.def"
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
- case BuiltinType::Id:
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
#include "clang/Basic/OpenCLExtensionTypes.def"
-#define SVE_TYPE(Name, Id, SingletonId) \
- case BuiltinType::Id:
+#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
#include "clang/Basic/AArch64ACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) \
- case BuiltinType::Id:
+#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
#include "clang/Basic/PPCTypes.def"
#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
#include "clang/Basic/RISCVVTypes.def"
diff --git a/clang/test/SemaCXX/array-compare-template.cpp b/clang/test/SemaCXX/array-compare-template.cpp
new file mode 100644
index 0000000000000..68bb1c75d2823
--- /dev/null
+++ b/clang/test/SemaCXX/array-compare-template.cpp
@@ -0,0 +1,8 @@
+// RUN: %clang_cc1 -std=c++26 -pedantic-errors -fsyntax-only -verify %s
+
+int main() {
+ int a[1]{}, b[1]{};
+ [](const auto &x, const auto &y) {
+ return x == y; // expected-error {{comparison between two arrays is ill-formed in C++26}}
+ }(a, b);
+}
>From 7727138792b14aa332315b99b91ee7b048682749 Mon Sep 17 00:00:00 2001
From: PrabbyDD <dhaliprabh at gmail.com>
Date: Fri, 10 Apr 2026 14:14:44 -0700
Subject: [PATCH 2/6] Undoing previous formatting changes on the entire file
and adding note in Release Notes.
---
clang/docs/ReleaseNotes.rst | 2 +-
clang/lib/Sema/SemaExpr.cpp | 2528 +++++++++++++++++------------------
2 files changed, 1219 insertions(+), 1311 deletions(-)
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 1601be699a604..5c3dc00509bd2 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -374,7 +374,7 @@ Bug Fixes in This Version
-------------------------
- Fixed atomic boolean compound assignment; the conversion back to atomic bool would be miscompiled. (#GH33210)
-
+- Clang now rejects array comparisons done within lambda functions and and templates (GH#190756)
- Fixed a failed assertion in the preprocessor when ``__has_embed`` parameters are missing parentheses. (#GH175088)
- Fix lifetime extension of temporaries in for-range-initializers in templates. (#GH165182)
- Fixed a preprocessor crash in ``__has_cpp_attribute`` on incomplete scoped attributes. (#GH178098)
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index ef67a26a588ab..9fd8c6a0a5451 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -141,7 +141,7 @@ void Sema::NoteDeletedFunction(FunctionDecl *Decl) {
return NoteDeletedInheritingConstructor(Ctor);
Diag(Decl->getLocation(), diag::note_availability_specified_here)
- << Decl << 1;
+ << Decl << 1;
}
/// Determine whether a FunctionDecl was ever declared with an
@@ -219,7 +219,7 @@ void Sema::MaybeSuggestAddingStaticToDecl(const FunctionDecl *Cur) {
if (!hasAnyExplicitStorageClass(First)) {
SourceLocation DeclBegin = First->getSourceRange().getBegin();
Diag(DeclBegin, diag::note_convert_inline_to_static)
- << Cur << FixItHint::CreateInsertion(DeclBegin, "static ");
+ << Cur << FixItHint::CreateInsertion(DeclBegin, "static ");
}
}
@@ -258,7 +258,7 @@ bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
if (ParsingInitForAutoVars.count(D)) {
if (isa<BindingDecl>(D)) {
Diag(Loc, diag::err_binding_cannot_appear_in_own_initializer)
- << D->getDeclName();
+ << D->getDeclName();
} else {
Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer)
<< diag::ParsingInitFor::Var << D->getDeclName()
@@ -300,7 +300,8 @@ bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
// constraint expression, for example)
return true;
if (!Satisfaction.IsSatisfied) {
- Diag(Loc, diag::err_reference_to_function_with_unsatisfied_constraints)
+ Diag(Loc,
+ diag::err_reference_to_function_with_unsatisfied_constraints)
<< D;
DiagnoseUnsatisfiedConstraint(Satisfaction);
return true;
@@ -315,6 +316,7 @@ bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
if (getLangOpts().CUDA && !CUDA().CheckCall(Loc, FD))
return true;
+
}
if (auto *Concept = dyn_cast<ConceptDecl>(D);
@@ -328,12 +330,12 @@ bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
cast<CXXConstructorDecl>(MD)->isDefaultConstructor()) ||
MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())) {
Diag(Loc, diag::warn_cxx17_compat_lambda_def_ctor_assign)
- << !isa<CXXConstructorDecl>(MD);
+ << !isa<CXXConstructorDecl>(MD);
}
}
- auto getReferencedObjCProp =
- [](const NamedDecl *D) -> const ObjCPropertyDecl * {
+ auto getReferencedObjCProp = [](const NamedDecl *D) ->
+ const ObjCPropertyDecl * {
if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
return MD->findPropertyDecl();
return nullptr;
@@ -342,7 +344,7 @@ bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
if (diagnoseArgIndependentDiagnoseIfAttrs(ObjCPDecl, Loc))
return true;
} else if (diagnoseArgIndependentDiagnoseIfAttrs(D, Loc)) {
- return true;
+ return true;
}
// [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions
@@ -519,8 +521,7 @@ ExprResult Sema::DefaultFunctionArrayConversion(Expr *E, bool Diagnose) {
// Handle any placeholder expressions which made it here.
if (E->hasPlaceholderType()) {
ExprResult result = CheckPlaceholderExpr(E);
- if (result.isInvalid())
- return ExprError();
+ if (result.isInvalid()) return ExprError();
E = result.get();
}
@@ -534,8 +535,7 @@ ExprResult Sema::DefaultFunctionArrayConversion(Expr *E, bool Diagnose) {
return ExprError();
E = ImpCastExprToType(E, Context.getPointerType(Ty),
- CK_FunctionToPointerDecay)
- .get();
+ CK_FunctionToPointerDecay).get();
} else if (Ty->isArrayType()) {
// In C90 mode, arrays only promote to pointers if the array expression is
// an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has
@@ -585,7 +585,8 @@ static void CheckForNullPointerDereference(Sema &S, Expr *E) {
}
static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE,
- SourceLocation AssignLoc, const Expr *RHS) {
+ SourceLocation AssignLoc,
+ const Expr* RHS) {
const ObjCIvarDecl *IV = OIRE->getDecl();
if (!IV)
return;
@@ -603,12 +604,13 @@ static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE,
if (ObjCInterfaceDecl *IDecl = OTy->getInterface()) {
ObjCInterfaceDecl *ClassDeclared = nullptr;
ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
- if (!ClassDeclared->getSuperClass() &&
- (*ClassDeclared->ivar_begin()) == IV) {
+ if (!ClassDeclared->getSuperClass()
+ && (*ClassDeclared->ivar_begin()) == IV) {
if (RHS) {
- NamedDecl *ObjectSetClass = S.LookupSingleName(
- S.TUScope, &S.Context.Idents.get("object_setClass"),
- SourceLocation(), S.LookupOrdinaryName);
+ NamedDecl *ObjectSetClass =
+ S.LookupSingleName(S.TUScope,
+ &S.Context.Idents.get("object_setClass"),
+ SourceLocation(), S.LookupOrdinaryName);
if (ObjectSetClass) {
SourceLocation RHSLocEnd = S.getLocForEndOfToken(RHS->getEndLoc());
S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_assign)
@@ -617,12 +619,14 @@ static void DiagnoseDirectIsaAccess(Sema &S, const ObjCIvarRefExpr *OIRE,
<< FixItHint::CreateReplacement(
SourceRange(OIRE->getOpLoc(), AssignLoc), ",")
<< FixItHint::CreateInsertion(RHSLocEnd, ")");
- } else
+ }
+ else
S.Diag(OIRE->getLocation(), diag::warn_objc_isa_assign);
} else {
- NamedDecl *ObjectGetClass = S.LookupSingleName(
- S.TUScope, &S.Context.Idents.get("object_getClass"),
- SourceLocation(), S.LookupOrdinaryName);
+ NamedDecl *ObjectGetClass =
+ S.LookupSingleName(S.TUScope,
+ &S.Context.Idents.get("object_getClass"),
+ SourceLocation(), S.LookupOrdinaryName);
if (ObjectGetClass)
S.Diag(OIRE->getExprLoc(), diag::warn_objc_isa_use)
<< FixItHint::CreateInsertion(OIRE->getBeginLoc(),
@@ -641,16 +645,14 @@ ExprResult Sema::DefaultLvalueConversion(Expr *E) {
// Handle any placeholder expressions which made it here.
if (E->hasPlaceholderType()) {
ExprResult result = CheckPlaceholderExpr(E);
- if (result.isInvalid())
- return ExprError();
+ if (result.isInvalid()) return ExprError();
E = result.get();
}
// C++ [conv.lval]p1:
// A glvalue of a non-function, non-array type T can be
// converted to a prvalue.
- if (!E->isGLValue())
- return E;
+ if (!E->isGLValue()) return E;
QualType T = E->getType();
assert(!T.isNull() && "r-value conversion on typeless expression?");
@@ -681,15 +683,16 @@ ExprResult Sema::DefaultLvalueConversion(Expr *E) {
if (getLangOpts().OpenCL &&
!getOpenCLOptions().isAvailableOption("cl_khr_fp16", getLangOpts()) &&
T->isHalfType()) {
- Diag(E->getExprLoc(), diag::err_opencl_half_load_store) << 0 << T;
+ Diag(E->getExprLoc(), diag::err_opencl_half_load_store)
+ << 0 << T;
return ExprError();
}
CheckForNullPointerDereference(*this, E);
if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(E->IgnoreParenCasts())) {
- NamedDecl *ObjectGetClass =
- LookupSingleName(TUScope, &Context.Idents.get("object_getClass"),
- SourceLocation(), LookupOrdinaryName);
+ NamedDecl *ObjectGetClass = LookupSingleName(TUScope,
+ &Context.Idents.get("object_getClass"),
+ SourceLocation(), LookupOrdinaryName);
if (ObjectGetClass)
Diag(E->getExprLoc(), diag::warn_objc_isa_use)
<< FixItHint::CreateInsertion(OISA->getBeginLoc(), "object_getClass(")
@@ -697,9 +700,10 @@ ExprResult Sema::DefaultLvalueConversion(Expr *E) {
SourceRange(OISA->getOpLoc(), OISA->getIsaMemberLoc()), ")");
else
Diag(E->getExprLoc(), diag::warn_objc_isa_use);
- } else if (const ObjCIvarRefExpr *OIRE =
- dyn_cast<ObjCIvarRefExpr>(E->IgnoreParenCasts()))
- DiagnoseDirectIsaAccess(*this, OIRE, SourceLocation(), /* Expr*/ nullptr);
+ }
+ else if (const ObjCIvarRefExpr *OIRE =
+ dyn_cast<ObjCIvarRefExpr>(E->IgnoreParenCasts()))
+ DiagnoseDirectIsaAccess(*this, OIRE, SourceLocation(), /* Expr*/nullptr);
// C++ [conv.lval]p1:
// [...] If T is a non-class type, the type of the prvalue is the
@@ -723,8 +727,8 @@ ExprResult Sema::DefaultLvalueConversion(Expr *E) {
return Res;
E = Res.get();
- // Loading a __weak object implicitly retains the value, so we need a cleanup
- // to balance that.
+ // Loading a __weak object implicitly retains the value, so we need a cleanup to
+ // balance that.
if (E->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
Cleanup.setExprNeedsCleanups(true);
@@ -933,8 +937,8 @@ ExprResult Sema::DefaultArgumentPromotion(Expr *E) {
// potentially potentially evaluated contexts.
if (getLangOpts().CPlusPlus && E->isGLValue() && !isUnevaluatedContext()) {
ExprResult Temp = PerformCopyInitialization(
- InitializedEntity::InitializeTemporary(E->getType()), E->getExprLoc(),
- E);
+ InitializedEntity::InitializeTemporary(E->getType()),
+ E->getExprLoc(), E);
if (Temp.isInvalid())
return ExprError();
E = Temp.get();
@@ -1130,10 +1134,8 @@ static bool handleComplexIntegerToFloatConversion(Sema &S, ExprResult &IntExpr,
QualType IntTy,
QualType ComplexTy,
bool SkipCast) {
- if (IntTy->isComplexType() || IntTy->isRealFloatingType())
- return true;
- if (SkipCast)
- return false;
+ if (IntTy->isComplexType() || IntTy->isRealFloatingType()) return true;
+ if (SkipCast) return false;
if (IntTy->isIntegerType()) {
QualType fpTy = ComplexTy->castAs<ComplexType>()->getElementType();
IntExpr = S.ImpCastExprToType(IntExpr.get(), fpTy, CK_IntegralToFloating);
@@ -1209,8 +1211,8 @@ static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr,
if (IntTy->isIntegerType()) {
if (ConvertInt)
// Convert intExpr to the lhs floating point type.
- IntExpr =
- S.ImpCastExprToType(IntExpr.get(), FloatTy, CK_IntegralToFloating);
+ IntExpr = S.ImpCastExprToType(IntExpr.get(), FloatTy,
+ CK_IntegralToFloating);
return FloatTy;
}
@@ -1225,17 +1227,17 @@ static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr,
// float -> _Complex float
if (ConvertFloat)
- FloatExpr =
- S.ImpCastExprToType(FloatExpr.get(), result, CK_FloatingRealToComplex);
+ FloatExpr = S.ImpCastExprToType(FloatExpr.get(), result,
+ CK_FloatingRealToComplex);
return result;
}
/// Handle arithmethic conversion with floating point types. Helper
/// function of UsualArithmeticConversions()
-static QualType handleFloatConversion(Sema &S, ExprResult &LHS, ExprResult &RHS,
- QualType LHSType, QualType RHSType,
- bool IsCompAssign) {
+static QualType handleFloatConversion(Sema &S, ExprResult &LHS,
+ ExprResult &RHS, QualType LHSType,
+ QualType RHSType, bool IsCompAssign) {
bool LHSFloat = LHSType->isRealFloatingType();
bool RHSFloat = RHSType->isRealFloatingType();
@@ -1272,11 +1274,11 @@ static QualType handleFloatConversion(Sema &S, ExprResult &LHS, ExprResult &RHS,
return handleIntToFloatConversion(S, LHS, RHS, LHSType, RHSType,
/*ConvertFloat=*/!IsCompAssign,
- /*ConvertInt=*/true);
+ /*ConvertInt=*/ true);
}
assert(RHSFloat);
return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType,
- /*ConvertFloat=*/true,
+ /*ConvertFloat=*/ true,
/*ConvertInt=*/!IsCompAssign);
}
@@ -1321,7 +1323,7 @@ ExprResult doComplexIntegralCast(Sema &S, Expr *op, QualType toType) {
return S.ImpCastExprToType(op, S.Context.getComplexType(toType),
CK_IntegralComplexCast);
}
-} // namespace
+}
/// Handle integer arithmetic conversions. Helper function of
/// UsualArithmeticConversions()
@@ -1366,7 +1368,7 @@ static QualType handleIntegerConversion(Sema &S, ExprResult &LHS,
// on most 32-bit systems). Use the unsigned type corresponding
// to the signed type.
QualType result =
- S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType);
+ S.Context.getCorrespondingUnsignedType(LHSSigned ? LHSType : RHSType);
RHS = (*doRHSCast)(S, RHS.get(), result);
if (!IsCompAssign)
LHS = (*doLHSCast)(S, LHS.get(), result);
@@ -1387,8 +1389,8 @@ static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS,
QualType LHSEltType = LHSComplexInt->getElementType();
QualType RHSEltType = RHSComplexInt->getElementType();
QualType ScalarType =
- handleIntegerConversion<doComplexIntegralCast, doComplexIntegralCast>(
- S, LHS, RHS, LHSEltType, RHSEltType, IsCompAssign);
+ handleIntegerConversion<doComplexIntegralCast, doComplexIntegralCast>
+ (S, LHS, RHS, LHSEltType, RHSEltType, IsCompAssign);
return S.Context.getComplexType(ScalarType);
}
@@ -1396,10 +1398,11 @@ static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS,
if (LHSComplexInt) {
QualType LHSEltType = LHSComplexInt->getElementType();
QualType ScalarType =
- handleIntegerConversion<doComplexIntegralCast, doIntegralCast>(
- S, LHS, RHS, LHSEltType, RHSType, IsCompAssign);
+ handleIntegerConversion<doComplexIntegralCast, doIntegralCast>
+ (S, LHS, RHS, LHSEltType, RHSType, IsCompAssign);
QualType ComplexType = S.Context.getComplexType(ScalarType);
- RHS = S.ImpCastExprToType(RHS.get(), ComplexType, CK_IntegralRealToComplex);
+ RHS = S.ImpCastExprToType(RHS.get(), ComplexType,
+ CK_IntegralRealToComplex);
return ComplexType;
}
@@ -1408,12 +1411,13 @@ static QualType handleComplexIntConversion(Sema &S, ExprResult &LHS,
QualType RHSEltType = RHSComplexInt->getElementType();
QualType ScalarType =
- handleIntegerConversion<doIntegralCast, doComplexIntegralCast>(
- S, LHS, RHS, LHSType, RHSEltType, IsCompAssign);
+ handleIntegerConversion<doIntegralCast, doComplexIntegralCast>
+ (S, LHS, RHS, LHSType, RHSEltType, IsCompAssign);
QualType ComplexType = S.Context.getComplexType(ScalarType);
if (!IsCompAssign)
- LHS = S.ImpCastExprToType(LHS.get(), ComplexType, CK_IntegralRealToComplex);
+ LHS = S.ImpCastExprToType(LHS.get(), ComplexType,
+ CK_IntegralRealToComplex);
return ComplexType;
}
@@ -1784,6 +1788,7 @@ QualType Sema::UsualArithmeticConversions(ExprResult &LHS, ExprResult &RHS,
// Semantic Analysis for various Expression Types
//===----------------------------------------------------------------------===//
+
ExprResult Sema::ActOnGenericSelectionExpr(
SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc,
bool PredicateIsExpr, void *ControllingExprOrType,
@@ -1791,10 +1796,10 @@ ExprResult Sema::ActOnGenericSelectionExpr(
unsigned NumAssocs = ArgTypes.size();
assert(NumAssocs == ArgExprs.size());
- TypeSourceInfo **Types = new TypeSourceInfo *[NumAssocs];
+ TypeSourceInfo **Types = new TypeSourceInfo*[NumAssocs];
for (unsigned i = 0; i < NumAssocs; ++i) {
if (ArgTypes[i])
- (void)GetTypeFromParser(ArgTypes[i], &Types[i]);
+ (void) GetTypeFromParser(ArgTypes[i], &Types[i]);
else
Types[i] = nullptr;
}
@@ -1812,7 +1817,7 @@ ExprResult Sema::ActOnGenericSelectionExpr(
ExprResult ER = CreateGenericSelectionExpr(
KeyLoc, DefaultLoc, RParenLoc, PredicateIsExpr, ControllingExprOrType,
llvm::ArrayRef(Types, NumAssocs), ArgExprs);
- delete[] Types;
+ delete [] Types;
return ER;
}
@@ -1961,17 +1966,19 @@ ExprResult Sema::CreateGenericSelectionExpr(
// C11 6.5.1.1p2 "No two generic associations in the same generic
// selection shall specify compatible types."
- for (unsigned j = i + 1; j < NumAssocs; ++j)
+ for (unsigned j = i+1; j < NumAssocs; ++j)
if (Types[j] && !Types[j]->getType()->isDependentType() &&
areTypesCompatibleForGeneric(Context, Types[i]->getType(),
Types[j]->getType())) {
Diag(Types[j]->getTypeLoc().getBeginLoc(),
diag::err_assoc_compatible_types)
- << Types[j]->getTypeLoc().getSourceRange()
- << Types[j]->getType() << Types[i]->getType();
- Diag(Types[i]->getTypeLoc().getBeginLoc(), diag::note_compat_assoc)
- << Types[i]->getTypeLoc().getSourceRange()
- << Types[i]->getType();
+ << Types[j]->getTypeLoc().getSourceRange()
+ << Types[j]->getType()
+ << Types[i]->getType();
+ Diag(Types[i]->getTypeLoc().getBeginLoc(),
+ diag::note_compat_assoc)
+ << Types[i]->getTypeLoc().getSourceRange()
+ << Types[i]->getType();
TypeErrorFound = true;
}
}
@@ -2040,8 +2047,10 @@ ExprResult Sema::CreateGenericSelectionExpr(
Diag(SR.getBegin(), diag::err_generic_sel_multi_match)
<< SR << P.second << (unsigned)CompatIndices.size();
for (unsigned I : CompatIndices) {
- Diag(Types[I]->getTypeLoc().getBeginLoc(), diag::note_compat_assoc)
- << Types[I]->getTypeLoc().getSourceRange() << Types[I]->getType();
+ Diag(Types[I]->getTypeLoc().getBeginLoc(),
+ diag::note_compat_assoc)
+ << Types[I]->getTypeLoc().getSourceRange()
+ << Types[I]->getType();
}
return ExprError();
}
@@ -2062,7 +2071,8 @@ ExprResult Sema::CreateGenericSelectionExpr(
// then the result expression of the generic selection is the expression
// in that generic association. Otherwise, the result expression of the
// generic selection is the expression in the default generic association."
- unsigned ResultIndex = CompatIndices.size() ? CompatIndices[0] : DefaultIndex;
+ unsigned ResultIndex =
+ CompatIndices.size() ? CompatIndices[0] : DefaultIndex;
if (ControllingExpr) {
return GenericSelectionExpr::Create(
@@ -2117,7 +2127,7 @@ static SourceLocation getUDSuffixLoc(Sema &S, SourceLocation TokLoc,
static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope,
IdentifierInfo *UDSuffix,
SourceLocation UDSuffixLoc,
- ArrayRef<Expr *> Args,
+ ArrayRef<Expr*> Args,
SourceLocation LitEndLoc) {
assert(Args.size() <= 2 && "too many arguments for literal operator");
@@ -2129,7 +2139,7 @@ static ExprResult BuildCookedLiteralOperatorCall(Sema &S, Scope *Scope,
}
DeclarationName OpName =
- S.Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
+ S.Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
@@ -2221,8 +2231,8 @@ Sema::ExpandFunctionLocalPredefinedMacros(ArrayRef<Token> Toks) {
return ExpandedToks;
}
-ExprResult Sema::ActOnStringLiteral(ArrayRef<Token> StringToks,
- Scope *UDLScope) {
+ExprResult
+Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) {
assert(!StringToks.empty() && "Must have at least one string!");
// StringToks needs backing storage as it doesn't hold array elements itself
@@ -2302,8 +2312,8 @@ ExprResult Sema::ActOnStringLiteral(ArrayRef<Token> StringToks,
// We're building a user-defined literal.
IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
SourceLocation UDSuffixLoc =
- getUDSuffixLoc(*this, StringTokLocs[Literal.getUDSuffixToken()],
- Literal.getUDSuffixOffset());
+ getUDSuffixLoc(*this, StringTokLocs[Literal.getUDSuffixToken()],
+ Literal.getUDSuffixOffset());
// Make sure we're allowed user-defined literals here.
if (!UDLScope)
@@ -2314,11 +2324,13 @@ ExprResult Sema::ActOnStringLiteral(ArrayRef<Token> StringToks,
QualType SizeType = Context.getSizeType();
DeclarationName OpName =
- Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
+ Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
- QualType ArgTy[] = {Context.getArrayDecayedType(StrTy), SizeType};
+ QualType ArgTy[] = {
+ Context.getArrayDecayedType(StrTy), SizeType
+ };
LookupResult R(*this, OpName, UDSuffixLoc, LookupOrdinaryName);
switch (LookupLiteralOperator(UDLScope, R, ArgTy,
@@ -2328,9 +2340,9 @@ ExprResult Sema::ActOnStringLiteral(ArrayRef<Token> StringToks,
case LOLR_Cooked: {
llvm::APInt Len(Context.getIntWidth(SizeType), Literal.GetNumStringChars());
- IntegerLiteral *LenArg =
- IntegerLiteral::Create(Context, Len, SizeType, StringTokLocs[0]);
- Expr *Args[] = {Lit, LenArg};
+ IntegerLiteral *LenArg = IntegerLiteral::Create(Context, Len, SizeType,
+ StringTokLocs[0]);
+ Expr *Args[] = { Lit, LenArg };
return BuildLiteralOperatorCall(R, OpNameInfo, Args, StringTokLocs.back());
}
@@ -2352,8 +2364,7 @@ ExprResult Sema::ActOnStringLiteral(ArrayRef<Token> StringToks,
llvm::APSInt Value(CharBits, CharIsUnsigned);
TemplateArgument TypeArg(CharTy);
- TemplateArgumentLocInfo TypeArgInfo(
- Context.getTrivialTypeSourceInfo(CharTy));
+ TemplateArgumentLocInfo TypeArgInfo(Context.getTrivialTypeSourceInfo(CharTy));
ExplicitArgs.addArgument(TemplateArgumentLoc(TypeArg, TypeArgInfo));
SourceLocation Loc = StringTokLocs.back();
@@ -2374,9 +2385,10 @@ ExprResult Sema::ActOnStringLiteral(ArrayRef<Token> StringToks,
llvm_unreachable("unexpected literal operator lookup result");
}
-DeclRefExpr *Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
- SourceLocation Loc,
- const CXXScopeSpec *SS) {
+DeclRefExpr *
+Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
+ SourceLocation Loc,
+ const CXXScopeSpec *SS) {
DeclarationNameInfo NameInfo(D->getDeclName(), Loc);
return BuildDeclRefExpr(D, Ty, VK, NameInfo, SS);
}
@@ -2507,10 +2519,11 @@ Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
return E;
}
-void Sema::DecomposeUnqualifiedId(
- const UnqualifiedId &Id, TemplateArgumentListInfo &Buffer,
- DeclarationNameInfo &NameInfo,
- const TemplateArgumentListInfo *&TemplateArgs) {
+void
+Sema::DecomposeUnqualifiedId(const UnqualifiedId &Id,
+ TemplateArgumentListInfo &Buffer,
+ DeclarationNameInfo &NameInfo,
+ const TemplateArgumentListInfo *&TemplateArgs) {
if (Id.getKind() == UnqualifiedIdKind::IK_TemplateId) {
Buffer.setLAngleLoc(Id.TemplateId->LAngleLoc);
Buffer.setRAngleLoc(Id.TemplateId->RAngleLoc);
@@ -2667,14 +2680,15 @@ bool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
OverloadCandidateSet::CSK_Normal);
OverloadCandidateSet::iterator Best;
for (NamedDecl *CD : Corrected) {
- if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(CD))
- AddTemplateOverloadCandidate(FTD,
- DeclAccessPair::make(FTD, AS_none),
- ExplicitTemplateArgs, Args, OCS);
+ if (FunctionTemplateDecl *FTD =
+ dyn_cast<FunctionTemplateDecl>(CD))
+ AddTemplateOverloadCandidate(
+ FTD, DeclAccessPair::make(FTD, AS_none), ExplicitTemplateArgs,
+ Args, OCS);
else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(CD))
if (!ExplicitTemplateArgs || ExplicitTemplateArgs->size() == 0)
- AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none), Args,
- OCS);
+ AddOverloadCandidate(FD, DeclAccessPair::make(FD, AS_none),
+ Args, OCS);
}
switch (OCS.BestViableFunction(*this, R.getNameLoc(), Best)) {
case OR_Success:
@@ -2692,8 +2706,8 @@ bool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
CXXRecordDecl *Record =
Corrected.getCorrectionSpecifier().getAsRecordDecl();
if (!Record)
- Record =
- cast<CXXRecordDecl>(ND->getDeclContext()->getRedeclContext());
+ Record = cast<CXXRecordDecl>(
+ ND->getDeclContext()->getRedeclContext());
R.setNamingClass(Record);
}
@@ -2800,13 +2814,12 @@ recoverFromMSUnqualifiedLookup(Sema &S, ASTContext &Context,
TemplateArgs);
}
-ExprResult Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
- SourceLocation TemplateKWLoc,
- UnqualifiedId &Id, bool HasTrailingLParen,
- bool IsAddressOfOperand,
- CorrectionCandidateCallback *CCC,
- bool IsInlineAsmIdentifier,
- Token *KeywordReplacement) {
+ExprResult
+Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
+ SourceLocation TemplateKWLoc, UnqualifiedId &Id,
+ bool HasTrailingLParen, bool IsAddressOfOperand,
+ CorrectionCandidateCallback *CCC,
+ bool IsInlineAsmIdentifier, Token *KeywordReplacement) {
assert(!(IsAddressOfOperand && HasTrailingLParen) &&
"cannot be direct & operand and have a trailing lparen");
if (SS.isInvalid())
@@ -2897,8 +2910,7 @@ ExprResult Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
if (R.empty() && HasTrailingLParen && II &&
getLangOpts().implicitFunctionsAllowed()) {
NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *II, S);
- if (D)
- R.addDecl(D);
+ if (D) R.addDecl(D);
}
// Determine whether this name might be a candidate for
@@ -3024,7 +3036,7 @@ ExprResult Sema::BuildQualifiedDeclarationNameExpr(
if (CD->isInvalidDecl() || CD->isBeingDefined())
return ExprError();
Diag(NameInfo.getLoc(), diag::err_no_member)
- << NameInfo.getName() << DC << SS.getRange();
+ << NameInfo.getName() << DC << SS.getRange();
return ExprError();
}
@@ -3189,15 +3201,14 @@ ExprResult Sema::PerformObjectMemberConversion(Expr *From,
// Otherwise build the appropriate casts.
if (IsDerivedFrom(FromLoc, FromRecordType, QRecordType)) {
CXXCastPath BasePath;
- if (CheckDerivedToBaseConversion(FromRecordType, QRecordType, FromLoc,
- FromRange, &BasePath))
+ if (CheckDerivedToBaseConversion(FromRecordType, QRecordType,
+ FromLoc, FromRange, &BasePath))
return ExprError();
if (PointerConversions)
QType = Context.getPointerType(QType);
- From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase, VK,
- &BasePath)
- .get();
+ From = ImpCastExprToType(From, QType, CK_UncheckedDerivedToBase,
+ VK, &BasePath).get();
FromType = QType;
FromRecordType = QRecordType;
@@ -3210,8 +3221,8 @@ ExprResult Sema::PerformObjectMemberConversion(Expr *From,
}
CXXCastPath BasePath;
- if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType, FromLoc,
- FromRange, &BasePath,
+ if (CheckDerivedToBaseConversion(FromRecordType, DestRecordType,
+ FromLoc, FromRange, &BasePath,
/*IgnoreAccess=*/true))
return ExprError();
@@ -3277,6 +3288,7 @@ bool Sema::UseArgumentDependentLookup(const CXXScopeSpec &SS,
return true;
}
+
/// Diagnoses obvious problems with the use of the given declaration
/// as an expression. This is only actually called for lookups that
/// were not overloaded, and it doesn't promise that the declaration
@@ -3682,7 +3694,7 @@ ExprResult Sema::ActOnCharacterConstant(const Token &Tok, Scope *UDLScope) {
else if (Literal.isUTF32())
Ty = Context.Char32Ty; // U'x' -> char32_t in C11 and C++11.
else if (!getLangOpts().CPlusPlus || Literal.isMultiChar())
- Ty = Context.IntTy; // 'x' -> int in C, 'wxyz' -> int in C++.
+ Ty = Context.IntTy; // 'x' -> int in C, 'wxyz' -> int in C++.
else
Ty = Context.CharTy; // 'x' -> char in C++;
// u8'x' -> char in C11-C17 and in C++ without char8_t.
@@ -3697,8 +3709,8 @@ ExprResult Sema::ActOnCharacterConstant(const Token &Tok, Scope *UDLScope) {
else if (Literal.isUTF8())
Kind = CharacterLiteralKind::UTF8;
- Expr *Lit = new (Context)
- CharacterLiteral(Literal.getValue(), Kind, Ty, Tok.getLocation());
+ Expr *Lit = new (Context) CharacterLiteral(Literal.getValue(), Kind, Ty,
+ Tok.getLocation());
if (Literal.getUDSuffix().empty())
return Lit;
@@ -3706,7 +3718,7 @@ ExprResult Sema::ActOnCharacterConstant(const Token &Tok, Scope *UDLScope) {
// We're building a user-defined literal.
IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
SourceLocation UDSuffixLoc =
- getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());
+ getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());
// Make sure we're allowed user-defined literals here.
if (!UDLScope)
@@ -3823,7 +3835,7 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
// We're building a user-defined literal.
const IdentifierInfo *UDSuffix = &Context.Idents.get(Literal.getUDSuffix());
SourceLocation UDSuffixLoc =
- getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());
+ getUDSuffixLoc(*this, Tok.getLocation(), Literal.getUDSuffixOffset());
// Make sure we're allowed user-defined literals here.
if (!UDLScope)
@@ -3843,7 +3855,7 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
}
DeclarationName OpName =
- Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
+ Context.DeclarationNames.getCXXLiteralOperatorName(UDSuffix);
DeclarationNameInfo OpNameInfo(OpName, UDSuffixLoc);
OpNameInfo.setCXXLiteralOperatorNameLoc(UDSuffixLoc);
@@ -3937,8 +3949,7 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
}
}
- if (Literal.isUnsigned)
- Ty = Context.getCorrespondingUnsignedType(Ty);
+ if (Literal.isUnsigned) Ty = Context.getCorrespondingUnsignedType(Ty);
bool isSigned = !Literal.isUnsigned;
unsigned scale = Context.getFixedPointScale(Ty);
@@ -3962,7 +3973,7 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
Tok.getLocation(), scale);
} else if (Literal.isFloatingLiteral()) {
QualType Ty;
- if (Literal.isHalf) {
+ if (Literal.isHalf){
if (getLangOpts().HLSL ||
getOpenCLOptions().isAvailableOption("cl_khr_fp16", getLangOpts()))
Ty = Context.HalfTy;
@@ -4134,7 +4145,7 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
// Does it fit in a unsigned int?
if (ResultVal.isIntN(IntSize)) {
// Does it fit in a signed int?
- if (!Literal.isUnsigned && ResultVal[IntSize - 1] == 0)
+ if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0)
Ty = Context.IntTy;
else if (AllowUnsigned)
Ty = Context.UnsignedIntTy;
@@ -4149,7 +4160,7 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
// Does it fit in a unsigned long?
if (ResultVal.isIntN(LongSize)) {
// Does it fit in a signed long?
- if (!Literal.isUnsigned && ResultVal[LongSize - 1] == 0)
+ if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0)
Ty = Context.LongTy;
else if (AllowUnsigned)
Ty = Context.UnsignedLongTy;
@@ -4182,9 +4193,8 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
// Does it fit in a signed long long?
// To be compatible with MSVC, hex integer literals ending with the
// LL or i64 suffix are always signed in Microsoft mode.
- if (!Literal.isUnsigned &&
- (ResultVal[LongLongSize - 1] == 0 ||
- (getLangOpts().MSVCCompat && Literal.isLongLong)))
+ if (!Literal.isUnsigned && (ResultVal[LongLongSize-1] == 0 ||
+ (getLangOpts().MSVCCompat && Literal.isLongLong)))
Ty = Context.LongLongTy;
else if (AllowUnsigned)
Ty = Context.UnsignedLongLongTy;
@@ -4223,8 +4233,8 @@ ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
// If this is an imaginary literal, create the ImaginaryLiteral wrapper.
if (Literal.isImaginary) {
- Res = new (Context)
- ImaginaryLiteral(Res, Context.getComplexType(Res->getType()));
+ Res = new (Context) ImaginaryLiteral(Res,
+ Context.getComplexType(Res->getType()));
// In C++, this is a GNU extension. In C, it's a C2y extension.
unsigned DiagId;
@@ -4256,7 +4266,8 @@ static bool CheckVecStepTraitOperandType(Sema &S, QualType T,
// Every built-in scalar type (OpenCL 1.1 6.1.1) is either an arithmetic
// type (C99 6.2.5p18) or void.
if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) {
- S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type) << T << ArgRange;
+ S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type)
+ << T << ArgRange;
return true;
}
@@ -4339,7 +4350,8 @@ static bool CheckObjCTraitOperandConstraints(Sema &S, QualType T,
// runtime doesn't allow it.
if (!S.LangOpts.ObjCRuntime.allowsSizeofAlignof() && T->isObjCObjectType()) {
S.Diag(Loc, diag::err_sizeof_nonfragile_interface)
- << T << (TraitKind == UETT_SizeOf) << ArgRange;
+ << T << (TraitKind == UETT_SizeOf)
+ << ArgRange;
return true;
}
@@ -4359,9 +4371,9 @@ static void warnOnSizeofOnArrayDecay(Sema &S, SourceLocation Loc, QualType T,
if (!ICE || ICE->getCastKind() != CK_ArrayToPointerDecay)
return;
- S.Diag(Loc, diag::warn_sizeof_array_decay)
- << ICE->getSourceRange() << ICE->getType()
- << ICE->getSubExpr()->getType();
+ S.Diag(Loc, diag::warn_sizeof_array_decay) << ICE->getSourceRange()
+ << ICE->getType()
+ << ICE->getSubExpr()->getType();
}
bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E,
@@ -4386,7 +4398,8 @@ bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E,
// used to build SFINAE gadgets.
// FIXME: Should we consider instantiation-dependent operands to 'alignof'?
if (IsUnevaluatedOperand && !inTemplateInstantiation() &&
- !E->isInstantiationDependent() && !E->getType()->isVariableArrayType() &&
+ !E->isInstantiationDependent() &&
+ !E->getType()->isVariableArrayType() &&
E->HasSideEffects(Context, false))
Diag(E->getExprLoc(), diag::warn_side_effects_unevaluated_context);
@@ -4464,7 +4477,8 @@ bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E,
QualType OType = PVD->getOriginalType();
QualType Type = PVD->getType();
if (Type->isPointerType() && OType->isArrayType()) {
- Diag(E->getExprLoc(), diag::warn_sizeof_array_param) << Type << OType;
+ Diag(E->getExprLoc(), diag::warn_sizeof_array_param)
+ << Type << OType;
Diag(PVD->getLocation(), diag::note_declared_at);
}
}
@@ -4491,7 +4505,7 @@ static bool CheckAlignOfExpr(Sema &S, Expr *E, UnaryExprOrTypeTrait ExprKind) {
if (E->getObjectKind() == OK_BitField) {
S.Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield)
- << 1 << E->getSourceRange();
+ << 1 << E->getSourceRange();
return true;
}
@@ -4525,7 +4539,7 @@ static bool CheckAlignOfExpr(Sema &S, Expr *E, UnaryExprOrTypeTrait ExprKind) {
// definition if we can find a member of it.
if (!FD->getParent()->isCompleteDefinition()) {
S.Diag(E->getExprLoc(), diag::err_alignof_member_of_incomplete_type)
- << E->getSourceRange();
+ << E->getSourceRange();
return true;
}
@@ -4809,8 +4823,9 @@ ExprResult Sema::CreateUnaryExprOrTypeTraitExpr(TypeSourceInfo *TInfo,
ExprKind, TInfo, Context.getSizeType(), OpLoc, R.getEnd());
}
-ExprResult Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
- UnaryExprOrTypeTrait ExprKind) {
+ExprResult
+Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
+ UnaryExprOrTypeTrait ExprKind) {
ExprResult PE = CheckPlaceholderExpr(E);
if (PE.isInvalid())
return ExprError();
@@ -4826,9 +4841,9 @@ ExprResult Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
} else if (ExprKind == UETT_VecStep) {
isInvalid = CheckVecStepExpr(E);
} else if (ExprKind == UETT_OpenMPRequiredSimdAlign) {
- Diag(E->getExprLoc(), diag::err_openmp_default_simd_align_expr);
- isInvalid = true;
- } else if (E->refersToBitField()) { // C99 6.5.3.4p1.
+ Diag(E->getExprLoc(), diag::err_openmp_default_simd_align_expr);
+ isInvalid = true;
+ } else if (E->refersToBitField()) { // C99 6.5.3.4p1.
Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 0;
isInvalid = true;
} else if (ExprKind == UETT_VectorElements || ExprKind == UETT_SizeOf ||
@@ -4842,8 +4857,7 @@ ExprResult Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
if ((ExprKind == UETT_SizeOf || ExprKind == UETT_CountOf) &&
E->getType()->isVariableArrayType()) {
PE = TransformToPotentiallyEvaluated(E);
- if (PE.isInvalid())
- return ExprError();
+ if (PE.isInvalid()) return ExprError();
E = PE.get();
}
@@ -4852,17 +4866,16 @@ ExprResult Sema::CreateUnaryExprOrTypeTraitExpr(Expr *E, SourceLocation OpLoc,
ExprKind, E, Context.getSizeType(), OpLoc, E->getSourceRange().getEnd());
}
-ExprResult Sema::ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,
- UnaryExprOrTypeTrait ExprKind,
- bool IsType, void *TyOrEx,
- SourceRange ArgRange) {
+ExprResult
+Sema::ActOnUnaryExprOrTypeTraitExpr(SourceLocation OpLoc,
+ UnaryExprOrTypeTrait ExprKind, bool IsType,
+ void *TyOrEx, SourceRange ArgRange) {
// If error parsing type, ignore.
- if (!TyOrEx)
- return ExprError();
+ if (!TyOrEx) return ExprError();
if (IsType) {
TypeSourceInfo *TInfo;
- (void)GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo);
+ (void) GetTypeFromParser(ParsedType::getFromOpaquePtr(TyOrEx), &TInfo);
return CreateUnaryExprOrTypeTraitExpr(TInfo, OpLoc, ExprKind, ArgRange);
}
@@ -4909,37 +4922,33 @@ static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc,
// Test for placeholders.
ExprResult PR = S.CheckPlaceholderExpr(V.get());
- if (PR.isInvalid())
- return QualType();
+ if (PR.isInvalid()) return QualType();
if (PR.get() != V.get()) {
V = PR;
return CheckRealImagOperand(S, V, Loc, IsReal);
}
// Reject anything else.
- S.Diag(Loc, diag::err_realimag_invalid_type)
- << V.get()->getType() << (IsReal ? "__real" : "__imag");
+ S.Diag(Loc, diag::err_realimag_invalid_type) << V.get()->getType()
+ << (IsReal ? "__real" : "__imag");
return QualType();
}
-ExprResult Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
- tok::TokenKind Kind, Expr *Input) {
+
+
+ExprResult
+Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
+ tok::TokenKind Kind, Expr *Input) {
UnaryOperatorKind Opc;
switch (Kind) {
- default:
- llvm_unreachable("Unknown unary op!");
- case tok::plusplus:
- Opc = UO_PostInc;
- break;
- case tok::minusminus:
- Opc = UO_PostDec;
- break;
+ default: llvm_unreachable("Unknown unary op!");
+ case tok::plusplus: Opc = UO_PostInc; break;
+ case tok::minusminus: Opc = UO_PostDec; break;
}
// Since this might is a postfix expression, get rid of ParenListExprs.
ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Input);
- if (Result.isInvalid())
- return ExprError();
+ if (Result.isInvalid()) return ExprError();
Input = Result.get();
return BuildUnaryOp(S, OpLoc, Opc, Input);
@@ -4948,7 +4957,8 @@ ExprResult Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
/// Diagnose if arithmetic on the given ObjC pointer is illegal.
///
/// \return true on error
-static bool checkArithmeticOnObjCPointer(Sema &S, SourceLocation opLoc,
+static bool checkArithmeticOnObjCPointer(Sema &S,
+ SourceLocation opLoc,
Expr *op) {
assert(op->getType()->isObjCObjectPointerType());
if (S.LangOpts.ObjCRuntime.allowsPointerArithmetic() &&
@@ -4956,8 +4966,8 @@ static bool checkArithmeticOnObjCPointer(Sema &S, SourceLocation opLoc,
return false;
S.Diag(opLoc, diag::err_arithmetic_nonfragile_interface)
- << op->getType()->castAs<ObjCObjectPointerType>()->getPointeeType()
- << op->getSourceRange();
+ << op->getType()->castAs<ObjCObjectPointerType>()->getPointeeType()
+ << op->getSourceRange();
return true;
}
@@ -5365,9 +5375,9 @@ void Sema::CheckSubscriptAccessOfNoDeref(const ArraySubscriptExpr *E) {
}
}
-ExprResult Sema::CreateBuiltinArraySubscriptExpr(Expr *Base,
- SourceLocation LLoc, Expr *Idx,
- SourceLocation RLoc) {
+ExprResult
+Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc,
+ Expr *Idx, SourceLocation RLoc) {
Expr *LHSExp = Base;
Expr *RHSExp = Idx;
@@ -5414,7 +5424,7 @@ ExprResult Sema::CreateBuiltinArraySubscriptExpr(Expr *Base,
IndexExpr = RHSExp;
ResultType = PTy->getPointeeType();
} else if (const ObjCObjectPointerType *PTy =
- LHSTy->getAs<ObjCObjectPointerType>()) {
+ LHSTy->getAs<ObjCObjectPointerType>()) {
BaseExpr = LHSExp;
IndexExpr = RHSExp;
@@ -5426,19 +5436,19 @@ ExprResult Sema::CreateBuiltinArraySubscriptExpr(Expr *Base,
ResultType = PTy->getPointeeType();
} else if (const PointerType *PTy = RHSTy->getAs<PointerType>()) {
- // Handle the uncommon case of "123[Ptr]".
+ // Handle the uncommon case of "123[Ptr]".
BaseExpr = RHSExp;
IndexExpr = LHSExp;
ResultType = PTy->getPointeeType();
} else if (const ObjCObjectPointerType *PTy =
- RHSTy->getAs<ObjCObjectPointerType>()) {
- // Handle the uncommon case of "123[Ptr]".
+ RHSTy->getAs<ObjCObjectPointerType>()) {
+ // Handle the uncommon case of "123[Ptr]".
BaseExpr = RHSExp;
IndexExpr = LHSExp;
ResultType = PTy->getPointeeType();
if (!LangOpts.isSubscriptPointerArithmetic()) {
Diag(LLoc, diag::err_subscript_nonfragile_interface)
- << ResultType << BaseExpr->getSourceRange();
+ << ResultType << BaseExpr->getSourceRange();
return ExprError();
}
} else if (LHSTy->isSubscriptableVectorType()) {
@@ -5482,8 +5492,7 @@ ExprResult Sema::CreateBuiltinArraySubscriptExpr(Expr *Base,
Diag(LHSExp->getBeginLoc(), diag::ext_subscript_non_lvalue)
<< LHSExp->getSourceRange();
LHSExp = ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy),
- CK_ArrayToPointerDecay)
- .get();
+ CK_ArrayToPointerDecay).get();
LHSTy = LHSExp->getType();
BaseExpr = LHSExp;
@@ -5494,8 +5503,7 @@ ExprResult Sema::CreateBuiltinArraySubscriptExpr(Expr *Base,
Diag(RHSExp->getBeginLoc(), diag::ext_subscript_non_lvalue)
<< RHSExp->getSourceRange();
RHSExp = ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy),
- CK_ArrayToPointerDecay)
- .get();
+ CK_ArrayToPointerDecay).get();
RHSTy = RHSExp->getType();
BaseExpr = RHSExp;
@@ -5503,7 +5511,7 @@ ExprResult Sema::CreateBuiltinArraySubscriptExpr(Expr *Base,
ResultType = RHSTy->castAs<PointerType>()->getPointeeType();
} else {
return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value)
- << LHSExp->getSourceRange() << RHSExp->getSourceRange());
+ << LHSExp->getSourceRange() << RHSExp->getSourceRange());
}
// C99 6.5.2.1p1
if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent())
@@ -5532,7 +5540,8 @@ ExprResult Sema::CreateBuiltinArraySubscriptExpr(Expr *Base,
if (ResultType->isVoidType() && !getLangOpts().CPlusPlus) {
// GNU extension: subscripting on pointer to void
- Diag(LLoc, diag::ext_gnu_subscript_void_type) << BaseExpr->getSourceRange();
+ Diag(LLoc, diag::ext_gnu_subscript_void_type)
+ << BaseExpr->getSourceRange();
// C forbids expressions of unqualified void type from being l-values.
// See IsCForbiddenLValueType.
@@ -5999,7 +6008,7 @@ class FunctionCallCCC final : public FunctionCallFilterCCC {
private:
const IdentifierInfo *const FunctionName;
};
-} // namespace
+}
static TypoCorrection TryTypoCorrectionForCall(Sema &S, Expr *Fn,
FunctionDecl *FDecl,
@@ -6059,12 +6068,13 @@ static bool isParenthetizedAndQualifiedAddressOfExpr(Expr *Fn) {
return false;
}
-bool Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
- FunctionDecl *FDecl,
- const FunctionProtoType *Proto,
- ArrayRef<Expr *> Args,
- SourceLocation RParenLoc,
- bool IsExecConfig) {
+bool
+Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
+ FunctionDecl *FDecl,
+ const FunctionProtoType *Proto,
+ ArrayRef<Expr *> Args,
+ SourceLocation RParenLoc,
+ bool IsExecConfig) {
// Bail out early if calling a builtin with custom typechecking.
if (FDecl)
if (unsigned ID = FDecl->getBuiltinID())
@@ -6082,9 +6092,9 @@ bool Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
bool Invalid = false;
unsigned MinArgs = FDecl ? FDecl->getMinRequiredArguments() : NumParams;
unsigned FnKind = Fn->getType()->isBlockPointerType()
- ? 1 /* block */
- : (IsExecConfig ? 3 /* kernel function (exec config) */
- : 0 /* function */);
+ ? 1 /* block */
+ : (IsExecConfig ? 3 /* kernel function (exec config) */
+ : 0 /* function */);
// If too few arguments are available (and we don't have default
// arguments for the remaining parameters), don't make the call.
@@ -6223,12 +6233,12 @@ bool Sema::GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
// Strip the unbridged-cast placeholder expression off, if applicable.
bool CFAudited = false;
- if (Arg->getType() == Context.ARCUnbridgedCastTy && FDecl &&
- FDecl->hasAttr<CFAuditedTransferAttr>() &&
+ if (Arg->getType() == Context.ARCUnbridgedCastTy &&
+ FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() &&
(!Param || !Param->hasAttr<CFConsumedAttr>()))
Arg = ObjC().stripARCUnbridgedCast(Arg);
- else if (getLangOpts().ObjCAutoRefCount && FDecl &&
- FDecl->hasAttr<CFAuditedTransferAttr>() &&
+ else if (getLangOpts().ObjCAutoRefCount &&
+ FDecl && FDecl->hasAttr<CFAuditedTransferAttr>() &&
(!Param || !Param->hasAttr<CFConsumedAttr>()))
CFAudited = true;
@@ -6306,7 +6316,7 @@ bool Sema::GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
AllArgs.push_back(arg.get());
}
- // Otherwise do argument promotion, (C99 6.5.2.2p7).
+ // Otherwise do argument promotion, (C99 6.5.2.2p7).
} else {
for (Expr *A : Args.slice(ArgIx)) {
ExprResult Arg = DefaultVariadicArgumentPromotion(A, CallType, FDecl);
@@ -6328,11 +6338,13 @@ static void DiagnoseCalleeStaticArrayParam(Sema &S, ParmVarDecl *PVD) {
TL = DTL.getOriginalLoc();
if (ArrayTypeLoc ATL = TL.getAs<ArrayTypeLoc>())
S.Diag(PVD->getLocation(), diag::note_callee_static_array)
- << ATL.getLocalSourceRange();
+ << ATL.getLocalSourceRange();
}
-void Sema::CheckStaticArrayArgument(SourceLocation CallLoc, ParmVarDecl *Param,
- const Expr *ArgExpr) {
+void
+Sema::CheckStaticArrayArgument(SourceLocation CallLoc,
+ ParmVarDecl *Param,
+ const Expr *ArgExpr) {
// Static array parameters are not supported in C++.
if (!Param || getLangOpts().CPlusPlus)
return;
@@ -6343,7 +6355,8 @@ void Sema::CheckStaticArrayArgument(SourceLocation CallLoc, ParmVarDecl *Param,
if (!AT || AT->getSizeModifier() != ArraySizeModifier::Static)
return;
- if (ArgExpr->isNullPointerConstant(Context, Expr::NPC_NeverValueDependent)) {
+ if (ArgExpr->isNullPointerConstant(Context,
+ Expr::NPC_NeverValueDependent)) {
Diag(CallLoc, diag::warn_null_arg) << ArgExpr->getSourceRange();
DiagnoseCalleeStaticArrayParam(*this, Param);
return;
@@ -6354,7 +6367,7 @@ void Sema::CheckStaticArrayArgument(SourceLocation CallLoc, ParmVarDecl *Param,
return;
const ConstantArrayType *ArgCAT =
- Context.getAsConstantArrayType(ArgExpr->IgnoreParenCasts()->getType());
+ Context.getAsConstantArrayType(ArgExpr->IgnoreParenCasts()->getType());
if (!ArgCAT)
return;
@@ -6390,21 +6403,23 @@ static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *fn);
static bool isPlaceholderToRemoveAsArg(QualType type) {
// Placeholders are never sugared.
const BuiltinType *placeholder = dyn_cast<BuiltinType>(type);
- if (!placeholder)
- return false;
+ if (!placeholder) return false;
switch (placeholder->getKind()) {
- // Ignore all the non-placeholder types.
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ // Ignore all the non-placeholder types.
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id:
#include "clang/Basic/OpenCLImageTypes.def"
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
+ case BuiltinType::Id:
#include "clang/Basic/OpenCLExtensionTypes.def"
- // In practice we'll never use this, since all SVE types are sugared
- // via TypedefTypes rather than exposed directly as BuiltinTypes.
-#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
+ // In practice we'll never use this, since all SVE types are sugared
+ // via TypedefTypes rather than exposed directly as BuiltinTypes.
+#define SVE_TYPE(Name, Id, SingletonId) \
+ case BuiltinType::Id:
#include "clang/Basic/AArch64ACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
+#define PPC_VECTOR_TYPE(Name, Id, Size) \
+ case BuiltinType::Id:
#include "clang/Basic/PPCTypes.def"
#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
#include "clang/Basic/RISCVVTypes.def"
@@ -6447,6 +6462,7 @@ static bool isPlaceholderToRemoveAsArg(QualType type) {
case BuiltinType::OMPArrayShaping:
case BuiltinType::OMPIterator:
return true;
+
}
llvm_unreachable("bad builtin type kind");
}
@@ -6458,10 +6474,8 @@ bool Sema::CheckArgsForPlaceholders(MultiExprArg args) {
for (size_t i = 0, e = args.size(); i != e; i++) {
if (isPlaceholderToRemoveAsArg(args[i]->getType())) {
ExprResult result = CheckPlaceholderExpr(args[i]);
- if (result.isInvalid())
- hasInvalid = true;
- else
- args[i] = result.get();
+ if (result.isInvalid()) hasInvalid = true;
+ else args[i] = result.get();
}
}
return hasInvalid;
@@ -6532,8 +6546,8 @@ static FunctionDecl *rewriteBuiltinFunctionDecl(Sema *Sema, ASTContext &Context,
FunctionProtoType::ExtProtoInfo EPI;
EPI.Variadic = FT->isVariadic();
- QualType OverloadTy =
- Context.getFunctionType(FT->getReturnType(), OverloadParams, EPI);
+ QualType OverloadTy = Context.getFunctionType(FT->getReturnType(),
+ OverloadParams, EPI);
DeclContext *Parent = FDecl->getParent();
FunctionDecl *OverloadDecl = FunctionDecl::Create(
Context, Parent, FDecl->getLocation(), FDecl->getLocation(),
@@ -6541,14 +6555,14 @@ static FunctionDecl *rewriteBuiltinFunctionDecl(Sema *Sema, ASTContext &Context,
/*TInfo=*/nullptr, SC_Extern, Sema->getCurFPFeatures().isFPConstrained(),
false,
/*hasPrototype=*/true);
- SmallVector<ParmVarDecl *, 16> Params;
+ SmallVector<ParmVarDecl*, 16> Params;
FT = cast<FunctionProtoType>(OverloadTy);
for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
QualType ParamType = FT->getParamType(i);
ParmVarDecl *Parm =
ParmVarDecl::Create(Context, OverloadDecl, SourceLocation(),
- SourceLocation(), nullptr, ParamType,
- /*TInfo=*/nullptr, SC_None, nullptr);
+ SourceLocation(), nullptr, ParamType,
+ /*TInfo=*/nullptr, SC_None, nullptr);
Parm->setScopeInfo(0, i);
Params.push_back(Parm);
}
@@ -6654,6 +6668,7 @@ tryImplicitlyCaptureThisIfImplicitMemberFunctionAccessWithDependentArgs(
if (!enclosingClassIsRelatedToClassInWhichMembersWereFound(UME, S))
return;
+
DeclContext *EnclosingFunctionCtx = S.CurContext->getParent()->getParent();
// If the enclosing function is not dependent, then this lambda is
// capture ready, so if we can capture this, do so.
@@ -6762,8 +6777,7 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
bool AllowRecovery) {
// Since this might be a postfix expression, get rid of ParenListExprs.
ExprResult Result = MaybeConvertParenListExprToParenExpr(Scope, Fn);
- if (Result.isInvalid())
- return ExprError();
+ if (Result.isInvalid()) return ExprError();
Fn = Result.get();
// The __builtin_amdgcn_is_invocable builtin is special, and will be resolved
@@ -6808,8 +6822,7 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
}
if (Fn->getType() == Context.PseudoObjectTy) {
ExprResult result = CheckPlaceholderExpr(Fn);
- if (result.isInvalid())
- return ExprError();
+ if (result.isInvalid()) return ExprError();
Fn = result.get();
}
@@ -6847,8 +6860,7 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
if (Fn->getType() == Context.UnknownAnyTy) {
ExprResult result = rebuildUnknownAnyFunction(*this, Fn);
- if (result.isInvalid())
- return ExprError();
+ if (result.isInvalid()) return ExprError();
Fn = result.get();
}
@@ -6882,8 +6894,7 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
// If we're directly calling a function, get the appropriate declaration.
if (Fn->getType() == Context.UnknownAnyTy) {
ExprResult result = rebuildUnknownAnyFunction(*this, Fn);
- if (result.isInvalid())
- return ExprError();
+ if (result.isInvalid()) return ExprError();
Fn = result.get();
}
@@ -6942,7 +6953,7 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
// type.
if (getLangOpts().HIP && FD && FD->getBuiltinID()) {
for (unsigned Idx = 0; Idx < ArgExprs.size() && Idx < FD->param_size();
- ++Idx) {
+ ++Idx) {
ParmVarDecl *Param = FD->getParamDecl(Idx);
if (!ArgExprs[Idx] || !Param || !Param->getType()->isPointerType() ||
!ArgExprs[Idx]->getType()->isPointerType())
@@ -6955,14 +6966,10 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
// Add address space cast if target address spaces are different
bool NeedImplicitASC =
- ParamAS != LangAS::Default && // Pointer params in generic AS don't
- // need special handling.
- (ArgAS ==
- LangAS::Default || // We do allow implicit conversion from
- // generic AS or from specific AS which has
- // target AS matching that of Param.
- getASTContext().getTargetAddressSpace(ArgAS) ==
- getASTContext().getTargetAddressSpace(ParamAS));
+ ParamAS != LangAS::Default && // Pointer params in generic AS don't need special handling.
+ ( ArgAS == LangAS::Default || // We do allow implicit conversion from generic AS
+ // or from specific AS which has target AS matching that of Param.
+ getASTContext().getTargetAddressSpace(ArgAS) == getASTContext().getTargetAddressSpace(ParamAS));
if (!NeedImplicitASC)
continue;
@@ -6979,8 +6986,9 @@ ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
ArgPtQuals.setAddressSpace(ParamAS);
auto NewArgPtTy =
Context.getQualifiedType(ArgPtTy.getUnqualifiedType(), ArgPtQuals);
- auto NewArgTy = Context.getQualifiedType(
- Context.getPointerType(NewArgPtTy), ArgTy.getQualifiers());
+ auto NewArgTy =
+ Context.getQualifiedType(Context.getPointerType(NewArgPtTy),
+ ArgTy.getQualifiers());
// Finally perform an implicit address space cast
ArgExprs[Idx] = ImpCastExprToType(ArgExprs[Idx], NewArgTy,
@@ -7207,8 +7215,7 @@ ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
if (Config) {
// CUDA: Kernel calls must be to global functions
if (FDecl && !FDecl->hasAttr<CUDAGlobalAttr>())
- return ExprError(
- Diag(LParenLoc, diag::err_kern_call_not_global_function)
+ return ExprError(Diag(LParenLoc,diag::err_kern_call_not_global_function)
<< FDecl << Fn->getSourceRange());
// CUDA: Kernel function must have 'void' return type
@@ -7216,12 +7223,12 @@ ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
!FuncT->getReturnType()->getAs<AutoType>() &&
!FuncT->getReturnType()->isInstantiationDependentType())
return ExprError(Diag(LParenLoc, diag::err_kern_type_not_void_return)
- << Fn->getType() << Fn->getSourceRange());
+ << Fn->getType() << Fn->getSourceRange());
} else {
// CUDA: Calls to global functions must be configured
if (FDecl && FDecl->hasAttr<CUDAGlobalAttr>())
return ExprError(Diag(LParenLoc, diag::err_global_call_not_config)
- << FDecl << Fn->getSourceRange());
+ << FDecl << Fn->getSourceRange());
}
}
@@ -7257,11 +7264,9 @@ ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
const FunctionDecl *Def = nullptr;
if (FDecl->hasBody(Def) && Args.size() != Def->param_size()) {
Proto = Def->getType()->getAs<FunctionProtoType>();
- if (!Proto ||
- !(Proto->isVariadic() && Args.size() >= Def->param_size()))
+ if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->param_size()))
Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments)
- << (Args.size() > Def->param_size()) << FDecl
- << Fn->getSourceRange();
+ << (Args.size() > Def->param_size()) << FDecl << Fn->getSourceRange();
}
// If the function we're calling isn't a function prototype, but we have
@@ -7360,9 +7365,9 @@ ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), FDecl);
}
-ExprResult Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty,
- SourceLocation RParenLoc,
- Expr *InitExpr) {
+ExprResult
+Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty,
+ SourceLocation RParenLoc, Expr *InitExpr) {
assert(Ty && "ActOnCompoundLiteral(): missing type");
assert(InitExpr && "ActOnCompoundLiteral(): missing expression");
@@ -7374,10 +7379,9 @@ ExprResult Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty,
return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, InitExpr);
}
-ExprResult Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc,
- TypeSourceInfo *TInfo,
- SourceLocation RParenLoc,
- Expr *LiteralExpr) {
+ExprResult
+Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo,
+ SourceLocation RParenLoc, Expr *LiteralExpr) {
QualType literalType = TInfo->getType();
if (literalType->isArrayType()) {
@@ -7413,21 +7417,20 @@ ExprResult Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc,
return ExprError();
}
} else if (!literalType->isDependentType() &&
- RequireCompleteType(
- LParenLoc, literalType,
- diag::err_typecheck_decl_incomplete_type,
- SourceRange(LParenLoc,
- LiteralExpr->getSourceRange().getEnd())))
+ RequireCompleteType(LParenLoc, literalType,
+ diag::err_typecheck_decl_incomplete_type,
+ SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd())))
return ExprError();
- InitializedEntity Entity =
- InitializedEntity::InitializeCompoundLiteralInit(TInfo);
- InitializationKind Kind = InitializationKind::CreateCStyleCast(
- LParenLoc, SourceRange(LParenLoc, RParenLoc),
- /*InitList=*/true);
+ InitializedEntity Entity
+ = InitializedEntity::InitializeCompoundLiteralInit(TInfo);
+ InitializationKind Kind
+ = InitializationKind::CreateCStyleCast(LParenLoc,
+ SourceRange(LParenLoc, RParenLoc),
+ /*InitList=*/true);
InitializationSequence InitSeq(*this, Entity, Kind, LiteralExpr);
- ExprResult Result =
- InitSeq.Perform(*this, Entity, Kind, LiteralExpr, &literalType);
+ ExprResult Result = InitSeq.Perform(*this, Entity, Kind, LiteralExpr,
+ &literalType);
if (Result.isInvalid())
return ExprError();
LiteralExpr = Result.get();
@@ -7484,7 +7487,8 @@ ExprResult Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc,
auto *E = new (Context) CompoundLiteralExpr(LParenLoc, TInfo, literalType, VK,
LiteralExpr, IsFileScope);
if (IsFileScope) {
- if (!LiteralExpr->isTypeDependent() && !LiteralExpr->isValueDependent() &&
+ if (!LiteralExpr->isTypeDependent() &&
+ !LiteralExpr->isValueDependent() &&
!literalType->isDependentType()) // C99 6.5.2.5p3
if (CheckForConstantInitializer(LiteralExpr))
return ExprError();
@@ -7494,7 +7498,7 @@ ExprResult Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc,
// "If the compound literal occurs inside the body of a function, the
// type name shall not be qualified by an address-space qualifier."
Diag(LParenLoc, diag::err_compound_literal_with_address_space)
- << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd());
+ << SourceRange(LParenLoc, LiteralExpr->getSourceRange().getEnd());
return ExprError();
}
@@ -7525,9 +7529,9 @@ ExprResult Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc,
return MaybeBindToTemporary(E);
}
-ExprResult Sema::ActOnInitList(SourceLocation LBraceLoc,
- MultiExprArg InitArgList,
- SourceLocation RBraceLoc) {
+ExprResult
+Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList,
+ SourceLocation RBraceLoc) {
// Only produce each kind of designated initialization diagnostic once.
SourceLocation FirstDesignator;
bool DiagnosedArrayDesignator = false;
@@ -7547,14 +7551,14 @@ ExprResult Sema::ActOnInitList(SourceLocation LBraceLoc,
if (!DiagnosedNestedDesignator && DIE->size() > 1) {
DiagnosedNestedDesignator = true;
Diag(DIE->getBeginLoc(), diag::ext_designated_init_nested)
- << DIE->getDesignatorsSourceRange();
+ << DIE->getDesignatorsSourceRange();
}
for (auto &Desig : DIE->designators()) {
if (!Desig.isFieldDesignator() && !DiagnosedArrayDesignator) {
DiagnosedArrayDesignator = true;
Diag(Desig.getBeginLoc(), diag::ext_designated_init_array)
- << Desig.getSourceRange();
+ << Desig.getSourceRange();
}
}
@@ -7562,18 +7566,18 @@ ExprResult Sema::ActOnInitList(SourceLocation LBraceLoc,
!isa<DesignatedInitExpr>(InitArgList[0])) {
DiagnosedMixedDesignator = true;
Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
- << DIE->getSourceRange();
+ << DIE->getSourceRange();
Diag(InitArgList[0]->getBeginLoc(), diag::note_designated_init_mixed)
- << InitArgList[0]->getSourceRange();
+ << InitArgList[0]->getSourceRange();
}
} else if (getLangOpts().CPlusPlus && !DiagnosedMixedDesignator &&
isa<DesignatedInitExpr>(InitArgList[0])) {
DiagnosedMixedDesignator = true;
auto *DIE = cast<DesignatedInitExpr>(InitArgList[0]);
Diag(DIE->getBeginLoc(), diag::ext_designated_init_mixed)
- << DIE->getSourceRange();
+ << DIE->getSourceRange();
Diag(InitArgList[I]->getBeginLoc(), diag::note_designated_init_mixed)
- << InitArgList[I]->getSourceRange();
+ << InitArgList[I]->getSourceRange();
}
}
@@ -7593,9 +7597,9 @@ ExprResult Sema::ActOnInitList(SourceLocation LBraceLoc,
return BuildInitList(LBraceLoc, InitArgList, RBraceLoc);
}
-ExprResult Sema::BuildInitList(SourceLocation LBraceLoc,
- MultiExprArg InitArgList,
- SourceLocation RBraceLoc) {
+ExprResult
+Sema::BuildInitList(SourceLocation LBraceLoc, MultiExprArg InitArgList,
+ SourceLocation RBraceLoc) {
// Semantic analysis for initializers is done by ActOnDeclarator() and
// CheckInitializer() - it requires knowledge of the object being initialized.
@@ -7607,8 +7611,7 @@ ExprResult Sema::BuildInitList(SourceLocation LBraceLoc,
// Ignore failures; dropping the entire initializer list because
// of one failure would be terrible for indexing/etc.
- if (result.isInvalid())
- continue;
+ if (result.isInvalid()) continue;
InitArgList[I] = result.get();
}
@@ -7625,8 +7628,7 @@ void Sema::maybeExtendBlockObject(ExprResult &E) {
assert(E.get()->isPRValue());
// Only do this in an r-value context.
- if (!getLangOpts().ObjCAutoRefCount)
- return;
+ if (!getLangOpts().ObjCAutoRefCount) return;
E = ImplicitCastExpr::Create(
Context, E.get()->getType(), CK_ARCExtendBlockObject, E.get(),
@@ -7662,8 +7664,7 @@ CastKind Sema::PrepareScalarCast(ExprResult &Src, QualType DestTy) {
}
case Type::STK_BlockPointer:
return (SrcKind == Type::STK_BlockPointer
- ? CK_BitCast
- : CK_AnyPointerToBlockPointerCast);
+ ? CK_BitCast : CK_AnyPointerToBlockPointerCast);
case Type::STK_ObjCObjectPointer:
if (SrcKind == Type::STK_ObjCObjectPointer)
return CK_BitCast;
@@ -7726,13 +7727,13 @@ CastKind Sema::PrepareScalarCast(ExprResult &Src, QualType DestTy) {
return CK_IntegralToFloating;
case Type::STK_IntegralComplex:
Src = ImpCastExprToType(Src.get(),
- DestTy->castAs<ComplexType>()->getElementType(),
- CK_IntegralCast);
+ DestTy->castAs<ComplexType>()->getElementType(),
+ CK_IntegralCast);
return CK_IntegralRealToComplex;
case Type::STK_FloatingComplex:
Src = ImpCastExprToType(Src.get(),
- DestTy->castAs<ComplexType>()->getElementType(),
- CK_IntegralToFloating);
+ DestTy->castAs<ComplexType>()->getElementType(),
+ CK_IntegralToFloating);
return CK_FloatingRealToComplex;
case Type::STK_MemberPointer:
llvm_unreachable("member pointer type in C");
@@ -7854,8 +7855,7 @@ static bool breakDownVectorType(QualType type, uint64_t &len,
// We allow lax conversion to and from non-vector types, but only if
// they're real types (i.e. non-complex, non-pointer scalar types).
- if (!type->isRealType())
- return false;
+ if (!type->isRealType()) return false;
len = 1;
eltType = type;
@@ -7938,10 +7938,8 @@ bool Sema::areLaxCompatibleVectorTypes(QualType srcTy, QualType destTy) {
// depend on them). Most scalar OP ExtVector cases are handled by the
// splat path anyway, which does what we want (convert, not bitcast).
// What this rules out for ExtVectors is crazy things like char4*float.
- if (srcTy->isScalarType() && destTy->isExtVectorType())
- return false;
- if (destTy->isScalarType() && srcTy->isExtVectorType())
- return false;
+ if (srcTy->isScalarType() && destTy->isExtVectorType()) return false;
+ if (destTy->isScalarType() && srcTy->isExtVectorType()) return false;
return areVectorTypesSameSize(srcTy, destTy);
}
@@ -7967,7 +7965,7 @@ bool Sema::isLaxVectorConversion(QualType srcTy, QualType destTy) {
// OK, integer (vector) -> integer (vector) bitcast.
break;
- case LangOptions::LaxVectorConversionKind::All:
+ case LangOptions::LaxVectorConversionKind::All:
break;
}
@@ -8002,14 +8000,14 @@ bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
if (Ty->isVectorType() || Ty->isIntegralType(Context)) {
if (!areLaxCompatibleVectorTypes(Ty, VectorTy))
return Diag(R.getBegin(),
- Ty->isVectorType()
- ? diag::err_invalid_conversion_between_vectors
- : diag::err_invalid_conversion_between_vector_and_integer)
- << VectorTy << Ty << R;
+ Ty->isVectorType() ?
+ diag::err_invalid_conversion_between_vectors :
+ diag::err_invalid_conversion_between_vector_and_integer)
+ << VectorTy << Ty << R;
} else
return Diag(R.getBegin(),
diag::err_invalid_conversion_between_vector_and_scalar)
- << VectorTy << Ty << R;
+ << VectorTy << Ty << R;
Kind = CK_BitCast;
return false;
@@ -8081,8 +8079,8 @@ ExprResult Sema::CheckExtVectorCast(SourceRange R, QualType DestTy,
(getLangOpts().OpenCL &&
!Context.hasSameUnqualifiedType(DestTy, SrcTy) &&
!Context.areCompatibleVectorTypes(DestTy, SrcTy))) {
- Diag(R.getBegin(), diag::err_invalid_conversion_between_ext_vectors)
- << DestTy << SrcTy << R;
+ Diag(R.getBegin(),diag::err_invalid_conversion_between_ext_vectors)
+ << DestTy << SrcTy << R;
return ExprError();
}
Kind = CK_BitCast;
@@ -8095,7 +8093,7 @@ ExprResult Sema::CheckExtVectorCast(SourceRange R, QualType DestTy,
if (SrcTy->isPointerType())
return Diag(R.getBegin(),
diag::err_invalid_conversion_between_vector_and_scalar)
- << DestTy << SrcTy << R;
+ << DestTy << SrcTy << R;
Kind = CK_VectorSplat;
return prepareVectorSplat(DestTy, CastExpr);
@@ -8136,9 +8134,10 @@ static void CheckSufficientAllocSize(Sema &S, QualType DestType,
<< Size.getQuantity() << TargetType << LhsSize->getQuantity();
}
-ExprResult Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
- Declarator &D, ParsedType &Ty,
- SourceLocation RParenLoc, Expr *CastExpr) {
+ExprResult
+Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
+ Declarator &D, ParsedType &Ty,
+ SourceLocation RParenLoc, Expr *CastExpr) {
assert(!D.isInvalidType() && (CastExpr != nullptr) &&
"ActOnCastExpr(): missing type or expr");
@@ -8162,9 +8161,8 @@ ExprResult Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
// i.e. all the elements are integer constants.
ParenExpr *PE = dyn_cast<ParenExpr>(CastExpr);
ParenListExpr *PLE = dyn_cast<ParenListExpr>(CastExpr);
- if ((getLangOpts().AltiVec || getLangOpts().ZVector ||
- getLangOpts().OpenCL) &&
- castType->isVectorType() && (PE || PLE)) {
+ if ((getLangOpts().AltiVec || getLangOpts().ZVector || getLangOpts().OpenCL)
+ && castType->isVectorType() && (PE || PLE)) {
if (PLE && PLE->getNumExprs() == 0) {
Diag(PLE->getExprLoc(), diag::err_altivec_empty_initializer);
return ExprError();
@@ -8173,7 +8171,8 @@ ExprResult Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
Expr *E = (PE ? PE->getSubExpr() : PLE->getExpr(0));
if (!E->isTypeDependent() && !E->getType()->isVectorType())
isVectorLiteral = true;
- } else
+ }
+ else
isVectorLiteral = true;
}
@@ -8187,8 +8186,7 @@ ExprResult Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
// sequence of BinOp comma operators.
if (isa<ParenListExpr>(CastExpr)) {
ExprResult Result = MaybeConvertParenListExprToParenExpr(S, CastExpr);
- if (Result.isInvalid())
- return ExprError();
+ if (Result.isInvalid()) return ExprError();
CastExpr = Result.get();
}
@@ -8255,12 +8253,16 @@ ExprResult Sema::BuildVectorLiteral(SourceLocation LParenLoc,
Literal = ImpCastExprToType(Literal.get(), ElemTy,
PrepareScalarCast(Literal, ElemTy));
return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get());
- } else if (numExprs < numElems) {
- Diag(E->getExprLoc(), diag::err_incorrect_number_of_vector_initializers);
+ }
+ else if (numExprs < numElems) {
+ Diag(E->getExprLoc(),
+ diag::err_incorrect_number_of_vector_initializers);
return ExprError();
- } else
+ }
+ else
initExprs.append(exprs, exprs + numExprs);
- } else {
+ }
+ else {
// For OpenCL, when the number of initializers is a single value,
// it will be replicated to all components of the vector.
if (getLangOpts().OpenCL && VTy->getVectorKind() == VectorKind::Generic &&
@@ -8285,14 +8287,14 @@ ExprResult Sema::BuildVectorLiteral(SourceLocation LParenLoc,
}
// FIXME: This means that pretty-printing the final AST will produce curly
// braces instead of the original commas.
- InitListExpr *initE = new (Context)
- InitListExpr(Context, LiteralLParenLoc, initExprs, LiteralRParenLoc);
+ InitListExpr *initE = new (Context) InitListExpr(Context, LiteralLParenLoc,
+ initExprs, LiteralRParenLoc);
initE->setType(Ty);
return BuildCompoundLiteralExpr(LParenLoc, TInfo, RParenLoc, initE);
}
-ExprResult Sema::MaybeConvertParenListExprToParenExpr(Scope *S,
- Expr *OrigExpr) {
+ExprResult
+Sema::MaybeConvertParenListExprToParenExpr(Scope *S, Expr *OrigExpr) {
ParenListExpr *E = dyn_cast<ParenListExpr>(OrigExpr);
if (!E)
return OrigExpr;
@@ -8300,16 +8302,16 @@ ExprResult Sema::MaybeConvertParenListExprToParenExpr(Scope *S,
ExprResult Result(E->getExpr(0));
for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i)
- Result =
- ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(), E->getExpr(i));
+ Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(),
+ E->getExpr(i));
- if (Result.isInvalid())
- return ExprError();
+ if (Result.isInvalid()) return ExprError();
return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), Result.get());
}
-ExprResult Sema::ActOnParenListExpr(SourceLocation L, SourceLocation R,
+ExprResult Sema::ActOnParenListExpr(SourceLocation L,
+ SourceLocation R,
MultiExprArg Val) {
return ParenListExpr::Create(Context, L, Val, R);
}
@@ -8327,14 +8329,16 @@ bool Sema::DiagnoseConditionalForNull(const Expr *LHSExpr, const Expr *RHSExpr,
SourceLocation QuestionLoc) {
const Expr *NullExpr = LHSExpr;
const Expr *NonPointerExpr = RHSExpr;
- Expr::NullPointerConstantKind NullKind = NullExpr->isNullPointerConstant(
- Context, Expr::NPC_ValueDependentIsNotNull);
+ Expr::NullPointerConstantKind NullKind =
+ NullExpr->isNullPointerConstant(Context,
+ Expr::NPC_ValueDependentIsNotNull);
if (NullKind == Expr::NPCK_NotNull) {
NullExpr = RHSExpr;
NonPointerExpr = LHSExpr;
- NullKind = NullExpr->isNullPointerConstant(
- Context, Expr::NPC_ValueDependentIsNotNull);
+ NullKind =
+ NullExpr->isNullPointerConstant(Context,
+ Expr::NPC_ValueDependentIsNotNull);
}
if (NullKind == Expr::NPCK_NotNull)
@@ -8367,16 +8371,15 @@ static bool checkCondition(Sema &S, const Expr *Cond,
// OpenCL v1.1 s6.3.i says the condition cannot be a floating point type.
if (S.getLangOpts().OpenCL && CondTy->isFloatingType()) {
S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
- << CondTy << Cond->getSourceRange();
+ << CondTy << Cond->getSourceRange();
return true;
}
// C99 6.5.15p2
- if (CondTy->isScalarType())
- return false;
+ if (CondTy->isScalarType()) return false;
S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_scalar)
- << CondTy << Cond->getSourceRange();
+ << CondTy << Cond->getSourceRange();
return true;
}
@@ -8386,7 +8389,7 @@ static bool checkConditionalNullPointer(Sema &S, ExprResult &NullExpr,
QualType PointerTy) {
if ((!PointerTy->isAnyPointerType() && !PointerTy->isBlockPointerType()) ||
!NullExpr.get()->isNullPointerConstant(S.Context,
- Expr::NPC_ValueDependentIsNull))
+ Expr::NPC_ValueDependentIsNull))
return true;
NullExpr = S.ImpCastExprToType(NullExpr.get(), PointerTy, CK_NullToPointer);
@@ -8448,8 +8451,7 @@ static QualType checkConditionalPointerCompatibility(Sema &S, ExprResult &LHS,
return QualType();
}
- unsigned MergedCVRQual =
- lhQual.getCVRQualifiers() | rhQual.getCVRQualifiers();
+ unsigned MergedCVRQual = lhQual.getCVRQualifiers() | rhQual.getCVRQualifiers();
auto LHSCastKind = CK_BitCast, RHSCastKind = CK_BitCast;
lhQual.removeCVRQualifiers();
rhQual.removeCVRQualifiers();
@@ -8549,8 +8551,8 @@ static QualType checkConditionalBlockPointerCompatibility(Sema &S,
return destType;
}
S.Diag(Loc, diag::err_typecheck_cond_incompatible_operands)
- << LHSTy << RHSTy << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ << LHSTy << RHSTy << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
return QualType();
}
@@ -8559,8 +8561,10 @@ static QualType checkConditionalBlockPointerCompatibility(Sema &S,
}
/// Return the resulting type when the operands are both pointers.
-static QualType checkConditionalObjectPointersCompatibility(
- Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc) {
+static QualType
+checkConditionalObjectPointersCompatibility(Sema &S, ExprResult &LHS,
+ ExprResult &RHS,
+ SourceLocation Loc) {
// get the pointer types
QualType LHSTy = LHS.get()->getType();
QualType RHSTy = RHS.get()->getType();
@@ -8572,8 +8576,8 @@ static QualType checkConditionalObjectPointersCompatibility(
// ignore qualifiers on void (C99 6.5.15p3, clause 6)
if (lhptee->isVoidType() && rhptee->isIncompleteOrObjectType()) {
// Figure out necessary qualifiers (C99 6.5.15p6)
- QualType destPointee =
- S.Context.getQualifiedType(lhptee, rhptee.getQualifiers());
+ QualType destPointee
+ = S.Context.getQualifiedType(lhptee, rhptee.getQualifiers());
QualType destType = S.Context.getPointerType(destPointee);
// Add qualifiers if necessary.
LHS = S.ImpCastExprToType(LHS.get(), destType, CK_NoOp);
@@ -8582,8 +8586,8 @@ static QualType checkConditionalObjectPointersCompatibility(
return destType;
}
if (rhptee->isVoidType() && lhptee->isIncompleteOrObjectType()) {
- QualType destPointee =
- S.Context.getQualifiedType(rhptee, lhptee.getQualifiers());
+ QualType destPointee
+ = S.Context.getQualifiedType(rhptee, lhptee.getQualifiers());
QualType destType = S.Context.getPointerType(destPointee);
// Add qualifiers if necessary.
RHS = S.ImpCastExprToType(RHS.get(), destType, CK_NoOp);
@@ -8598,7 +8602,7 @@ static QualType checkConditionalObjectPointersCompatibility(
/// Return false if the first expression is not an integer and the second
/// expression is not a pointer, true otherwise.
static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int,
- Expr *PointerExpr, SourceLocation Loc,
+ Expr* PointerExpr, SourceLocation Loc,
bool IsIntFirstExpr) {
if (!PointerExpr->getType()->isPointerType() ||
!Int.get()->getType()->isIntegerType())
@@ -8608,8 +8612,8 @@ static bool checkPointerIntegerMismatch(Sema &S, ExprResult &Int,
Expr *Expr2 = IsIntFirstExpr ? PointerExpr : Int.get();
S.Diag(Loc, diag::ext_typecheck_cond_pointer_integer_mismatch)
- << Expr1->getType() << Expr2->getType() << Expr1->getSourceRange()
- << Expr2->getSourceRange();
+ << Expr1->getType() << Expr2->getType()
+ << Expr1->getSourceRange() << Expr2->getSourceRange();
Int = S.ImpCastExprToType(Int.get(), PointerExpr->getType(),
CK_IntegralToPointer);
return true;
@@ -8640,19 +8644,19 @@ static QualType OpenCLArithmeticConversions(Sema &S, ExprResult &LHS,
// For conversion purposes, we ignore any qualifiers.
// For example, "const float" and "float" are equivalent.
QualType LHSType =
- S.Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType();
+ S.Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType();
QualType RHSType =
- S.Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType();
+ S.Context.getCanonicalType(RHS.get()->getType()).getUnqualifiedType();
if (!LHSType->isIntegerType() && !LHSType->isRealFloatingType()) {
S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
- << LHSType << LHS.get()->getSourceRange();
+ << LHSType << LHS.get()->getSourceRange();
return QualType();
}
if (!RHSType->isIntegerType() && !RHSType->isRealFloatingType()) {
S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_int_float)
- << RHSType << RHS.get()->getSourceRange();
+ << RHSType << RHS.get()->getSourceRange();
return QualType();
}
@@ -8666,8 +8670,8 @@ static QualType OpenCLArithmeticConversions(Sema &S, ExprResult &LHS,
/*IsCompAssign = */ false);
// Finally, we have two differing integer types.
- return handleIntegerConversion<doIntegralCast, doIntegralCast>(
- S, LHS, RHS, LHSType, RHSType, /*IsCompAssign = */ false);
+ return handleIntegerConversion<doIntegralCast, doIntegralCast>
+ (S, LHS, RHS, LHSType, RHSType, /*IsCompAssign = */ false);
}
/// Convert scalar operands to a vector that matches the
@@ -8681,12 +8685,11 @@ static QualType OpenCLArithmeticConversions(Sema &S, ExprResult &LHS,
/// into a vector of that type where the length matches the condition
/// vector type. s6.11.6 requires that the element types of the result
/// and the condition must have the same number of bits.
-static QualType OpenCLConvertScalarsToVectors(Sema &S, ExprResult &LHS,
- ExprResult &RHS, QualType CondTy,
- SourceLocation QuestionLoc) {
+static QualType
+OpenCLConvertScalarsToVectors(Sema &S, ExprResult &LHS, ExprResult &RHS,
+ QualType CondTy, SourceLocation QuestionLoc) {
QualType ResTy = OpenCLArithmeticConversions(S, LHS, RHS, QuestionLoc);
- if (ResTy.isNull())
- return QualType();
+ if (ResTy.isNull()) return QualType();
const VectorType *CV = CondTy->getAs<VectorType>();
assert(CV);
@@ -8696,8 +8699,8 @@ static QualType OpenCLConvertScalarsToVectors(Sema &S, ExprResult &LHS,
QualType VectorTy = S.Context.getExtVectorType(ResTy, NumElements);
// Ensure that all types have the same number of bits
- if (S.Context.getTypeSize(CV->getElementType()) !=
- S.Context.getTypeSize(ResTy)) {
+ if (S.Context.getTypeSize(CV->getElementType())
+ != S.Context.getTypeSize(ResTy)) {
// Since VectorTy is created internally, it does not pretty print
// with an OpenCL name. Instead, we just print a description.
std::string EleTyName = ResTy.getUnqualifiedType().getAsString();
@@ -8705,7 +8708,7 @@ static QualType OpenCLConvertScalarsToVectors(Sema &S, ExprResult &LHS,
llvm::raw_svector_ostream OS(Str);
OS << "(vector of " << NumElements << " '" << EleTyName << "' values)";
S.Diag(QuestionLoc, diag::err_conditional_vector_element_size)
- << CondTy << OS.str();
+ << CondTy << OS.str();
return QualType();
}
@@ -8724,11 +8727,10 @@ static bool checkOpenCLConditionVector(Sema &S, Expr *Cond,
const VectorType *CondTy = Cond->getType()->getAs<VectorType>();
assert(CondTy);
QualType EleTy = CondTy->getElementType();
- if (EleTy->isIntegerType())
- return false;
+ if (EleTy->isIntegerType()) return false;
S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
- << Cond->getType() << Cond->getSourceRange();
+ << Cond->getType() << Cond->getSourceRange();
return true;
}
@@ -8746,7 +8748,7 @@ static bool checkVectorResult(Sema &S, QualType CondTy, QualType VecResTy,
if (CV->getNumElements() != RV->getNumElements()) {
S.Diag(QuestionLoc, diag::err_conditional_vector_size)
- << CondTy << VecResTy;
+ << CondTy << VecResTy;
return true;
}
@@ -8767,9 +8769,10 @@ static bool checkVectorResult(Sema &S, QualType CondTy, QualType VecResTy,
/// Return the resulting type for the conditional operator in
/// OpenCL (aka "ternary selection operator", OpenCL v1.1
/// s6.3.i) when the condition is a vector type.
-static QualType OpenCLCheckVectorConditional(Sema &S, ExprResult &Cond,
- ExprResult &LHS, ExprResult &RHS,
- SourceLocation QuestionLoc) {
+static QualType
+OpenCLCheckVectorConditional(Sema &S, ExprResult &Cond,
+ ExprResult &LHS, ExprResult &RHS,
+ SourceLocation QuestionLoc) {
Cond = S.DefaultFunctionArrayLvalueConversion(Cond.get());
if (Cond.isInvalid())
return QualType();
@@ -8830,13 +8833,11 @@ QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
SourceLocation QuestionLoc) {
ExprResult LHSResult = CheckPlaceholderExpr(LHS.get());
- if (!LHSResult.isUsable())
- return QualType();
+ if (!LHSResult.isUsable()) return QualType();
LHS = LHSResult;
ExprResult RHSResult = CheckPlaceholderExpr(RHS.get());
- if (!RHSResult.isUsable())
- return QualType();
+ if (!RHSResult.isUsable()) return QualType();
RHS = RHSResult;
// C++ is sufficiently different to merit its own checker.
@@ -8895,16 +8896,16 @@ QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
// Diagnose attempts to convert between __ibm128, __float128 and long double
// where such conversions currently can't be handled.
if (unsupportedTypeConversion(*this, LHSTy, RHSTy)) {
- Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
- << LHSTy << RHSTy << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ Diag(QuestionLoc,
+ diag::err_typecheck_cond_incompatible_operands) << LHSTy << RHSTy
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
return QualType();
}
// OpenCL v2.0 s6.12.5 - Blocks cannot be used as expressions of the ternary
// selection operator (?:).
- if (getLangOpts().OpenCL && ((int)checkBlockType(*this, LHS.get()) |
- (int)checkBlockType(*this, RHS.get()))) {
+ if (getLangOpts().OpenCL &&
+ ((int)checkBlockType(*this, LHS.get()) | (int)checkBlockType(*this, RHS.get()))) {
return QualType();
}
@@ -8963,10 +8964,8 @@ QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
// C99 6.5.15p6 - "if one operand is a null pointer constant, the result has
// the type of the other operand."
- if (!checkConditionalNullPointer(*this, RHS, LHSTy))
- return LHSTy;
- if (!checkConditionalNullPointer(*this, LHS, RHSTy))
- return RHSTy;
+ if (!checkConditionalNullPointer(*this, RHS, LHSTy)) return LHSTy;
+ if (!checkConditionalNullPointer(*this, LHS, RHSTy)) return RHSTy;
// All objective-c pointer type analysis is done here.
QualType compositeType =
@@ -8976,6 +8975,7 @@ QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
if (!compositeType.isNull())
return compositeType;
+
// Handle block pointer types.
if (LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType())
return checkConditionalBlockPointerCompatibility(*this, LHS, RHS,
@@ -8989,10 +8989,10 @@ QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
// GCC compatibility: soften pointer/integer mismatch. Note that
// null pointers have been filtered out by this point.
if (checkPointerIntegerMismatch(*this, LHS, RHS.get(), QuestionLoc,
- /*IsIntFirstExpr=*/true))
+ /*IsIntFirstExpr=*/true))
return RHSTy;
if (checkPointerIntegerMismatch(*this, RHS, LHS.get(), QuestionLoc,
- /*IsIntFirstExpr=*/false))
+ /*IsIntFirstExpr=*/false))
return LHSTy;
// Emit a better diagnostic if one of the expressions is a null pointer
@@ -9008,8 +9008,8 @@ QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
// Otherwise, the operands are not compatible.
Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
- << LHSTy << RHSTy << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ << LHSTy << RHSTy << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
return QualType();
}
@@ -9021,9 +9021,9 @@ static void SuggestParentheses(Sema &Self, SourceLocation Loc,
SourceLocation EndLoc = Self.getLocForEndOfToken(ParenRange.getEnd());
if (ParenRange.getBegin().isFileID() && ParenRange.getEnd().isFileID() &&
EndLoc.isValid()) {
- Self.Diag(Loc, Note) << FixItHint::CreateInsertion(ParenRange.getBegin(),
- "(")
- << FixItHint::CreateInsertion(EndLoc, ")");
+ Self.Diag(Loc, Note)
+ << FixItHint::CreateInsertion(ParenRange.getBegin(), "(")
+ << FixItHint::CreateInsertion(EndLoc, ")");
} else {
// We can't display the parentheses, so just show the bare note.
Self.Diag(Loc, Note) << ParenRange;
@@ -9072,8 +9072,8 @@ static bool IsArithmeticBinaryExpr(const Expr *E, BinaryOperatorKind *Opcode,
// Make sure this is really a binary operator that is safe to pass into
// BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op.
OverloadedOperatorKind OO = Call->getOperator();
- if (OO < OO_Plus || OO > OO_Arrow || OO == OO_PlusPlus ||
- OO == OO_MinusMinus)
+ if (OO < OO_Plus || OO > OO_Arrow ||
+ OO == OO_PlusPlus || OO == OO_MinusMinus)
return false;
BinaryOperatorKind OpKind = BinaryOperator::getOverloadedOpcode(OO);
@@ -9129,8 +9129,9 @@ static void DiagnoseConditionalPrecedence(Sema &Self, SourceLocation OpLoc,
? diag::warn_precedence_bitwise_conditional
: diag::warn_precedence_conditional;
- Self.Diag(OpLoc, DiagID) << Condition->getSourceRange()
- << BinaryOperator::getOpcodeStr(CondOpcode);
+ Self.Diag(OpLoc, DiagID)
+ << Condition->getSourceRange()
+ << BinaryOperator::getOpcodeStr(CondOpcode);
SuggestParentheses(
Self, OpLoc,
@@ -9170,7 +9171,7 @@ static QualType computeConditionalNullability(QualType ResTy, bool IsBin,
MergedKind = NullabilityKind::NonNull;
else
MergedKind = RHSKind;
- // Compute nullability of a normal conditional expression.
+ // Compute nullability of a normal conditional expression.
} else {
if (LHSKind == NullabilityKind::Nullable ||
RHSKind == NullabilityKind::Nullable)
@@ -9196,8 +9197,9 @@ static QualType computeConditionalNullability(QualType ResTy, bool IsBin,
}
ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
- SourceLocation ColonLoc, Expr *CondExpr,
- Expr *LHSExpr, Expr *RHSExpr) {
+ SourceLocation ColonLoc,
+ Expr *CondExpr, Expr *LHSExpr,
+ Expr *RHSExpr) {
// If this is the gnu "x ?: y" extension, analyze the types as though the LHS
// was the condition.
OpaqueValueExpr *opaqueValue = nullptr;
@@ -9209,17 +9211,18 @@ ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
// as Objective-C++'s dictionary subscripting syntax.
if (commonExpr->hasPlaceholderType()) {
ExprResult result = CheckPlaceholderExpr(commonExpr);
- if (!result.isUsable())
- return ExprError();
+ if (!result.isUsable()) return ExprError();
commonExpr = result.get();
}
// We usually want to apply unary conversions *before* saving, except
// in the special case of a C++ l-value conditional.
- if (!(getLangOpts().CPlusPlus && !commonExpr->isTypeDependent() &&
- commonExpr->getValueKind() == RHSExpr->getValueKind() &&
- commonExpr->isGLValue() && commonExpr->isOrdinaryOrBitFieldObject() &&
- RHSExpr->isOrdinaryOrBitFieldObject() &&
- Context.hasSameType(commonExpr->getType(), RHSExpr->getType()))) {
+ if (!(getLangOpts().CPlusPlus
+ && !commonExpr->isTypeDependent()
+ && commonExpr->getValueKind() == RHSExpr->getValueKind()
+ && commonExpr->isGLValue()
+ && commonExpr->isOrdinaryOrBitFieldObject()
+ && RHSExpr->isOrdinaryOrBitFieldObject()
+ && Context.hasSameType(commonExpr->getType(), RHSExpr->getType()))) {
ExprResult commonRes = UsualUnaryConversions(commonExpr);
if (commonRes.isInvalid())
return ExprError();
@@ -9236,9 +9239,11 @@ ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
commonExpr = MatExpr.get();
}
- opaqueValue = new (Context) OpaqueValueExpr(
- commonExpr->getExprLoc(), commonExpr->getType(),
- commonExpr->getValueKind(), commonExpr->getObjectKind(), commonExpr);
+ opaqueValue = new (Context) OpaqueValueExpr(commonExpr->getExprLoc(),
+ commonExpr->getType(),
+ commonExpr->getValueKind(),
+ commonExpr->getObjectKind(),
+ commonExpr);
LHSExpr = CondExpr = opaqueValue;
}
@@ -9246,9 +9251,10 @@ ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
ExprValueKind VK = VK_PRValue;
ExprObjectKind OK = OK_Ordinary;
ExprResult Cond = CondExpr, LHS = LHSExpr, RHS = RHSExpr;
- QualType result =
- CheckConditionalOperands(Cond, LHS, RHS, VK, OK, QuestionLoc);
- if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() || RHS.isInvalid())
+ QualType result = CheckConditionalOperands(Cond, LHS, RHS,
+ VK, OK, QuestionLoc);
+ if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() ||
+ RHS.isInvalid())
return ExprError();
DiagnoseConditionalPrecedence(*this, QuestionLoc, Cond.get(), LHS.get(),
@@ -9256,8 +9262,8 @@ ExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc,
CheckBoolLikeConversion(Cond.get(), QuestionLoc);
- result =
- computeConditionalNullability(result, commonExpr, LHSTy, RHSTy, Context);
+ result = computeConditionalNullability(result, commonExpr, LHSTy, RHSTy,
+ Context);
if (!commonExpr)
return new (Context)
@@ -9431,9 +9437,9 @@ static AssignConvertType checkPointerTypesForAssignment(Sema &S,
if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) {
do {
std::tie(lhptee, lhq) =
- cast<PointerType>(lhptee)->getPointeeType().split().asPair();
+ cast<PointerType>(lhptee)->getPointeeType().split().asPair();
std::tie(rhptee, rhq) =
- cast<PointerType>(rhptee)->getPointeeType().split().asPair();
+ cast<PointerType>(rhptee)->getPointeeType().split().asPair();
// Inconsistent address spaces at this point is invalid, even if the
// address spaces would be compatible.
@@ -10039,8 +10045,8 @@ static void ConstructTransparentUnion(Sema &S, ASTContext &C,
// Build an initializer list that designates the appropriate member
// of the transparent union.
Expr *E = EResult.get();
- InitListExpr *Initializer =
- new (C) InitListExpr(C, SourceLocation(), E, SourceLocation());
+ InitListExpr *Initializer = new (C) InitListExpr(C, SourceLocation(),
+ E, SourceLocation());
Initializer->setType(UnionType);
Initializer->setInitializedFieldInUnion(Field);
@@ -10083,7 +10089,8 @@ Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType,
if (RHS.get()->isNullPointerConstant(Context,
Expr::NPC_ValueDependentIsNull)) {
- RHS = ImpCastExprToType(RHS.get(), it->getType(), CK_NullToPointer);
+ RHS = ImpCastExprToType(RHS.get(), it->getType(),
+ CK_NullToPointer);
InitField = it;
break;
}
@@ -10141,12 +10148,13 @@ AssignConvertType Sema::CheckSingleAssignmentConstraints(QualType LHSType,
RHS = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
AssignmentAction::Assigning);
} else {
- ImplicitConversionSequence ICS = TryImplicitConversion(
- RHS.get(), LHSType.getUnqualifiedType(),
- /*SuppressUserConversions=*/false, AllowedExplicit::None,
- /*InOverloadResolution=*/false,
- /*CStyle=*/false,
- /*AllowObjCWritebackConversion=*/false);
+ ImplicitConversionSequence ICS =
+ TryImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
+ /*SuppressUserConversions=*/false,
+ AllowedExplicit::None,
+ /*InOverloadResolution=*/false,
+ /*CStyle=*/false,
+ /*AllowObjCWritebackConversion=*/false);
if (ICS.isFailure())
return AssignConvertType::Incompatible;
RHS = PerformImplicitConversion(RHS.get(), LHSType.getUnqualifiedType(),
@@ -10348,27 +10356,27 @@ struct OriginalOperand {
Expr *Orig;
NamedDecl *Conversion;
};
-} // namespace
+}
QualType Sema::InvalidOperands(SourceLocation Loc, ExprResult &LHS,
ExprResult &RHS) {
OriginalOperand OrigLHS(LHS.get()), OrigRHS(RHS.get());
Diag(Loc, diag::err_typecheck_invalid_operands)
- << OrigLHS.getType() << OrigRHS.getType() << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ << OrigLHS.getType() << OrigRHS.getType()
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
// If a user-defined conversion was applied to either of the operands prior
// to applying the built-in operator rules, tell the user about it.
if (OrigLHS.Conversion) {
Diag(OrigLHS.Conversion->getLocation(),
diag::note_typecheck_invalid_operands_converted)
- << 0 << LHS.get()->getType();
+ << 0 << LHS.get()->getType();
}
if (OrigRHS.Conversion) {
Diag(OrigRHS.Conversion->getLocation(),
diag::note_typecheck_invalid_operands_converted)
- << 1 << RHS.get()->getType();
+ << 1 << RHS.get()->getType();
}
return QualType();
@@ -10411,8 +10419,10 @@ QualType Sema::InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS,
/// \param scalar - if non-null, actually perform the conversions
/// \return true if the operation fails (but without diagnosing the failure)
static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar,
- QualType scalarTy, QualType vectorEltTy,
- QualType vectorTy, unsigned &DiagID) {
+ QualType scalarTy,
+ QualType vectorEltTy,
+ QualType vectorTy,
+ unsigned &DiagID) {
// The conversion to apply to the scalar before splatting it,
// if necessary.
CastKind scalarCast = CK_NoOp;
@@ -10420,10 +10430,9 @@ static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar,
if (vectorEltTy->isBooleanType() && scalarTy->isIntegralType(S.Context)) {
scalarCast = CK_IntegralToBoolean;
} else if (vectorEltTy->isIntegralType(S.Context)) {
- if (S.getLangOpts().OpenCL &&
- (scalarTy->isRealFloatingType() ||
- (scalarTy->isIntegerType() &&
- S.Context.getIntegerTypeOrder(vectorEltTy, scalarTy) < 0))) {
+ if (S.getLangOpts().OpenCL && (scalarTy->isRealFloatingType() ||
+ (scalarTy->isIntegerType() &&
+ S.Context.getIntegerTypeOrder(vectorEltTy, scalarTy) < 0))) {
DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
return true;
}
@@ -10438,7 +10447,8 @@ static bool tryVectorConvertAndSplat(Sema &S, ExprResult *scalar,
return true;
}
scalarCast = CK_FloatingCast;
- } else if (scalarTy->isIntegralType(S.Context))
+ }
+ else if (scalarTy->isIntegralType(S.Context))
scalarCast = CK_IntegralToFloating;
else
return true;
@@ -10868,11 +10878,11 @@ QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
if (!IsCompAssign) {
*OtherExpr = ImpCastExprToType(OtherExpr->get(), VecType, CK_BitCast);
return VecType;
- // In a compound assignment, lhs += rhs, 'lhs' is a lvalue src, forbidding
- // any implicit cast. Here, the 'rhs' should be implicit casted to 'lhs'
- // type. Note that this is already done by non-compound assignments in
- // CheckAssignmentConstraints. If it's a scalar type, only bitcast for
- // <1 x T> -> T. The result is also a vector type.
+ // In a compound assignment, lhs += rhs, 'lhs' is a lvalue src, forbidding
+ // any implicit cast. Here, the 'rhs' should be implicit casted to 'lhs'
+ // type. Note that this is already done by non-compound assignments in
+ // CheckAssignmentConstraints. If it's a scalar type, only bitcast for
+ // <1 x T> -> T. The result is also a vector type.
} else if (OtherType->isExtVectorType() || OtherType->isVectorType() ||
(OtherType->isScalarType() && VT->getNumElements() == 1)) {
ExprResult *RHSExpr = &RHS;
@@ -10887,8 +10897,8 @@ QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
if ((!RHSVecType && !RHSType->isRealType()) ||
(!LHSVecType && !LHSType->isRealType())) {
Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
- << LHSType << RHSType << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ << LHSType << RHSType
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
return QualType();
}
@@ -10896,13 +10906,15 @@ QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
// If the operands are of more than one vector type, then an error shall
// occur. Implicit conversions between vector types are not permitted, per
// section 6.2.1.
- if (getLangOpts().OpenCL && RHSVecType && isa<ExtVectorType>(RHSVecType) &&
+ if (getLangOpts().OpenCL &&
+ RHSVecType && isa<ExtVectorType>(RHSVecType) &&
LHSVecType && isa<ExtVectorType>(LHSVecType)) {
- Diag(Loc, diag::err_opencl_implicit_vector_conversion)
- << LHSType << RHSType;
+ Diag(Loc, diag::err_opencl_implicit_vector_conversion) << LHSType
+ << RHSType;
return QualType();
}
+
// If there is a vector type that is not a ExtVector and a scalar, we reach
// this point if scalar could not be converted to the vector's element type
// without truncation.
@@ -10911,15 +10923,17 @@ QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
QualType Scalar = LHSVecType ? RHSType : LHSType;
QualType Vector = LHSVecType ? LHSType : RHSType;
unsigned ScalarOrVector = LHSVecType && RHSVecType ? 1 : 0;
- Diag(Loc, diag::err_typecheck_vector_not_convertable_implict_truncation)
+ Diag(Loc,
+ diag::err_typecheck_vector_not_convertable_implict_truncation)
<< ScalarOrVector << Scalar << Vector;
return QualType();
}
// Otherwise, use the generic diagnostic.
- Diag(Loc, DiagID) << LHSType << RHSType << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ Diag(Loc, DiagID)
+ << LHSType << RHSType
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
return QualType();
}
@@ -11033,8 +11047,8 @@ static void checkArithmeticNull(Sema &S, ExprResult &LHS, ExprResult &RHS,
return;
S.Diag(Loc, diag::warn_null_in_comparison_operation)
- << LHSNull /* LHS is NULL */ << NonNullType << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ << LHSNull /* LHS is NULL */ << NonNullType
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
}
static void DetectPrecisionLossInComplexDivision(Sema &S, QualType DivisorTy,
@@ -11077,7 +11091,7 @@ static void DetectPrecisionLossInComplexDivision(Sema &S, QualType DivisorTy,
}
static void DiagnoseDivisionSizeofPointerOrArray(Sema &S, Expr *LHS, Expr *RHS,
- SourceLocation Loc) {
+ SourceLocation Loc) {
const auto *LUE = dyn_cast<UnaryExprOrTypeTraitExpr>(LHS);
const auto *RUE = dyn_cast<UnaryExprOrTypeTraitExpr>(RHS);
if (!LUE || !RUE)
@@ -11124,7 +11138,7 @@ static void DiagnoseDivisionSizeofPointerOrArray(Sema &S, Expr *LHS, Expr *RHS,
}
}
-static void DiagnoseBadDivideOrRemainderValues(Sema &S, ExprResult &LHS,
+static void DiagnoseBadDivideOrRemainderValues(Sema& S, ExprResult &LHS,
ExprResult &RHS,
SourceLocation Loc, bool IsDiv) {
// Check for division/remainder by zero.
@@ -11134,7 +11148,7 @@ static void DiagnoseBadDivideOrRemainderValues(Sema &S, ExprResult &LHS,
RHSValue.Val.getInt() == 0)
S.DiagRuntimeBehavior(Loc, RHS.get(),
S.PDiag(diag::warn_remainder_division_by_zero)
- << IsDiv << RHS.get()->getSourceRange());
+ << IsDiv << RHS.get()->getSourceRange());
}
static void diagnoseScopedEnums(Sema &S, const SourceLocation Loc,
@@ -11221,8 +11235,8 @@ QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS,
return compType;
}
-QualType Sema::CheckRemainderOperands(ExprResult &LHS, ExprResult &RHS,
- SourceLocation Loc, bool IsCompAssign) {
+QualType Sema::CheckRemainderOperands(
+ ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign) {
checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
// Note: This check is here to simplify the double exclusions of
@@ -11289,19 +11303,19 @@ QualType Sema::CheckRemainderOperands(ExprResult &LHS, ExprResult &RHS,
static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc,
Expr *LHSExpr, Expr *RHSExpr) {
S.Diag(Loc, S.getLangOpts().CPlusPlus
- ? diag::err_typecheck_pointer_arith_void_type
- : diag::ext_gnu_void_ptr)
- << 1 /* two pointers */ << LHSExpr->getSourceRange()
- << RHSExpr->getSourceRange();
+ ? diag::err_typecheck_pointer_arith_void_type
+ : diag::ext_gnu_void_ptr)
+ << 1 /* two pointers */ << LHSExpr->getSourceRange()
+ << RHSExpr->getSourceRange();
}
/// Diagnose invalid arithmetic on a void pointer.
static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc,
Expr *Pointer) {
S.Diag(Loc, S.getLangOpts().CPlusPlus
- ? diag::err_typecheck_pointer_arith_void_type
- : diag::ext_gnu_void_ptr)
- << 0 /* one pointer */ << Pointer->getSourceRange();
+ ? diag::err_typecheck_pointer_arith_void_type
+ : diag::ext_gnu_void_ptr)
+ << 0 /* one pointer */ << Pointer->getSourceRange();
}
/// Diagnose invalid arithmetic on a null pointer.
@@ -11312,10 +11326,11 @@ static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc,
static void diagnoseArithmeticOnNullPointer(Sema &S, SourceLocation Loc,
Expr *Pointer, bool IsGNUIdiom) {
if (IsGNUIdiom)
- S.Diag(Loc, diag::warn_gnu_null_ptr_arith) << Pointer->getSourceRange();
+ S.Diag(Loc, diag::warn_gnu_null_ptr_arith)
+ << Pointer->getSourceRange();
else
S.Diag(Loc, diag::warn_pointer_arith_null_ptr)
- << S.getLangOpts().CPlusPlus << Pointer->getSourceRange();
+ << S.getLangOpts().CPlusPlus << Pointer->getSourceRange();
}
/// Diagnose invalid subraction on a null pointer.
@@ -11342,15 +11357,14 @@ static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc,
assert(LHS->getType()->isAnyPointerType());
assert(RHS->getType()->isAnyPointerType());
S.Diag(Loc, S.getLangOpts().CPlusPlus
- ? diag::err_typecheck_pointer_arith_function_type
- : diag::ext_gnu_ptr_func_arith)
- << 1 /* two pointers */
- << LHS->getType()->getPointeeType()
- // We only show the second type if it differs from the first.
- << (unsigned)!S.Context.hasSameUnqualifiedType(LHS->getType(),
- RHS->getType())
- << RHS->getType()->getPointeeType() << LHS->getSourceRange()
- << RHS->getSourceRange();
+ ? diag::err_typecheck_pointer_arith_function_type
+ : diag::ext_gnu_ptr_func_arith)
+ << 1 /* two pointers */ << LHS->getType()->getPointeeType()
+ // We only show the second type if it differs from the first.
+ << (unsigned)!S.Context.hasSameUnqualifiedType(LHS->getType(),
+ RHS->getType())
+ << RHS->getType()->getPointeeType()
+ << LHS->getSourceRange() << RHS->getSourceRange();
}
/// Diagnose invalid arithmetic on a function pointer.
@@ -11358,11 +11372,11 @@ static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc,
Expr *Pointer) {
assert(Pointer->getType()->isAnyPointerType());
S.Diag(Loc, S.getLangOpts().CPlusPlus
- ? diag::err_typecheck_pointer_arith_function_type
- : diag::ext_gnu_ptr_func_arith)
- << 0 /* one pointer */ << Pointer->getType()->getPointeeType()
- << 0 /* one pointer, so only one type */
- << Pointer->getSourceRange();
+ ? diag::err_typecheck_pointer_arith_function_type
+ : diag::ext_gnu_ptr_func_arith)
+ << 0 /* one pointer */ << Pointer->getType()->getPointeeType()
+ << 0 /* one pointer, so only one type */
+ << Pointer->getSourceRange();
}
/// Emit error if Operand is incomplete pointer type
@@ -11396,8 +11410,7 @@ static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc,
if (const AtomicType *ResAtomicType = ResType->getAs<AtomicType>())
ResType = ResAtomicType->getValueType();
- if (!ResType->isAnyPointerType())
- return true;
+ if (!ResType->isAnyPointerType()) return true;
QualType PointeeTy = ResType->getPointeeType();
if (PointeeTy->isVoidType()) {
@@ -11409,8 +11422,7 @@ static bool checkArithmeticOpPointerOperand(Sema &S, SourceLocation Loc,
return !S.getLangOpts().CPlusPlus;
}
- if (checkArithmeticIncompletePointerType(S, Loc, Operand))
- return false;
+ if (checkArithmeticIncompletePointerType(S, Loc, Operand)) return false;
return true;
}
@@ -11428,14 +11440,11 @@ static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc,
Expr *LHSExpr, Expr *RHSExpr) {
bool isLHSPointer = LHSExpr->getType()->isAnyPointerType();
bool isRHSPointer = RHSExpr->getType()->isAnyPointerType();
- if (!isLHSPointer && !isRHSPointer)
- return true;
+ if (!isLHSPointer && !isRHSPointer) return true;
QualType LHSPointeeTy, RHSPointeeTy;
- if (isLHSPointer)
- LHSPointeeTy = LHSExpr->getType()->getPointeeType();
- if (isRHSPointer)
- RHSPointeeTy = RHSExpr->getType()->getPointeeType();
+ if (isLHSPointer) LHSPointeeTy = LHSExpr->getType()->getPointeeType();
+ if (isRHSPointer) RHSPointeeTy = RHSExpr->getType()->getPointeeType();
// if both are pointers check if operation is valid wrt address spaces
if (isLHSPointer && isRHSPointer) {
@@ -11453,12 +11462,9 @@ static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc,
bool isLHSVoidPtr = isLHSPointer && LHSPointeeTy->isVoidType();
bool isRHSVoidPtr = isRHSPointer && RHSPointeeTy->isVoidType();
if (isLHSVoidPtr || isRHSVoidPtr) {
- if (!isRHSVoidPtr)
- diagnoseArithmeticOnVoidPointer(S, Loc, LHSExpr);
- else if (!isLHSVoidPtr)
- diagnoseArithmeticOnVoidPointer(S, Loc, RHSExpr);
- else
- diagnoseArithmeticOnTwoVoidPointers(S, Loc, LHSExpr, RHSExpr);
+ if (!isRHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, LHSExpr);
+ else if (!isLHSVoidPtr) diagnoseArithmeticOnVoidPointer(S, Loc, RHSExpr);
+ else diagnoseArithmeticOnTwoVoidPointers(S, Loc, LHSExpr, RHSExpr);
return !S.getLangOpts().CPlusPlus;
}
@@ -11466,12 +11472,10 @@ static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc,
bool isLHSFuncPtr = isLHSPointer && LHSPointeeTy->isFunctionType();
bool isRHSFuncPtr = isRHSPointer && RHSPointeeTy->isFunctionType();
if (isLHSFuncPtr || isRHSFuncPtr) {
- if (!isRHSFuncPtr)
- diagnoseArithmeticOnFunctionPointer(S, Loc, LHSExpr);
- else if (!isLHSFuncPtr)
- diagnoseArithmeticOnFunctionPointer(S, Loc, RHSExpr);
- else
- diagnoseArithmeticOnTwoFunctionPointers(S, Loc, LHSExpr, RHSExpr);
+ if (!isRHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc, LHSExpr);
+ else if (!isLHSFuncPtr) diagnoseArithmeticOnFunctionPointer(S, Loc,
+ RHSExpr);
+ else diagnoseArithmeticOnTwoFunctionPointers(S, Loc, LHSExpr, RHSExpr);
return !S.getLangOpts().CPlusPlus;
}
@@ -11488,15 +11492,15 @@ static bool checkArithmeticBinOpPointerOperands(Sema &S, SourceLocation Loc,
/// literal.
static void diagnoseStringPlusInt(Sema &Self, SourceLocation OpLoc,
Expr *LHSExpr, Expr *RHSExpr) {
- StringLiteral *StrExpr = dyn_cast<StringLiteral>(LHSExpr->IgnoreImpCasts());
- Expr *IndexExpr = RHSExpr;
+ StringLiteral* StrExpr = dyn_cast<StringLiteral>(LHSExpr->IgnoreImpCasts());
+ Expr* IndexExpr = RHSExpr;
if (!StrExpr) {
StrExpr = dyn_cast<StringLiteral>(RHSExpr->IgnoreImpCasts());
IndexExpr = LHSExpr;
}
- bool IsStringPlusInt =
- StrExpr && IndexExpr->getType()->isIntegralOrUnscopedEnumerationType();
+ bool IsStringPlusInt = StrExpr &&
+ IndexExpr->getType()->isIntegralOrUnscopedEnumerationType();
if (!IsStringPlusInt || IndexExpr->isValueDependent())
return;
@@ -11544,9 +11548,11 @@ static void diagnoseStringPlusChar(Sema &Self, SourceLocation OpLoc,
SourceRange DiagRange(LHSExpr->getBeginLoc(), RHSExpr->getEndLoc());
const QualType CharType = CharExpr->getType();
- if (!CharType->isAnyCharacterType() && CharType->isIntegerType() &&
+ if (!CharType->isAnyCharacterType() &&
+ CharType->isIntegerType() &&
llvm::isUIntN(Ctx.getCharWidth(), CharExpr->getValue())) {
- Self.Diag(OpLoc, diag::warn_string_plus_char) << DiagRange << Ctx.CharTy;
+ Self.Diag(OpLoc, diag::warn_string_plus_char)
+ << DiagRange << Ctx.CharTy;
} else {
Self.Diag(OpLoc, diag::warn_string_plus_char)
<< DiagRange << CharExpr->getType();
@@ -11570,14 +11576,14 @@ static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc,
assert(LHSExpr->getType()->isAnyPointerType());
assert(RHSExpr->getType()->isAnyPointerType());
S.Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
- << LHSExpr->getType() << RHSExpr->getType() << LHSExpr->getSourceRange()
- << RHSExpr->getSourceRange();
+ << LHSExpr->getType() << RHSExpr->getType() << LHSExpr->getSourceRange()
+ << RHSExpr->getSourceRange();
}
// C99 6.5.6
QualType Sema::CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS,
SourceLocation Loc, BinaryOperatorKind Opc,
- QualType *CompLHSTy) {
+ QualType* CompLHSTy) {
checkArithmeticNull(*this, LHS, RHS, Loc, /*IsCompare=*/false);
if (LHS.get()->getType()->isVectorType() ||
@@ -11588,8 +11594,7 @@ QualType Sema::CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS,
/*AllowBoolConversions*/ getLangOpts().ZVector,
/*AllowBooleanOperation*/ false,
/*ReportInvalid*/ true);
- if (CompLHSTy)
- *CompLHSTy = compType;
+ if (CompLHSTy) *CompLHSTy = compType;
return compType;
}
@@ -11625,8 +11630,7 @@ QualType Sema::CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS,
// handle the common case first (both operands are arithmetic).
if (!compType.isNull() && compType->isArithmeticType()) {
- if (CompLHSTy)
- *CompLHSTy = compType;
+ if (CompLHSTy) *CompLHSTy = compType;
return compType;
}
@@ -11661,9 +11665,10 @@ QualType Sema::CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS,
Context, Expr::NPC_ValueDependentIsNotNull)) {
// In C++ adding zero to a null pointer is defined.
Expr::EvalResult KnownVal;
- if (!getLangOpts().CPlusPlus || (!IExp->isValueDependent() &&
- (!IExp->EvaluateAsInt(KnownVal, Context) ||
- KnownVal.Val.getInt() != 0))) {
+ if (!getLangOpts().CPlusPlus ||
+ (!IExp->isValueDependent() &&
+ (!IExp->EvaluateAsInt(KnownVal, Context) ||
+ KnownVal.Val.getInt() != 0))) {
// Check the conditions to see if this is the 'p = nullptr + n' idiom.
bool IsGNUIdiom = BinaryOperator::isNullPointerArithmeticExtension(
Context, BO_Add, PExp, IExp);
@@ -11716,8 +11721,7 @@ QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
/*AllowBoolConversions*/ getLangOpts().ZVector,
/*AllowBooleanOperation*/ false,
/*ReportInvalid*/ true);
- if (CompLHSTy)
- *CompLHSTy = compType;
+ if (CompLHSTy) *CompLHSTy = compType;
return compType;
}
@@ -11749,8 +11753,7 @@ QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
// Handle the common case first (both operands are arithmetic).
if (!compType.isNull() && compType->isArithmeticType()) {
- if (CompLHSTy)
- *CompLHSTy = compType;
+ if (CompLHSTy) *CompLHSTy = compType;
return compType;
}
@@ -11777,8 +11780,8 @@ QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
// Subtracting from a null pointer should produce a warning.
// The last argument to the diagnose call says this doesn't match the
// GNU int-to-pointer idiom.
- if (LHS.get()->IgnoreParenCasts()->isNullPointerConstant(
- Context, Expr::NPC_ValueDependentIsNotNull)) {
+ if (LHS.get()->IgnoreParenCasts()->isNullPointerConstant(Context,
+ Expr::NPC_ValueDependentIsNotNull)) {
// In C++ adding zero to a null pointer is defined.
Expr::EvalResult KnownVal;
if (!getLangOpts().CPlusPlus ||
@@ -11793,17 +11796,16 @@ QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
return QualType();
// Check array bounds for pointer arithemtic
- CheckArrayAccess(LHS.get(), RHS.get(), /*ArraySubscriptExpr*/ nullptr,
- /*AllowOnePastEnd*/ true, /*IndexNegated*/ true);
+ CheckArrayAccess(LHS.get(), RHS.get(), /*ArraySubscriptExpr*/nullptr,
+ /*AllowOnePastEnd*/true, /*IndexNegated*/true);
- if (CompLHSTy)
- *CompLHSTy = LHS.get()->getType();
+ if (CompLHSTy) *CompLHSTy = LHS.get()->getType();
return LHS.get()->getType();
}
// Handle pointer-pointer subtractions.
- if (const PointerType *RHSPTy =
- RHS.get()->getType()->getAs<PointerType>()) {
+ if (const PointerType *RHSPTy
+ = RHS.get()->getType()->getAs<PointerType>()) {
QualType rpointee = RHSPTy->getPointeeType();
if (getLangOpts().CPlusPlus) {
@@ -11821,8 +11823,8 @@ QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
}
}
- if (!checkArithmeticBinOpPointerOperands(*this, Loc, LHS.get(),
- RHS.get()))
+ if (!checkArithmeticBinOpPointerOperands(*this, Loc,
+ LHS.get(), RHS.get()))
return QualType();
bool LHSIsNullPtr = LHS.get()->IgnoreParenCasts()->isNullPointerConstant(
@@ -11842,14 +11844,13 @@ QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
if (!rpointee->isVoidType() && !rpointee->isFunctionType()) {
CharUnits ElementSize = Context.getTypeSizeInChars(rpointee);
if (ElementSize.isZero()) {
- Diag(Loc, diag::warn_sub_ptr_zero_size_types)
- << rpointee.getUnqualifiedType() << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ Diag(Loc,diag::warn_sub_ptr_zero_size_types)
+ << rpointee.getUnqualifiedType()
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
}
}
- if (CompLHSTy)
- *CompLHSTy = LHS.get()->getType();
+ if (CompLHSTy) *CompLHSTy = LHS.get()->getType();
return Context.getPointerDiffType();
}
}
@@ -11865,12 +11866,11 @@ static bool isScopedEnumerationType(QualType T) {
return false;
}
-static void DiagnoseBadShiftValues(Sema &S, ExprResult &LHS, ExprResult &RHS,
+static void DiagnoseBadShiftValues(Sema& S, ExprResult &LHS, ExprResult &RHS,
SourceLocation Loc, BinaryOperatorKind Opc,
QualType LHSType) {
- // OpenCL 6.3j: shift values are effectively % word size of LHS (more
- // defined), so skip remaining warnings as we don't want to modify values
- // within Sema.
+ // OpenCL 6.3j: shift values are effectively % word size of LHS (more defined),
+ // so skip remaining warnings as we don't want to modify values within Sema.
if (S.getLangOpts().OpenCL)
return;
@@ -11958,8 +11958,8 @@ static void DiagnoseBadShiftValues(Sema &S, ExprResult &LHS, ExprResult &RHS,
// turned off separately if needed.
if (ResultBits - 1 == LeftSize) {
S.Diag(Loc, diag::warn_shift_result_sets_sign_bit)
- << HexResult << LHSType << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ << HexResult << LHSType
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
return;
}
@@ -11977,20 +11977,18 @@ static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS,
if ((S.LangOpts.OpenCL || S.LangOpts.ZVector) &&
!LHS.get()->getType()->isVectorType()) {
S.Diag(Loc, diag::err_shift_rhs_only_vector)
- << RHS.get()->getType() << LHS.get()->getType()
- << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
+ << RHS.get()->getType() << LHS.get()->getType()
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
return QualType();
}
if (!IsCompAssign) {
LHS = S.UsualUnaryConversions(LHS.get());
- if (LHS.isInvalid())
- return QualType();
+ if (LHS.isInvalid()) return QualType();
}
RHS = S.UsualUnaryConversions(RHS.get());
- if (RHS.isInvalid())
- return QualType();
+ if (RHS.isInvalid()) return QualType();
QualType LHSType = LHS.get()->getType();
// Note that LHS might be a scalar because the routine calls not only in
@@ -12015,13 +12013,13 @@ static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS,
// The operands need to be integers.
if (!LHSEleType->isIntegerType()) {
S.Diag(Loc, diag::err_typecheck_expect_int)
- << LHS.get()->getType() << LHS.get()->getSourceRange();
+ << LHS.get()->getType() << LHS.get()->getSourceRange();
return QualType();
}
if (!RHSEleType->isIntegerType()) {
S.Diag(Loc, diag::err_typecheck_expect_int)
- << RHS.get()->getType() << RHS.get()->getSourceRange();
+ << RHS.get()->getType() << RHS.get()->getSourceRange();
return QualType();
}
@@ -12030,7 +12028,7 @@ static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS,
if (IsCompAssign)
return RHSType;
if (LHSEleType != RHSEleType) {
- LHS = S.ImpCastExprToType(LHS.get(), RHSEleType, CK_IntegralCast);
+ LHS = S.ImpCastExprToType(LHS.get(),RHSEleType, CK_IntegralCast);
LHSEleType = RHSEleType;
}
QualType VecTy =
@@ -12043,8 +12041,8 @@ static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS,
// that the number of elements is the same as LHS...
if (RHSVecTy->getNumElements() != LHSVecTy->getNumElements()) {
S.Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
- << LHS.get()->getType() << RHS.get()->getType()
- << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
+ << LHS.get()->getType() << RHS.get()->getType()
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
return QualType();
}
if (!S.LangOpts.OpenCL && !S.LangOpts.ZVector) {
@@ -12060,7 +12058,7 @@ static QualType checkVectorShift(Sema &S, ExprResult &LHS, ExprResult &RHS,
} else {
// ...else expand RHS to match the number of elements in LHS.
QualType VecTy =
- S.Context.getExtVectorType(RHSEleType, LHSVecTy->getNumElements());
+ S.Context.getExtVectorType(RHSEleType, LHSVecTy->getNumElements());
RHS = S.ImpCastExprToType(RHS.get(), VecTy, CK_VectorSplat);
}
@@ -12195,8 +12193,7 @@ QualType Sema::CheckShiftOperands(ExprResult &LHS, ExprResult &RHS,
if (LHS.isInvalid())
return QualType();
QualType LHSType = LHS.get()->getType();
- if (IsCompAssign)
- LHS = OldLHS;
+ if (IsCompAssign) LHS = OldLHS;
// The RHS is simpler.
RHS = UsualUnaryConversions(RHS.get());
@@ -12226,8 +12223,8 @@ static void diagnoseDistinctPointerComparison(Sema &S, SourceLocation Loc,
bool IsError) {
S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_distinct_pointers
: diag::ext_typecheck_comparison_of_distinct_pointers)
- << LHS.get()->getType() << RHS.get()->getType()
- << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
+ << LHS.get()->getType() << RHS.get()->getType()
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
}
/// Returns false if the pointers are converted to a composite type,
@@ -12252,7 +12249,7 @@ static bool convertPointersToCompositeType(Sema &S, SourceLocation Loc,
if (T.isNull()) {
if ((LHSType->isAnyPointerType() || LHSType->isMemberPointerType()) &&
(RHSType->isAnyPointerType() || RHSType->isMemberPointerType()))
- diagnoseDistinctPointerComparison(S, Loc, LHS, RHS, /*isError*/ true);
+ diagnoseDistinctPointerComparison(S, Loc, LHS, RHS, /*isError*/true);
else
S.InvalidOperands(Loc, LHS, RHS);
return true;
@@ -12267,8 +12264,8 @@ static void diagnoseFunctionPointerToVoidComparison(Sema &S, SourceLocation Loc,
bool IsError) {
S.Diag(Loc, IsError ? diag::err_typecheck_comparison_of_fptr_to_void
: diag::ext_typecheck_comparison_of_fptr_to_void)
- << LHS.get()->getType() << RHS.get()->getType()
- << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
+ << LHS.get()->getType() << RHS.get()->getType()
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
}
static bool isObjCObjectLiteral(ExprResult &E) {
@@ -12286,7 +12283,7 @@ static bool isObjCObjectLiteral(ExprResult &E) {
static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS) {
const ObjCObjectPointerType *Type =
- LHS->getType()->getAs<ObjCObjectPointerType>();
+ LHS->getType()->getAs<ObjCObjectPointerType>();
// If this is not actually an Objective-C object, bail out.
if (!Type)
@@ -12333,7 +12330,7 @@ static bool hasIsEqualMethod(Sema &S, const Expr *LHS, const Expr *RHS) {
static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc,
ExprResult &LHS, ExprResult &RHS,
- BinaryOperator::Opcode Opc) {
+ BinaryOperator::Opcode Opc){
Expr *Literal;
Expr *Other;
if (isObjCObjectLiteral(LHS)) {
@@ -12361,22 +12358,22 @@ static void diagnoseObjCLiteralComparison(Sema &S, SourceLocation Loc,
if (LiteralKind == SemaObjC::LK_String)
S.Diag(Loc, diag::warn_objc_string_literal_comparison)
- << Literal->getSourceRange();
+ << Literal->getSourceRange();
else
S.Diag(Loc, diag::warn_objc_literal_comparison)
- << LiteralKind << Literal->getSourceRange();
+ << LiteralKind << Literal->getSourceRange();
if (BinaryOperator::isEqualityOp(Opc) &&
hasIsEqualMethod(S, LHS.get(), RHS.get())) {
SourceLocation Start = LHS.get()->getBeginLoc();
SourceLocation End = S.getLocForEndOfToken(RHS.get()->getEndLoc());
CharSourceRange OpRange =
- CharSourceRange::getCharRange(Loc, S.getLocForEndOfToken(Loc));
+ CharSourceRange::getCharRange(Loc, S.getLocForEndOfToken(Loc));
S.Diag(Loc, diag::note_objc_literal_comparison_isequal)
- << FixItHint::CreateInsertion(Start, Opc == BO_EQ ? "[" : "![")
- << FixItHint::CreateReplacement(OpRange, " isEqual:")
- << FixItHint::CreateInsertion(End, "]");
+ << FixItHint::CreateInsertion(Start, Opc == BO_EQ ? "[" : "![")
+ << FixItHint::CreateReplacement(OpRange, " isEqual:")
+ << FixItHint::CreateInsertion(End, "]");
}
}
@@ -12386,17 +12383,14 @@ static void diagnoseLogicalNotOnLHSofCheck(Sema &S, ExprResult &LHS,
BinaryOperatorKind Opc) {
// Check that left hand side is !something.
UnaryOperator *UO = dyn_cast<UnaryOperator>(LHS.get()->IgnoreImpCasts());
- if (!UO || UO->getOpcode() != UO_LNot)
- return;
+ if (!UO || UO->getOpcode() != UO_LNot) return;
// Only check if the right hand side is non-bool arithmetic type.
- if (RHS.get()->isKnownToHaveBooleanValue())
- return;
+ if (RHS.get()->isKnownToHaveBooleanValue()) return;
// Make sure that the something in !something is not bool.
Expr *SubExpr = UO->getSubExpr()->IgnoreImpCasts();
- if (SubExpr->isKnownToHaveBooleanValue())
- return;
+ if (SubExpr->isKnownToHaveBooleanValue()) return;
// Emit warning.
bool IsBitwiseOp = Opc == BO_And || Opc == BO_Or || Opc == BO_Xor;
@@ -12410,7 +12404,8 @@ static void diagnoseLogicalNotOnLHSofCheck(Sema &S, ExprResult &LHS,
if (FirstClose.isInvalid())
FirstOpen = SourceLocation();
S.Diag(UO->getOperatorLoc(), diag::note_logical_not_fix)
- << IsBitwiseOp << FixItHint::CreateInsertion(FirstOpen, "(")
+ << IsBitwiseOp
+ << FixItHint::CreateInsertion(FirstOpen, "(")
<< FixItHint::CreateInsertion(FirstClose, ")");
// Second note suggests (!x) < y
@@ -12493,7 +12488,8 @@ static void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc,
QualType LHSType = LHS->getType();
QualType RHSType = RHS->getType();
if (LHSType->hasFloatingRepresentation() ||
- (LHSType->isBlockPointerType() && !BinaryOperator::isEqualityOp(Opc)))
+ (LHSType->isBlockPointerType() && !BinaryOperator::isEqualityOp(Opc)) ||
+ S.inTemplateInstantiation())
return;
// WebAssembly Tables cannot be compared, therefore shouldn't emit
@@ -12616,8 +12612,8 @@ static void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc,
LiteralStringStripped = LHSStripped;
} else if ((isa<StringLiteral>(RHSStripped) ||
isa<ObjCEncodeExpr>(RHSStripped)) &&
- !LHSStripped->isNullPointerConstant(
- S.Context, Expr::NPC_ValueDependentIsNull)) {
+ !LHSStripped->isNullPointerConstant(S.Context,
+ Expr::NPC_ValueDependentIsNull)) {
LiteralString = RHS;
LiteralStringStripped = RHSStripped;
}
@@ -12833,7 +12829,7 @@ void Sema::CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE) {
if (!E.get()->getType()->isAnyPointerType() &&
E.get()->isNullPointerConstant(Context,
Expr::NPC_ValueDependentIsNotNull) ==
- Expr::NPCK_ZeroExpression) {
+ Expr::NPCK_ZeroExpression) {
if (const auto *CL = dyn_cast<CharacterLiteral>(E.get())) {
if (CL->getValue() == 0)
Diag(E.get()->getExprLoc(), diag::warn_pointer_compare)
@@ -12841,14 +12837,14 @@ void Sema::CheckPtrComparisonWithNullChar(ExprResult &E, ExprResult &NullE) {
<< FixItHint::CreateReplacement(E.get()->getExprLoc(),
NullValue ? "NULL" : "(void *)0");
} else if (const auto *CE = dyn_cast<CStyleCastExpr>(E.get())) {
- TypeSourceInfo *TI = CE->getTypeInfoAsWritten();
- QualType T = Context.getCanonicalType(TI->getType()).getUnqualifiedType();
- if (T == Context.CharTy)
- Diag(E.get()->getExprLoc(), diag::warn_pointer_compare)
- << NullValue
- << FixItHint::CreateReplacement(E.get()->getExprLoc(),
- NullValue ? "NULL" : "(void *)0");
- }
+ TypeSourceInfo *TI = CE->getTypeInfoAsWritten();
+ QualType T = Context.getCanonicalType(TI->getType()).getUnqualifiedType();
+ if (T == Context.CharTy)
+ Diag(E.get()->getExprLoc(), diag::warn_pointer_compare)
+ << NullValue
+ << FixItHint::CreateReplacement(E.get()->getExprLoc(),
+ NullValue ? "NULL" : "(void *)0");
+ }
}
}
@@ -12864,14 +12860,6 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
return Ty->isPointerType() || Ty->isMemberPointerType();
};
- // Skip comparison check if we are using templates until types are known.
- if (this->inTemplateInstantiation()) {
- QualType LHSType = LHS.get()->getType();
- QualType RHSType = RHS.get()->getType();
- if (!LHSType->isArrayType() && !RHSType->isArrayType())
- return QualType();
- }
-
// C++2a [expr.spaceship]p6: If at least one of the operands is of pointer
// type, array-to-pointer, ..., conversions are performed on both operands to
// bring them to their composite type.
@@ -13033,9 +13021,9 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
// All of the following pointer-related warnings are GCC extensions, except
// when handling null pointer constants.
QualType LCanPointeeTy =
- LHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
+ LHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
QualType RCanPointeeTy =
- RHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
+ RHSType->castAs<PointerType>()->getPointeeType().getCanonicalType();
// C99 6.5.9p2 and C99 6.5.8p2
if (Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(),
@@ -13054,15 +13042,13 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
} else if (!IsRelational &&
(LCanPointeeTy->isVoidType() || RCanPointeeTy->isVoidType())) {
// Valid unless comparison between non-null pointer and function pointer
- if ((LCanPointeeTy->isFunctionType() ||
- RCanPointeeTy->isFunctionType()) &&
- !LHSIsNull && !RHSIsNull)
+ if ((LCanPointeeTy->isFunctionType() || RCanPointeeTy->isFunctionType())
+ && !LHSIsNull && !RHSIsNull)
diagnoseFunctionPointerToVoidComparison(*this, Loc, LHS, RHS,
- /*isError*/ false);
+ /*isError*/false);
} else {
// Invalid
- diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS,
- /*isError*/ false);
+ diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS, /*isError*/false);
}
if (LCanPointeeTy != RCanPointeeTy) {
// Treat NULL constant as a special case in OpenCL.
@@ -13077,8 +13063,8 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
}
LangAS AddrSpaceL = LCanPointeeTy.getAddressSpace();
LangAS AddrSpaceR = RCanPointeeTy.getAddressSpace();
- CastKind Kind =
- AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion : CK_BitCast;
+ CastKind Kind = AddrSpaceL != AddrSpaceR ? CK_AddressSpaceConversion
+ : CK_BitCast;
const FunctionType *LFn = LCanPointeeTy->getAs<FunctionType>();
const FunctionType *RFn = RCanPointeeTy->getAs<FunctionType>();
@@ -13095,6 +13081,7 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
return computeResultTy();
}
+
// C++ [expr.eq]p4:
// Two operands of type std::nullptr_t or one operand of type
// std::nullptr_t and the other a null pointer constant compare
@@ -13189,36 +13176,34 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
if (!LHSIsNull && !RHSIsNull &&
!Context.typesAreCompatible(lpointee, rpointee)) {
Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
- << LHSType << RHSType << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ << LHSType << RHSType << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
}
RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
return computeResultTy();
}
// Allow block pointers to be compared with null pointer constants.
- if (!IsOrdered &&
- ((LHSType->isBlockPointerType() && RHSType->isPointerType()) ||
- (LHSType->isPointerType() && RHSType->isBlockPointerType()))) {
+ if (!IsOrdered
+ && ((LHSType->isBlockPointerType() && RHSType->isPointerType())
+ || (LHSType->isPointerType() && RHSType->isBlockPointerType()))) {
if (!LHSIsNull && !RHSIsNull) {
- if (!((RHSType->isPointerType() &&
- RHSType->castAs<PointerType>()->getPointeeType()->isVoidType()) ||
- (LHSType->isPointerType() &&
- LHSType->castAs<PointerType>()->getPointeeType()->isVoidType())))
+ if (!((RHSType->isPointerType() && RHSType->castAs<PointerType>()
+ ->getPointeeType()->isVoidType())
+ || (LHSType->isPointerType() && LHSType->castAs<PointerType>()
+ ->getPointeeType()->isVoidType())))
Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks)
- << LHSType << RHSType << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ << LHSType << RHSType << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
}
if (LHSIsNull && !RHSIsNull)
LHS = ImpCastExprToType(LHS.get(), RHSType,
- RHSType->isPointerType()
- ? CK_BitCast
- : CK_AnyPointerToBlockPointerCast);
+ RHSType->isPointerType() ? CK_BitCast
+ : CK_AnyPointerToBlockPointerCast);
else
RHS = ImpCastExprToType(RHS.get(), LHSType,
- LHSType->isPointerType()
- ? CK_BitCast
- : CK_AnyPointerToBlockPointerCast);
+ LHSType->isPointerType() ? CK_BitCast
+ : CK_AnyPointerToBlockPointerCast);
return computeResultTy();
}
@@ -13233,7 +13218,7 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
if (!LPtrToVoid && !RPtrToVoid &&
!Context.typesAreCompatible(LHSType, RHSType)) {
diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS,
- /*isError*/ false);
+ /*isError*/false);
}
// FIXME: If LPtrToVoid, we should presumably convert the LHS rather than
// the RHS, but we have test coverage for this behavior.
@@ -13243,17 +13228,18 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
if (getLangOpts().ObjCAutoRefCount)
ObjC().CheckObjCConversion(SourceRange(), RHSType, E,
CheckedConversionKind::Implicit);
- LHS = ImpCastExprToType(
- E, RHSType, RPT ? CK_BitCast : CK_CPointerToObjCPointerCast);
- } else {
+ LHS = ImpCastExprToType(E, RHSType,
+ RPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
+ }
+ else {
Expr *E = RHS.get();
if (getLangOpts().ObjCAutoRefCount)
ObjC().CheckObjCConversion(SourceRange(), LHSType, E,
CheckedConversionKind::Implicit,
/*Diagnose=*/true,
/*DiagnoseCFAudited=*/false, Opc);
- RHS = ImpCastExprToType(
- E, LHSType, LPT ? CK_BitCast : CK_CPointerToObjCPointerCast);
+ RHS = ImpCastExprToType(E, LHSType,
+ LPT ? CK_BitCast :CK_CPointerToObjCPointerCast);
}
return computeResultTy();
}
@@ -13261,7 +13247,7 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
RHSType->isObjCObjectPointerType()) {
if (!Context.areComparableObjCPointerTypes(LHSType, RHSType))
diagnoseDistinctPointerComparison(*this, Loc, LHS, RHS,
- /*isError*/ false);
+ /*isError*/false);
if (isObjCObjectLiteral(LHS) || isObjCObjectLiteral(RHS))
diagnoseObjCLiteralComparison(*this, Loc, LHS, RHS, Opc);
@@ -13297,9 +13283,8 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
if (IsOrdered) {
isError = getLangOpts().CPlusPlus;
DiagID =
- isError
- ? diag::err_typecheck_ordered_comparison_of_pointer_and_zero
- : diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
+ isError ? diag::err_typecheck_ordered_comparison_of_pointer_and_zero
+ : diag::ext_typecheck_ordered_comparison_of_pointer_and_zero;
}
} else if (getLangOpts().CPlusPlus) {
DiagID = diag::err_typecheck_comparison_of_pointer_integer;
@@ -13310,31 +13295,30 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
DiagID = diag::ext_typecheck_comparison_of_pointer_integer;
if (DiagID) {
- Diag(Loc, DiagID) << LHSType << RHSType << LHS.get()->getSourceRange()
- << RHS.get()->getSourceRange();
+ Diag(Loc, DiagID)
+ << LHSType << RHSType << LHS.get()->getSourceRange()
+ << RHS.get()->getSourceRange();
if (isError)
return QualType();
}
if (LHSType->isIntegerType())
LHS = ImpCastExprToType(LHS.get(), RHSType,
- LHSIsNull ? CK_NullToPointer
- : CK_IntegralToPointer);
+ LHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
else
RHS = ImpCastExprToType(RHS.get(), LHSType,
- RHSIsNull ? CK_NullToPointer
- : CK_IntegralToPointer);
+ RHSIsNull ? CK_NullToPointer : CK_IntegralToPointer);
return computeResultTy();
}
// Handle block pointers.
- if (!IsOrdered && RHSIsNull && LHSType->isBlockPointerType() &&
- RHSType->isIntegerType()) {
+ if (!IsOrdered && RHSIsNull
+ && LHSType->isBlockPointerType() && RHSType->isIntegerType()) {
RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
return computeResultTy();
}
- if (!IsOrdered && LHSIsNull && LHSType->isIntegerType() &&
- RHSType->isBlockPointerType()) {
+ if (!IsOrdered && LHSIsNull
+ && LHSType->isIntegerType() && RHSType->isBlockPointerType()) {
LHS = ImpCastExprToType(LHS.get(), RHSType, CK_NullToPointer);
return computeResultTy();
}
@@ -13989,14 +13973,11 @@ inline QualType Sema::CheckLogicalOperands(ExprResult &LHS, ExprResult &RHS,
static bool IsReadonlyMessage(Expr *E, Sema &S) {
const MemberExpr *ME = dyn_cast<MemberExpr>(E);
- if (!ME)
- return false;
- if (!isa<FieldDecl>(ME->getMemberDecl()))
- return false;
+ if (!ME) return false;
+ if (!isa<FieldDecl>(ME->getMemberDecl())) return false;
ObjCMessageExpr *Base = dyn_cast<ObjCMessageExpr>(
ME->getBase()->IgnoreImplicit()->IgnoreParenImpCasts());
- if (!Base)
- return false;
+ if (!Base) return false;
return Base->getMethodDecl() != nullptr;
}
@@ -14010,10 +13991,8 @@ static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E) {
// Must be a reference to a declaration from an enclosing scope.
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
- if (!DRE)
- return NCCK_None;
- if (!DRE->refersToEnclosingVariableOrCapture())
- return NCCK_None;
+ if (!DRE) return NCCK_None;
+ if (!DRE->refersToEnclosingVariableOrCapture()) return NCCK_None;
ValueDecl *Value = DRE->getDecl();
@@ -14152,8 +14131,8 @@ static void DiagnoseConstAssignment(Sema &S, const Expr *E,
const FunctionDecl *FD = CE->getDirectCallee();
if (FD && !IsTypeModifiable(FD->getReturnType(), IsDereference)) {
if (!DiagnosticEmitted) {
- S.Diag(Loc, diag::err_typecheck_assign_const)
- << ExprRange << ConstFunction << FD;
+ S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange
+ << ConstFunction << FD;
DiagnosticEmitted = true;
}
S.Diag(FD->getReturnTypeSourceRange().getBegin(),
@@ -14197,7 +14176,11 @@ static void DiagnoseConstAssignment(Sema &S, const Expr *E,
S.Diag(Loc, diag::err_typecheck_assign_const) << ExprRange << ConstUnknown;
}
-enum OriginalExprKind { OEK_Variable, OEK_Member, OEK_LValue };
+enum OriginalExprKind {
+ OEK_Variable,
+ OEK_Member,
+ OEK_LValue
+};
static void DiagnoseRecursiveConstFields(Sema &S, const ValueDecl *VD,
const RecordType *Ty,
@@ -14220,12 +14203,13 @@ static void DiagnoseRecursiveConstFields(Sema &S, const ValueDecl *VD,
if (FieldTy.isConstQualified()) {
if (!DiagnosticEmitted) {
S.Diag(Loc, diag::err_typecheck_assign_const)
- << Range << NestedConstMember << OEK << VD << IsNested << Field;
+ << Range << NestedConstMember << OEK << VD
+ << IsNested << Field;
DiagnosticEmitted = true;
}
S.Diag(Field->getLocation(), diag::note_typecheck_assign_const)
- << NestedConstMember << IsNested << Field << FieldTy
- << Field->getSourceRange();
+ << NestedConstMember << IsNested << Field
+ << FieldTy << Field->getSourceRange();
}
// Then we append it to the list to check next in order.
@@ -14250,14 +14234,14 @@ static void DiagnoseRecursiveConstFields(Sema &S, const Expr *E,
bool DiagEmitted = false;
if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
- DiagnoseRecursiveConstFields(S, ME->getMemberDecl(), RTy, Loc, Range,
- OEK_Member, DiagEmitted);
+ DiagnoseRecursiveConstFields(S, ME->getMemberDecl(), RTy, Loc,
+ Range, OEK_Member, DiagEmitted);
else if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
- DiagnoseRecursiveConstFields(S, DRE->getDecl(), RTy, Loc, Range,
- OEK_Variable, DiagEmitted);
+ DiagnoseRecursiveConstFields(S, DRE->getDecl(), RTy, Loc,
+ Range, OEK_Variable, DiagEmitted);
else
- DiagnoseRecursiveConstFields(S, nullptr, RTy, Loc, Range, OEK_LValue,
- DiagEmitted);
+ DiagnoseRecursiveConstFields(S, nullptr, RTy, Loc,
+ Range, OEK_LValue, DiagEmitted);
if (!DiagEmitted)
DiagnoseConstAssignment(S, E, Loc);
}
@@ -14270,7 +14254,8 @@ static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
S.CheckShadowingDeclModification(E, Loc);
SourceLocation OrigLoc = Loc;
- Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context, &Loc);
+ Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context,
+ &Loc);
if (IsLV == Expr::MLV_ClassTemporary && IsReadonlyMessage(E, S))
IsLV = Expr::MLV_InvalidMessageExpression;
if (IsLV == Expr::MLV_Valid)
@@ -14307,15 +14292,15 @@ static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
ObjCMethodDecl *method = S.getCurMethodDecl();
if (method && var == method->getSelfDecl()) {
DiagID = method->isClassMethod()
- ? diag::err_typecheck_arc_assign_self_class_method
- : diag::err_typecheck_arc_assign_self;
+ ? diag::err_typecheck_arc_assign_self_class_method
+ : diag::err_typecheck_arc_assign_self;
- // - Objective-C externally_retained attribute.
+ // - Objective-C externally_retained attribute.
} else if (var->hasAttr<ObjCExternallyRetainedAttr>() ||
isa<ParmVarDecl>(var)) {
DiagID = diag::err_typecheck_arc_assign_externally_retained;
- // - fast enumeration variables
+ // - fast enumeration variables
} else {
DiagID = diag::err_typecheck_arr_assign_enumeration;
}
@@ -14366,9 +14351,8 @@ static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
break;
case Expr::MLV_IncompleteType:
case Expr::MLV_IncompleteVoidType:
- return S.RequireCompleteType(
- Loc, E->getType(),
- diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E);
+ return S.RequireCompleteType(Loc, E->getType(),
+ diag::err_typecheck_incomplete_type_not_modifiable_lvalue, E);
case Expr::MLV_DuplicateVectorComponents:
DiagID = diag::err_typecheck_duplicate_vector_components_not_mlvalue;
break;
@@ -14396,7 +14380,8 @@ static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
}
static void CheckIdentityFieldAssignment(Expr *LHSExpr, Expr *RHSExpr,
- SourceLocation Loc, Sema &Sema) {
+ SourceLocation Loc,
+ Sema &Sema) {
if (Sema.inTemplateInstantiation())
return;
if (Sema.isUnevaluatedContext())
@@ -14450,8 +14435,8 @@ QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS,
return QualType();
QualType LHSType = LHSExpr->getType();
- QualType RHSType =
- CompoundType.isNull() ? RHS.get()->getType() : CompoundType;
+ QualType RHSType = CompoundType.isNull() ? RHS.get()->getType() :
+ CompoundType;
if (RHS.isUsable()) {
// Even if this check fails don't return early to allow the best
@@ -14478,8 +14463,8 @@ QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS,
if (getLangOpts().OpenCL &&
!getOpenCLOptions().isAvailableOption("cl_khr_fp16", getLangOpts()) &&
LHSType->isHalfType()) {
- Diag(Loc, diag::err_opencl_half_load_store)
- << 1 << LHSType.getUnqualifiedType();
+ Diag(Loc, diag::err_opencl_half_load_store) << 1
+ << LHSType.getUnqualifiedType();
return QualType();
}
@@ -14525,8 +14510,8 @@ QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS,
Loc.getLocWithOffset(2) != UO->getSubExpr()->getBeginLoc() &&
UO->getSubExpr()->getBeginLoc().isFileID()) {
Diag(Loc, diag::warn_not_compound_assign)
- << (UO->getOpcode() == UO_Plus ? "+" : "-")
- << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
+ << (UO->getOpcode() == UO_Plus ? "+" : "-")
+ << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc());
}
}
@@ -14726,7 +14711,7 @@ static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op,
// Increment of bool sets it to true, but is deprecated.
S.Diag(OpLoc, S.getLangOpts().CPlusPlus17 ? diag::ext_increment_bool
: diag::warn_increment_bool)
- << Op->getSourceRange();
+ << Op->getSourceRange();
} else if (S.getLangOpts().CPlusPlus && ResType->isEnumeralType()) {
// Error on enum increments and decrements in C++ mode
S.Diag(OpLoc, diag::err_increment_decrement_enum) << IsInc << ResType;
@@ -14752,10 +14737,9 @@ static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op,
<< IsInc << Op->getSourceRange();
} else if (ResType->isPlaceholderType()) {
ExprResult PR = S.CheckPlaceholderExpr(Op);
- if (PR.isInvalid())
- return QualType();
- return CheckIncrementDecrementOperand(S, PR.get(), VK, OK, OpLoc, IsInc,
- IsPrefix);
+ if (PR.isInvalid()) return QualType();
+ return CheckIncrementDecrementOperand(S, PR.get(), VK, OK, OpLoc,
+ IsInc, IsPrefix);
} else if (S.getLangOpts().AltiVec && ResType->isVectorType()) {
// OK! ( C/C++ Language Extensions for CBEA(Version 2.6) 10.3 )
} else if (S.getLangOpts().ZVector && ResType->isVectorType() &&
@@ -14767,7 +14751,7 @@ static QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op,
// OpenCL V1.2 6.3 says dec/inc ops operate on integer vector types.
} else {
S.Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement)
- << ResType << int(IsInc) << Op->getSourceRange();
+ << ResType << int(IsInc) << Op->getSourceRange();
return QualType();
}
// At this point, we know we have a real, complex or pointer type.
@@ -14823,8 +14807,8 @@ static ValueDecl *getPrimaryDecl(Expr *E) {
case Stmt::ArraySubscriptExprClass: {
// FIXME: This code shouldn't be necessary! We should catch the implicit
// promotion of register arrays earlier.
- Expr *Base = cast<ArraySubscriptExpr>(E)->getBase();
- if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Base)) {
+ Expr* Base = cast<ArraySubscriptExpr>(E)->getBase();
+ if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) {
if (ICE->getSubExpr()->getType()->isArrayType())
return getPrimaryDecl(ICE->getSubExpr());
}
@@ -14833,7 +14817,7 @@ static ValueDecl *getPrimaryDecl(Expr *E) {
case Stmt::UnaryOperatorClass: {
UnaryOperator *UO = cast<UnaryOperator>(E);
- switch (UO->getOpcode()) {
+ switch(UO->getOpcode()) {
case UO_Real:
case UO_Imag:
case UO_Extension:
@@ -14868,8 +14852,8 @@ enum {
/// Diagnose invalid operand for address of operations.
///
/// \param Type The type of operand which cannot have its address taken.
-static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc, Expr *E,
- unsigned Type) {
+static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc,
+ Expr *E, unsigned Type) {
S.Diag(Loc, diag::err_typecheck_address_of) << Type << E->getSourceRange();
}
@@ -14902,14 +14886,13 @@ bool Sema::CheckUseOfCXXMethodAsAddressOfOperand(SourceLocation OpLoc,
}
QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
- if (const BuiltinType *PTy =
- OrigOp.get()->getType()->getAsPlaceholderType()) {
+ if (const BuiltinType *PTy = OrigOp.get()->getType()->getAsPlaceholderType()){
if (PTy->getKind() == BuiltinType::Overload) {
Expr *E = OrigOp.get()->IgnoreParens();
if (!isa<OverloadExpr>(E)) {
assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf);
Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof_addrof_function)
- << OrigOp.get()->getSourceRange();
+ << OrigOp.get()->getSourceRange();
return QualType();
}
@@ -14917,7 +14900,7 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
if (isa<UnresolvedMemberExpr>(Ovl))
if (!ResolveSingleFunctionTemplateSpecialization(Ovl)) {
Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
- << OrigOp.get()->getSourceRange();
+ << OrigOp.get()->getSourceRange();
return QualType();
}
@@ -14929,13 +14912,12 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
if (PTy->getKind() == BuiltinType::BoundMember) {
Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
- << OrigOp.get()->getSourceRange();
+ << OrigOp.get()->getSourceRange();
return QualType();
}
OrigOp = CheckPlaceholderExpr(OrigOp.get());
- if (OrigOp.isInvalid())
- return QualType();
+ if (OrigOp.isInvalid()) return QualType();
}
if (OrigOp.get()->isTypeDependent())
@@ -14952,7 +14934,7 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
// depending on a vendor implementation. Thus preventing
// taking an address of the capture to avoid invalid AS casts.
if (LangOpts.OpenCL) {
- auto *VarRef = dyn_cast<DeclRefExpr>(op);
+ auto* VarRef = dyn_cast<DeclRefExpr>(op);
if (VarRef && VarRef->refersToEnclosingVariableOrCapture()) {
Diag(op->getExprLoc(), diag::err_opencl_taking_address_capture);
return QualType();
@@ -14961,7 +14943,7 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
if (getLangOpts().C99) {
// Implement C99-only parts of addressof rules.
- if (UnaryOperator *uOp = dyn_cast<UnaryOperator>(op)) {
+ if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) {
if (uOp->getOpcode() == UO_Deref)
// Per C99 6.5.3.2, the address of a deref always returns a valid result
// (assuming the deref expression is valid).
@@ -14999,7 +14981,7 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
// If the underlying expression isn't a decl ref, give up.
if (!isa<DeclRefExpr>(op)) {
Diag(OpLoc, diag::err_invalid_form_pointer_member_function)
- << OrigOp.get()->getSourceRange();
+ << OrigOp.get()->getSourceRange();
return QualType();
}
DeclRefExpr *DRE = cast<DeclRefExpr>(op);
@@ -15054,7 +15036,7 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
AddressOfError = AO_Property_Expansion;
} else {
Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof)
- << op->getType() << op->getSourceRange();
+ << op->getType() << op->getSourceRange();
return QualType();
}
} else if (const auto *DRE = dyn_cast<DeclRefExpr>(op)) {
@@ -15077,7 +15059,8 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) {
// in C++ it is not error to take address of a register
// variable (c++03 7.1.1P3)
- if (vd->getStorageClass() == SC_Register && !getLangOpts().CPlusPlus) {
+ if (vd->getStorageClass() == SC_Register &&
+ !getLangOpts().CPlusPlus) {
AddressOfError = AO_Register_Variable;
}
} else if (isa<MSPropertyDecl>(dcl)) {
@@ -15101,7 +15084,7 @@ QualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {
if (dcl->getType()->isReferenceType()) {
Diag(OpLoc,
diag::err_cannot_form_pointer_to_member_of_reference_type)
- << dcl->getDeclName() << dcl->getType();
+ << dcl->getDeclName() << dcl->getType();
return QualType();
}
@@ -15168,7 +15151,7 @@ static void RecordModifiableNonNullParam(Sema &S, const Expr *Exp) {
const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D);
if (!Param)
return;
- if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Param->getDeclContext()))
+ if (const FunctionDecl* FD = dyn_cast<FunctionDecl>(Param->getDeclContext()))
if (!FD->hasAttr<NonNullAttr>() && !Param->hasAttr<NonNullAttr>())
return;
if (FunctionScopeInfo *FD = S.getCurFunction())
@@ -15188,26 +15171,27 @@ static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
if (isa<CXXReinterpretCastExpr>(Op->IgnoreParens())) {
QualType OpOrigType = Op->IgnoreParenCasts()->getType();
- S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/ true,
+ S.CheckCompatibleReinterpretCast(OpOrigType, OpTy, /*IsDereference*/true,
Op->getSourceRange());
}
- if (const PointerType *PT = OpTy->getAs<PointerType>()) {
+ if (const PointerType *PT = OpTy->getAs<PointerType>())
+ {
Result = PT->getPointeeType();
- } else if (const ObjCObjectPointerType *OPT =
- OpTy->getAs<ObjCObjectPointerType>())
+ }
+ else if (const ObjCObjectPointerType *OPT =
+ OpTy->getAs<ObjCObjectPointerType>())
Result = OPT->getPointeeType();
else {
ExprResult PR = S.CheckPlaceholderExpr(Op);
- if (PR.isInvalid())
- return QualType();
+ if (PR.isInvalid()) return QualType();
if (PR.get() != Op)
return CheckIndirectionOperand(S, PR.get(), VK, OpLoc);
}
if (Result.isNull()) {
S.Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
- << OpTy << Op->getSourceRange();
+ << OpTy << Op->getSourceRange();
return QualType();
}
@@ -15237,150 +15221,60 @@ static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
BinaryOperatorKind Sema::ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind) {
BinaryOperatorKind Opc;
switch (Kind) {
- default:
- llvm_unreachable("Unknown binop!");
- case tok::periodstar:
- Opc = BO_PtrMemD;
- break;
- case tok::arrowstar:
- Opc = BO_PtrMemI;
- break;
- case tok::star:
- Opc = BO_Mul;
- break;
- case tok::slash:
- Opc = BO_Div;
- break;
- case tok::percent:
- Opc = BO_Rem;
- break;
- case tok::plus:
- Opc = BO_Add;
- break;
- case tok::minus:
- Opc = BO_Sub;
- break;
- case tok::lessless:
- Opc = BO_Shl;
- break;
- case tok::greatergreater:
- Opc = BO_Shr;
- break;
- case tok::lessequal:
- Opc = BO_LE;
- break;
- case tok::less:
- Opc = BO_LT;
- break;
- case tok::greaterequal:
- Opc = BO_GE;
- break;
- case tok::greater:
- Opc = BO_GT;
- break;
- case tok::exclaimequal:
- Opc = BO_NE;
- break;
- case tok::equalequal:
- Opc = BO_EQ;
- break;
- case tok::spaceship:
- Opc = BO_Cmp;
- break;
- case tok::amp:
- Opc = BO_And;
- break;
- case tok::caret:
- Opc = BO_Xor;
- break;
- case tok::pipe:
- Opc = BO_Or;
- break;
- case tok::ampamp:
- Opc = BO_LAnd;
- break;
- case tok::pipepipe:
- Opc = BO_LOr;
- break;
- case tok::equal:
- Opc = BO_Assign;
- break;
- case tok::starequal:
- Opc = BO_MulAssign;
- break;
- case tok::slashequal:
- Opc = BO_DivAssign;
- break;
- case tok::percentequal:
- Opc = BO_RemAssign;
- break;
- case tok::plusequal:
- Opc = BO_AddAssign;
- break;
- case tok::minusequal:
- Opc = BO_SubAssign;
- break;
- case tok::lesslessequal:
- Opc = BO_ShlAssign;
- break;
- case tok::greatergreaterequal:
- Opc = BO_ShrAssign;
- break;
- case tok::ampequal:
- Opc = BO_AndAssign;
- break;
- case tok::caretequal:
- Opc = BO_XorAssign;
- break;
- case tok::pipeequal:
- Opc = BO_OrAssign;
- break;
- case tok::comma:
- Opc = BO_Comma;
- break;
+ default: llvm_unreachable("Unknown binop!");
+ case tok::periodstar: Opc = BO_PtrMemD; break;
+ case tok::arrowstar: Opc = BO_PtrMemI; break;
+ case tok::star: Opc = BO_Mul; break;
+ case tok::slash: Opc = BO_Div; break;
+ case tok::percent: Opc = BO_Rem; break;
+ case tok::plus: Opc = BO_Add; break;
+ case tok::minus: Opc = BO_Sub; break;
+ case tok::lessless: Opc = BO_Shl; break;
+ case tok::greatergreater: Opc = BO_Shr; break;
+ case tok::lessequal: Opc = BO_LE; break;
+ case tok::less: Opc = BO_LT; break;
+ case tok::greaterequal: Opc = BO_GE; break;
+ case tok::greater: Opc = BO_GT; break;
+ case tok::exclaimequal: Opc = BO_NE; break;
+ case tok::equalequal: Opc = BO_EQ; break;
+ case tok::spaceship: Opc = BO_Cmp; break;
+ case tok::amp: Opc = BO_And; break;
+ case tok::caret: Opc = BO_Xor; break;
+ case tok::pipe: Opc = BO_Or; break;
+ case tok::ampamp: Opc = BO_LAnd; break;
+ case tok::pipepipe: Opc = BO_LOr; break;
+ case tok::equal: Opc = BO_Assign; break;
+ case tok::starequal: Opc = BO_MulAssign; break;
+ case tok::slashequal: Opc = BO_DivAssign; break;
+ case tok::percentequal: Opc = BO_RemAssign; break;
+ case tok::plusequal: Opc = BO_AddAssign; break;
+ case tok::minusequal: Opc = BO_SubAssign; break;
+ case tok::lesslessequal: Opc = BO_ShlAssign; break;
+ case tok::greatergreaterequal: Opc = BO_ShrAssign; break;
+ case tok::ampequal: Opc = BO_AndAssign; break;
+ case tok::caretequal: Opc = BO_XorAssign; break;
+ case tok::pipeequal: Opc = BO_OrAssign; break;
+ case tok::comma: Opc = BO_Comma; break;
}
return Opc;
}
-static inline UnaryOperatorKind
-ConvertTokenKindToUnaryOpcode(tok::TokenKind Kind) {
+static inline UnaryOperatorKind ConvertTokenKindToUnaryOpcode(
+ tok::TokenKind Kind) {
UnaryOperatorKind Opc;
switch (Kind) {
- default:
- llvm_unreachable("Unknown unary op!");
- case tok::plusplus:
- Opc = UO_PreInc;
- break;
- case tok::minusminus:
- Opc = UO_PreDec;
- break;
- case tok::amp:
- Opc = UO_AddrOf;
- break;
- case tok::star:
- Opc = UO_Deref;
- break;
- case tok::plus:
- Opc = UO_Plus;
- break;
- case tok::minus:
- Opc = UO_Minus;
- break;
- case tok::tilde:
- Opc = UO_Not;
- break;
- case tok::exclaim:
- Opc = UO_LNot;
- break;
- case tok::kw___real:
- Opc = UO_Real;
- break;
- case tok::kw___imag:
- Opc = UO_Imag;
- break;
- case tok::kw___extension__:
- Opc = UO_Extension;
- break;
+ default: llvm_unreachable("Unknown unary op!");
+ case tok::plusplus: Opc = UO_PreInc; break;
+ case tok::minusminus: Opc = UO_PreDec; break;
+ case tok::amp: Opc = UO_AddrOf; break;
+ case tok::star: Opc = UO_Deref; break;
+ case tok::plus: Opc = UO_Plus; break;
+ case tok::minus: Opc = UO_Minus; break;
+ case tok::tilde: Opc = UO_Not; break;
+ case tok::exclaim: Opc = UO_LNot; break;
+ case tok::kw___real: Opc = UO_Real; break;
+ case tok::kw___imag: Opc = UO_Imag; break;
+ case tok::kw___extension__: Opc = UO_Extension; break;
}
return Opc;
}
@@ -15433,13 +15327,14 @@ static void DiagnoseSelfAssignment(Sema &S, Expr *LHSExpr, Expr *RHSExpr,
RHSExpr = RHSExpr->IgnoreParenImpCasts();
const DeclRefExpr *LHSDeclRef = dyn_cast<DeclRefExpr>(LHSExpr);
const DeclRefExpr *RHSDeclRef = dyn_cast<DeclRefExpr>(RHSExpr);
- if (!LHSDeclRef || !RHSDeclRef || LHSDeclRef->getLocation().isMacroID() ||
+ if (!LHSDeclRef || !RHSDeclRef ||
+ LHSDeclRef->getLocation().isMacroID() ||
RHSDeclRef->getLocation().isMacroID())
return;
const ValueDecl *LHSDecl =
- cast<ValueDecl>(LHSDeclRef->getDecl()->getCanonicalDecl());
+ cast<ValueDecl>(LHSDeclRef->getDecl()->getCanonicalDecl());
const ValueDecl *RHSDecl =
- cast<ValueDecl>(RHSDeclRef->getDecl()->getCanonicalDecl());
+ cast<ValueDecl>(RHSDeclRef->getDecl()->getCanonicalDecl());
if (LHSDecl != RHSDecl)
return;
if (LHSDecl->getType().isVolatileQualified())
@@ -15474,7 +15369,8 @@ static void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R,
if (LHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) {
ObjCPointerExpr = LHS;
OtherExpr = RHS;
- } else if (RHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) {
+ }
+ else if (RHS->IgnoreParenCasts()->getType()->isObjCObjectPointerType()) {
ObjCPointerExpr = RHS;
OtherExpr = LHS;
}
@@ -15497,7 +15393,8 @@ static void checkObjCPointerIntrospection(Sema &S, ExprResult &L, ExprResult &R,
Diag = diag::warn_objc_pointer_masking_performSelector;
}
- S.Diag(OpLoc, Diag) << ObjCPointerExpr->getSourceRange();
+ S.Diag(OpLoc, Diag)
+ << ObjCPointerExpr->getSourceRange();
}
}
@@ -15584,7 +15481,7 @@ ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
}
ExprResult LHS = LHSExpr, RHS = RHSExpr;
- QualType ResultTy; // Result type of the binary operator.
+ QualType ResultTy; // Result type of the binary operator.
// The following two variables are used for compound assignment operators
QualType CompLHSTy; // Type of LHS after promotions for computation
QualType CompResultTy; // Type of computation result
@@ -15611,8 +15508,9 @@ ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
// OpenCL special types - image, sampler, pipe, and blocks are to be used
// only with a builtin functions and therefore should be disallowed here.
- if (LHSTy->isImageType() || RHSTy->isImageType() || LHSTy->isSamplerT() ||
- RHSTy->isSamplerT() || LHSTy->isPipeType() || RHSTy->isPipeType() ||
+ if (LHSTy->isImageType() || RHSTy->isImageType() ||
+ LHSTy->isSamplerT() || RHSTy->isSamplerT() ||
+ LHSTy->isPipeType() || RHSTy->isPipeType() ||
LHSTy->isBlockPointerType() || RHSTy->isBlockPointerType()) {
ResultTy = InvalidOperands(OpLoc, LHS, RHS);
return ExprError();
@@ -15661,8 +15559,8 @@ ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
break;
case BO_PtrMemD:
case BO_PtrMemI:
- ResultTy =
- CheckPointerToMemberOperands(LHS, RHS, VK, OpLoc, Opc == BO_PtrMemI);
+ ResultTy = CheckPointerToMemberOperands(LHS, RHS, VK, OpLoc,
+ Opc == BO_PtrMemI);
break;
case BO_Mul:
case BO_Div:
@@ -15794,11 +15692,10 @@ ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
CheckArrayAccess(LHS.get());
CheckArrayAccess(RHS.get());
- if (const ObjCIsaExpr *OISA =
- dyn_cast<ObjCIsaExpr>(LHS.get()->IgnoreParenCasts())) {
- NamedDecl *ObjectSetClass =
- LookupSingleName(TUScope, &Context.Idents.get("object_setClass"),
- SourceLocation(), LookupOrdinaryName);
+ if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(LHS.get()->IgnoreParenCasts())) {
+ NamedDecl *ObjectSetClass = LookupSingleName(TUScope,
+ &Context.Idents.get("object_setClass"),
+ SourceLocation(), LookupOrdinaryName);
if (ObjectSetClass && isa<ObjCIsaExpr>(LHS.get())) {
SourceLocation RHSLocEnd = getLocForEndOfToken(RHS.get()->getEndLoc());
Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign)
@@ -15807,10 +15704,12 @@ ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
<< FixItHint::CreateReplacement(SourceRange(OISA->getOpLoc(), OpLoc),
",")
<< FixItHint::CreateInsertion(RHSLocEnd, ")");
- } else
+ }
+ else
Diag(LHS.get()->getExprLoc(), diag::warn_objc_isa_assign);
- } else if (const ObjCIvarRefExpr *OIRE =
- dyn_cast<ObjCIvarRefExpr>(LHS.get()->IgnoreParenCasts()))
+ }
+ else if (const ObjCIvarRefExpr *OIRE =
+ dyn_cast<ObjCIvarRefExpr>(LHS.get()->IgnoreParenCasts()))
DiagnoseDirectIsaAccess(*this, OIRE, OpLoc, RHS.get());
// Opc is not a compound assignment if CompResultTy is null.
@@ -15823,8 +15722,8 @@ ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
}
// Handle compound assignments.
- if (getLangOpts().CPlusPlus &&
- LHS.get()->getObjectKind() != OK_ObjCProperty) {
+ if (getLangOpts().CPlusPlus && LHS.get()->getObjectKind() !=
+ OK_ObjCProperty) {
VK = VK_LValue;
OK = LHS.get()->getObjectKind();
}
@@ -15877,29 +15776,29 @@ static void DiagnoseBitwisePrecedence(Sema &Self, BinaryOperatorKind Opc,
: SourceRange(LHSExpr->getBeginLoc(), RHSBO->getLHS()->getEndLoc());
Self.Diag(OpLoc, diag::warn_precedence_bitwise_rel)
- << DiagRange << BinaryOperator::getOpcodeStr(Opc) << OpStr;
+ << DiagRange << BinaryOperator::getOpcodeStr(Opc) << OpStr;
SuggestParentheses(Self, OpLoc,
- Self.PDiag(diag::note_precedence_silence) << OpStr,
- (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());
+ Self.PDiag(diag::note_precedence_silence) << OpStr,
+ (isLeftComp ? LHSExpr : RHSExpr)->getSourceRange());
SuggestParentheses(Self, OpLoc,
- Self.PDiag(diag::note_precedence_bitwise_first)
- << BinaryOperator::getOpcodeStr(Opc),
- ParensRange);
+ Self.PDiag(diag::note_precedence_bitwise_first)
+ << BinaryOperator::getOpcodeStr(Opc),
+ ParensRange);
}
/// It accepts a '&&' expr that is inside a '||' one.
/// Emit a diagnostic together with a fixit hint that wraps the '&&' expression
/// in parentheses.
-static void EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self,
- SourceLocation OpLoc,
- BinaryOperator *Bop) {
+static void
+EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc,
+ BinaryOperator *Bop) {
assert(Bop->getOpcode() == BO_LAnd);
Self.Diag(Bop->getOperatorLoc(), diag::warn_logical_and_in_logical_or)
<< Bop->getSourceRange() << OpLoc;
SuggestParentheses(Self, Bop->getOperatorLoc(),
- Self.PDiag(diag::note_precedence_silence)
- << Bop->getOpcodeStr(),
- Bop->getSourceRange());
+ Self.PDiag(diag::note_precedence_silence)
+ << Bop->getOpcodeStr(),
+ Bop->getSourceRange());
}
/// Look for '&&' in the left hand of a '||' expr.
@@ -15944,12 +15843,12 @@ static void DiagnoseBitwiseOpInBitwiseOp(Sema &S, BinaryOperatorKind Opc,
if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(SubExpr)) {
if (Bop->isBitwiseOp() && Bop->getOpcode() < Opc) {
S.Diag(Bop->getOperatorLoc(), diag::warn_bitwise_op_in_bitwise_op)
- << Bop->getOpcodeStr() << BinaryOperator::getOpcodeStr(Opc)
- << Bop->getSourceRange() << OpLoc;
+ << Bop->getOpcodeStr() << BinaryOperator::getOpcodeStr(Opc)
+ << Bop->getSourceRange() << OpLoc;
SuggestParentheses(S, Bop->getOperatorLoc(),
- S.PDiag(diag::note_precedence_silence)
- << Bop->getOpcodeStr(),
- Bop->getSourceRange());
+ S.PDiag(diag::note_precedence_silence)
+ << Bop->getOpcodeStr(),
+ Bop->getSourceRange());
}
}
}
@@ -15962,14 +15861,14 @@ static void DiagnoseAdditionInShift(Sema &S, SourceLocation OpLoc,
S.Diag(Bop->getOperatorLoc(), diag::warn_addition_in_bitshift)
<< Bop->getSourceRange() << OpLoc << Shift << Op;
SuggestParentheses(S, Bop->getOperatorLoc(),
- S.PDiag(diag::note_precedence_silence) << Op,
- Bop->getSourceRange());
+ S.PDiag(diag::note_precedence_silence) << Op,
+ Bop->getSourceRange());
}
}
}
-static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc, Expr *LHSExpr,
- Expr *RHSExpr) {
+static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc,
+ Expr *LHSExpr, Expr *RHSExpr) {
CXXOperatorCallExpr *OCE = dyn_cast<CXXOperatorCallExpr>(LHSExpr);
if (!OCE)
return;
@@ -15998,28 +15897,27 @@ static void DiagnoseShiftCompare(Sema &S, SourceLocation OpLoc, Expr *LHSExpr,
/// precedence.
static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc,
SourceLocation OpLoc, Expr *LHSExpr,
- Expr *RHSExpr) {
+ Expr *RHSExpr){
// Diagnose "arg1 'bitwise' arg2 'eq' arg3".
if (BinaryOperator::isBitwiseOp(Opc))
DiagnoseBitwisePrecedence(Self, Opc, OpLoc, LHSExpr, RHSExpr);
// Diagnose "arg1 & arg2 | arg3"
if ((Opc == BO_Or || Opc == BO_Xor) &&
- !OpLoc.isMacroID() /* Don't warn in macros. */) {
+ !OpLoc.isMacroID()/* Don't warn in macros. */) {
DiagnoseBitwiseOpInBitwiseOp(Self, Opc, OpLoc, LHSExpr);
DiagnoseBitwiseOpInBitwiseOp(Self, Opc, OpLoc, RHSExpr);
}
// Warn about arg1 || arg2 && arg3, as GCC 4.3+ does.
// We don't warn for 'assert(a || b && "bad")' since this is safe.
- if (Opc == BO_LOr && !OpLoc.isMacroID() /* Don't warn in macros. */) {
+ if (Opc == BO_LOr && !OpLoc.isMacroID()/* Don't warn in macros. */) {
DiagnoseLogicalAndInLogicalOrLHS(Self, OpLoc, LHSExpr, RHSExpr);
DiagnoseLogicalAndInLogicalOrRHS(Self, OpLoc, LHSExpr, RHSExpr);
}
- if ((Opc == BO_Shl &&
- LHSExpr->getType()->isIntegralType(Self.getASTContext())) ||
- Opc == BO_Shr) {
+ if ((Opc == BO_Shl && LHSExpr->getType()->isIntegralType(Self.getASTContext()))
+ || Opc == BO_Shr) {
StringRef Shift = BinaryOperator::getOpcodeStr(Opc);
DiagnoseAdditionInShift(Self, OpLoc, LHSExpr, Shift);
DiagnoseAdditionInShift(Self, OpLoc, RHSExpr, Shift);
@@ -16032,7 +15930,8 @@ static void DiagnoseBinOpPrecedence(Sema &Self, BinaryOperatorKind Opc,
}
ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc,
- tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr) {
+ tok::TokenKind Kind,
+ Expr *LHSExpr, Expr *RHSExpr) {
BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Kind);
assert(LHSExpr && "ActOnBinOp(): missing left expression");
assert(RHSExpr && "ActOnBinOp(): missing right expression");
@@ -16065,8 +15964,8 @@ void Sema::LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc,
/// Build an overloaded binary operator expression in the given scope.
static ExprResult BuildOverloadedBinOp(Sema &S, Scope *Sc, SourceLocation OpLoc,
- BinaryOperatorKind Opc, Expr *LHS,
- Expr *RHS) {
+ BinaryOperatorKind Opc,
+ Expr *LHS, Expr *RHS) {
switch (Opc) {
case BO_Assign:
// In the non-overloaded case, we warn about self-assignment (x = x) for
@@ -16127,8 +16026,7 @@ ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc,
// that an overload set can be dependently-typed, but it never
// instantiates to having an overloadable type.
ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr);
- if (resolvedRHS.isInvalid())
- return ExprError();
+ if (resolvedRHS.isInvalid()) return ExprError();
RHSExpr = resolvedRHS.get();
if (RHSExpr->isTypeDependent() ||
@@ -16159,8 +16057,7 @@ ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc,
}
ExprResult LHS = CheckPlaceholderExpr(LHSExpr);
- if (LHS.isInvalid())
- return ExprError();
+ if (LHS.isInvalid()) return ExprError();
LHSExpr = LHS.get();
}
@@ -16184,8 +16081,7 @@ ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc,
return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
ExprResult resolvedRHS = CheckPlaceholderExpr(RHSExpr);
- if (!resolvedRHS.isUsable())
- return ExprError();
+ if (!resolvedRHS.isUsable()) return ExprError();
RHSExpr = resolvedRHS.get();
}
@@ -16273,11 +16169,10 @@ ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc,
QualType Ty = InputExpr->getType();
// The only legal unary operation for atomics is '&'.
if ((Opc != UO_AddrOf && Ty->isAtomicType()) ||
- // OpenCL special types - image, sampler, pipe, and blocks are to be
- // used only with a builtin functions and therefore should be disallowed
- // here.
- (Ty->isImageType() || Ty->isSamplerT() || Ty->isPipeType() ||
- Ty->isBlockPointerType())) {
+ // OpenCL special types - image, sampler, pipe, and blocks are to be used
+ // only with a builtin functions and therefore should be disallowed here.
+ (Ty->isImageType() || Ty->isSamplerT() || Ty->isPipeType()
+ || Ty->isBlockPointerType())) {
return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
<< InputExpr->getType()
<< Input.get()->getSourceRange());
@@ -16574,15 +16469,15 @@ ExprResult Sema::BuildUnaryOp(Scope *S, SourceLocation OpLoc,
// & gets special logic for several kinds of placeholder.
// The builtin code knows what to do.
- if (Opc == UO_AddrOf && (pty->getKind() == BuiltinType::Overload ||
- pty->getKind() == BuiltinType::UnknownAny ||
- pty->getKind() == BuiltinType::BoundMember))
+ if (Opc == UO_AddrOf &&
+ (pty->getKind() == BuiltinType::Overload ||
+ pty->getKind() == BuiltinType::UnknownAny ||
+ pty->getKind() == BuiltinType::BoundMember))
return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
// Anything else needs to be handled now.
ExprResult Result = CheckPlaceholderExpr(Input);
- if (Result.isInvalid())
- return ExprError();
+ if (Result.isInvalid()) return ExprError();
Input = Result.get();
}
@@ -16720,32 +16615,32 @@ ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
// a struct/union/class.
if (!Dependent && !ArgTy->isRecordType())
return ExprError(Diag(BuiltinLoc, diag::err_offsetof_record_type)
- << ArgTy << TypeRange);
+ << ArgTy << TypeRange);
// Type must be complete per C99 7.17p3 because a declaring a variable
// with an incomplete type would be ill-formed.
- if (!Dependent &&
- RequireCompleteType(BuiltinLoc, ArgTy, diag::err_offsetof_incomplete_type,
- TypeRange))
+ if (!Dependent
+ && RequireCompleteType(BuiltinLoc, ArgTy,
+ diag::err_offsetof_incomplete_type, TypeRange))
return ExprError();
bool DidWarnAboutNonPOD = false;
QualType CurrentType = ArgTy;
SmallVector<OffsetOfNode, 4> Comps;
- SmallVector<Expr *, 4> Exprs;
+ SmallVector<Expr*, 4> Exprs;
for (const OffsetOfComponent &OC : Components) {
if (OC.isBrackets) {
// Offset of an array sub-field. TODO: Should we allow vector elements?
if (!CurrentType->isDependentType()) {
const ArrayType *AT = Context.getAsArrayType(CurrentType);
- if (!AT)
+ if(!AT)
return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type)
<< CurrentType);
CurrentType = AT->getElementType();
} else
CurrentType = Context.DependentTy;
- ExprResult IdxRval = DefaultLvalueConversion(static_cast<Expr *>(OC.U.E));
+ ExprResult IdxRval = DefaultLvalueConversion(static_cast<Expr*>(OC.U.E));
if (IdxRval.isInvalid())
return ExprError();
Expr *Idx = IdxRval.get();
@@ -16792,10 +16687,9 @@ ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
// If type is not a standard-layout class (Clause 9), the results are
// undefined.
if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
- bool IsSafe =
- LangOpts.CPlusPlus11 ? CRD->isStandardLayout() : CRD->isPOD();
- unsigned DiagID = LangOpts.CPlusPlus11
- ? diag::ext_offsetof_non_standardlayout_type
+ bool IsSafe = LangOpts.CPlusPlus11? CRD->isStandardLayout() : CRD->isPOD();
+ unsigned DiagID =
+ LangOpts.CPlusPlus11? diag::ext_offsetof_non_standardlayout_type
: diag::ext_offsetof_non_pod_type;
if (!IsSafe && !DidWarnAboutNonPOD && !isUnevaluatedContext()) {
@@ -16831,7 +16725,8 @@ ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
// We diagnose this as an error.
if (MemberDecl->isBitField()) {
Diag(OC.LocEnd, diag::err_offsetof_bitfield)
- << MemberDecl->getDeclName() << SourceRange(BuiltinLoc, RParenLoc);
+ << MemberDecl->getDeclName()
+ << SourceRange(BuiltinLoc, RParenLoc);
Diag(MemberDecl->getLocation(), diag::note_bitfield_decl);
return ExprError();
}
@@ -16847,7 +16742,8 @@ ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
Context.getCanonicalTagType(Parent), Paths)) {
if (Paths.getDetectedVirtual()) {
Diag(OC.LocEnd, diag::err_offsetof_field_of_virtual_base)
- << MemberDecl->getDeclName() << SourceRange(BuiltinLoc, RParenLoc);
+ << MemberDecl->getDeclName()
+ << SourceRange(BuiltinLoc, RParenLoc);
return ExprError();
}
@@ -16859,8 +16755,8 @@ ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
if (IndirectMemberDecl) {
for (auto *FI : IndirectMemberDecl->chain()) {
assert(isa<FieldDecl>(FI));
- Comps.push_back(
- OffsetOfNode(OC.LocStart, cast<FieldDecl>(FI), OC.LocEnd));
+ Comps.push_back(OffsetOfNode(OC.LocStart,
+ cast<FieldDecl>(FI), OC.LocEnd));
}
} else
Comps.push_back(OffsetOfNode(OC.LocStart, MemberDecl, OC.LocEnd));
@@ -16872,7 +16768,8 @@ ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc,
Comps, Exprs, RParenLoc);
}
-ExprResult Sema::ActOnBuiltinOffsetOf(Scope *S, SourceLocation BuiltinLoc,
+ExprResult Sema::ActOnBuiltinOffsetOf(Scope *S,
+ SourceLocation BuiltinLoc,
SourceLocation TypeLoc,
ParsedType ParsedArgTy,
ArrayRef<OffsetOfComponent> Components,
@@ -16889,7 +16786,9 @@ ExprResult Sema::ActOnBuiltinOffsetOf(Scope *S, SourceLocation BuiltinLoc,
return BuildBuiltinOffsetOf(BuiltinLoc, ArgTInfo, Components, RParenLoc);
}
-ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc, Expr *CondExpr,
+
+ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc,
+ Expr *CondExpr,
Expr *LHSExpr, Expr *RHSExpr,
SourceLocation RPLoc) {
assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)");
@@ -16975,8 +16874,8 @@ void Sema::ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
// Look for an explicit signature in that function type.
FunctionProtoTypeLoc ExplicitSignature;
- if ((ExplicitSignature =
- Sig->getTypeLoc().getAsAdjusted<FunctionProtoTypeLoc>())) {
+ if ((ExplicitSignature = Sig->getTypeLoc()
+ .getAsAdjusted<FunctionProtoTypeLoc>())) {
// Check whether that explicit signature was synthesized by
// GetTypeForDeclarator. If so, don't save that as part of the
@@ -17015,7 +16914,7 @@ void Sema::ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
}
// Push block parameters from the declarator if we had them.
- SmallVector<ParmVarDecl *, 8> Params;
+ SmallVector<ParmVarDecl*, 8> Params;
if (ExplicitSignature) {
for (unsigned I = 0, E = ExplicitSignature.getNumParams(); I != E; ++I) {
ParmVarDecl *Param = ExplicitSignature.getParam(I);
@@ -17028,8 +16927,8 @@ void Sema::ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
Params.push_back(Param);
}
- // Fake up parameter variables if we have a typedef, like
- // ^ fntype { ... }
+ // Fake up parameter variables if we have a typedef, like
+ // ^ fntype { ... }
} else if (const FunctionProtoType *Fn = T->getAs<FunctionProtoType>()) {
for (const auto &I : Fn->param_types()) {
ParmVarDecl *Param = BuildParmVarDeclForTypedef(
@@ -17074,8 +16973,8 @@ void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {
PopFunctionScopeInfo();
}
-ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
- Scope *CurScope) {
+ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc,
+ Stmt *Body, Scope *CurScope) {
// If blocks are disabled, emit an error.
if (!LangOpts.Blocks)
Diag(CaretLoc, diag::err_blocks_disable) << LangOpts.OpenCL;
@@ -17107,8 +17006,7 @@ ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
const FunctionType *FTy = BSI->FunctionType->castAs<FunctionType>();
FunctionType::ExtInfo Ext = FTy->getExtInfo();
- if (NoReturn && !Ext.getNoReturn())
- Ext = Ext.withNoReturn(true);
+ if (NoReturn && !Ext.getNoReturn()) Ext = Ext.withNoReturn(true);
// Turn protoless block types into nullary block types.
if (isa<FunctionNoProtoType>(FTy)) {
@@ -17122,7 +17020,7 @@ ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
(!NoReturn || FTy->getNoReturnAttr())) {
BlockTy = BSI->FunctionType;
- // Otherwise, make the minimal modifications to the function type.
+ // Otherwise, make the minimal modifications to the function type.
} else {
const FunctionProtoType *FPT = cast<FunctionProtoType>(FTy);
FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
@@ -17131,7 +17029,7 @@ ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
BlockTy = Context.getFunctionType(RetTy, FPT->getParamTypes(), EPI);
}
- // If we don't have a function type, just build one from nothing.
+ // If we don't have a function type, just build one from nothing.
} else {
FunctionProtoType::ExtProtoInfo EPI;
EPI.ExtInfo = FunctionType::ExtInfo().withNoReturn(NoReturn);
@@ -17142,7 +17040,8 @@ ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
BlockTy = Context.getBlockPointerType(BlockTy);
// If needed, diagnose invalid gotos and switches in the block.
- if (getCurFunction()->NeedsScopeChecking() && !PP.isCodeCompletionEnabled())
+ if (getCurFunction()->NeedsScopeChecking() &&
+ !PP.isCodeCompletionEnabled())
DiagnoseInvalidJumps(cast<CompoundStmt>(Body));
BD->setBody(cast<CompoundStmt>(Body));
@@ -17217,9 +17116,9 @@ ExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
// Build a full-expression copy expression if initialization
// succeeded and used a non-trivial constructor. Recover from
// errors by pretending that the copy isn't necessary.
- if (!Result.isInvalid() && !cast<CXXConstructExpr>(Result.get())
- ->getConstructor()
- ->isTrivial()) {
+ if (!Result.isInvalid() &&
+ !cast<CXXConstructExpr>(Result.get())->getConstructor()
+ ->isTrivial()) {
Result = MaybeCreateExprWithCleanups(Result);
CopyExpr = Result.get();
}
@@ -17276,8 +17175,9 @@ ExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,
return BuildVAArgExpr(BuiltinLoc, E, TInfo, RPLoc);
}
-ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,
- TypeSourceInfo *TInfo, SourceLocation RPLoc) {
+ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc,
+ Expr *E, TypeSourceInfo *TInfo,
+ SourceLocation RPLoc) {
Expr *OrigExpr = E;
bool IsMS = false;
@@ -17299,8 +17199,7 @@ ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,
// as Microsoft ABI on an actual Microsoft platform, where
// __builtin_ms_va_list and __builtin_va_list are the same.)
if (!E->isTypeDependent() && Context.getTargetInfo().hasBuiltinMSVaList() &&
- Context.getTargetInfo().getBuiltinVaListKind() !=
- TargetInfo::CharPtrBuiltinVaList) {
+ Context.getTargetInfo().getBuiltinVaListKind() != TargetInfo::CharPtrBuiltinVaList) {
QualType MSVaListType = Context.getBuiltinMSVaListType();
if (Context.hasSameType(MSVaListType, E->getType())) {
if (CheckForModifiableLvalue(E, BuiltinLoc, *this))
@@ -17353,17 +17252,19 @@ ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,
TInfo->getTypeLoc()))
return ExprError();
- if (RequireNonAbstractType(
- TInfo->getTypeLoc().getBeginLoc(), TInfo->getType(),
- diag::err_second_parameter_to_va_arg_abstract, TInfo->getTypeLoc()))
+ if (RequireNonAbstractType(TInfo->getTypeLoc().getBeginLoc(),
+ TInfo->getType(),
+ diag::err_second_parameter_to_va_arg_abstract,
+ TInfo->getTypeLoc()))
return ExprError();
if (!TInfo->getType().isPODType(Context)) {
Diag(TInfo->getTypeLoc().getBeginLoc(),
TInfo->getType()->isObjCLifetimeType()
- ? diag::warn_second_parameter_to_va_arg_ownership_qualified
- : diag::warn_second_parameter_to_va_arg_not_pod)
- << TInfo->getType() << TInfo->getTypeLoc().getSourceRange();
+ ? diag::warn_second_parameter_to_va_arg_ownership_qualified
+ : diag::warn_second_parameter_to_va_arg_not_pod)
+ << TInfo->getType()
+ << TInfo->getTypeLoc().getSourceRange();
}
if (TInfo->getType()->isArrayType()) {
@@ -17425,11 +17326,11 @@ ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,
if (TInfo->getType()->isSpecificBuiltinType(BuiltinType::Float))
PromoteType = Context.DoubleTy;
if (!PromoteType.isNull())
- DiagRuntimeBehavior(
- TInfo->getTypeLoc().getBeginLoc(), E,
- PDiag(diag::warn_second_parameter_to_va_arg_never_compatible)
- << TInfo->getType() << PromoteType
- << TInfo->getTypeLoc().getSourceRange());
+ DiagRuntimeBehavior(TInfo->getTypeLoc().getBeginLoc(), E,
+ PDiag(diag::warn_second_parameter_to_va_arg_never_compatible)
+ << TInfo->getType()
+ << PromoteType
+ << TInfo->getTypeLoc().getSourceRange());
}
QualType T = TInfo->getType().getNonLValueExprType(Context);
@@ -17592,9 +17493,10 @@ static bool maybeDiagnoseAssignmentToFunction(Sema &S, QualType DstType,
}
bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
- SourceLocation Loc, QualType DstType,
- QualType SrcType, Expr *SrcExpr,
- AssignmentAction Action, bool *Complained) {
+ SourceLocation Loc,
+ QualType DstType, QualType SrcType,
+ Expr *SrcExpr, AssignmentAction Action,
+ bool *Complained) {
if (Complained)
*Complained = false;
@@ -17663,7 +17565,7 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
}
CheckInferredResultType = DstType->isObjCObjectPointerType() &&
- SrcType->isObjCObjectPointerType();
+ SrcType->isObjCObjectPointerType();
if (CheckInferredResultType) {
SrcType = SrcType.getUnqualifiedType();
DstType = DstType.getUnqualifiedType();
@@ -17690,8 +17592,7 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
break;
case AssignConvertType::IncompatiblePointerDiscardsQualifiers: {
// Perform array-to-pointer decay if necessary.
- if (SrcType->isArrayType())
- SrcType = Context.getArrayDecayedType(SrcType);
+ if (SrcType->isArrayType()) SrcType = Context.getArrayDecayedType(SrcType);
isInvalid = true;
@@ -17731,10 +17632,10 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType))
return false;
if (getLangOpts().CPlusPlus) {
- DiagKind = diag::err_typecheck_convert_discards_qualifiers;
+ DiagKind = diag::err_typecheck_convert_discards_qualifiers;
isInvalid = true;
} else {
- DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
+ DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
}
break;
@@ -17761,23 +17662,24 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
case AssignConvertType::IncompatibleObjCQualifiedId: {
if (SrcType->isObjCQualifiedIdType()) {
const ObjCObjectPointerType *srcOPT =
- SrcType->castAs<ObjCObjectPointerType>();
+ SrcType->castAs<ObjCObjectPointerType>();
for (auto *srcProto : srcOPT->quals()) {
PDecl = srcProto;
break;
}
if (const ObjCInterfaceType *IFaceT =
- DstType->castAs<ObjCObjectPointerType>()->getInterfaceType())
+ DstType->castAs<ObjCObjectPointerType>()->getInterfaceType())
IFace = IFaceT->getDecl();
- } else if (DstType->isObjCQualifiedIdType()) {
+ }
+ else if (DstType->isObjCQualifiedIdType()) {
const ObjCObjectPointerType *dstOPT =
- DstType->castAs<ObjCObjectPointerType>();
+ DstType->castAs<ObjCObjectPointerType>();
for (auto *dstProto : dstOPT->quals()) {
PDecl = dstProto;
break;
}
if (const ObjCInterfaceType *IFaceT =
- SrcType->castAs<ObjCObjectPointerType>()->getInterfaceType())
+ SrcType->castAs<ObjCObjectPointerType>()->getInterfaceType())
IFace = IFaceT->getDecl();
}
if (getLangOpts().CPlusPlus) {
@@ -17881,9 +17783,7 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
FDiag << H;
}
- if (MayHaveConvFixit) {
- FDiag << (unsigned)(ConvHints.Kind);
- }
+ if (MayHaveConvFixit) { FDiag << (unsigned) (ConvHints.Kind); }
if (MayHaveFunctionDiff)
HandleFunctionTypeMismatch(FDiag, SecondType, FirstType);
@@ -17896,8 +17796,8 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
<< IFace << PDecl;
if (SecondType == Context.OverloadTy)
- NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression, FirstType,
- /*TakingAddress=*/true);
+ NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression,
+ FirstType, /*TakingAddress=*/true);
if (CheckInferredResultType)
ObjC().EmitRelatedResultTypeNote(SrcExpr);
@@ -17911,7 +17811,8 @@ bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
return isInvalid;
}
-ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
+ExprResult Sema::VerifyIntegerConstantExpression(Expr *E,
+ llvm::APSInt *Result,
AllowFoldKind CanFold) {
class SimpleICEDiagnoser : public VerifyICEDiagnoser {
public:
@@ -17928,7 +17829,8 @@ ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
return VerifyIntegerConstantExpression(E, Result, Diagnoser, CanFold);
}
-ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
+ExprResult Sema::VerifyIntegerConstantExpression(Expr *E,
+ llvm::APSInt *Result,
unsigned DiagID,
AllowFoldKind CanFold) {
class IDDiagnoser : public VerifyICEDiagnoser {
@@ -17936,7 +17838,7 @@ ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
public:
IDDiagnoser(unsigned DiagID)
- : VerifyICEDiagnoser(DiagID == 0), DiagID(DiagID) {}
+ : VerifyICEDiagnoser(DiagID == 0), DiagID(DiagID) { }
SemaDiagnosticBuilder diagnoseNotICE(Sema &S, SourceLocation Loc) override {
return S.Diag(Loc, DiagID);
@@ -17957,9 +17859,10 @@ Sema::VerifyICEDiagnoser::diagnoseFold(Sema &S, SourceLocation Loc) {
return S.Diag(Loc, diag::ext_expr_not_ice) << S.LangOpts.CPlusPlus;
}
-ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
- VerifyICEDiagnoser &Diagnoser,
- AllowFoldKind CanFold) {
+ExprResult
+Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
+ VerifyICEDiagnoser &Diagnoser,
+ AllowFoldKind CanFold) {
SourceLocation DiagLoc = E->getBeginLoc();
if (getLangOpts().CPlusPlus11) {
@@ -17971,7 +17874,6 @@ ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
ExprResult Converted;
class CXX11ConvertDiagnoser : public ICEConvertDiagnoser {
VerifyICEDiagnoser &BaseDiagnoser;
-
public:
CXX11ConvertDiagnoser(VerifyICEDiagnoser &BaseDiagnoser)
: ICEConvertDiagnoser(/*AllowScopedEnumerations*/ false,
@@ -17983,43 +17885,41 @@ ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
return BaseDiagnoser.diagnoseNotICEType(S, Loc, T);
}
- SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
- QualType T) override {
+ SemaDiagnosticBuilder diagnoseIncomplete(
+ Sema &S, SourceLocation Loc, QualType T) override {
return S.Diag(Loc, diag::err_ice_incomplete_type) << T;
}
- SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
- QualType T,
- QualType ConvTy) override {
+ SemaDiagnosticBuilder diagnoseExplicitConv(
+ Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
return S.Diag(Loc, diag::err_ice_explicit_conversion) << T << ConvTy;
}
- SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv,
- QualType ConvTy) override {
+ SemaDiagnosticBuilder noteExplicitConv(
+ Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here)
- << ConvTy->isEnumeralType() << ConvTy;
+ << ConvTy->isEnumeralType() << ConvTy;
}
- SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
- QualType T) override {
+ SemaDiagnosticBuilder diagnoseAmbiguous(
+ Sema &S, SourceLocation Loc, QualType T) override {
return S.Diag(Loc, diag::err_ice_ambiguous_conversion) << T;
}
- SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
- QualType ConvTy) override {
+ SemaDiagnosticBuilder noteAmbiguous(
+ Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override {
return S.Diag(Conv->getLocation(), diag::note_ice_conversion_here)
- << ConvTy->isEnumeralType() << ConvTy;
+ << ConvTy->isEnumeralType() << ConvTy;
}
- SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
- QualType T,
- QualType ConvTy) override {
+ SemaDiagnosticBuilder diagnoseConversion(
+ Sema &S, SourceLocation Loc, QualType T, QualType ConvTy) override {
llvm_unreachable("conversion functions are permitted");
}
} ConvertDiagnoser(Diagnoser);
- Converted =
- PerformContextualImplicitConversion(DiagLoc, E, ConvertDiagnoser);
+ Converted = PerformContextualImplicitConversion(DiagLoc, E,
+ ConvertDiagnoser);
if (Converted.isInvalid())
return Converted;
E = Converted.get();
@@ -18062,7 +17962,7 @@ ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
// the caret at its location rather than producing an essentially
// redundant note.
if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
- diag::note_invalid_subexpr_in_const_expr) {
+ diag::note_invalid_subexpr_in_const_expr) {
DiagLoc = Notes[0].first;
Notes.clear();
}
@@ -18109,8 +18009,8 @@ ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
// If our only note is the usual "invalid subexpression" note, just point
// the caret at its location rather than producing an essentially
// redundant note.
- if (Notes.size() == 1 &&
- Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr) {
+ if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
+ diag::note_invalid_subexpr_in_const_expr) {
DiagLoc = Notes[0].first;
Notes.clear();
}
@@ -18135,57 +18035,58 @@ ExprResult Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
}
namespace {
-// Handle the case where we conclude a expression which we speculatively
-// considered to be unevaluated is actually evaluated.
-class TransformToPE : public TreeTransform<TransformToPE> {
- typedef TreeTransform<TransformToPE> BaseTransform;
+ // Handle the case where we conclude a expression which we speculatively
+ // considered to be unevaluated is actually evaluated.
+ class TransformToPE : public TreeTransform<TransformToPE> {
+ typedef TreeTransform<TransformToPE> BaseTransform;
-public:
- TransformToPE(Sema &SemaRef) : BaseTransform(SemaRef) {}
+ public:
+ TransformToPE(Sema &SemaRef) : BaseTransform(SemaRef) { }
- // Make sure we redo semantic analysis
- bool AlwaysRebuild() { return true; }
- bool ReplacingOriginal() { return true; }
+ // Make sure we redo semantic analysis
+ bool AlwaysRebuild() { return true; }
+ bool ReplacingOriginal() { return true; }
- // We need to special-case DeclRefExprs referring to FieldDecls which
- // are not part of a member pointer formation; normal TreeTransforming
- // doesn't catch this case because of the way we represent them in the AST.
- // FIXME: This is a bit ugly; is it really the best way to handle this
- // case?
- //
- // Error on DeclRefExprs referring to FieldDecls.
- ExprResult TransformDeclRefExpr(DeclRefExpr *E) {
- if (isa<FieldDecl>(E->getDecl()) && !SemaRef.isUnevaluatedContext())
- return SemaRef.Diag(E->getLocation(),
- diag::err_invalid_non_static_member_use)
- << E->getDecl() << E->getSourceRange();
+ // We need to special-case DeclRefExprs referring to FieldDecls which
+ // are not part of a member pointer formation; normal TreeTransforming
+ // doesn't catch this case because of the way we represent them in the AST.
+ // FIXME: This is a bit ugly; is it really the best way to handle this
+ // case?
+ //
+ // Error on DeclRefExprs referring to FieldDecls.
+ ExprResult TransformDeclRefExpr(DeclRefExpr *E) {
+ if (isa<FieldDecl>(E->getDecl()) &&
+ !SemaRef.isUnevaluatedContext())
+ return SemaRef.Diag(E->getLocation(),
+ diag::err_invalid_non_static_member_use)
+ << E->getDecl() << E->getSourceRange();
- return BaseTransform::TransformDeclRefExpr(E);
- }
+ return BaseTransform::TransformDeclRefExpr(E);
+ }
- // Exception: filter out member pointer formation
- ExprResult TransformUnaryOperator(UnaryOperator *E) {
- if (E->getOpcode() == UO_AddrOf && E->getType()->isMemberPointerType())
- return E;
+ // Exception: filter out member pointer formation
+ ExprResult TransformUnaryOperator(UnaryOperator *E) {
+ if (E->getOpcode() == UO_AddrOf && E->getType()->isMemberPointerType())
+ return E;
- return BaseTransform::TransformUnaryOperator(E);
- }
+ return BaseTransform::TransformUnaryOperator(E);
+ }
- // The body of a lambda-expression is in a separate expression evaluation
- // context so never needs to be transformed.
- // FIXME: Ideally we wouldn't transform the closure type either, and would
- // just recreate the capture expressions and lambda expression.
- StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body) {
- return SkipLambdaBody(E, Body);
- }
-};
-} // namespace
+ // The body of a lambda-expression is in a separate expression evaluation
+ // context so never needs to be transformed.
+ // FIXME: Ideally we wouldn't transform the closure type either, and would
+ // just recreate the capture expressions and lambda expression.
+ StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body) {
+ return SkipLambdaBody(E, Body);
+ }
+ };
+}
ExprResult Sema::TransformToPotentiallyEvaluated(Expr *E) {
assert(isUnevaluatedContext() &&
"Should only transform unevaluated expressions");
ExprEvalContexts.back().Context =
- ExprEvalContexts[ExprEvalContexts.size() - 2].Context;
+ ExprEvalContexts[ExprEvalContexts.size()-2].Context;
if (isUnevaluatedContext())
return E;
return TransformToPE(*this).TransformExpr(E);
@@ -18200,7 +18101,8 @@ TypeSourceInfo *Sema::TransformToPotentiallyEvaluated(TypeSourceInfo *TInfo) {
return TransformToPE(*this).TransformType(TInfo);
}
-void Sema::PushExpressionEvaluationContext(
+void
+Sema::PushExpressionEvaluationContext(
ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl,
ExpressionEvaluationContextRecord::ExpressionKind ExprContext) {
ExprEvalContexts.emplace_back(NewContext, ExprCleanupObjects.size(), Cleanup,
@@ -18228,7 +18130,8 @@ void Sema::PushExpressionEvaluationContext(
std::swap(MaybeODRUseExprs, ExprEvalContexts.back().SavedMaybeODRUseExprs);
}
-void Sema::PushExpressionEvaluationContext(
+void
+Sema::PushExpressionEvaluationContext(
ExpressionEvaluationContext NewContext, ReuseLambdaContextDecl_t,
ExpressionEvaluationContextRecord::ExpressionKind ExprContext) {
Decl *ClosureContextDecl = ExprEvalContexts.back().ManglingContextDecl;
@@ -18497,7 +18400,7 @@ static void RemoveNestedImmediateInvocation(
SmallVector<Sema::ImmediateInvocationCandidate,
4>::reverse_iterator Current)
: Base(SemaRef), DRSet(DR), IISet(II), CurrentII(Current) {}
- void RemoveImmediateInvocation(ConstantExpr *E) {
+ void RemoveImmediateInvocation(ConstantExpr* E) {
auto It = std::find_if(CurrentII, IISet.rend(),
[E](Sema::ImmediateInvocationCandidate Elem) {
return Elem.getPointer() == E;
@@ -18701,7 +18604,7 @@ HandleImmediateInvocations(Sema &SemaRef,
}
void Sema::PopExpressionEvaluationContext() {
- ExpressionEvaluationContextRecord &Rec = ExprEvalContexts.back();
+ ExpressionEvaluationContextRecord& Rec = ExprEvalContexts.back();
if (!Rec.Lambdas.empty()) {
using ExpressionKind = ExpressionEvaluationContextRecord::ExpressionKind;
if (!getLangOpts().CPlusPlus20 &&
@@ -18761,7 +18664,7 @@ void Sema::PopExpressionEvaluationContext() {
Cleanup = Rec.ParentCleanup;
CleanupVarDeclMarking();
std::swap(MaybeODRUseExprs, Rec.SavedMaybeODRUseExprs);
- // Otherwise, merge the contexts together.
+ // Otherwise, merge the contexts together.
} else {
Cleanup.mergeFrom(Rec.ParentCleanup);
MaybeODRUseExprs.insert_range(Rec.SavedMaybeODRUseExprs);
@@ -18774,9 +18677,9 @@ void Sema::PopExpressionEvaluationContext() {
}
void Sema::DiscardCleanupsInEvaluationContext() {
- ExprCleanupObjects.erase(ExprCleanupObjects.begin() +
- ExprEvalContexts.back().NumCleanupObjects,
- ExprCleanupObjects.end());
+ ExprCleanupObjects.erase(
+ ExprCleanupObjects.begin() + ExprEvalContexts.back().NumCleanupObjects,
+ ExprCleanupObjects.end());
Cleanup.reset();
MaybeODRUseExprs.clear();
}
@@ -18797,27 +18700,27 @@ static bool isPotentiallyConstantEvaluatedContext(Sema &SemaRef) {
/// C++2a [expr.const]p12:
// An expression or conversion is potentially constant evaluated if it is
switch (SemaRef.ExprEvalContexts.back().Context) {
- case Sema::ExpressionEvaluationContext::ConstantEvaluated:
- case Sema::ExpressionEvaluationContext::ImmediateFunctionContext:
-
- // -- a manifestly constant-evaluated expression,
- case Sema::ExpressionEvaluationContext::PotentiallyEvaluated:
- case Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
- case Sema::ExpressionEvaluationContext::DiscardedStatement:
- // -- a potentially-evaluated expression,
- case Sema::ExpressionEvaluationContext::UnevaluatedList:
- // -- an immediate subexpression of a braced-init-list,
-
- // -- [FIXME] an expression of the form & cast-expression that occurs
- // within a templated entity
- // -- a subexpression of one of the above that is not a subexpression of
- // a nested unevaluated operand.
- return true;
+ case Sema::ExpressionEvaluationContext::ConstantEvaluated:
+ case Sema::ExpressionEvaluationContext::ImmediateFunctionContext:
+
+ // -- a manifestly constant-evaluated expression,
+ case Sema::ExpressionEvaluationContext::PotentiallyEvaluated:
+ case Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
+ case Sema::ExpressionEvaluationContext::DiscardedStatement:
+ // -- a potentially-evaluated expression,
+ case Sema::ExpressionEvaluationContext::UnevaluatedList:
+ // -- an immediate subexpression of a braced-init-list,
+
+ // -- [FIXME] an expression of the form & cast-expression that occurs
+ // within a templated entity
+ // -- a subexpression of one of the above that is not a subexpression of
+ // a nested unevaluated operand.
+ return true;
- case Sema::ExpressionEvaluationContext::Unevaluated:
- case Sema::ExpressionEvaluationContext::UnevaluatedAbstract:
- // Expressions in this context are never evaluated.
- return false;
+ case Sema::ExpressionEvaluationContext::Unevaluated:
+ case Sema::ExpressionEvaluationContext::UnevaluatedAbstract:
+ // Expressions in this context are never evaluated.
+ return false;
}
llvm_unreachable("Invalid context");
}
@@ -19095,7 +18998,7 @@ void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
PointOfInstantiation = Loc;
if (auto *MSI = Func->getMemberSpecializationInfo())
MSI->setPointOfInstantiation(Loc);
- // FIXME: Notify listener.
+ // FIXME: Notify listener.
else
Func->setTemplateSpecializationKind(TSK, PointOfInstantiation);
} else if (TSK != TSK_ImplicitInstantiation) {
@@ -19188,7 +19091,8 @@ void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
if (!Func->isDefined() && !Func->isInAnotherModuleUnit()) {
if (mightHaveNonExternalLinkage(Func))
UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
- else if (Func->getMostRecentDecl()->isInlined() && !LangOpts.GNUInline &&
+ else if (Func->getMostRecentDecl()->isInlined() &&
+ !LangOpts.GNUInline &&
!Func->getMostRecentDecl()->hasAttr<GNUInlineAttr>())
UndefinedButUsed.insert(std::make_pair(Func->getCanonicalDecl(), Loc));
else if (isExternalWithNoLinkageType(Func))
@@ -19318,7 +19222,8 @@ static void diagnoseUncapturableValueReferenceOrBinding(Sema &S,
// If the parameter still belongs to the translation unit, then
// we're actually just using one parameter in the declaration of
// the next.
- if (isa<ParmVarDecl>(var) && isa<TranslationUnitDecl>(VarDC))
+ if (isa<ParmVarDecl>(var) &&
+ isa<TranslationUnitDecl>(VarDC))
return;
// For C code, don't diagnose about capture if we're not actually in code
@@ -19343,8 +19248,9 @@ static void diagnoseUncapturableValueReferenceOrBinding(Sema &S,
}
S.Diag(loc, diag::err_reference_to_local_in_enclosing_context)
- << var << ValueKind << ContextKind << VarDC;
- S.Diag(var->getLocation(), diag::note_entity_declared_at) << var;
+ << var << ValueKind << ContextKind << VarDC;
+ S.Diag(var->getLocation(), diag::note_entity_declared_at)
+ << var;
// FIXME: Add additional diagnostic info about class etc. which prevents
// capture.
@@ -19508,7 +19414,8 @@ static bool captureInBlock(BlockScopeInfo *BSI, ValueDecl *Var,
if (!Invalid &&
CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) {
if (BuildAndDiagnose) {
- S.Diag(Loc, diag::err_arc_autoreleasing_capture) << /*block*/ 0;
+ S.Diag(Loc, diag::err_arc_autoreleasing_capture)
+ << /*block*/ 0;
S.Diag(Var->getLocation(), diag::note_previous_decl) << Var;
Invalid = true;
} else {
@@ -19639,7 +19546,7 @@ static bool captureInLambda(LambdaScopeInfo *LSI, ValueDecl *Var,
// captured entity is a reference to a function, the
// corresponding data member is also a reference to a
// function. - end note ]
- if (const ReferenceType *RefType = CaptureType->getAs<ReferenceType>()) {
+ if (const ReferenceType *RefType = CaptureType->getAs<ReferenceType>()){
if (!RefType->getPointeeType()->isFunctionType())
CaptureType = RefType->getPointeeType();
}
@@ -19650,7 +19557,7 @@ static bool captureInLambda(LambdaScopeInfo *LSI, ValueDecl *Var,
if (BuildAndDiagnose) {
S.Diag(Loc, diag::err_arc_autoreleasing_capture) << /*lambda*/ 1;
S.Diag(Var->getLocation(), diag::note_previous_decl)
- << Var->getDeclName();
+ << Var->getDeclName();
Invalid = true;
} else {
return false;
@@ -19837,8 +19744,7 @@ bool Sema::tryCaptureVariable(
assert(VD && "Cannot capture a null variable");
const unsigned MaxFunctionScopesIndex = FunctionScopeIndexToStopAt
- ? *FunctionScopeIndexToStopAt
- : FunctionScopes.size() - 1;
+ ? *FunctionScopeIndexToStopAt : FunctionScopes.size() - 1;
// We need to sync up the Declaration Context with the
// FunctionScopeIndexToStopAt
if (FunctionScopeIndexToStopAt) {
@@ -19923,7 +19829,7 @@ bool Sema::tryCaptureVariable(
return true;
}
- FunctionScopeInfo *FSI = FunctionScopes[FunctionScopesIndex];
+ FunctionScopeInfo *FSI = FunctionScopes[FunctionScopesIndex];
CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FSI);
// Check whether we've already captured it.
@@ -20071,13 +19977,13 @@ bool Sema::tryCaptureVariable(
// If the variable had already been captured previously, we start capturing
// at the lambda nested within that one.
bool Invalid = false;
- for (unsigned I = ++FunctionScopesIndex, N = MaxFunctionScopesIndex + 1;
- I != N; ++I) {
+ for (unsigned I = ++FunctionScopesIndex, N = MaxFunctionScopesIndex + 1; I != N;
+ ++I) {
CapturingScopeInfo *CSI = cast<CapturingScopeInfo>(FunctionScopes[I]);
- // Certain capturing entities (lambdas, blocks etc.) are not allowed to
- // capture certain types of variables (unnamed, variably modified types
- // etc.) so check for eligibility.
+ // Certain capturing entities (lambdas, blocks etc.) are not allowed to capture
+ // certain types of variables (unnamed, variably modified types etc.)
+ // so check for eligibility.
if (!Invalid)
Invalid =
!isVariableCapturable(CSI, Var, ExprLoc, BuildAndDiagnose, *this);
@@ -20088,12 +19994,10 @@ bool Sema::tryCaptureVariable(
return true;
if (BlockScopeInfo *BSI = dyn_cast<BlockScopeInfo>(CSI)) {
- Invalid =
- !captureInBlock(BSI, Var, ExprLoc, BuildAndDiagnose, CaptureType,
- DeclRefType, Nested, *this, Invalid);
+ Invalid = !captureInBlock(BSI, Var, ExprLoc, BuildAndDiagnose, CaptureType,
+ DeclRefType, Nested, *this, Invalid);
Nested = true;
- } else if (CapturedRegionScopeInfo *RSI =
- dyn_cast<CapturedRegionScopeInfo>(CSI)) {
+ } else if (CapturedRegionScopeInfo *RSI = dyn_cast<CapturedRegionScopeInfo>(CSI)) {
Invalid = !captureInCapturedRegion(
RSI, Var, ExprLoc, BuildAndDiagnose, CaptureType, DeclRefType, Nested,
Kind, /*IsTopScope*/ I == N - 1, *this, Invalid);
@@ -20118,8 +20022,8 @@ bool Sema::tryCaptureVariable(ValueDecl *Var, SourceLocation Loc,
QualType CaptureType;
QualType DeclRefType;
return tryCaptureVariable(Var, Loc, Kind, EllipsisLoc,
- /*BuildAndDiagnose=*/true, CaptureType, DeclRefType,
- nullptr);
+ /*BuildAndDiagnose=*/true, CaptureType,
+ DeclRefType, nullptr);
}
bool Sema::NeedToCaptureVariable(ValueDecl *Var, SourceLocation Loc) {
@@ -20153,24 +20057,23 @@ namespace {
class CopiedTemplateArgs {
bool HasArgs;
TemplateArgumentListInfo TemplateArgStorage;
-
public:
- template <typename RefExpr>
+ template<typename RefExpr>
CopiedTemplateArgs(RefExpr *E) : HasArgs(E->hasExplicitTemplateArgs()) {
if (HasArgs)
E->copyTemplateArgumentsInto(TemplateArgStorage);
}
- operator TemplateArgumentListInfo *()
+ operator TemplateArgumentListInfo*()
#ifdef __has_cpp_attribute
#if __has_cpp_attribute(clang::lifetimebound)
- [[clang::lifetimebound]]
+ [[clang::lifetimebound]]
#endif
#endif
{
return HasArgs ? &TemplateArgStorage : nullptr;
}
};
-} // namespace
+}
/// Walk the set of potential results of an expression and mark them all as
/// non-odr-uses if they satisfy the side-conditions of the NonOdrUseReason.
@@ -20362,7 +20265,7 @@ static ExprResult rebuildPotentialResultsAsNonOdrUsed(Sema &S, Expr *E,
if (!Sub.isUsable())
return Sub;
BO->setLHS(Sub.get());
- // -- If e is a comma expression, ...
+ // -- If e is a comma expression, ...
} else if (BO->getOpcode() == BO_Comma) {
ExprResult Sub = Rebuild(RHS);
if (!Sub.isUsable())
@@ -20559,8 +20462,8 @@ void Sema::CleanupVarDeclMarking() {
for (Expr *E : LocalMaybeODRUseExprs) {
if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
- MarkVarDeclODRUsed(cast<VarDecl>(DRE->getDecl()), DRE->getLocation(),
- *this);
+ MarkVarDeclODRUsed(cast<VarDecl>(DRE->getDecl()),
+ DRE->getLocation(), *this);
} else if (auto *ME = dyn_cast<MemberExpr>(E)) {
MarkVarDeclODRUsed(cast<VarDecl>(ME->getMemberDecl()), ME->getMemberLoc(),
*this);
@@ -20681,7 +20584,7 @@ static void DoMarkVarDeclReferenced(
PointOfInstantiation = Loc;
if (MSI)
MSI->setPointOfInstantiation(PointOfInstantiation);
- // FIXME: Notify listener.
+ // FIXME: Notify listener.
else
Var->setTemplateSpecializationKind(TSK, PointOfInstantiation);
}
@@ -20707,8 +20610,8 @@ static void DoMarkVarDeclReferenced(
else if (auto *ME = dyn_cast_or_null<MemberExpr>(E))
ME->setMemberDecl(ME->getMemberDecl());
} else if (FirstInstantiation) {
- SemaRef.PendingInstantiations.push_back(
- std::make_pair(Var, PointOfInstantiation));
+ SemaRef.PendingInstantiations
+ .push_back(std::make_pair(Var, PointOfInstantiation));
} else {
bool Inserted = false;
for (auto &I : SemaRef.SavedPendingInstantiations) {
@@ -20730,8 +20633,8 @@ static void DoMarkVarDeclReferenced(
// no direct way to avoid enqueueing the pending instantiation
// multiple times.
if (isa<VarTemplateSpecializationDecl>(Var) && !Inserted)
- SemaRef.PendingInstantiations.push_back(
- std::make_pair(Var, PointOfInstantiation));
+ SemaRef.PendingInstantiations
+ .push_back(std::make_pair(Var, PointOfInstantiation));
}
}
}
@@ -20905,8 +20808,8 @@ MarkExprReferenced(Sema &SemaRef, SourceLocation Loc, Decl *D, Expr *E,
if (!MD)
return;
// Only attempt to devirtualize if this is truly a virtual call.
- bool IsVirtualCall =
- MD->isVirtual() && ME->performsVirtualDispatch(SemaRef.getLangOpts());
+ bool IsVirtualCall = MD->isVirtual() &&
+ ME->performsVirtualDispatch(SemaRef.getLangOpts());
if (!IsVirtualCall)
return;
@@ -20987,13 +20890,13 @@ void Sema::MarkAnyDeclReferenced(SourceLocation Loc, Decl *D,
}
namespace {
-// Mark all of the declarations used by a type as referenced.
-// FIXME: Not fully implemented yet! We need to have a better understanding
-// of when we're entering a context we should not recurse into.
-// FIXME: This is and EvaluatedExprMarker are more-or-less equivalent to
-// TreeTransforms rebuilding the type in a new context. Rather than
-// duplicating the TreeTransform logic, we should consider reusing it here.
-// Currently that causes problems when rebuilding LambdaExprs.
+ // Mark all of the declarations used by a type as referenced.
+ // FIXME: Not fully implemented yet! We need to have a better understanding
+ // of when we're entering a context we should not recurse into.
+ // FIXME: This is and EvaluatedExprMarker are more-or-less equivalent to
+ // TreeTransforms rebuilding the type in a new context. Rather than
+ // duplicating the TreeTransform logic, we should consider reusing it here.
+ // Currently that causes problems when rebuilding LambdaExprs.
class MarkReferencedDecls : public DynamicRecursiveASTVisitor {
Sema &S;
SourceLocation Loc;
@@ -21003,7 +20906,7 @@ class MarkReferencedDecls : public DynamicRecursiveASTVisitor {
bool TraverseTemplateArgument(const TemplateArgument &Arg) override;
};
-} // namespace
+}
bool MarkReferencedDecls::TraverseTemplateArgument(
const TemplateArgument &Arg) {
@@ -21076,8 +20979,9 @@ class EvaluatedExprMarker : public UsedDeclVisitor<EvaluatedExprMarker> {
};
} // namespace
-void Sema::MarkDeclarationsReferencedInExpr(Expr *E, bool SkipLocalVariables,
- ArrayRef<const Expr *> StopAt) {
+void Sema::MarkDeclarationsReferencedInExpr(Expr *E,
+ bool SkipLocalVariables,
+ ArrayRef<const Expr*> StopAt) {
EvaluatedExprMarker(*this, SkipLocalVariables, StopAt).Visit(E);
}
@@ -21134,7 +21038,7 @@ bool Sema::DiagIfReachable(SourceLocation Loc, ArrayRef<const Stmt *> Stmts,
/// behavior of a program, such as passing a non-POD value through an ellipsis.
/// Failure to do so will likely result in spurious diagnostics or failures
/// during overload resolution or within sizeof/alignof/typeof/typeid.
-bool Sema::DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt *> Stmts,
+bool Sema::DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt*> Stmts,
const PartialDiagnostic &PD) {
if (ExprEvalContexts.back().isDiscardedStatementContext())
@@ -21187,12 +21091,12 @@ bool Sema::CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
public:
CallReturnIncompleteDiagnoser(FunctionDecl *FD, CallExpr *CE)
- : FD(FD), CE(CE) {}
+ : FD(FD), CE(CE) { }
void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
if (!FD) {
S.Diag(Loc, diag::err_call_incomplete_return)
- << T << CE->getSourceRange();
+ << T << CE->getSourceRange();
return;
}
@@ -21224,8 +21128,8 @@ void Sema::DiagnoseAssignmentAsCondition(Expr *E) {
IsOrAssign = Op->getOpcode() == BO_OrAssign;
// Greylist some idioms by putting them into a warning subcategory.
- if (ObjCMessageExpr *ME =
- dyn_cast<ObjCMessageExpr>(Op->getRHS()->IgnoreParenCasts())) {
+ if (ObjCMessageExpr *ME
+ = dyn_cast<ObjCMessageExpr>(Op->getRHS()->IgnoreParenCasts())) {
Selector Sel = ME->getSelector();
// self = [<foo> init...]
@@ -21256,15 +21160,15 @@ void Sema::DiagnoseAssignmentAsCondition(Expr *E) {
SourceLocation Open = E->getBeginLoc();
SourceLocation Close = getLocForEndOfToken(E->getSourceRange().getEnd());
Diag(Loc, diag::note_condition_assign_silence)
- << FixItHint::CreateInsertion(Open, "(")
- << FixItHint::CreateInsertion(Close, ")");
+ << FixItHint::CreateInsertion(Open, "(")
+ << FixItHint::CreateInsertion(Close, ")");
if (IsOrAssign)
Diag(Loc, diag::note_condition_or_assign_to_comparison)
- << FixItHint::CreateReplacement(Loc, "!=");
+ << FixItHint::CreateReplacement(Loc, "!=");
else
Diag(Loc, diag::note_condition_assign_to_comparison)
- << FixItHint::CreateReplacement(Loc, "==");
+ << FixItHint::CreateReplacement(Loc, "==");
}
void Sema::DiagnoseEqualityWithExtraParens(ParenExpr *ParenE) {
@@ -21282,17 +21186,17 @@ void Sema::DiagnoseEqualityWithExtraParens(ParenExpr *ParenE) {
if (BinaryOperator *opE = dyn_cast<BinaryOperator>(E))
if (opE->getOpcode() == BO_EQ &&
- opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(Context) ==
- Expr::MLV_Valid) {
+ opE->getLHS()->IgnoreParenImpCasts()->isModifiableLvalue(Context)
+ == Expr::MLV_Valid) {
SourceLocation Loc = opE->getOperatorLoc();
Diag(Loc, diag::warn_equality_with_extra_parens) << E->getSourceRange();
SourceRange ParenERange = ParenE->getSourceRange();
Diag(Loc, diag::note_equality_comparison_silence)
- << FixItHint::CreateRemoval(ParenERange.getBegin())
- << FixItHint::CreateRemoval(ParenERange.getEnd());
+ << FixItHint::CreateRemoval(ParenERange.getBegin())
+ << FixItHint::CreateRemoval(ParenERange.getEnd());
Diag(Loc, diag::note_equality_comparison_to_assign)
- << FixItHint::CreateReplacement(Loc, "=");
+ << FixItHint::CreateReplacement(Loc, "=");
}
}
@@ -21303,8 +21207,7 @@ ExprResult Sema::CheckBooleanCondition(SourceLocation Loc, Expr *E,
DiagnoseEqualityWithExtraParens(parenE);
ExprResult result = CheckPlaceholderExpr(E);
- if (result.isInvalid())
- return ExprError();
+ if (result.isInvalid()) return ExprError();
E = result.get();
if (!E->isTypeDependent()) {
@@ -21322,7 +21225,7 @@ ExprResult Sema::CheckBooleanCondition(SourceLocation Loc, Expr *E,
QualType T = E->getType();
if (!T->isScalarType()) { // C99 6.8.4.1p1
Diag(Loc, diag::err_typecheck_statement_requires_scalar)
- << T << E->getSourceRange();
+ << T << E->getSourceRange();
return ExprError();
}
CheckBoolLikeConversion(E, Loc);
@@ -21370,182 +21273,190 @@ Sema::ConditionResult Sema::ActOnCondition(Scope *S, SourceLocation Loc,
}
namespace {
-/// A visitor for rebuilding a call to an __unknown_any expression
-/// to have an appropriate type.
-struct RebuildUnknownAnyFunction
+ /// A visitor for rebuilding a call to an __unknown_any expression
+ /// to have an appropriate type.
+ struct RebuildUnknownAnyFunction
: StmtVisitor<RebuildUnknownAnyFunction, ExprResult> {
- Sema &S;
+ Sema &S;
- RebuildUnknownAnyFunction(Sema &S) : S(S) {}
+ RebuildUnknownAnyFunction(Sema &S) : S(S) {}
- ExprResult VisitStmt(Stmt *S) { llvm_unreachable("unexpected statement!"); }
+ ExprResult VisitStmt(Stmt *S) {
+ llvm_unreachable("unexpected statement!");
+ }
- ExprResult VisitExpr(Expr *E) {
- S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_call)
+ ExprResult VisitExpr(Expr *E) {
+ S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_call)
<< E->getSourceRange();
- return ExprError();
- }
-
- /// Rebuild an expression which simply semantically wraps another
- /// expression which it shares the type and value kind of.
- template <class T> ExprResult rebuildSugarExpr(T *E) {
- ExprResult SubResult = Visit(E->getSubExpr());
- if (SubResult.isInvalid())
return ExprError();
+ }
- Expr *SubExpr = SubResult.get();
- E->setSubExpr(SubExpr);
- E->setType(SubExpr->getType());
- E->setValueKind(SubExpr->getValueKind());
- assert(E->getObjectKind() == OK_Ordinary);
- return E;
- }
+ /// Rebuild an expression which simply semantically wraps another
+ /// expression which it shares the type and value kind of.
+ template <class T> ExprResult rebuildSugarExpr(T *E) {
+ ExprResult SubResult = Visit(E->getSubExpr());
+ if (SubResult.isInvalid()) return ExprError();
- ExprResult VisitParenExpr(ParenExpr *E) { return rebuildSugarExpr(E); }
+ Expr *SubExpr = SubResult.get();
+ E->setSubExpr(SubExpr);
+ E->setType(SubExpr->getType());
+ E->setValueKind(SubExpr->getValueKind());
+ assert(E->getObjectKind() == OK_Ordinary);
+ return E;
+ }
- ExprResult VisitUnaryExtension(UnaryOperator *E) {
- return rebuildSugarExpr(E);
- }
+ ExprResult VisitParenExpr(ParenExpr *E) {
+ return rebuildSugarExpr(E);
+ }
- ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
- ExprResult SubResult = Visit(E->getSubExpr());
- if (SubResult.isInvalid())
- return ExprError();
+ ExprResult VisitUnaryExtension(UnaryOperator *E) {
+ return rebuildSugarExpr(E);
+ }
- Expr *SubExpr = SubResult.get();
- E->setSubExpr(SubExpr);
- E->setType(S.Context.getPointerType(SubExpr->getType()));
- assert(E->isPRValue());
- assert(E->getObjectKind() == OK_Ordinary);
- return E;
- }
+ ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
+ ExprResult SubResult = Visit(E->getSubExpr());
+ if (SubResult.isInvalid()) return ExprError();
- ExprResult resolveDecl(Expr *E, ValueDecl *VD) {
- if (!isa<FunctionDecl>(VD))
- return VisitExpr(E);
+ Expr *SubExpr = SubResult.get();
+ E->setSubExpr(SubExpr);
+ E->setType(S.Context.getPointerType(SubExpr->getType()));
+ assert(E->isPRValue());
+ assert(E->getObjectKind() == OK_Ordinary);
+ return E;
+ }
- E->setType(VD->getType());
+ ExprResult resolveDecl(Expr *E, ValueDecl *VD) {
+ if (!isa<FunctionDecl>(VD)) return VisitExpr(E);
- assert(E->isPRValue());
- if (S.getLangOpts().CPlusPlus &&
- !(isa<CXXMethodDecl>(VD) && cast<CXXMethodDecl>(VD)->isInstance()))
- E->setValueKind(VK_LValue);
+ E->setType(VD->getType());
- return E;
- }
+ assert(E->isPRValue());
+ if (S.getLangOpts().CPlusPlus &&
+ !(isa<CXXMethodDecl>(VD) &&
+ cast<CXXMethodDecl>(VD)->isInstance()))
+ E->setValueKind(VK_LValue);
- ExprResult VisitMemberExpr(MemberExpr *E) {
- return resolveDecl(E, E->getMemberDecl());
- }
+ return E;
+ }
- ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
- return resolveDecl(E, E->getDecl());
- }
-};
-} // namespace
+ ExprResult VisitMemberExpr(MemberExpr *E) {
+ return resolveDecl(E, E->getMemberDecl());
+ }
+
+ ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
+ return resolveDecl(E, E->getDecl());
+ }
+ };
+}
/// Given a function expression of unknown-any type, try to rebuild it
/// to have a function type.
static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *FunctionExpr) {
ExprResult Result = RebuildUnknownAnyFunction(S).Visit(FunctionExpr);
- if (Result.isInvalid())
- return ExprError();
+ if (Result.isInvalid()) return ExprError();
return S.DefaultFunctionArrayConversion(Result.get());
}
namespace {
-/// A visitor for rebuilding an expression of type __unknown_anytype
-/// into one which resolves the type directly on the referring
-/// expression. Strict preservation of the original source
-/// structure is not a goal.
-struct RebuildUnknownAnyExpr : StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {
+ /// A visitor for rebuilding an expression of type __unknown_anytype
+ /// into one which resolves the type directly on the referring
+ /// expression. Strict preservation of the original source
+ /// structure is not a goal.
+ struct RebuildUnknownAnyExpr
+ : StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {
- Sema &S;
+ Sema &S;
- /// The current destination type.
- QualType DestType;
+ /// The current destination type.
+ QualType DestType;
- RebuildUnknownAnyExpr(Sema &S, QualType CastType)
+ RebuildUnknownAnyExpr(Sema &S, QualType CastType)
: S(S), DestType(CastType) {}
- ExprResult VisitStmt(Stmt *S) { llvm_unreachable("unexpected statement!"); }
+ ExprResult VisitStmt(Stmt *S) {
+ llvm_unreachable("unexpected statement!");
+ }
- ExprResult VisitExpr(Expr *E) {
- S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr)
+ ExprResult VisitExpr(Expr *E) {
+ S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr)
<< E->getSourceRange();
- return ExprError();
- }
+ return ExprError();
+ }
- ExprResult VisitCallExpr(CallExpr *E);
- ExprResult VisitObjCMessageExpr(ObjCMessageExpr *E);
+ ExprResult VisitCallExpr(CallExpr *E);
+ ExprResult VisitObjCMessageExpr(ObjCMessageExpr *E);
- /// Rebuild an expression which simply semantically wraps another
- /// expression which it shares the type and value kind of.
- template <class T> ExprResult rebuildSugarExpr(T *E) {
- ExprResult SubResult = Visit(E->getSubExpr());
- if (SubResult.isInvalid())
- return ExprError();
- Expr *SubExpr = SubResult.get();
- E->setSubExpr(SubExpr);
- E->setType(SubExpr->getType());
- E->setValueKind(SubExpr->getValueKind());
- assert(E->getObjectKind() == OK_Ordinary);
- return E;
- }
+ /// Rebuild an expression which simply semantically wraps another
+ /// expression which it shares the type and value kind of.
+ template <class T> ExprResult rebuildSugarExpr(T *E) {
+ ExprResult SubResult = Visit(E->getSubExpr());
+ if (SubResult.isInvalid()) return ExprError();
+ Expr *SubExpr = SubResult.get();
+ E->setSubExpr(SubExpr);
+ E->setType(SubExpr->getType());
+ E->setValueKind(SubExpr->getValueKind());
+ assert(E->getObjectKind() == OK_Ordinary);
+ return E;
+ }
- ExprResult VisitParenExpr(ParenExpr *E) { return rebuildSugarExpr(E); }
+ ExprResult VisitParenExpr(ParenExpr *E) {
+ return rebuildSugarExpr(E);
+ }
- ExprResult VisitUnaryExtension(UnaryOperator *E) {
- return rebuildSugarExpr(E);
- }
+ ExprResult VisitUnaryExtension(UnaryOperator *E) {
+ return rebuildSugarExpr(E);
+ }
- ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
- const PointerType *Ptr = DestType->getAs<PointerType>();
- if (!Ptr) {
- S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof)
+ ExprResult VisitUnaryAddrOf(UnaryOperator *E) {
+ const PointerType *Ptr = DestType->getAs<PointerType>();
+ if (!Ptr) {
+ S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof)
<< E->getSourceRange();
- return ExprError();
- }
+ return ExprError();
+ }
- if (isa<CallExpr>(E->getSubExpr())) {
- S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof_call)
+ if (isa<CallExpr>(E->getSubExpr())) {
+ S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof_call)
<< E->getSourceRange();
- return ExprError();
- }
+ return ExprError();
+ }
- assert(E->isPRValue());
- assert(E->getObjectKind() == OK_Ordinary);
- E->setType(DestType);
+ assert(E->isPRValue());
+ assert(E->getObjectKind() == OK_Ordinary);
+ E->setType(DestType);
- // Build the sub-expression as if it were an object of the pointee type.
- DestType = Ptr->getPointeeType();
- ExprResult SubResult = Visit(E->getSubExpr());
- if (SubResult.isInvalid())
- return ExprError();
- E->setSubExpr(SubResult.get());
- return E;
- }
+ // Build the sub-expression as if it were an object of the pointee type.
+ DestType = Ptr->getPointeeType();
+ ExprResult SubResult = Visit(E->getSubExpr());
+ if (SubResult.isInvalid()) return ExprError();
+ E->setSubExpr(SubResult.get());
+ return E;
+ }
- ExprResult VisitImplicitCastExpr(ImplicitCastExpr *E);
+ ExprResult VisitImplicitCastExpr(ImplicitCastExpr *E);
- ExprResult resolveDecl(Expr *E, ValueDecl *VD);
+ ExprResult resolveDecl(Expr *E, ValueDecl *VD);
- ExprResult VisitMemberExpr(MemberExpr *E) {
- return resolveDecl(E, E->getMemberDecl());
- }
+ ExprResult VisitMemberExpr(MemberExpr *E) {
+ return resolveDecl(E, E->getMemberDecl());
+ }
- ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
- return resolveDecl(E, E->getDecl());
- }
-};
-} // namespace
+ ExprResult VisitDeclRefExpr(DeclRefExpr *E) {
+ return resolveDecl(E, E->getDecl());
+ }
+ };
+}
/// Rebuilds a call expression which yielded __unknown_anytype.
ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *E) {
Expr *CalleeExpr = E->getCallee();
- enum FnKind { FK_MemberFunction, FK_FunctionPointer, FK_BlockPointer };
+ enum FnKind {
+ FK_MemberFunction,
+ FK_FunctionPointer,
+ FK_BlockPointer
+ };
FnKind Kind;
QualType CalleeType = CalleeExpr->getType();
@@ -21569,7 +21480,8 @@ ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *E) {
if (Kind == FK_BlockPointer)
diagID = diag::err_block_returning_array_function;
- S.Diag(E->getExprLoc(), diagID) << DestType->isFunctionType() << DestType;
+ S.Diag(E->getExprLoc(), diagID)
+ << DestType->isFunctionType() << DestType;
return ExprError();
}
@@ -21612,7 +21524,8 @@ ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *E) {
DestType = S.Context.getFunctionType(DestType, ParamTypes,
Proto->getExtProtoInfo());
} else {
- DestType = S.Context.getFunctionNoProtoType(DestType, FnType->getExtInfo());
+ DestType = S.Context.getFunctionNoProtoType(DestType,
+ FnType->getExtInfo());
}
// Rebuild the appropriate pointer-to-function type.
@@ -21632,8 +21545,7 @@ ExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *E) {
// Finally, we can recurse.
ExprResult CalleeResult = Visit(CalleeExpr);
- if (!CalleeResult.isUsable())
- return ExprError();
+ if (!CalleeResult.isUsable()) return ExprError();
E->setCallee(CalleeResult.get());
// Bind a temporary if necessary.
@@ -21644,7 +21556,7 @@ ExprResult RebuildUnknownAnyExpr::VisitObjCMessageExpr(ObjCMessageExpr *E) {
// Verify that this is a legal result type of a call.
if (DestType->isArrayType() || DestType->isFunctionType()) {
S.Diag(E->getExprLoc(), diag::err_func_returning_array_function)
- << DestType->isFunctionType() << DestType;
+ << DestType->isFunctionType() << DestType;
return ExprError();
}
@@ -21673,8 +21585,7 @@ ExprResult RebuildUnknownAnyExpr::VisitImplicitCastExpr(ImplicitCastExpr *E) {
DestType = DestType->castAs<PointerType>()->getPointeeType();
ExprResult Result = Visit(E->getSubExpr());
- if (!Result.isUsable())
- return ExprError();
+ if (!Result.isUsable()) return ExprError();
E->setSubExpr(Result.get());
return E;
@@ -21690,8 +21601,7 @@ ExprResult RebuildUnknownAnyExpr::VisitImplicitCastExpr(ImplicitCastExpr *E) {
DestType = S.Context.getLValueReferenceType(DestType);
ExprResult Result = Visit(E->getSubExpr());
- if (!Result.isUsable())
- return ExprError();
+ if (!Result.isUsable()) return ExprError();
E->setSubExpr(Result.get());
return E;
@@ -21711,15 +21621,14 @@ ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {
if (const PointerType *Ptr = Type->getAs<PointerType>()) {
DestType = Ptr->getPointeeType();
ExprResult Result = resolveDecl(E, VD);
- if (Result.isInvalid())
- return ExprError();
+ if (Result.isInvalid()) return ExprError();
return S.ImpCastExprToType(Result.get(), Type, CK_FunctionToPointerDecay,
VK_PRValue);
}
if (!Type->isFunctionType()) {
S.Diag(E->getExprLoc(), diag::err_unknown_any_function)
- << VD << E->getSourceRange();
+ << VD << E->getSourceRange();
return ExprError();
}
if (const FunctionProtoType *FT = Type->getAs<FunctionProtoType>()) {
@@ -21728,11 +21637,9 @@ ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {
// type. See the lengthy commentary in that routine.
QualType FDT = FD->getType();
const FunctionType *FnType = FDT->castAs<FunctionType>();
- const FunctionProtoType *Proto =
- dyn_cast_or_null<FunctionProtoType>(FnType);
+ const FunctionProtoType *Proto = dyn_cast_or_null<FunctionProtoType>(FnType);
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
- if (DRE && Proto && Proto->getParamTypes().empty() &&
- Proto->isVariadic()) {
+ if (DRE && Proto && Proto->getParamTypes().empty() && Proto->isVariadic()) {
SourceLocation Loc = FD->getLocation();
FunctionDecl *NewFD = FunctionDecl::Create(
S.Context, FD->getDeclContext(), Loc, Loc,
@@ -21744,9 +21651,10 @@ ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {
if (FD->getQualifier())
NewFD->setQualifierInfo(FD->getQualifierLoc());
- SmallVector<ParmVarDecl *, 16> Params;
+ SmallVector<ParmVarDecl*, 16> Params;
for (const auto &AI : FT->param_types()) {
- ParmVarDecl *Param = S.BuildParmVarDeclForTypedef(FD, Loc, AI);
+ ParmVarDecl *Param =
+ S.BuildParmVarDeclForTypedef(FD, Loc, AI);
Param->setScopeInfo(0, Params.size());
Params.push_back(Param);
}
@@ -21766,20 +21674,20 @@ ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {
if (!S.getLangOpts().CPlusPlus)
ValueKind = VK_PRValue;
- // - variables
+ // - variables
} else if (isa<VarDecl>(VD)) {
if (const ReferenceType *RefTy = Type->getAs<ReferenceType>()) {
Type = RefTy->getPointeeType();
} else if (Type->isFunctionType()) {
S.Diag(E->getExprLoc(), diag::err_unknown_any_var_function_type)
- << VD << E->getSourceRange();
+ << VD << E->getSourceRange();
return ExprError();
}
- // - nothing else
+ // - nothing else
} else {
S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_decl)
- << VD << E->getSourceRange();
+ << VD << E->getSourceRange();
return ExprError();
}
@@ -21802,8 +21710,7 @@ ExprResult Sema::checkUnknownAnyCast(SourceRange TypeRange, QualType CastType,
// Rewrite the casted expression from scratch.
ExprResult result = RebuildUnknownAnyExpr(*this, CastType).Visit(CastExpr);
- if (!result.isUsable())
- return ExprError();
+ if (!result.isUsable()) return ExprError();
CastExpr = result.get();
VK = CastExpr->getValueKind();
@@ -21816,15 +21723,14 @@ ExprResult Sema::forceUnknownAnyToType(Expr *E, QualType ToType) {
return RebuildUnknownAnyExpr(*this, ToType).Visit(E);
}
-ExprResult Sema::checkUnknownAnyArg(SourceLocation callLoc, Expr *arg,
- QualType ¶mType) {
+ExprResult Sema::checkUnknownAnyArg(SourceLocation callLoc,
+ Expr *arg, QualType ¶mType) {
// If the syntactic form of the argument is not an explicit cast of
// any sort, just do default argument promotion.
ExplicitCastExpr *castArg = dyn_cast<ExplicitCastExpr>(arg->IgnoreParens());
if (!castArg) {
ExprResult result = DefaultArgumentPromotion(arg);
- if (result.isInvalid())
- return ExprError();
+ if (result.isInvalid()) return ExprError();
paramType = result.get()->getType();
return result;
}
@@ -21835,8 +21741,8 @@ ExprResult Sema::checkUnknownAnyArg(SourceLocation callLoc, Expr *arg,
// Copy-initialize a parameter of that type.
InitializedEntity entity =
- InitializedEntity::InitializeParameter(Context, paramType,
- /*consumed*/ false);
+ InitializedEntity::InitializeParameter(Context, paramType,
+ /*consumed*/ false);
return PerformCopyInitialization(entity, callLoc, arg);
}
@@ -21867,13 +21773,13 @@ static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E) {
d = msg->getMethodDecl();
if (!d) {
S.Diag(loc, diag::err_uncasted_send_to_unknown_any_method)
- << static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector()
- << orig->getSourceRange();
+ << static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector()
+ << orig->getSourceRange();
return ExprError();
}
} else {
S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr)
- << E->getSourceRange();
+ << E->getSourceRange();
return ExprError();
}
@@ -21885,8 +21791,7 @@ static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E) {
ExprResult Sema::CheckPlaceholderExpr(Expr *E) {
const BuiltinType *placeholderType = E->getType()->getAsPlaceholderType();
- if (!placeholderType)
- return E;
+ if (!placeholderType) return E;
switch (placeholderType->getKind()) {
case BuiltinType::UnresolvedTemplate: {
@@ -22067,15 +21972,18 @@ ExprResult Sema::CheckPlaceholderExpr(Expr *E) {
case BuiltinType::OMPIterator:
return ExprError(Diag(E->getBeginLoc(), diag::err_omp_iterator_use));
- // Everything else should be impossible.
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+ // Everything else should be impossible.
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id:
#include "clang/Basic/OpenCLImageTypes.def"
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
+ case BuiltinType::Id:
#include "clang/Basic/OpenCLExtensionTypes.def"
-#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
+#define SVE_TYPE(Name, Id, SingletonId) \
+ case BuiltinType::Id:
#include "clang/Basic/AArch64ACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
+#define PPC_VECTOR_TYPE(Name, Id, Size) \
+ case BuiltinType::Id:
#include "clang/Basic/PPCTypes.def"
#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
#include "clang/Basic/RISCVVTypes.def"
>From 3a9d57bc0e1b0289d6ffdcd4791266fa790d8584 Mon Sep 17 00:00:00 2001
From: PrabbyDD <dhaliprabh at gmail.com>
Date: Fri, 10 Apr 2026 14:39:24 -0700
Subject: [PATCH 3/6] Unformat the whole file
---
clang/lib/Sema/SemaExpr.cpp | 11 +++++++++--
1 file changed, 9 insertions(+), 2 deletions(-)
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 9fd8c6a0a5451..0533ca072e471 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -12488,8 +12488,7 @@ static void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc,
QualType LHSType = LHS->getType();
QualType RHSType = RHS->getType();
if (LHSType->hasFloatingRepresentation() ||
- (LHSType->isBlockPointerType() && !BinaryOperator::isEqualityOp(Opc)) ||
- S.inTemplateInstantiation())
+ (LHSType->isBlockPointerType() && !BinaryOperator::isEqualityOp(Opc)))
return;
// WebAssembly Tables cannot be compared, therefore shouldn't emit
@@ -12860,6 +12859,14 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
return Ty->isPointerType() || Ty->isMemberPointerType();
};
+ // If types are arrays, skip this check so we can throw an error later.
+ if (this->inTemplateInstantiation()) {
+ QualType LHSType = LHS.get()->getType();
+ QualType RHSType = RHS.get()->getType();
+ if (!LHSType->isArrayType() && !RHSType->isArrayType())
+ return QualType();
+ }
+
// C++2a [expr.spaceship]p6: If at least one of the operands is of pointer
// type, array-to-pointer, ..., conversions are performed on both operands to
// bring them to their composite type.
>From f60c79f67c9da29c12290d3bfb5c787e693011d0 Mon Sep 17 00:00:00 2001
From: PrabbyDD <dhaliprabh at gmail.com>
Date: Wed, 15 Apr 2026 08:50:14 -0700
Subject: [PATCH 4/6] moving entire check from diagnoseTautologicalComparison
to checkCompareOperands.
---
clang/lib/Sema/SemaExpr.cpp | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 0533ca072e471..11cc61b8f4e01 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -12487,9 +12487,6 @@ static void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc,
QualType LHSType = LHS->getType();
QualType RHSType = RHS->getType();
- if (LHSType->hasFloatingRepresentation() ||
- (LHSType->isBlockPointerType() && !BinaryOperator::isEqualityOp(Opc)))
- return;
// WebAssembly Tables cannot be compared, therefore shouldn't emit
// Tautological diagnostics.
@@ -12863,6 +12860,9 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
if (this->inTemplateInstantiation()) {
QualType LHSType = LHS.get()->getType();
QualType RHSType = RHS.get()->getType();
+ if (LHSType->hasFloatingRepresentation() ||
+ (LHSType->isBlockPointerType() && !BinaryOperator::isEqualityOp(Opc)))
+ return;
if (!LHSType->isArrayType() && !RHSType->isArrayType())
return QualType();
}
>From 3182c58a9a89898ca310598a3fcfc9931b0034d2 Mon Sep 17 00:00:00 2001
From: PrabbyDD <dhaliprabh at gmail.com>
Date: Fri, 17 Apr 2026 13:43:50 -0700
Subject: [PATCH 5/6] shuffling around checks from diagnoseTaut.. to
compareCheckOperands()
---
clang/lib/Sema/SemaExpr.cpp | 53 ++++++++++++++++++++-----------------
1 file changed, 28 insertions(+), 25 deletions(-)
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 11cc61b8f4e01..911eccc25056d 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -12487,6 +12487,9 @@ static void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc,
QualType LHSType = LHS->getType();
QualType RHSType = RHS->getType();
+ if (LHSType->hasFloatingRepresentation() ||
+ (LHSType->isBlockPointerType() && !BinaryOperator::isEqualityOp(Opc)))
+ return;
// WebAssembly Tables cannot be compared, therefore shouldn't emit
// Tautological diagnostics.
@@ -12517,28 +12520,6 @@ static void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc,
AlwaysEqual, // std::strong_ordering::equal from operator<=>
};
- // C++1a [array.comp]:
- // Equality and relational comparisons ([expr.eq], [expr.rel]) between two
- // operands of array type.
- // C++2a [depr.array.comp]:
- // Equality and relational comparisons ([expr.eq], [expr.rel]) between two
- // operands of array type are deprecated.
- if (S.getLangOpts().CPlusPlus && LHSStripped->getType()->isArrayType() &&
- RHSStripped->getType()->isArrayType()) {
- auto IsDeprArrayComparionIgnored =
- S.getDiagnostics().isIgnored(diag::warn_depr_array_comparison, Loc);
- auto DiagID = S.getLangOpts().CPlusPlus26
- ? diag::warn_array_comparison_cxx26
- : !S.getLangOpts().CPlusPlus20 || IsDeprArrayComparionIgnored
- ? diag::warn_array_comparison
- : diag::warn_depr_array_comparison;
- S.Diag(Loc, DiagID) << LHS->getSourceRange() << RHS->getSourceRange()
- << LHSStripped->getType() << RHSStripped->getType();
- // Carry on to produce the tautological comparison warning, if this
- // expression is potentially-evaluated, we can resolve the array to a
- // non-weak declaration, and so on.
- }
-
if (!LHS->getBeginLoc().isMacroID() && !RHS->getBeginLoc().isMacroID()) {
if (Expr::isSameComparisonOperand(LHS, RHS)) {
unsigned Result;
@@ -12860,13 +12841,35 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
if (this->inTemplateInstantiation()) {
QualType LHSType = LHS.get()->getType();
QualType RHSType = RHS.get()->getType();
- if (LHSType->hasFloatingRepresentation() ||
- (LHSType->isBlockPointerType() && !BinaryOperator::isEqualityOp(Opc)))
- return;
if (!LHSType->isArrayType() && !RHSType->isArrayType())
return QualType();
}
+ // C++1a [array.comp]:
+ // Equality and relational comparisons ([expr.eq], [expr.rel]) between two
+ // operands of array type.
+ // C++2a [depr.array.comp]:
+ // Equality and relational comparisons ([expr.eq], [expr.rel]) between two
+ // operands of array type are deprecated.
+ Expr *LHSStripped = LHS.get()->IgnoreParenImpCasts();
+ Expr *RHSStripped = RHS.get()->IgnoreParenImpCasts();
+ if (this->getLangOpts().CPlusPlus && LHSStripped->getType()->isArrayType() &&
+ RHSStripped->getType()->isArrayType()) {
+ auto IsDeprArrayComparionIgnored =
+ this->getDiagnostics().isIgnored(diag::warn_depr_array_comparison, Loc);
+ auto DiagID =
+ this->getLangOpts().CPlusPlus26 ? diag::warn_array_comparison_cxx26
+ : !this->getLangOpts().CPlusPlus20 || IsDeprArrayComparionIgnored
+ ? diag::warn_array_comparison
+ : diag::warn_depr_array_comparison;
+ this->Diag(Loc, DiagID)
+ << LHS.get()->getSourceRange() << RHS.get()->getSourceRange()
+ << LHSStripped->getType() << RHSStripped->getType();
+ // Carry on to produce the tautological comparison warning, if this
+ // expression is potentially-evaluated, we can resolve the array to a
+ // non-weak declaration, and so on.
+ }
+
// C++2a [expr.spaceship]p6: If at least one of the operands is of pointer
// type, array-to-pointer, ..., conversions are performed on both operands to
// bring them to their composite type.
>From 9825d3d96e0e5b8c2185d5f43307ebe6c6c19bf0 Mon Sep 17 00:00:00 2001
From: PrabbyDD <dhaliprabh at gmail.com>
Date: Sat, 18 Apr 2026 09:20:42 -0700
Subject: [PATCH 6/6] shuffling around code between checkCompareOperands and
diagnoseTautologicalComparisons and reformatted test to include new verify
statement
---
clang/lib/Sema/SemaExpr.cpp | 28 ++++++-------------
clang/test/SemaCXX/array-compare-template.cpp | 2 +-
2 files changed, 9 insertions(+), 21 deletions(-)
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 911eccc25056d..b95159c61a3d6 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -12487,8 +12487,8 @@ static void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc,
QualType LHSType = LHS->getType();
QualType RHSType = RHS->getType();
- if (LHSType->hasFloatingRepresentation() ||
- (LHSType->isBlockPointerType() && !BinaryOperator::isEqualityOp(Opc)))
+ if ((LHSType->isBlockPointerType() && !BinaryOperator::isEqualityOp(Opc)) ||
+ S.inTemplateInstantiation())
return;
// WebAssembly Tables cannot be compared, therefore shouldn't emit
@@ -12837,14 +12837,6 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
return Ty->isPointerType() || Ty->isMemberPointerType();
};
- // If types are arrays, skip this check so we can throw an error later.
- if (this->inTemplateInstantiation()) {
- QualType LHSType = LHS.get()->getType();
- QualType RHSType = RHS.get()->getType();
- if (!LHSType->isArrayType() && !RHSType->isArrayType())
- return QualType();
- }
-
// C++1a [array.comp]:
// Equality and relational comparisons ([expr.eq], [expr.rel]) between two
// operands of array type.
@@ -12853,21 +12845,17 @@ QualType Sema::CheckCompareOperands(ExprResult &LHS, ExprResult &RHS,
// operands of array type are deprecated.
Expr *LHSStripped = LHS.get()->IgnoreParenImpCasts();
Expr *RHSStripped = RHS.get()->IgnoreParenImpCasts();
- if (this->getLangOpts().CPlusPlus && LHSStripped->getType()->isArrayType() &&
+ if (getLangOpts().CPlusPlus && LHSStripped->getType()->isArrayType() &&
RHSStripped->getType()->isArrayType()) {
auto IsDeprArrayComparionIgnored =
- this->getDiagnostics().isIgnored(diag::warn_depr_array_comparison, Loc);
- auto DiagID =
- this->getLangOpts().CPlusPlus26 ? diag::warn_array_comparison_cxx26
- : !this->getLangOpts().CPlusPlus20 || IsDeprArrayComparionIgnored
- ? diag::warn_array_comparison
- : diag::warn_depr_array_comparison;
+ getDiagnostics().isIgnored(diag::warn_depr_array_comparison, Loc);
+ auto DiagID = getLangOpts().CPlusPlus26 ? diag::warn_array_comparison_cxx26
+ : !getLangOpts().CPlusPlus20 || IsDeprArrayComparionIgnored
+ ? diag::warn_array_comparison
+ : diag::warn_depr_array_comparison;
this->Diag(Loc, DiagID)
<< LHS.get()->getSourceRange() << RHS.get()->getSourceRange()
<< LHSStripped->getType() << RHSStripped->getType();
- // Carry on to produce the tautological comparison warning, if this
- // expression is potentially-evaluated, we can resolve the array to a
- // non-weak declaration, and so on.
}
// C++2a [expr.spaceship]p6: If at least one of the operands is of pointer
diff --git a/clang/test/SemaCXX/array-compare-template.cpp b/clang/test/SemaCXX/array-compare-template.cpp
index 68bb1c75d2823..ad481b052e254 100644
--- a/clang/test/SemaCXX/array-compare-template.cpp
+++ b/clang/test/SemaCXX/array-compare-template.cpp
@@ -4,5 +4,5 @@ int main() {
int a[1]{}, b[1]{};
[](const auto &x, const auto &y) {
return x == y; // expected-error {{comparison between two arrays is ill-formed in C++26}}
- }(a, b);
+ }(a, b); // expected-note {{in instantiation of function template specialization}}
}
More information about the cfe-commits
mailing list