Skip to content

Commit 3bdbfbe

Browse files
CentrilCentril
committed
syntax: de-dups in item parsing.
1 parent e0fe4be commit 3bdbfbe

File tree

1 file changed

+44
-50
lines changed

1 file changed

+44
-50
lines changed

‎src/libsyntax/parse/parser/item.rs‎

Lines changed: 44 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -98,23 +98,22 @@ impl<'a> Parser<'a> {
9898

9999
let lo = self.token.span;
100100

101-
let visibility = self.parse_visibility(false)?;
101+
let vis = self.parse_visibility(false)?;
102102

103103
if self.eat_keyword(kw::Use) {
104104
// USE ITEM
105105
let item_ = ItemKind::Use(P(self.parse_use_tree()?));
106106
self.expect(&token::Semi)?;
107107

108108
let span = lo.to(self.prev_span);
109-
let item =
110-
self.mk_item(span, Ident::invalid(), item_, visibility, attrs);
109+
let item = self.mk_item(span, Ident::invalid(), item_, vis, attrs);
111110
return Ok(Some(item));
112111
}
113112

114113
if self.eat_keyword(kw::Extern) {
115114
let extern_sp = self.prev_span;
116115
if self.eat_keyword(kw::Crate) {
117-
return Ok(Some(self.parse_item_extern_crate(lo, visibility, attrs)?));
116+
return Ok(Some(self.parse_item_extern_crate(lo, vis, attrs)?));
118117
}
119118

120119
let opt_abi = self.parse_opt_abi()?;
@@ -128,10 +127,10 @@ impl<'a> Parser<'a> {
128127
constness: respan(fn_span, Constness::NotConst),
129128
abi: opt_abi.unwrap_or(Abi::C),
130129
};
131-
return self.parse_item_fn(lo, visibility, attrs, header);
130+
return self.parse_item_fn(lo, vis, attrs, header);
132131
} else if self.check(&token::OpenDelim(token::Brace)) {
133132
return Ok(Some(
134-
self.parse_item_foreign_mod(lo, opt_abi, visibility, attrs, extern_sp)?,
133+
self.parse_item_foreign_mod(lo, opt_abi, vis, attrs, extern_sp)?,
135134
));
136135
}
137136

@@ -142,10 +141,8 @@ impl<'a> Parser<'a> {
142141
self.bump();
143142
// STATIC ITEM
144143
let m = self.parse_mutability();
145-
let (ident, item_, extra_attrs) = self.parse_item_const(Some(m))?;
146-
let span = lo.to(self.prev_span);
147-
let attrs = maybe_append(attrs, extra_attrs);
148-
return Ok(Some(self.mk_item(span, ident, item_, visibility, attrs)));
144+
let info = self.parse_item_const(Some(m));
145+
return self.mk_item_with_info(attrs, lo, vis, info);
149146
}
150147
if self.eat_keyword(kw::Const) {
151148
let const_span = self.prev_span;
@@ -168,7 +165,7 @@ impl<'a> Parser<'a> {
168165
constness: respan(const_span, Constness::Const),
169166
abi,
170167
};
171-
return self.parse_item_fn(lo, visibility, attrs, header);
168+
return self.parse_item_fn(lo, vis, attrs, header);
172169
}
173170

174171
// CONST ITEM
@@ -184,10 +181,8 @@ impl<'a> Parser<'a> {
184181
)
185182
.emit();
186183
}
187-
let (ident, item_, extra_attrs) = self.parse_item_const(None)?;
188-
let span = lo.to(self.prev_span);
189-
let attrs = maybe_append(attrs, extra_attrs);
190-
return Ok(Some(self.mk_item(span, ident, item_, visibility, attrs)));
184+
let info = self.parse_item_const(None);
185+
return self.mk_item_with_info(attrs, lo, vis, info);
191186
}
192187

