Eliminate needless returns

compiler/rustc_ast/src/ast_traits.rs

@@ -153,7 +153,7 @@ impl HasTokens for StmtKind {
             StmtKind::Let(local) => local.tokens.as_ref(),
             StmtKind::Item(item) => item.tokens(),
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.tokens(),
-            StmtKind::Empty => return None,
+            StmtKind::Empty => None,
             StmtKind::MacCall(mac) => mac.tokens.as_ref(),
         }
     }
@@ -162,7 +162,7 @@ impl HasTokens for StmtKind {
             StmtKind::Let(local) => Some(&mut local.tokens),
             StmtKind::Item(item) => item.tokens_mut(),
             StmtKind::Expr(expr) | StmtKind::Semi(expr) => expr.tokens_mut(),
-            StmtKind::Empty => return None,
+            StmtKind::Empty => None,
             StmtKind::MacCall(mac) => Some(&mut mac.tokens),
         }
     }

compiler/rustc_attr/src/builtin.rs

@@ -1240,5 +1240,5 @@ pub fn parse_confusables(attr: &Attribute) -> Option<Vec<Symbol>> {
         candidates.push(meta_lit.symbol);
     }
 
-    return Some(candidates);
+    Some(candidates)
 }

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -3665,11 +3665,13 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     }
                 }
             }
+
             if any_match {
                 reinits.push(location);
-                return true;
+                true
+            } else {
+                false
             }
-            return false;
         };
 
         while let Some(location) = stack.pop() {

compiler/rustc_borrowck/src/lib.rs

@@ -1904,7 +1904,6 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                     (place_span.0, place_span.0, place_span.1),
                     uninit_mpi,
                 );
-                return; // don't bother finding other problems.
             }
         }
     }

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -214,7 +214,7 @@ impl<'me, 'bccx, 'tcx> NllTypeRelating<'me, 'bccx, 'tcx> {
         let delegate = FnMutDelegate {
             regions: &mut |br: ty::BoundRegion| {
                 if let Some(ex_reg_var) = reg_map.get(&br) {
-                    return *ex_reg_var;
+                    *ex_reg_var
                 } else {
                     let ex_reg_var = self.next_existential_region_var(true, br.kind.get_name());
                     debug!(?ex_reg_var);

compiler/rustc_codegen_llvm/src/llvm_util.rs

@@ -290,7 +290,7 @@ pub(crate) fn check_tied_features(
             }
         }
     }
-    return None;
+    None
 }
 
 /// Used to generate cfg variables and apply features

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -438,7 +438,7 @@ fn link_rlib<'a>(
         ab.add_file(&lib)
     }
 
-    return Ok(ab);
+    Ok(ab)
 }
 
 /// Extract all symbols defined in raw-dylib libraries, collated by library name.
@@ -1319,15 +1319,15 @@ fn link_sanitizer_runtime(
     fn find_sanitizer_runtime(sess: &Session, filename: &str) -> PathBuf {
         let path = sess.target_tlib_path.dir.join(filename);
         if path.exists() {
-            return sess.target_tlib_path.dir.clone();
+            sess.target_tlib_path.dir.clone()
         } else {
             let default_sysroot =
                 filesearch::get_or_default_sysroot().expect("Failed finding sysroot");
             let default_tlib = filesearch::make_target_lib_path(
                 &default_sysroot,
                 sess.opts.target_triple.triple(),
             );
-            return default_tlib;
+            default_tlib
         }
     }
 

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -1484,7 +1484,6 @@ impl<'a> Linker for L4Bender<'a> {
     fn export_symbols(&mut self, _: &Path, _: CrateType, _: &[String]) {
         // ToDo, not implemented, copy from GCC
         self.sess.dcx().emit_warn(errors::L4BenderExportingSymbolsUnimplemented);
-        return;
     }
 
     fn subsystem(&mut self, subsystem: &str) {

compiler/rustc_codegen_ssa/src/back/metadata.rs

@@ -171,10 +171,10 @@ pub(super) fn get_metadata_xcoff<'a>(path: &Path, data: &'a [u8]) -> Result<&'a
                 "Metadata at offset {offset} with size {len} is beyond .info section"
             ));
         }
-        return Ok(&info_data[offset..(offset + len)]);
+        Ok(&info_data[offset..(offset + len)])
     } else {
-        return Err(format!("Unable to find symbol {AIX_METADATA_SYMBOL_NAME}"));
-    };
+        Err(format!("Unable to find symbol {AIX_METADATA_SYMBOL_NAME}"))
+    }
 }
 
 pub(crate) fn create_object_file(sess: &Session) -> Option<write::Object<'static>> {
