Skip to content

Commit da40916

Browse files
ljedrzljedrz
committed
resolve: improve common patterns
1 parent 37ba107 commit da40916

File tree

4 files changed

+108
-124
lines changed

4 files changed

+108
-124
lines changed

‎src/librustc_resolve/build_reduced_graph.rs‎

Lines changed: 4 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -139,7 +139,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
139139

140140
let prefix_iter = || parent_prefix.iter().cloned()
141141
.chain(use_tree.prefix.segments.iter().map(|seg| seg.ident));
142-
let prefix_start = prefix_iter().nth(0);
142+
let prefix_start = prefix_iter().next();
143143
let starts_with_non_keyword = prefix_start.map_or(false, |ident| {
144144
!ident.is_path_segment_keyword()
145145
});
@@ -1048,13 +1048,10 @@ impl<'a, 'b, 'cl> Visitor<'a> for BuildReducedGraphVisitor<'a, 'b, 'cl> {
10481048

10491049
fn visit_token(&mut self, t: Token) {
10501050
if let Token::Interpolated(nt) = t {
1051-
match nt.0 {
1052-
token::NtExpr(ref expr) => {
1053-
if let ast::ExprKind::Mac(..) = expr.node {
1054-
self.visit_invoc(expr.id);
1055-
}
1051+
if let token::NtExpr(ref expr) = nt.0 {
1052+
if let ast::ExprKind::Mac(..) = expr.node {
1053+
self.visit_invoc(expr.id);
10561054
}
1057-
_ => {}
10581055
}
10591056
}
10601057
}

‎src/librustc_resolve/check_unused.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -109,7 +109,7 @@ impl<'a, 'b, 'cl> Visitor<'a> for UnusedImportCheckVisitor<'a, 'b, 'cl> {
109109
self.item_span
110110
};
111111

112-
if items.len() == 0 {
112+
if items.is_empty() {
113113
self.unused_imports
114114
.entry(self.base_id)
115115
.or_default()
@@ -170,7 +170,7 @@ pub fn check_crate(resolver: &mut Resolver, krate: &ast::Crate) {
170170

171171
for (id, spans) in &visitor.unused_imports {
172172
let len = spans.len();
173-
let mut spans = spans.values().map(|s| *s).collect::<Vec<Span>>();
173+
let mut spans = spans.values().cloned().collect::<Vec<Span>>();
174174
spans.sort();
175175
let ms = MultiSpan::from_spans(spans.clone());
176176
let mut span_snippets = spans.iter()
@@ -183,7 +183,7 @@ pub fn check_crate(resolver: &mut Resolver, krate: &ast::Crate) {
183183
span_snippets.sort();
184184
let msg = format!("unused import{}{}",
185185
if len > 1 { "s" } else { "" },
186-
if span_snippets.len() > 0 {
186+
if !span_snippets.is_empty() {
187187
format!(": {}", span_snippets.join(", "))
188188
} else {
189189
String::new()

‎src/librustc_resolve/lib.rs‎

Lines changed: 28 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -1633,19 +1633,17 @@ impl<'a, 'crateloader> Resolver<'a, 'crateloader> {
16331633
*def = module.def().unwrap(),
16341634
PathResult::NonModule(path_res) if path_res.unresolved_segments() == 0 =>
16351635
*def = path_res.base_def(),
1636-
PathResult::NonModule(..) => match self.resolve_path(
1637-
None,
1638-
&path,
1639-
None,
1640-
true,
1641-
span,
1642-
CrateLint::No,
1643-
) {
1644-
PathResult::Failed(span, msg, _) => {
1636+
PathResult::NonModule(..) =>
1637+
if let PathResult::Failed(span, msg, _) = self.resolve_path(
1638+
None,
1639+
&path,
1640+
None,
1641+
true,
1642+
span,
1643+
CrateLint::No,
1644+
) {
16451645
error_callback(self, span, ResolutionError::FailedToResolve(&msg));
1646-
}
1647-
_ => {}
1648-
},
1646+
},
16491647
PathResult::Module(ModuleOrUniformRoot::UniformRoot(_)) |
16501648
PathResult::Indeterminate => unreachable!(),
16511649
PathResult::Failed(span, msg, _) => {
@@ -2351,7 +2349,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
23512349
span: prefix.span.to(use_tree.prefix.span),
23522350
};
23532351

2354-
if items.len() == 0 {
2352+
if items.is_empty() {
23552353
// Resolve prefix of an import with empty braces (issue #28388).
23562354
self.smart_resolve_path_with_crate_lint(
23572355
id,
@@ -2690,7 +2688,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
26902688

26912689
let map_j = self.binding_mode_map(&q);
26922690
for (&key, &binding_i) in &map_i {
2693-
if map_j.len() == 0 { // Account for missing bindings when
2691+
if map_j.is_empty() { // Account for missing bindings when
26942692
let binding_error = missing_vars // map_j has none.
26952693
.entry(key.name)
26962694
.or_insert(BindingError {
@@ -2751,9 +2749,8 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
27512749
// This has to happen *after* we determine which pat_idents are variants
27522750
self.check_consistent_bindings(&arm.pats);
27532751

2754-
match arm.guard {
2755-
Some(ast::Guard::If(ref expr)) => self.visit_expr(expr),
2756-
_ => {}
2752+
if let Some(ast::Guard::If(ref expr)) = arm.guard {
2753+
self.visit_expr(expr)
27572754
}
27582755
self.visit_expr(&arm.body);
27592756

@@ -2994,14 +2991,14 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
29942991
// Make the base error.
29952992
let expected = source.descr_expected();
29962993
let path_str = names_to_string(path);
2997-
let item_str = path[path.len() - 1];
2994+
let item_str = path.last().unwrap();
29982995
let code = source.error_code(def.is_some());
29992996
let (base_msg, fallback_label, base_span) = if let Some(def) = def {
30002997
(format!("expected {}, found {} `{}`", expected, def.kind_name(), path_str),
30012998
format!("not a {}", expected),
30022999
span)
30033000
} else {
3004-
let item_span = path[path.len() - 1].span;
3001+
let item_span = path.last().unwrap().span;
30053002
let (mod_prefix, mod_str) = if path.len() == 1 {
30063003
(String::new(), "this scope".to_string())
30073004
} else if path.len() == 2 && path[0].name == keywords::CrateRoot.name() {
@@ -3368,7 +3365,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
33683365
);
33693366
}
33703367
break;
3371-
} else if snippet.trim().len() != 0 {
3368+
} else if !snippet.trim().is_empty() {
33723369
debug!("tried to find type ascription `:` token, couldn't find it");
33733370
break;
33743371
}
@@ -3930,7 +3927,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
39303927
}
39313928
_ => {}
39323929
}
3933-
return def;
3930+
def
39343931
}
39353932

39363933
fn lookup_assoc_candidate<FilterFn>(&mut self,
@@ -4482,21 +4479,17 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
44824479
let extern_prelude_names = self.extern_prelude.clone();
44834480
for &name in extern_prelude_names.iter() {
44844481
let ident = Ident::with_empty_ctxt(name);
4485-
match self.crate_loader.maybe_process_path_extern(name, ident.span) {
4486-
Some(crate_id) => {
4487-
let crate_root = self.get_module(DefId {
4488-
krate: crate_id,
4489-
index: CRATE_DEF_INDEX,
4490-
});
4491-
self.populate_module_if_necessary(&crate_root);
4482+
if let Some(crate_id) = self.crate_loader.maybe_process_path_extern(name,
4483+
ident.span)
4484+
{
4485+
let crate_root = self.get_module(DefId {
4486+
krate: crate_id,
4487+
index: CRATE_DEF_INDEX,
4488+
});
4489+
self.populate_module_if_necessary(&crate_root);
44924490

4493-
suggestions.extend(
4494-
self.lookup_import_candidates_from_module(
4495-
lookup_name, namespace, crate_root, ident, &filter_fn
4496-
)
4497-
);
4498-
}
4499-
None => {}
4491+
suggestions.extend(self.lookup_import_candidates_from_module(
4492+
lookup_name, namespace, crate_root, ident, &filter_fn));
45004493
}
45014494
}
45024495
}

‎src/librustc_resolve/resolve_imports.rs‎

Lines changed: 73 additions & 79 deletions
Original file line numberDiff line numberDiff line change
@@ -672,7 +672,7 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
672672
};
673673

674674
let has_explicit_self =
675-
import.module_path.len() > 0 &&
675+
!import.module_path.is_empty() &&
676676
import.module_path[0].name == keywords::SelfValue.name();
677677

678678
self.per_ns(|_, ns| {
@@ -703,9 +703,8 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
703703
if let SingleImport { source, ref result, .. } = import.subclass {
704704
if source.name == "self" {
705705
// Silence `unresolved import` error if E0429 is already emitted
706-
match result.value_ns.get() {
707-
Err(Determined) => continue,
708-
_ => {},
706+
if let Err(Determined) = result.value_ns.get() {
707+
continue;
709708
}
710709
}
711710
}
@@ -822,20 +821,19 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
822821
fn throw_unresolved_import_error(&self, error_vec: Vec<(Span, String, String)>,
823822
span: Option<MultiSpan>) {
824823
let max_span_label_msg_count = 10; // upper limit on number of span_label message.
825-
let (span,msg) = match error_vec.is_empty() {
826-
true => (span.unwrap(), "unresolved import".to_string()),
827-
false => {
828-
let span = MultiSpan::from_spans(error_vec.clone().into_iter()
829-
.map(|elem: (Span, String, String)| { elem.0 }
830-
).collect());
831-
let path_vec: Vec<String> = error_vec.clone().into_iter()
832-
.map(|elem: (Span, String, String)| { format!("`{}`", elem.1) }
833-
).collect();
834-
let path = path_vec.join(", ");
835-
let msg = format!("unresolved import{} {}",
836-
if path_vec.len() > 1 { "s" } else { "" }, path);
837-
(span, msg)
838-
}
824+
let (span, msg) = if error_vec.is_empty() {
825+
(span.unwrap(), "unresolved import".to_string())
826+
} else {
827+
let span = MultiSpan::from_spans(error_vec.clone().into_iter()
828+
.map(|elem: (Span, String, String)| { elem.0 })
829+
.collect());
830+
let path_vec: Vec<String> = error_vec.clone().into_iter()
831+
.map(|elem: (Span, String, String)| { format!("`{}`", elem.1) })
832+
.collect();
833+
let path = path_vec.join(", ");
834+
let msg = format!("unresolved import{} {}",
835+
if path_vec.len() > 1 { "s" } else { "" }, path);
836+
(span, msg)
839837
};
840838
let mut err = struct_span_err!(self.resolver.session, span, E0432, "{}", &msg);
841839
for span_error in error_vec.into_iter().take(max_span_label_msg_count) {
@@ -1026,9 +1024,8 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
10261024
if all_ns_err {
10271025
let mut all_ns_failed = true;
10281026
self.per_ns(|this, ns| if !type_ns_only || ns == TypeNS {
1029-
match this.resolve_ident_in_module(module, ident, ns, record_used, span) {
1030-
Ok(_) => all_ns_failed = false,
1031-
_ => {}
1027+
if this.resolve_ident_in_module(module, ident, ns, record_used, span).is_ok() {
1028+
all_ns_failed = false;
10321029
}
10331030
});
10341031

@@ -1247,65 +1244,62 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
12471244
}
12481245
}
12491246

1250-
match binding.kind {
1251-
NameBindingKind::Import { binding: orig_binding, directive, .. } => {
1252-
if ns == TypeNS && orig_binding.is_variant() &&
1253-
!orig_binding.vis.is_at_least(binding.vis, &*self) {
1254-
let msg = match directive.subclass {
1255-
ImportDirectiveSubclass::SingleImport { .. } => {
1256-
format!("variant `{}` is private and cannot be re-exported",
1257-
ident)
1258-
},
1259-
ImportDirectiveSubclass::GlobImport { .. } => {
1260-
let msg = "enum is private and its variants \
1261-
cannot be re-exported".to_owned();
1262-
let error_id = (DiagnosticMessageId::ErrorId(0), // no code?!
1263-
Some(binding.span),
1264-
msg.clone());
1265-
let fresh = self.session.one_time_diagnostics
1266-
.borrow_mut().insert(error_id);
1267-
if !fresh {
1268-
continue;
1269-
}
1270-
msg
1271-
},
1272-
ref s @ _ => bug!("unexpected import subclass {:?}", s)
1273-
};
1274-
let mut err = self.session.struct_span_err(binding.span, &msg);
1275-
1276-
let imported_module = match directive.imported_module.get() {
1277-
Some(ModuleOrUniformRoot::Module(module)) => module,
1278-
_ => bug!("module should exist"),
1279-
};
1280-
let resolutions = imported_module.parent.expect("parent should exist")
1281-
.resolutions.borrow();
1282-
let enum_path_segment_index = directive.module_path.len() - 1;
1283-
let enum_ident = directive.module_path[enum_path_segment_index];
1284-
1285-
let enum_resolution = resolutions.get(&(enum_ident, TypeNS))
1286-
.expect("resolution should exist");
1287-
let enum_span = enum_resolution.borrow()
1288-
.binding.expect("binding should exist")
1289-
.span;
1290-
let enum_def_span = self.session.source_map().def_span(enum_span);
1291-
let enum_def_snippet = self.session.source_map()
1292-
.span_to_snippet(enum_def_span).expect("snippet should exist");
1293-
// potentially need to strip extant `crate`/`pub(path)` for suggestion
1294-
let after_vis_index = enum_def_snippet.find("enum")
1295-
.expect("`enum` keyword should exist in snippet");
1296-
let suggestion = format!("pub {}",
1297-
&enum_def_snippet[after_vis_index..]);
1298-
1299-
self.session
1300-
.diag_span_suggestion_once(&mut err,
1301-
DiagnosticMessageId::ErrorId(0),
1302-
enum_def_span,
1303-
"consider making the enum public",
1304-
suggestion);
1305-
err.emit();
1306-
}
1247+
if let NameBindingKind::Import { binding: orig_binding, directive, .. } = binding.kind {
1248+
if ns == TypeNS && orig_binding.is_variant() &&
1249+
!orig_binding.vis.is_at_least(binding.vis, &*self) {
1250+
let msg = match directive.subclass {
1251+
ImportDirectiveSubclass::SingleImport { .. } => {
1252+
format!("variant `{}` is private and cannot be re-exported",
1253+
ident)
1254+
},
1255+
ImportDirectiveSubclass::GlobImport { .. } => {
1256+
let msg = "enum is private and its variants \
1257+
cannot be re-exported".to_owned();
1258+
let error_id = (DiagnosticMessageId::ErrorId(0), // no code?!
1259+
Some(binding.span),
1260+
msg.clone());
1261+
let fresh = self.session.one_time_diagnostics
1262+
.borrow_mut().insert(error_id);
1263+
if !fresh {
1264+
continue;
1265+
}
1266+
msg
1267+
},
1268+
ref s @ _ => bug!("unexpected import subclass {:?}", s)
1269+
};
1270+
let mut err = self.session.struct_span_err(binding.span, &msg);
1271+
1272+
let imported_module = match directive.imported_module.get() {
1273+
Some(ModuleOrUniformRoot::Module(module)) => module,
1274+
_ => bug!("module should exist"),
1275+
};
1276+
let resolutions = imported_module.parent.expect("parent should exist")
1277+
.resolutions.borrow();
1278+
let enum_path_segment_index = directive.module_path.len() - 1;
1279+
let enum_ident = directive.module_path[enum_path_segment_index];
1280+
1281+
let enum_resolution = resolutions.get(&(enum_ident, TypeNS))
1282+
.expect("resolution should exist");
1283+
let enum_span = enum_resolution.borrow()
1284+
.binding.expect("binding should exist")
1285+
.span;
1286+
let enum_def_span = self.session.source_map().def_span(enum_span);
1287+
let enum_def_snippet = self.session.source_map()
1288+
.span_to_snippet(enum_def_span).expect("snippet should exist");
1289+
// potentially need to strip extant `crate`/`pub(path)` for suggestion
1290+
let after_vis_index = enum_def_snippet.find("enum")
1291+
.expect("`enum` keyword should exist in snippet");
1292+
let suggestion = format!("pub {}",
1293+
&enum_def_snippet[after_vis_index..]);
1294+
1295+
self.session
1296+
.diag_span_suggestion_once(&mut err,
1297+
DiagnosticMessageId::ErrorId(0),
1298+
enum_def_span,
1299+
"consider making the enum public",
1300+
suggestion);
1301+
err.emit();
13071302
}
1308-
_ => {}
13091303
}
13101304
}
13111305

0 commit comments

Comments
 (0)