@@ -1031,13 +1031,10 @@ impl<'a> Parser<'a> {
1031
1031
let pat = self . mk_pat_ident ( ty. span , bm, ident) ;
1032
1032
( pat, ty)
1033
1033
}
1034
+ // If this is a C-variadic argument and we hit an error, return the error.
1035
+ Err ( err) if self . token == token:: DotDotDot => return Err ( err) ,
1036
+ // Recover from attempting to parse the argument as a type without pattern.
1034
1037
Err ( mut err) => {
1035
- // If this is a C-variadic argument and we hit an error, return the
1036
- // error.
1037
- if self . token == token:: DotDotDot {
1038
- return Err ( err) ;
1039
- }
1040
- // Recover from attempting to parse the argument as a type without pattern.
1041
1038
err. cancel ( ) ;
1042
1039
mem:: replace ( self , parser_snapshot_before_ty) ;
1043
1040
self . recover_arg_parse ( ) ?
@@ -1200,42 +1197,44 @@ impl<'a> Parser<'a> {
1200
1197
1201
1198
}
1202
1199
1203
- fn parse_fn_params ( & mut self , named_params : bool , allow_c_variadic : bool )
1204
- -> PResult < ' a , Vec < Param > > {
1200
+ fn parse_fn_params (
1201
+ & mut self ,
1202
+ named_params : bool ,
1203
+ allow_c_variadic : bool ,
1204
+ ) -> PResult < ' a , Vec < Param > > {
1205
1205
let sp = self . token . span ;
1206
+ let do_not_enforce_named_params_for_c_variadic = |token : & token:: Token | {
1207
+ match token. kind {
1208
+ token:: DotDotDot => false ,
1209
+ _ => named_params,
1210
+ }
1211
+ } ;
1206
1212
let mut c_variadic = false ;
1207
- let ( params, _) : ( Vec < Option < Param > > , _ ) = self . parse_paren_comma_seq ( |p| {
1208
- let do_not_enforce_named_arguments_for_c_variadic =
1209
- |token : & token:: Token | -> bool {
1210
- if token == & token:: DotDotDot {
1211
- false
1212
- } else {
1213
- named_params
1214
- }
1215
- } ;
1213
+ let ( params, _) = self . parse_paren_comma_seq ( |p| {
1216
1214
match p. parse_param_general (
1217
1215
false ,
1218
1216
false ,
1219
1217
allow_c_variadic,
1220
- do_not_enforce_named_arguments_for_c_variadic
1218
+ do_not_enforce_named_params_for_c_variadic ,
1221
1219
) {
1222
- Ok ( param) => {
1220
+ Ok ( param) => Ok (
1223
1221
if let TyKind :: CVarArgs = param. ty . kind {
1224
1222
c_variadic = true ;
1225
1223
if p. token != token:: CloseDelim ( token:: Paren ) {
1226
- let span = p. token . span ;
1227
- p. span_err ( span,
1228
- "`...` must be the last argument of a C-variadic function" ) ;
1224
+ p. span_err (
1225
+ p. token . span ,
1226
+ "`...` must be the last argument of a C-variadic function" ,
1227
+ ) ;
1229
1228
// FIXME(eddyb) this should probably still push `CVarArgs`.
1230
1229
// Maybe AST validation/HIR lowering should emit the above error?
1231
- Ok ( None )
1230
+ None
1232
1231
} else {
1233
- Ok ( Some ( param) )
1232
+ Some ( param)
1234
1233
}
1235
1234
} else {
1236
- Ok ( Some ( param) )
1235
+ Some ( param)
1237
1236
}
1238
- } ,
1237
+ ) ,
1239
1238
Err ( mut e) => {
1240
1239
e. emit ( ) ;
1241
1240
let lo = p. prev_span ;
@@ -1251,8 +1250,10 @@ impl<'a> Parser<'a> {
1251
1250
let params: Vec < _ > = params. into_iter ( ) . filter_map ( |x| x) . collect ( ) ;
1252
1251
1253
1252
if c_variadic && params. len ( ) <= 1 {
1254
- self . span_err ( sp,
1255
- "C-variadic function must be declared with at least one named argument" ) ;
1253
+ self . span_err (
1254
+ sp,
1255
+ "C-variadic function must be declared with at least one named argument" ,
1256
+ ) ;
1256
1257
}
1257
1258
1258
1259
Ok ( params)
0 commit comments