@@ -413,7 +413,7 @@ fn macho_object_build_version_for_target(target: &Target) -> object::write::Mach
 
 /// Is Apple's CPU subtype `arm64e`s
 fn macho_is_arm64e(target: &Target) -> bool {
-    return target.llvm_target.starts_with("arm64e");
+    target.llvm_target.starts_with("arm64e")
 }
 
 pub enum MetadataPosition {

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -1006,11 +1006,7 @@ fn place_as_reborrow<'tcx>(
                 // reborrow, even if the check above were to disappear.
                 let inner_ty = place_base.ty(body, tcx).ty;
 
-                if let ty::Ref(..) = inner_ty.kind() {
-                    return Some(place_base);
-                } else {
-                    return None;
-                }
+                if let ty::Ref(..) = inner_ty.kind() { Some(place_base) } else { None }
             }
         }
         _ => None,

compiler/rustc_const_eval/src/interpret/call.rs

@@ -235,13 +235,13 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         if self.layout_compat(caller_abi.layout, callee_abi.layout)? {
             // Ensure that our checks imply actual ABI compatibility for this concrete call.
             assert!(caller_abi.eq_abi(callee_abi));
-            return Ok(true);
+            Ok(true)
         } else {
             trace!(
                 "check_argument_compat: incompatible ABIs:\ncaller: {:?}\ncallee: {:?}",
                 caller_abi, callee_abi
             );
-            return Ok(false);
+            Ok(false)
         }
     }
 

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -861,7 +861,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             }
             Some(GlobalAlloc::VTable(..)) => {
                 // No data to be accessed here. But vtables are pointer-aligned.
-                return (Size::ZERO, self.tcx.data_layout.pointer_align.abi, AllocKind::VTable);
+                (Size::ZERO, self.tcx.data_layout.pointer_align.abi, AllocKind::VTable)
             }
             // The rest must be dead.
             None => {

compiler/rustc_expand/src/mbe/transcribe.rs

@@ -775,7 +775,7 @@ fn extract_symbol_from_pnr<'a>(
             if let IdentIsRaw::Yes = is_raw {
                 return Err(dcx.struct_span_err(span_err, RAW_IDENT_ERR));
             }
-            return Ok(nt_ident.name);
+            Ok(nt_ident.name)
         }
         ParseNtResult::Tt(TokenTree::Token(
             Token { kind: TokenKind::Ident(symbol, is_raw), .. },
@@ -784,23 +784,21 @@ fn extract_symbol_from_pnr<'a>(
             if let IdentIsRaw::Yes = is_raw {
                 return Err(dcx.struct_span_err(span_err, RAW_IDENT_ERR));
             }
-            return Ok(*symbol);
+            Ok(*symbol)
         }
         ParseNtResult::Tt(TokenTree::Token(
             Token {
                 kind: TokenKind::Literal(Lit { kind: LitKind::Str, symbol, suffix: None }),
                 ..
             },
             _,
-        )) => {
-            return Ok(*symbol);
-        }
+        )) => Ok(*symbol),
         ParseNtResult::Nt(nt)
             if let Nonterminal::NtLiteral(expr) = &**nt
                 && let ExprKind::Lit(Lit { kind: LitKind::Str, symbol, suffix: None }) =
                     &expr.kind =>
         {
-            return Ok(*symbol);
+            Ok(*symbol)
         }
         _ => Err(dcx
             .struct_err(

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1118,7 +1118,6 @@ fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) {
                         primitive scalar (integer/float/pointer) type"
                 )
                 .emit();
-                return;
             }
         }
     }

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -1038,7 +1038,7 @@ fn report_trait_method_mismatch<'tcx>(
         false,
     );
 
-    return diag.emit();
+    diag.emit()
 }
 
 fn check_region_bounds_on_impl_item<'tcx>(

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -271,10 +271,10 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
                             ty: ty_a,
                         }));
 
-                        return false;
+                        false
+                    } else {
+                        true
                     }
-
-                    return true;
                 })
                 .collect::<Vec<_>>();
 

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -122,7 +122,7 @@ fn anon_const_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx> {
                 (ty, None)
             };
             tcx.dcx().emit_err(TypeofReservedKeywordUsed { span, ty, opt_sugg });
-            return ty;
+            ty
         }
 
         _ => Ty::new_error_with_message(

compiler/rustc_hir_analysis/src/errors/wrong_number_of_generic_args.rs

@@ -807,7 +807,7 @@ impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
                         num_assoc_fn_excess_args,
                         num_trait_generics_except_self,
                     ),
-                _ => return,
+                _ => {}
             }
         }
     }

compiler/rustc_hir_typeck/src/closure.rs

@@ -605,7 +605,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             Abi::Rust,
         ));
 
-        return Some(ExpectedSig { cause_span, sig });
+        Some(ExpectedSig { cause_span, sig })
     }
 
     fn sig_of_closure(

compiler/rustc_hir_typeck/src/demand.rs

@@ -1042,7 +1042,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 return true;
             }
         }
-        return false;
+        false
     }
 
     fn explain_self_literal(
@@ -1182,7 +1182,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 };
                 maybe_emit_help(def_id, method.ident, args, CallableKind::Method)
             }
