mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

replaced some map_or with map_or_else

Browse source
This commit is contained in:
klensy 2021-02-24 01:02:05 +03:00
parent 5ff1be197e
commit c75c4a579b
12 changed files with 82 additions and 70 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
View file

@ -2372,7 +2372,7 @@ fn compute_type_parameters(cx: &CodegenCx<'ll, 'tcx>, ty: Ty<'tcx>) -> &'ll DIAr
fn get_parameter_names(cx: &CodegenCx<'_, '_>, generics: &ty::Generics) -> Vec<Symbol> { fn get_parameter_names(cx: &CodegenCx<'_, '_>, generics: &ty::Generics) -> Vec<Symbol> {
let mut names = generics let mut names = generics
.parent .parent
.map_or(vec![], |def_id| get_parameter_names(cx, cx.tcx.generics_of(def_id))); .map_or_else(|| vec![], |def_id| get_parameter_names(cx, cx.tcx.generics_of(def_id)));
names.extend(generics.params.iter().map(|param| param.name)); names.extend(generics.params.iter().map(|param| param.name));
names names
} }

7
compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
View file

@ -481,9 +481,10 @@ impl DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
} }
fn get_parameter_names(cx: &CodegenCx<'_, '_>, generics: &ty::Generics) -> Vec<Symbol> { fn get_parameter_names(cx: &CodegenCx<'_, '_>, generics: &ty::Generics) -> Vec<Symbol> {
let mut names = generics let mut names = generics.parent.map_or_else(
.parent || vec![],
.map_or(vec![], |def_id| get_parameter_names(cx, cx.tcx.generics_of(def_id))); |def_id| get_parameter_names(cx, cx.tcx.generics_of(def_id)),
);
names.extend(generics.params.iter().map(|param| param.name)); names.extend(generics.params.iter().map(|param| param.name));
names names
} }

4
compiler/rustc_codegen_llvm/src/metadata.rs
View file

