Use if-let guards in the codebase

Author: LeSeulArtichaut

compiler/rustc_ast/src/attr/mod.rs

@@ -564,11 +564,11 @@ impl NestedMetaItem {
  I: Iterator<Item = TokenTree>,
  {
  match tokens.peek() {
- Some(TokenTree::Token(token)) => {
- if let Ok(lit) = Lit::from_token(token) {
-  tokens.next();
-  return Some(NestedMetaItem::Literal(lit));
- }
+ Some(TokenTree::Token(token))
+ if let Ok(lit) = Lit::from_token(token) =>
+ {
+ tokens.next();
+ return Some(NestedMetaItem::Literal(lit));
  }
  Some(TokenTree::Delimited(_, token::NoDelim, inner_tokens)) => {
  let inner_tokens = inner_tokens.clone();

compiler/rustc_ast/src/lib.rs

@@ -11,10 +11,12 @@
 #![feature(box_patterns)]
 #![cfg_attr(bootstrap, feature(const_fn_transmute))]
 #![feature(crate_visibility_modifier)]
+#![feature(if_let_guard)]
 #![feature(iter_zip)]
 #![feature(label_break_value)]
 #![feature(nll)]
 #![feature(min_specialization)]
+#![cfg_attr(bootstrap, allow(incomplete_features))] // if_let_guard
 #![recursion_limit = "256"]
 
 #[macro_use]

compiler/rustc_errors/src/lib.rs

@@ -5,9 +5,11 @@
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![feature(crate_visibility_modifier)]
 #![feature(backtrace)]
+#![feature(if_let_guard)]
 #![feature(format_args_capture)]
 #![feature(iter_zip)]
 #![feature(nll)]
+#![cfg_attr(bootstrap, allow(incomplete_features))] // if_let_guard
 
 #[macro_use]
 extern crate rustc_macros;
@@ -1027,15 +1029,15 @@ impl HandlerInner {
  let mut error_codes = self
  .emitted_diagnostic_codes
  .iter()
- .filter_map(|x| match &x {
- DiagnosticId::Error(s) => {
- if let Ok(Some(_explanation)) = registry.try_find_description(s) {
- Some(s.clone())
- } else {
- None
- }
+ .filter_map(|x| {
+ match &x {
+ DiagnosticId::Error(s)
+ if let Ok(Some(_explanation)) = registry.try_find_description(s) =>
+ {
+ Some(s.clone())
  }
  _ => None,
+ }
  })
  .collect::<Vec<_>>();
  if !error_codes.is_empty() {

compiler/rustc_expand/src/config.rs

@@ -305,15 +305,14 @@ impl<'a> StripUnconfigured<'a> {
  Some((AttrAnnotatedTokenTree::Delimited(sp, delim, inner), *spacing))
  .into_iter()
  }
+ AttrAnnotatedTokenTree::Token(ref token) if let TokenKind::Interpolated(ref nt) = token.kind => {
+ panic!(
+ "Nonterminal should have been flattened at {:?}: {:?}",
+ token.span, nt
+ );
+ }
  AttrAnnotatedTokenTree::Token(token) => {
- if let TokenKind::Interpolated(nt) = token.kind {
- panic!(
- "Nonterminal should have been flattened at {:?}: {:?}",
- token.span, nt
- );
- } else {
- Some((AttrAnnotatedTokenTree::Token(token), *spacing)).into_iter()
- }
+ Some((AttrAnnotatedTokenTree::Token(token), *spacing)).into_iter()
  }
  })
  .collect();

compiler/rustc_expand/src/lib.rs

@@ -2,11 +2,13 @@
 #![feature(decl_macro)]
 #![feature(destructuring_assignment)]
 #![feature(format_args_capture)]
+#![feature(if_let_guard)]
 #![feature(iter_zip)]
 #![feature(proc_macro_diagnostic)]
 #![feature(proc_macro_internals)]
 #![feature(proc_macro_span)]
 #![feature(try_blocks)]
+#![cfg_attr(bootstrap, allow(incomplete_features))] // if_let_guard
 
 #[macro_use]
 extern crate rustc_macros;

compiler/rustc_expand/src/module.rs

@@ -86,13 +86,12 @@ crate fn mod_dir_path(
  inline: Inline,
 ) -> (PathBuf, DirOwnership) {
  match inline {
+ Inline::Yes if let Some(file_path) = mod_file_path_from_attr(sess, attrs, &module.dir_path) => {
+ // For inline modules file path from `#[path]` is actually the directory path
+ // for historical reasons, so we don't pop the last segment here.
+ (file_path, DirOwnership::Owned { relative: None })
+ }
  Inline::Yes => {
- if let Some(file_path) = mod_file_path_from_attr(sess, attrs, &module.dir_path) {
- // For inline modules file path from `#[path]` is actually the directory path
- // for historical reasons, so we don't pop the last segment here.
- return (file_path, DirOwnership::Owned { relative: None });
- }
-
  // We have to push on the current module name in the case of relative
  // paths in order to ensure that any additional module paths from inline
  // `mod x { ... }` come after the relative extension.

compiler/rustc_expand/src/proc_macro_server.rs

@@ -178,18 +178,19 @@ impl FromInternal<(TreeAndSpacing, &'_ mut Vec<Self>, &mut Rustc<'_>)>
  tt!(Punct::new('#', false))
  }
 
+ Interpolated(nt)
+ if let Some((name, is_raw)) = ident_name_compatibility_hack(&nt, span, rustc) =>
+ {
+ TokenTree::Ident(Ident::new(rustc.sess, name.name, is_raw, name.span))
+ }
  Interpolated(nt) => {
- if let Some((name, is_raw)) = ident_name_compatibility_hack(&nt, span, rustc) {
- TokenTree::Ident(Ident::new(rustc.sess, name.name, is_raw, name.span))
- } else {
- let stream = nt_to_tokenstream(&nt, rustc.sess, CanSynthesizeMissingTokens::No);
- TokenTree::Group(Group {
- delimiter: Delimiter::None,
- stream,
- span: DelimSpan::from_single(span),
- flatten: crate::base::pretty_printing_compatibility_hack(&nt, rustc.sess),
- })
- }
+ let stream = nt_to_tokenstream(&nt, rustc.sess, CanSynthesizeMissingTokens::No);
+ TokenTree::Group(Group {
+ delimiter: Delimiter::None,
+ stream,
+ span: DelimSpan::from_single(span),
+ flatten: crate::base::pretty_printing_compatibility_hack(&nt, rustc.sess),
+ })
  }
 
  OpenDelim(..) | CloseDelim(..) => unreachable!(),

compiler/rustc_middle/src/lib.rs

@@ -31,6 +31,7 @@
 #![feature(box_patterns)]
 #![feature(core_intrinsics)]
 #![feature(discriminant_kind)]
+#![feature(if_let_guard)]
 #![feature(never_type)]
 #![feature(extern_types)]
 #![feature(new_uninit)]
@@ -52,6 +53,7 @@
 #![feature(try_reserve)]
 #![feature(try_reserve_kind)]
 #![feature(nonzero_ops)]
+#![cfg_attr(bootstrap, allow(incomplete_features))] // if_let_guard
 #![recursion_limit = "512"]
 
 #[macro_use]

compiler/rustc_middle/src/ty/error.rs

@@ -279,13 +279,10 @@ impl<'tcx> ty::TyS<'tcx> {
  }
  ty::FnDef(..) => "fn item".into(),
  ty::FnPtr(_) => "fn pointer".into(),
- ty::Dynamic(ref inner, ..) => {
- if let Some(principal) = inner.principal() {
- format!("trait object `dyn {}`", tcx.def_path_str(principal.def_id())).into()
- } else {
- "trait object".into()
- }
+ ty::Dynamic(ref inner, ..) if let Some(principal) = inner.principal() => {
+ format!("trait object `dyn {}`", tcx.def_path_str(principal.def_id())).into()
  }
+ ty::Dynamic(..) => "trait object".into(),
  ty::Closure(..) => "closure".into(),
  ty::Generator(def_id, ..) => tcx.generator_kind(def_id).unwrap().descr().into(),
  ty::GeneratorWitness(..) => "generator witness".into(),
@@ -365,20 +362,19 @@ impl<'tcx> TyCtxt<'tcx> {
  // Issue #63167
  db.note("distinct uses of `impl Trait` result in different opaque types");
  }
- (ty::Float(_), ty::Infer(ty::IntVar(_))) => {
+ (ty::Float(_), ty::Infer(ty::IntVar(_)))
  if let Ok(
  // Issue #53280
  snippet,
- ) = self.sess.source_map().span_to_snippet(sp)
- {
- if snippet.chars().all(|c| c.is_digit(10) || c == '-' || c == '_') {
- db.span_suggestion(
- sp,
- "use a float literal",
- format!("{}.0", snippet),
- MachineApplicable,
- );
- }
+ ) = self.sess.source_map().span_to_snippet(sp) =>
+ {
+ if snippet.chars().all(|c| c.is_digit(10) || c == '-' || c == '_') {
+ db.span_suggestion(
+ sp,
+ "use a float literal",
+ format!("{}.0", snippet),
+ MachineApplicable,
+ );
  }
  }
  (ty::Param(expected), ty::Param(found)) => {

compiler/rustc_middle/src/ty/util.rs

@@ -225,14 +225,12 @@ impl<'tcx> TyCtxt<'tcx> {
  }
  }
 
- ty::Tuple(tys) => {
- if let Some((&last_ty, _)) = tys.split_last() {
- ty = last_ty.expect_ty();
- } else {
- break;
- }
+ ty::Tuple(tys) if let Some((&last_ty, _)) = tys.split_last() => {
+ ty = last_ty.expect_ty();
  }
 
+ ty::Tuple(_) => break,
+
  ty::Projection(_) | ty::Opaque(..) => {
  let normalized = normalize(ty);
  if ty == normalized {