193188
// Parses `async unsafe? fn`.
@@ -212,7 +207,7 @@ impl<'a> Parser<'a> {
212207
constness: respan(fn_span, Constness::NotConst),
213208
abi: Abi::Rust,
214209
};
215-
return self.parse_item_fn(lo, visibility, attrs, header);
210+
return self.parse_item_fn(lo, vis, attrs, header);
216211
}
217212
}
218213
if self.check_keyword(kw::Unsafe) &&
@@ -227,10 +222,8 @@ impl<'a> Parser<'a> {
227222
self.expect_keyword(kw::Trait)?;
228223
IsAuto::Yes
229224
};
230-
let (ident, item_, extra_attrs) = self.parse_item_trait(is_auto, Unsafety::Unsafe)?;
231-
let span = lo.to(self.prev_span);
232-
let attrs = maybe_append(attrs, extra_attrs);
233-
return Ok(Some(self.mk_item(span, ident, item_, visibility, attrs)));
225+
let info = self.parse_item_trait(is_auto, Unsafety::Unsafe);
226+
return self.mk_item_with_info(attrs, lo, vis, info);
234227
}
235228
if self.check_keyword(kw::Impl) ||
236229
self.check_keyword(kw::Unsafe) &&
@@ -241,10 +234,8 @@ impl<'a> Parser<'a> {
241234
let defaultness = self.parse_defaultness();
242235
let unsafety = self.parse_unsafety();
243236
self.expect_keyword(kw::Impl)?;
244-
let (ident, item_, extra_attrs) = self.parse_item_impl(unsafety, defaultness)?;
245-
let span = lo.to(self.prev_span);
246-
let attrs = maybe_append(attrs, extra_attrs);
247-
return Ok(Some(self.mk_item(span, ident, item_, visibility, attrs)));
237+
let info = self.parse_item_impl(unsafety, defaultness);
238+
return self.mk_item_with_info(attrs, lo, vis, info);
248239
}
249240
if self.check_keyword(kw::Fn) {
250241
// FUNCTION ITEM
@@ -256,7 +247,7 @@ impl<'a> Parser<'a> {
256247
constness: respan(fn_span, Constness::NotConst),
257248
abi: Abi::Rust,
258249
};
259-
return self.parse_item_fn(lo, visibility, attrs, header);
250+
return self.parse_item_fn(lo, vis, attrs, header);
260251
}
261252
if self.check_keyword(kw::Unsafe)
262253
&& self.look_ahead(1, |t| *t != token::OpenDelim(token::Brace)) {
@@ -273,14 +264,12 @@ impl<'a> Parser<'a> {
273264
constness: respan(fn_span, Constness::NotConst),
274265
abi,
275266
};
276-
return self.parse_item_fn(lo, visibility, attrs, header);
267+
return self.parse_item_fn(lo, vis, attrs, header);
277268
}
278269
if self.eat_keyword(kw::Mod) {
279270
// MODULE ITEM
280-
let (ident, item_, extra_attrs) = self.parse_item_mod(&attrs[..])?;
281-
let span = lo.to(self.prev_span);
282-
let attrs = maybe_append(attrs, extra_attrs);
283-
return Ok(Some(self.mk_item(span, ident, item_, visibility, attrs)));
271+
let info = self.parse_item_mod(&attrs[..]);
272+
return self.mk_item_with_info(attrs, lo, vis, info);
284273
}
285274
if let Some(type_) = self.eat_type() {
286275
let (ident, alias, generics) = type_?;
@@ -290,14 +279,12 @@ impl<'a> Parser<'a> {
290279
AliasKind::OpaqueTy(bounds) => ItemKind::OpaqueTy(bounds, generics),
291280
};
292281
let span = lo.to(self.prev_span);
293-
return Ok(Some(self.mk_item(span, ident, item_, visibility, attrs)));
282+
return Ok(Some(self.mk_item(span, ident, item_, vis, attrs)));
294283
}
295284
if self.eat_keyword(kw::Enum) {
296285
// ENUM ITEM
297-
let (ident, item_, extra_attrs) = self.parse_item_enum()?;
298-
let span = lo.to(self.prev_span);
299-
let attrs = maybe_append(attrs, extra_attrs);
300-
return Ok(Some(self.mk_item(span, ident, item_, visibility, attrs)));
286+
let info = self.parse_item_enum();
287+
return self.mk_item_with_info(attrs, lo, vis, info);
301288
}
302289
if self.check_keyword(kw::Trait)
303290
|| (self.check_keyword(kw::Auto)
@@ -311,33 +298,27 @@ impl<'a> Parser<'a> {
311298
IsAuto::Yes
312299
};
313300
// TRAIT ITEM
314-
let (ident, item_, extra_attrs) = self.parse_item_trait(is_auto, Unsafety::Normal)?;
315-
let span = lo.to(self.prev_span);
316-
let attrs = maybe_append(attrs, extra_attrs);
317-
return Ok(Some(self.mk_item(span, ident, item_, visibility, attrs)));
301+
let info = self.parse_item_trait(is_auto, Unsafety::Normal);
302+
return self.mk_item_with_info(attrs, lo, vis, info);
318303
}
319304
if self.eat_keyword(kw::Struct) {
320305
// STRUCT ITEM
321-
let (ident, item_, extra_attrs) = self.parse_item_struct()?;
322-
let span = lo.to(self.prev_span);
323-
let attrs = maybe_append(attrs, extra_attrs);
324-
return Ok(Some(self.mk_item(span, ident, item_, visibility, attrs)));
306+
let info = self.parse_item_struct();
307+
return self.mk_item_with_info(attrs, lo, vis, info);
325308
}
326309
if self.is_union_item() {
327310
// UNION ITEM
328311
self.bump();
329-
let (ident, item_, extra_attrs) = self.parse_item_union()?;
330-
let span = lo.to(self.prev_span);
331-
let attrs = maybe_append(attrs, extra_attrs);
332-
return Ok(Some(self.mk_item(span, ident, item_, visibility, attrs)));
312+
let info = self.parse_item_union();
313+
return self.mk_item_with_info(attrs, lo, vis, info);
333314
}
334-
if let Some(macro_def) = self.eat_macro_def(&attrs, &visibility, lo)? {
315+
if let Some(macro_def) = self.eat_macro_def(&attrs, &vis, lo)? {
335316
return Ok(Some(macro_def));
336317
}
337318

338319
// Verify whether we have encountered a struct or method definition where the user forgot to
339320
// add the `struct` or `fn` keyword after writing `pub`: `pub S {}`
340-
if visibility.node.is_pub() &&
321+
if vis.node.is_pub() &&
341322
self.check_ident() &&
342323
self.look_ahead(1, |t| *t != token::Not)
343324
{
@@ -428,7 +409,20 @@ impl<'a> Parser<'a> {
428409
return Err(err);
429410
}
430411
}
431-
self.parse_macro_use_or_failure(attrs, macros_allowed, attributes_allowed, lo, visibility)
412+
self.parse_macro_use_or_failure(attrs, macros_allowed, attributes_allowed, lo, vis)
413+
}
414+
415+
fn mk_item_with_info(
416+
&self,
417+
attrs: Vec<Attribute>,
418+
lo: Span,
419+
vis: Visibility,
420+
info: PResult<'a, ItemInfo>,
421+
) -> PResult<'a, Option<P<Item>>> {
422+
let (ident, item, extra_attrs) = info?;
423+
let span = lo.to(self.prev_span);
424+
let attrs = maybe_append(attrs, extra_attrs);
425+
Ok(Some(self.mk_item(span, ident, item, vis, attrs)))
432426
}
433427

434428
fn recover_first_param(&mut self) -> &'static str {

0 commit comments

Comments
 (0)