@ -65,8 +65,8 @@ fn search_meta_section<'a>(
while llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False { while llvm::LLVMIsSectionIteratorAtEnd(of.llof, si.llsi) == False {
let mut name_buf = None; let mut name_buf = None;
let name_len = llvm::LLVMRustGetSectionName(si.llsi, &mut name_buf); let name_len = llvm::LLVMRustGetSectionName(si.llsi, &mut name_buf);
let name = name_buf.map_or( let name = name_buf.map_or_else(
String::new(), // We got a NULL ptr, ignore `name_len`. || String::new(), // We got a NULL ptr, ignore `name_len`.
|buf| { |buf| {
String::from_utf8( String::from_utf8(
slice::from_raw_parts(buf.as_ptr() as *const u8, name_len as usize) slice::from_raw_parts(buf.as_ptr() as *const u8, name_len as usize)

2
compiler/rustc_macros/src/query.rs
View file

@ -409,7 +409,7 @@ fn add_query_description_impl(
}; };
let (tcx, desc) = modifiers.desc; let (tcx, desc) = modifiers.desc;
let tcx = tcx.as_ref().map_or(quote! { _ }, |t| quote! { #t }); let tcx = tcx.as_ref().map_or_else(|| quote! { _ }, |t| quote! { #t });
let desc = quote! { let desc = quote! {
#[allow(unused_variables)] #[allow(unused_variables)]

2
compiler/rustc_mir/src/const_eval/eval_queries.rs
View file

@ -50,7 +50,7 @@ fn eval_body_using_ecx<'mir, 'tcx>(
let name = let name =
with_no_trimmed_paths(|| ty::tls::with(|tcx| tcx.def_path_str(cid.instance.def_id()))); with_no_trimmed_paths(|| ty::tls::with(|tcx| tcx.def_path_str(cid.instance.def_id())));
let prom = cid.promoted.map_or(String::new(), |p| format!("::promoted[{:?}]", p)); let prom = cid.promoted.map_or_else(|| String::new(), |p| format!("::promoted[{:?}]", p));
trace!("eval_body_using_ecx: pushing stack frame for global: {}{}", name, prom); trace!("eval_body_using_ecx: pushing stack frame for global: {}{}", name, prom);
ecx.push_stack_frame( ecx.push_stack_frame(

2
compiler/rustc_parse/src/parser/diagnostics.rs
View file

@ -223,7 +223,7 @@ impl<'a> Parser<'a> {
fn tokens_to_string(tokens: &[TokenType]) -> String { fn tokens_to_string(tokens: &[TokenType]) -> String {
let mut i = tokens.iter(); let mut i = tokens.iter();
// This might be a sign we need a connect method on `Iterator`. // This might be a sign we need a connect method on `Iterator`.
let b = i.next().map_or(String::new(), |t| t.to_string()); let b = i.next().map_or_else(|| String::new(), |t| t.to_string());
i.enumerate().fold(b, |mut b, (i, a)| { i.enumerate().fold(b, |mut b, (i, a)| {
if tokens.len() > 2 && i == tokens.len() - 2 { if tokens.len() > 2 && i == tokens.len() - 2 {
b.push_str(", or "); b.push_str(", or ");

111
compiler/rustc_resolve/src/late/lifetimes.rs
View file

@ -1971,65 +1971,68 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
// Therefore, we would compute `object_lifetime_defaults` to a // Therefore, we would compute `object_lifetime_defaults` to a
// vector like `['x, 'static]`. Note that the vector only // vector like `['x, 'static]`. Note that the vector only
// includes type parameters. // includes type parameters.
let object_lifetime_defaults = type_def_id.map_or(vec![], |def_id| { let object_lifetime_defaults = type_def_id.map_or_else(
let in_body = { || vec![],
let mut scope = self.scope; |def_id| {
loop { let in_body = {
match *scope { let mut scope = self.scope;
Scope::Root => break false, loop {
match *scope {
Scope::Root => break false,
Scope::Body { .. } => break true, Scope::Body { .. } => break true,
Scope::Binder { s, .. } Scope::Binder { s, .. }
| Scope::Elision { s, .. } | Scope::Elision { s, .. }
| Scope::ObjectLifetimeDefault { s, .. } => { | Scope::ObjectLifetimeDefault { s, .. } => {
scope = s; scope = s;
}
}
}
};
let map = &self.map;
let unsubst = if let Some(def_id) = def_id.as_local() {
let id = self.tcx.hir().local_def_id_to_hir_id(def_id);
&map.object_lifetime_defaults[&id]
} else {
let tcx = self.tcx;
self.xcrate_object_lifetime_defaults.entry(def_id).or_insert_with(|| {
tcx.generics_of(def_id)
.params
.iter()
.filter_map(|param| match param.kind {
GenericParamDefKind::Type { object_lifetime_default, .. } => {
Some(object_lifetime_default)
} }
GenericParamDefKind::Lifetime | GenericParamDefKind::Const => None,
})
.collect()
})
};
debug!("visit_segment_args: unsubst={:?}", unsubst);
unsubst
.iter()
.map(|set| match *set {
Set1::Empty => {
if in_body {
None
} else {
Some(Region::Static)
} }
} }
Set1::One(r) => { };
let lifetimes = generic_args.args.iter().filter_map(|arg| match arg {
GenericArg::Lifetime(lt) => Some(lt), let map = &self.map;
_ => None, let unsubst = if let Some(def_id) = def_id.as_local() {
}); let id = self.tcx.hir().local_def_id_to_hir_id(def_id);
r.subst(lifetimes, map) &map.object_lifetime_defaults[&id]
} } else {
Set1::Many => None, let tcx = self.tcx;
}) self.xcrate_object_lifetime_defaults.entry(def_id).or_insert_with(|| {
.collect() tcx.generics_of(def_id)
}); .params
.iter()
.filter_map(|param| match param.kind {
GenericParamDefKind::Type { object_lifetime_default, .. } => {
Some(object_lifetime_default)
}
GenericParamDefKind::Lifetime | GenericParamDefKind::Const => None,
})
.collect()
})
};
debug!("visit_segment_args: unsubst={:?}", unsubst);
unsubst
.iter()
.map(|set| match *set {
Set1::Empty => {
if in_body {
None
} else {
Some(Region::Static)
}
}
Set1::One(r) => {
let lifetimes = generic_args.args.iter().filter_map(|arg| match arg {
GenericArg::Lifetime(lt) => Some(lt),
_ => None,
});
r.subst(lifetimes, map)
}
Set1::Many => None,
})
.collect()
},
);
debug!("visit_segment_args: object_lifetime_defaults={:?}", object_lifetime_defaults); debug!("visit_segment_args: object_lifetime_defaults={:?}", object_lifetime_defaults);

11
compiler/rustc_trait_selection/src/traits/specialize/mod.rs
View file

@ -349,7 +349,7 @@ fn report_negative_positive_conflict(
E0751, E0751,
"found both positive and negative implementation of trait `{}`{}:", "found both positive and negative implementation of trait `{}`{}:",
overlap.trait_desc, overlap.trait_desc,
overlap.self_desc.clone().map_or(String::new(), |ty| format!(" for type `{}`", ty)) overlap.self_desc.clone().map_or_else(|| String::new(), |ty| format!(" for type `{}`", ty))
); );
match tcx.span_of_impl(negative_impl_def_id) { match tcx.span_of_impl(negative_impl_def_id) {
@ -397,7 +397,10 @@ fn report_conflicting_impls(
let msg = format!( let msg = format!(
"conflicting implementations of trait `{}`{}:{}", "conflicting implementations of trait `{}`{}:{}",
overlap.trait_desc, overlap.trait_desc,
overlap.self_desc.clone().map_or(String::new(), |ty| { format!(" for type `{}`", ty) }), overlap
.self_desc
.clone()
.map_or_else(|| String::new(), |ty| { format!(" for type `{}`", ty) }),
match used_to_be_allowed { match used_to_be_allowed {
Some(FutureCompatOverlapErrorKind::Issue33140) => " (E0119)", Some(FutureCompatOverlapErrorKind::Issue33140) => " (E0119)",
_ => "", _ => "",
@ -415,7 +418,9 @@ fn report_conflicting_impls(
impl_span, impl_span,
format!( format!(
"conflicting implementation{}", "conflicting implementation{}",
overlap.self_desc.map_or(String::new(), |ty| format!(" for `{}`", ty)) overlap
.self_desc
.map_or_else(|| String::new(), |ty| format!(" for `{}`", ty))
), ),
); );
} }

2
compiler/rustc_typeck/src/check/method/probe.rs
View file

@ -1695,7 +1695,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
} else { } else {
self.fcx self.fcx
.associated_item(def_id, name, Namespace::ValueNS) .associated_item(def_id, name, Namespace::ValueNS)
.map_or(Vec::new(), |x| vec![x]) .map_or_else(|| Vec::new(), |x| vec![x])
} }
} else { } else {
self.tcx.associated_items(def_id).in_definition_order().copied().collect() self.tcx.associated_items(def_id).in_definition_order().copied().collect()

5
compiler/rustc_typeck/src/check/mod.rs
View file

@ -1062,7 +1062,10 @@ fn report_unexpected_variant_res(tcx: TyCtxt<'_>, res: Res, span: Span) {
E0533, E0533,
"expected unit struct, unit variant or constant, found {}{}", "expected unit struct, unit variant or constant, found {}{}",
res.descr(), res.descr(),
tcx.sess.source_map().span_to_snippet(span).map_or(String::new(), |s| format!(" `{}`", s)), tcx.sess
.source_map()
.span_to_snippet(span)
.map_or_else(|_| String::new(), |s| format!(" `{}`", s)),
) )
.emit(); .emit();
} }

2
compiler/rustc_typeck/src/check/pat.rs
View file

@ -879,7 +879,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let sm = tcx.sess.source_map(); let sm = tcx.sess.source_map();
let path_str = sm let path_str = sm
.span_to_snippet(sm.span_until_char(pat.span, '(')) .span_to_snippet(sm.span_until_char(pat.span, '('))
.map_or(String::new(), |s| format!(" `{}`", s.trim_end())); .map_or_else(|_| String::new(), |s| format!(" `{}`", s.trim_end()));
let msg = format!( let msg = format!(
"expected tuple struct or tuple variant, found {}{}", "expected tuple struct or tuple variant, found {}{}",
res.descr(), res.descr(),

2
compiler/rustc_typeck/src/collect.rs
View file

@ -2387,7 +2387,7 @@ fn compute_sig_of_foreign_fn_decl<'tcx>(
.sess .sess
.source_map() .source_map()
.span_to_snippet(ast_ty.span) .span_to_snippet(ast_ty.span)
.map_or(String::new(), |s| format!(" `{}`", s)); .map_or_else(|_| String::new(), |s| format!(" `{}`", s));
tcx.sess tcx.sess
.struct_span_err( .struct_span_err(
ast_ty.span, ast_ty.span,