Skip to content

Commit c2c0ef5

Browse files
EndilllEndilll
committed
[clang][NFC] Convert Sema::VariadicCallType to scoped enum
1 parent 6efdcc1 commit c2c0ef5

File tree

8 files changed

+81
-71
lines changed

8 files changed

+81
-71
lines changed

‎clang/include/clang/Sema/Sema.h‎

Lines changed: 15 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -510,6 +510,15 @@ enum class FormatStringType {
510510
Unknown
511511
};
512512

513+
// Used for emitting the right warning by DefaultVariadicArgumentPromotion
514+
enum class VariadicCallType {
515+
Function,
516+
Block,
517+
Method,
518+
Constructor,
519+
DoesNotApply
520+
};
521+
513522
/// Sema - This implements semantic analysis and AST building for C.
514523
/// \nosubgrouping
515524
class Sema final : public SemaBase {
@@ -2381,15 +2390,6 @@ class Sema final : public SemaBase {
23812390
void DiagnoseSelfMove(const Expr *LHSExpr, const Expr *RHSExpr,
23822391
SourceLocation OpLoc);
23832392

2384-
// Used for emitting the right warning by DefaultVariadicArgumentPromotion
2385-
enum VariadicCallType {
2386-
VariadicFunction,
2387-
VariadicBlock,
2388-
VariadicMethod,
2389-
VariadicConstructor,
2390-
VariadicDoesNotApply
2391-
};
2392-
23932393
bool IsLayoutCompatible(QualType T1, QualType T2) const;
23942394
bool IsPointerInterconvertibleBaseOf(const TypeSourceInfo *Base,
23952395
const TypeSourceInfo *Derived);
@@ -7739,13 +7739,12 @@ class Sema final : public SemaBase {
77397739

77407740
/// GatherArgumentsForCall - Collector argument expressions for various
77417741
/// form of call prototypes.
7742-
bool GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
7743-
const FunctionProtoType *Proto,
7744-
unsigned FirstParam, ArrayRef<Expr *> Args,
7745-
SmallVectorImpl<Expr *> &AllArgs,
7746-
VariadicCallType CallType = VariadicDoesNotApply,
7747-
bool AllowExplicit = false,
7748-
bool IsListInitialization = false);
7742+
bool GatherArgumentsForCall(
7743+
SourceLocation CallLoc, FunctionDecl *FDecl,
7744+
const FunctionProtoType *Proto, unsigned FirstParam,
7745+
ArrayRef<Expr *> Args, SmallVectorImpl<Expr *> &AllArgs,
7746+
VariadicCallType CallType = VariadicCallType::DoesNotApply,
7747+
bool AllowExplicit = false, bool IsListInitialization = false);
77497748

77507749
// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
77517750
// will create a runtime trap if the resulting type is not a POD type.

‎clang/lib/Sema/SemaChecking.cpp‎

Lines changed: 31 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -82,6 +82,7 @@
8282
#include "llvm/ADT/DenseMap.h"
8383
#include "llvm/ADT/FoldingSet.h"
8484
#include "llvm/ADT/STLExtras.h"
85+
#include "llvm/ADT/STLForwardCompat.h"
8586
#include "llvm/ADT/SmallBitVector.h"
8687
#include "llvm/ADT/SmallPtrSet.h"
8788
#include "llvm/ADT/SmallString.h"
@@ -3345,7 +3346,7 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto,
33453346
// Refuse POD arguments that weren't caught by the format string
33463347
// checks above.
33473348
auto *FD = dyn_cast_or_null<FunctionDecl>(FDecl);
3348-
if (CallType != VariadicDoesNotApply &&
3349+
if (CallType != VariadicCallType::DoesNotApply &&
33493350
(!FD || FD->getBuiltinID() != Builtin::BI__noop)) {
33503351
unsigned NumParams = Proto ? Proto->getNumParams()
33513352
: isa_and_nonnull<FunctionDecl>(FDecl)
@@ -3396,7 +3397,7 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto,
33963397
if (Context.getTargetInfo().getTriple().isOSAIX() && FDecl && Arg &&
33973398
FDecl->hasLinkage() &&
33983399
FDecl->getFormalLinkage() != Linkage::Internal &&
3399-
CallType == VariadicDoesNotApply)
3400+
CallType == VariadicCallType::DoesNotApply)
34003401
PPC().checkAIXMemberAlignment((Arg->getExprLoc()), Arg);
34013402

34023403
QualType ParamTy = Proto->getParamType(ArgIdx);
@@ -3518,8 +3519,9 @@ void Sema::CheckConstructorCall(FunctionDecl *FDecl, QualType ThisType,
35183519
ArrayRef<const Expr *> Args,
35193520
const FunctionProtoType *Proto,
35203521
SourceLocation Loc) {
3521-
VariadicCallType CallType =
3522-
Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
3522+
VariadicCallType CallType = Proto->isVariadic()
3523+
? VariadicCallType::Constructor
3524+
: VariadicCallType::DoesNotApply;
35233525

35243526
auto *Ctor = cast<CXXConstructorDecl>(FDecl);
35253527
CheckArgAlignment(
@@ -3630,11 +3632,11 @@ bool Sema::CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,
36303632

36313633
VariadicCallType CallType;
36323634
if (!Proto || !Proto->isVariadic()) {
3633-
CallType = VariadicDoesNotApply;
3635+
CallType = VariadicCallType::DoesNotApply;
36343636
} else if (Ty->isBlockPointerType()) {
3635-
CallType = VariadicBlock;
3637+
CallType = VariadicCallType::Block;
36363638
} else { // Ty->isFunctionPointerType()
3637-
CallType = VariadicFunction;
3639+
CallType = VariadicCallType::Function;
36383640
}
36393641

36403642
checkCall(NDecl, Proto, /*ThisArg=*/nullptr,
@@ -5527,7 +5529,7 @@ bool Sema::BuiltinOSLogFormat(CallExpr *TheCall) {
55275529
unsigned FirstDataArg = i;
55285530
while (i < NumArgs) {
55295531
ExprResult Arg = DefaultVariadicArgumentPromotion(
5530-
TheCall->getArg(i), VariadicFunction, nullptr);
5532+
TheCall->getArg(i), VariadicCallType::Function, nullptr);
55315533
if (Arg.isInvalid())
55325534
return true;
55335535
CharUnits ArgSize = Context.getTypeSizeInChars(Arg.get()->getType());
@@ -5547,8 +5549,8 @@ bool Sema::BuiltinOSLogFormat(CallExpr *TheCall) {
55475549
ArrayRef<const Expr *> Args(TheCall->getArgs(), TheCall->getNumArgs());
55485550
bool Success = CheckFormatArguments(
55495551
Args, FAPK_Variadic, nullptr, FormatIdx, FirstDataArg,
5550-
FormatStringType::OSLog, VariadicFunction, TheCall->getBeginLoc(),
5551-
SourceRange(), CheckedVarArgs);
5552+
FormatStringType::OSLog, VariadicCallType::Function,
5553+
TheCall->getBeginLoc(), SourceRange(), CheckedVarArgs);
55525554
if (!Success)
55535555
return true;
55545556
}
@@ -5990,7 +5992,7 @@ static void CheckFormatString(
59905992
const StringLiteral *ReferenceFormatString, const Expr *OrigFormatExpr,
59915993
ArrayRef<const Expr *> Args, Sema::FormatArgumentPassingKind APK,
59925994
unsigned format_idx, unsigned firstDataArg, FormatStringType Type,
5993-
bool inFunctionCall, Sema::VariadicCallType CallType,
5995+
bool inFunctionCall, VariadicCallType CallType,
59945996
llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,
59955997
bool IgnoreStringsWithoutSpecifiers);
59965998

@@ -6005,7 +6007,7 @@ static StringLiteralCheckType checkFormatStringExpr(
60056007
Sema &S, const StringLiteral *ReferenceFormatString, const Expr *E,
60066008
ArrayRef<const Expr *> Args, Sema::FormatArgumentPassingKind APK,
60076009
unsigned format_idx, unsigned firstDataArg, FormatStringType Type,
6008-
Sema::VariadicCallType CallType, bool InFunctionCall,
6010+
VariadicCallType CallType, bool InFunctionCall,
60096011
llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,
60106012
llvm::APSInt Offset, bool IgnoreStringsWithoutSpecifiers = false) {
60116013
if (S.isConstantEvaluatedContext())
@@ -6465,7 +6467,8 @@ bool Sema::CheckFormatArguments(const FormatAttr *Format,
64656467
llvm::SmallBitVector &CheckedVarArgs) {
64666468
FormatStringInfo FSI;
64676469
if (getFormatStringInfo(Format->getFormatIdx(), Format->getFirstArg(),
6468-
IsCXXMember, CallType != VariadicDoesNotApply, &FSI))
6470+
IsCXXMember,
6471+
CallType != VariadicCallType::DoesNotApply, &FSI))
64696472
return CheckFormatArguments(
64706473
Args, FSI.ArgPassingKind, nullptr, FSI.FormatIdx, FSI.FirstDataArg,
64716474
GetFormatStringType(Format), CallType, Loc, Range, CheckedVarArgs);
@@ -6594,7 +6597,7 @@ class CheckFormatHandler : public analyze_format_string::FormatStringHandler {
65946597
bool usesPositionalArgs = false;
65956598
bool atFirstArg = true;
65966599
bool inFunctionCall;
6597-
Sema::VariadicCallType CallType;
6600+
VariadicCallType CallType;
65986601
llvm::SmallBitVector &CheckedVarArgs;
65996602
UncoveredArgHandler &UncoveredArg;
66006603

@@ -6604,7 +6607,7 @@ class CheckFormatHandler : public analyze_format_string::FormatStringHandler {
66046607
unsigned firstDataArg, unsigned numDataArgs,
66056608
const char *beg, Sema::FormatArgumentPassingKind APK,
66066609
ArrayRef<const Expr *> Args, unsigned formatIdx,
6607-
bool inFunctionCall, Sema::VariadicCallType callType,
6610+
bool inFunctionCall, VariadicCallType callType,
66086611
llvm::SmallBitVector &CheckedVarArgs,
66096612
UncoveredArgHandler &UncoveredArg)
66106613
: S(s), FExpr(fexpr), OrigFormatExpr(origFormatExpr), FSType(type),
@@ -7052,7 +7055,7 @@ class CheckPrintfHandler : public CheckFormatHandler {
70527055
unsigned firstDataArg, unsigned numDataArgs, bool isObjC,
70537056
const char *beg, Sema::FormatArgumentPassingKind APK,
70547057
ArrayRef<const Expr *> Args, unsigned formatIdx,
7055-
bool inFunctionCall, Sema::VariadicCallType CallType,
7058+
bool inFunctionCall, VariadicCallType CallType,
70567059
llvm::SmallBitVector &CheckedVarArgs,
70577060
UncoveredArgHandler &UncoveredArg)
70587061
: CheckFormatHandler(s, fexpr, origFormatExpr, type, firstDataArg,
@@ -7187,7 +7190,7 @@ class DecomposePrintfHandler : public CheckPrintfHandler {
71877190
unsigned numDataArgs, bool isObjC, const char *beg,
71887191
Sema::FormatArgumentPassingKind APK,
71897192
ArrayRef<const Expr *> Args, unsigned formatIdx,
7190-
bool inFunctionCall, Sema::VariadicCallType CallType,
7193+
bool inFunctionCall, VariadicCallType CallType,
71917194
llvm::SmallBitVector &CheckedVarArgs,
71927195
UncoveredArgHandler &UncoveredArg,
71937196
llvm::SmallVectorImpl<EquatableFormatArgument> &Specs)
@@ -7461,8 +7464,8 @@ bool DecomposePrintfHandler::GetSpecifiers(
74617464
const Expr *PrintfArgs[] = {FSL->getFormatString()};
74627465
DecomposePrintfHandler H(S, FSL, FSL->getFormatString(), Type, 0, 0, IsObjC,
74637466
Str, Sema::FAPK_Elsewhere, PrintfArgs, 0,
7464-
InFunctionCall, Sema::VariadicDoesNotApply, BV, UA,
7465-
Args);
7467+
InFunctionCall, VariadicCallType::DoesNotApply, BV,
7468+
UA, Args);
74667469

74677470
if (!analyze_format_string::ParsePrintfString(
74687471
H, Str, Str + Data.size(), S.getLangOpts(), S.Context.getTargetInfo(),
@@ -8331,12 +8334,13 @@ CheckPrintfHandler::checkFormatExpr(const analyze_printf::PrintfSpecifier &FS,
83318334
}
83328335
case Sema::VAK_Undefined:
83338336
case Sema::VAK_MSVCUndefined:
8334-
if (CallType == Sema::VariadicDoesNotApply) {
8337+
if (CallType == VariadicCallType::DoesNotApply) {
83358338
EmitTypeMismatch = true;
83368339
} else {
83378340
EmitFormatDiagnostic(
83388341
S.PDiag(diag::warn_non_pod_vararg_with_format_string)
8339-
<< S.getLangOpts().CPlusPlus11 << ExprTy << CallType
8342+
<< S.getLangOpts().CPlusPlus11 << ExprTy
8343+
<< llvm::to_underlying(CallType)
83408344
<< AT.getRepresentativeTypeName(S.Context) << CSR
83418345
<< E->getSourceRange(),
83428346
E->getBeginLoc(), /*IsStringLocation*/ false, CSR);
@@ -8345,20 +8349,21 @@ CheckPrintfHandler::checkFormatExpr(const analyze_printf::PrintfSpecifier &FS,
83458349
break;
83468350

83478351
case Sema::VAK_Invalid:
8348-
if (CallType == Sema::VariadicDoesNotApply)
8352+
if (CallType == VariadicCallType::DoesNotApply)
83498353
EmitTypeMismatch = true;
83508354
else if (ExprTy->isObjCObjectType())
83518355
EmitFormatDiagnostic(
83528356
S.PDiag(diag::err_cannot_pass_objc_interface_to_vararg_format)
8353-
<< S.getLangOpts().CPlusPlus11 << ExprTy << CallType
8357+
<< S.getLangOpts().CPlusPlus11 << ExprTy
8358+
<< llvm::to_underlying(CallType)
83548359
<< AT.getRepresentativeTypeName(S.Context) << CSR
83558360
<< E->getSourceRange(),
83568361
E->getBeginLoc(), /*IsStringLocation*/ false, CSR);
83578362
else
83588363
// FIXME: If this is an initializer list, suggest removing the braces
83598364
// or inserting a cast to the target type.
83608365
S.Diag(E->getBeginLoc(), diag::err_cannot_pass_to_vararg_format)
8361-
<< isa<InitListExpr>(E) << ExprTy << CallType
8366+
<< isa<InitListExpr>(E) << ExprTy << llvm::to_underlying(CallType)
83628367
<< AT.getRepresentativeTypeName(S.Context) << E->getSourceRange();
83638368
break;
83648369
}
@@ -8395,7 +8400,7 @@ class CheckScanfHandler : public CheckFormatHandler {
83958400
unsigned firstDataArg, unsigned numDataArgs,
83968401
const char *beg, Sema::FormatArgumentPassingKind APK,
83978402
ArrayRef<const Expr *> Args, unsigned formatIdx,
8398-
bool inFunctionCall, Sema::VariadicCallType CallType,
8403+
bool inFunctionCall, VariadicCallType CallType,
83998404
llvm::SmallBitVector &CheckedVarArgs,
84008405
UncoveredArgHandler &UncoveredArg)
84018406
: CheckFormatHandler(s, fexpr, origFormatExpr, type, firstDataArg,
@@ -8624,7 +8629,7 @@ static void CheckFormatString(
86248629
const StringLiteral *ReferenceFormatString, const Expr *OrigFormatExpr,
86258630
ArrayRef<const Expr *> Args, Sema::FormatArgumentPassingKind APK,
86268631
unsigned format_idx, unsigned firstDataArg, FormatStringType Type,
8627-
bool inFunctionCall, Sema::VariadicCallType CallType,
8632+
bool inFunctionCall, VariadicCallType CallType,
86288633
llvm::SmallBitVector &CheckedVarArgs, UncoveredArgHandler &UncoveredArg,
86298634
bool IgnoreStringsWithoutSpecifiers) {
86308635
// CHECK: is the format string a wide literal?

‎clang/lib/Sema/SemaDeclCXX.cpp‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -16425,8 +16425,9 @@ bool Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
1642516425
else
1642616426
ConvertedArgs.reserve(NumArgs);
1642716427

16428-
VariadicCallType CallType =
16429-
Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
16428+
VariadicCallType CallType = Proto->isVariadic()
16429+
? VariadicCallType::Constructor
16430+
: VariadicCallType::DoesNotApply;
1643016431
SmallVector<Expr *, 8> AllArgs;
1643116432
bool Invalid = GatherArgumentsForCall(
1643216433
Loc, Constructor, Proto, 0, llvm::ArrayRef(Args, NumArgs), AllArgs,

‎clang/lib/Sema/SemaExpr.cpp‎

Lines changed: 20 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -1022,37 +1022,40 @@ void Sema::checkVariadicArgument(const Expr *E, VariadicCallType CT) {
10221022
case VAK_ValidInCXX11:
10231023
DiagRuntimeBehavior(
10241024
E->getBeginLoc(), nullptr,
1025-
PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg) << Ty << CT);
1025+
PDiag(diag::warn_cxx98_compat_pass_non_pod_arg_to_vararg)
1026+
<< Ty << llvm::to_underlying(CT));
10261027
[[fallthrough]];
10271028
case VAK_Valid:
10281029
if (Ty->isRecordType()) {
10291030
// This is unlikely to be what the user intended. If the class has a
10301031
// 'c_str' member function, the user probably meant to call that.
10311032
DiagRuntimeBehavior(E->getBeginLoc(), nullptr,
10321033
PDiag(diag::warn_pass_class_arg_to_vararg)
1033-
<< Ty << CT << hasCStrMethod(E) << ".c_str()");
1034+
<< Ty << llvm::to_underlying(CT)
1035+
<< hasCStrMethod(E) << ".c_str()");
10341036
}
10351037
break;
10361038

10371039
case VAK_Undefined:
10381040
case VAK_MSVCUndefined:
10391041
DiagRuntimeBehavior(E->getBeginLoc(), nullptr,
10401042
PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg)
1041-
<< getLangOpts().CPlusPlus11 << Ty << CT);
1043+
<< getLangOpts().CPlusPlus11 << Ty
1044+
<< llvm::to_underlying(CT));
10421045
break;
10431046

10441047
case VAK_Invalid:
10451048
if (Ty.isDestructedType() == QualType::DK_nontrivial_c_struct)
10461049
Diag(E->getBeginLoc(),
10471050
diag::err_cannot_pass_non_trivial_c_struct_to_vararg)
1048-
<< Ty << CT;
1051+
<< Ty << llvm::to_underlying(CT);
10491052
else if (Ty->isObjCObjectType())
10501053
DiagRuntimeBehavior(E->getBeginLoc(), nullptr,
10511054
PDiag(diag::err_cannot_pass_objc_interface_to_vararg)
1052-
<< Ty << CT);
1055+
<< Ty << llvm::to_underlying(CT));
10531056
else
10541057
Diag(E->getBeginLoc(), diag::err_cannot_pass_to_vararg)
1055-
<< isa<InitListExpr>(E) << Ty << CT;
1058+
<< isa<InitListExpr>(E) << Ty << llvm::to_underlying(CT);
10561059
break;
10571060
}
10581061
}
@@ -1062,7 +1065,7 @@ ExprResult Sema::DefaultVariadicArgumentPromotion(Expr *E, VariadicCallType CT,
10621065
if (const BuiltinType *PlaceholderTy = E->getType()->getAsPlaceholderType()) {
10631066
// Strip the unbridged-cast placeholder expression off, if applicable.
10641067
if (PlaceholderTy->getKind() == BuiltinType::ARCUnbridgedCast &&
1065-
(CT == VariadicMethod ||
1068+
(CT == VariadicCallType::Method ||
10661069
(FDecl && FDecl->hasAttr<CFAuditedTransferAttr>()))) {
10671070
E = ObjC().stripARCUnbridgedCast(E);
10681071

@@ -5772,23 +5775,23 @@ ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
57725775
return ExprError();
57735776
}
57745777

5775-
Sema::VariadicCallType
5776-
Sema::getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto,
5777-
Expr *Fn) {
5778+
VariadicCallType Sema::getVariadicCallType(FunctionDecl *FDecl,
5779+
const FunctionProtoType *Proto,
5780+
Expr *Fn) {
57785781
if (Proto && Proto->isVariadic()) {
57795782
if (isa_and_nonnull<CXXConstructorDecl>(FDecl))
5780-
return VariadicConstructor;
5783+
return VariadicCallType::Constructor;
57815784
else if (Fn && Fn->getType()->isBlockPointerType())
5782-
return VariadicBlock;
5785+
return VariadicCallType::Block;
57835786
else if (FDecl) {
57845787
if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl))
57855788
if (Method->isInstance())
5786-
return VariadicMethod;
5789+
return VariadicCallType::Method;
57875790
} else if (Fn && Fn->getType() == Context.BoundMemberTy)
5788-
return VariadicMethod;
5789-
return VariadicFunction;
5791+
return VariadicCallType::Method;
5792+
return VariadicCallType::Function;
57905793
}
5791-
return VariadicDoesNotApply;
5794+
return VariadicCallType::DoesNotApply;
57925795
}
57935796

57945797
namespace {
@@ -6099,7 +6102,7 @@ bool Sema::GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
60996102
}
61006103

61016104
// If this is a variadic call, handle args passed through "...".
6102-
if (CallType != VariadicDoesNotApply) {
6105+
if (CallType != VariadicCallType::DoesNotApply) {
61036106
// Assume that extern "C" functions with variadic arguments that
61046107
// return __unknown_anytype aren't *really* variadic.
61056108
if (Proto->getReturnType() == Context.UnknownAnyTy && FDecl &&

‎clang/lib/Sema/SemaExprCXX.cpp‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2452,8 +2452,9 @@ ExprResult Sema::BuildCXXNew(SourceRange Range, bool UseGlobal,
24522452
SmallVector<Expr *, 8> AllPlaceArgs;
24532453
if (OperatorNew) {
24542454
auto *Proto = OperatorNew->getType()->castAs<FunctionProtoType>();
2455-
VariadicCallType CallType = Proto->isVariadic() ? VariadicFunction
2456-
: VariadicDoesNotApply;
2455+
VariadicCallType CallType = Proto->isVariadic()
2456+
? VariadicCallType::Function
2457+
: VariadicCallType::DoesNotApply;
24572458

24582459
// We've already converted the placement args, just fill in any default
24592460
// arguments. Skip the first parameter because we don't have a corresponding

‎clang/lib/Sema/SemaExprObjC.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1894,7 +1894,7 @@ bool SemaObjC::CheckMessageArgumentTypes(
18941894
continue;
18951895

18961896
ExprResult Arg = SemaRef.DefaultVariadicArgumentPromotion(
1897-
Args[i], Sema::VariadicMethod, nullptr);
1897+
Args[i], VariadicCallType::Method, nullptr);
18981898
IsError |= Arg.isInvalid();
18991899
Args[i] = Arg.get();
19001900
}

0 commit comments

Comments
 (0)