-            _ => return,
+            _ => {}
         }
     }
 }

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -899,7 +899,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     match kind {
                         hir::ClosureKind::CoroutineClosure(_) => {
                             // FIXME(async_closures): Implement this.
-                            return None;
+                            None
                         }
                         hir::ClosureKind::Closure => Some((def_id, fn_decl, true)),
                         hir::ClosureKind::Coroutine(hir::CoroutineKind::Desugared(

compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs

@@ -305,9 +305,10 @@ impl<'tcx> ArgMatrix<'tcx> {
             // Map unwrap to remove the first layer of Some
             let final_permutation: Vec<Option<usize>> =
                 permutation.into_iter().map(|x| x.unwrap()).collect();
-            return Some(Issue::Permutation(final_permutation));
+            Some(Issue::Permutation(final_permutation))
+        } else {
+            None
         }
-        return None;
     }
 
     // Obviously, detecting exact user intention is impossible, so the goal here is to
@@ -410,6 +411,6 @@ impl<'tcx> ArgMatrix<'tcx> {
         // sort errors with same type by the order they appear in the source
         // so that suggestion will be handled properly, see #112507
         errors.sort();
-        return (errors, matched_inputs);
+        (errors, matched_inputs)
     }
 }

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -697,7 +697,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         assoc.name,
                     ),
                 );
-                return;
             }
         };
         // A "softer" version of the `demand_compatible`, which checks types without persisting them,

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -2028,7 +2028,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let span = expr.span.find_oldest_ancestor_in_same_ctxt();
         err.span_suggestion_verbose(span.shrink_to_hi(), msg, sugg, Applicability::HasPlaceholders);
-        return true;
+        true
     }
 
     pub(crate) fn suggest_coercing_result_via_try_operator(

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -511,9 +511,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         .is_ok()
                 {
                     self.sugg_let = Some(binding);
-                    return true;
+                    true
+                } else {
+                    false
                 }
-                return false;
             }
         }
 

compiler/rustc_infer/src/infer/canonical/canonicalizer.rs

@@ -380,7 +380,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
             ty::Infer(ty::IntVar(vid)) => {
                 let nt = self.infcx.unwrap().opportunistic_resolve_int_var(vid);
                 if nt != t {
-                    return self.fold_ty(nt);
+                    self.fold_ty(nt)
                 } else {
                     self.canonicalize_ty_var(
                         CanonicalVarInfo { kind: CanonicalVarKind::Ty(CanonicalTyVarKind::Int) },
@@ -391,7 +391,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
             ty::Infer(ty::FloatVar(vid)) => {
                 let nt = self.infcx.unwrap().opportunistic_resolve_float_var(vid);
                 if nt != t {
-                    return self.fold_ty(nt);
+                    self.fold_ty(nt)
                 } else {
                     self.canonicalize_ty_var(
                         CanonicalVarInfo { kind: CanonicalVarKind::Ty(CanonicalTyVarKind::Float) },

compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs

@@ -371,7 +371,7 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
     fn sub_region_values(&self, a: VarValue<'tcx>, b: VarValue<'tcx>) -> bool {
         match (a, b) {
             // Error region is `'static`
-            (VarValue::ErrorValue, _) | (_, VarValue::ErrorValue) => return true,
+            (VarValue::ErrorValue, _) | (_, VarValue::ErrorValue) => true,
             (VarValue::Empty(a_ui), VarValue::Empty(b_ui)) => {
                 // Empty regions are ordered according to the universe
                 // they are associated with.
@@ -439,7 +439,7 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
                         // If this empty region is from a universe that can
                         // name the placeholder, then the placeholder is
                         // larger; otherwise, the only ancestor is `'static`.
-                        return a_ui.can_name(placeholder.universe);
+                        a_ui.can_name(placeholder.universe)
                     }
                 }
             }

compiler/rustc_infer/src/infer/mod.rs

@@ -1481,7 +1481,7 @@ impl<'tcx> InferCtxt<'tcx> {
         // This hoists the borrow/release out of the loop body.
         let inner = self.inner.try_borrow();
 
-        return move |infer_var: TyOrConstInferVar| match (infer_var, &inner) {
+        move |infer_var: TyOrConstInferVar| match (infer_var, &inner) {
             (TyOrConstInferVar::Ty(ty_var), Ok(inner)) => {
                 use self::type_variable::TypeVariableValue;
 
@@ -1491,7 +1491,7 @@ impl<'tcx> InferCtxt<'tcx> {
                 )
             }
             _ => false,
-        };
+        }
     }
 
     /// `ty_or_const_infer_var_changed` is equivalent to one of these two:

compiler/rustc_lint/src/drop_forget_useless.rs

@@ -219,7 +219,7 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetUseless {
                         },
                     );
                 }
-                _ => return,
+                _ => {}
             };
         }
     }