Emit a lint for small functions without #[inline]

Author: saethlin

compiler/rustc_builtin_macros/src/deriving/debug.rs

@@ -9,6 +9,9 @@ use rustc_span::symbol::{sym, Ident, Symbol};
 use rustc_span::Span;
 use thin_vec::{thin_vec, ThinVec};
 
+use rustc_ast::ItemKind;
+use rustc_ast::VariantData;
+
 pub fn expand_deriving_debug(
     cx: &mut ExtCtxt<'_>,
     span: Span,
@@ -20,6 +23,21 @@ pub fn expand_deriving_debug(
     // &mut ::std::fmt::Formatter
     let fmtr = Ref(Box::new(Path(path_std!(fmt::Formatter))), ast::Mutability::Mut);
 
+    let mut attributes = ThinVec::new();
+    if let Annotatable::Item(item) = item {
+        match &item.kind {
+            ItemKind::Struct(VariantData::Unit(_), _) => {
+                attributes = thin_vec![cx.attr_word(sym::inline, span)];
+            }
+            ItemKind::Enum(EnumDef { variants }, _) => {
+                if variants.iter().all(|v| matches!(v.data, VariantData::Unit(_))) {
+                    attributes = thin_vec![cx.attr_word(sym::inline, span)];
+                }
+            }
+            _ => {}
+        }
+    }
+
     let trait_def = TraitDef {
         span,
         path: path_std!(fmt::Debug),
@@ -33,7 +51,7 @@ pub fn expand_deriving_debug(
             explicit_self: true,
             nonself_args: vec![(fmtr, sym::f)],
             ret_ty: Path(path_std!(fmt::Result)),
-            attributes: ast::AttrVec::new(),
+            attributes,
             fieldless_variants_strategy:
                 FieldlessVariantsStrategy::SpecializeIfAllVariantsFieldless,
             combine_substructure: combine_substructure(Box::new(|a, b, c| {

compiler/rustc_mir_transform/messages.ftl

@@ -42,6 +42,9 @@ mir_transform_requires_unsafe = {$details} is unsafe and requires unsafe {$op_in
     }
     .not_inherited = items do not inherit unsafety from separate enclosing items
 
+mir_transform_small_fn_without_inline = this function looks small ({$statements}) but doesn't have #[inline], consider adding it
+    .suggestion = add the inline attribute
+
 mir_transform_target_feature_call_label = call to function with `#[target_feature]`
 mir_transform_target_feature_call_note = can only be called if the required target features are available
 

compiler/rustc_mir_transform/src/cross_crate_inline.rs

@@ -55,14 +55,39 @@ fn cross_crate_inlinable(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
     }
 
     let mir = tcx.optimized_mir(def_id);
-    let mut checker =
-        CostChecker { tcx, callee_body: mir, calls: 0, statements: 0, landing_pads: 0, resumes: 0 };
+    let mut checker = CostChecker {
+        tcx,
+        callee_body: mir,
+        calls: 0,
+        statements: 0,
+        landing_pads: 0,
+        resumes: 0,
+        branches: 0,
+        asserts: 0,
+    };
     checker.visit_body(mir);
-    checker.calls == 0
+    let is_leaf = checker.calls == 0
         && checker.resumes == 0
         && checker.landing_pads == 0
         && checker.statements
-            <= tcx.sess.opts.unstable_opts.cross_crate_inline_threshold.unwrap_or(100)
+            <= tcx.sess.opts.unstable_opts.cross_crate_inline_threshold.unwrap_or(100);
+
+    let is_trivial_wrapper = checker.calls == 1
+        && checker.resumes == 0
+        && checker.landing_pads == 0
+        && mir.basic_blocks.len() == 2;
+
+    if is_trivial_wrapper {
+        let span = tcx.def_span(def_id);
+        if !span.from_expansion() {
+            tcx.sess.emit_warning(crate::errors::SuggestAddingInline {
+                place: span,
+                suggest_inline: span.with_hi(span.lo()),
+                statements: checker.statements,
+            });
+        }
+    }
+    is_leaf
 }
 
 struct CostChecker<'b, 'tcx> {
@@ -72,6 +97,8 @@ struct CostChecker<'b, 'tcx> {
     statements: usize,
     landing_pads: usize,
     resumes: usize,
+    branches: usize,
+    asserts: usize,
 }
 
 impl<'tcx> Visitor<'tcx> for CostChecker<'_, 'tcx> {
@@ -105,7 +132,7 @@ impl<'tcx> Visitor<'tcx> for CostChecker<'_, 'tcx> {
                 }
             }
             TerminatorKind::Assert { unwind, .. } => {
-                self.calls += 1;
+                self.asserts += 1;
                 if let UnwindAction::Cleanup(_) = unwind {
                     self.landing_pads += 1;
                 }
@@ -117,6 +144,10 @@ impl<'tcx> Visitor<'tcx> for CostChecker<'_, 'tcx> {
                     self.landing_pads += 1;
                 }
             }
+            TerminatorKind::SwitchInt { .. } => {
+                self.statements += 1;
+                self.branches += 1;
+            }
             TerminatorKind::Return => {}
             _ => self.statements += 1,
         }

compiler/rustc_mir_transform/src/errors.rs

@@ -278,3 +278,13 @@ pub(crate) struct MustNotSuspendReason {
     pub span: Span,
     pub reason: String,
 }
+
+#[derive(Diagnostic)]
+#[diag(mir_transform_small_fn_without_inline)]
+pub struct SuggestAddingInline {
+    #[primary_span]
+    pub place: Span,
+    #[suggestion(code = "#[inline]\n", applicability = "machine-applicable")]
+    pub suggest_inline: Span,
+    pub statements: usize,
+}

library/core/src/alloc/layout.rs

@@ -482,6 +482,7 @@ impl Error for LayoutError {}
 // (we need this for downstream impl of trait Error)
 #[stable(feature = "alloc_layout", since = "1.28.0")]
 impl fmt::Display for LayoutError {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str("invalid parameters to Layout::from_size_align")
     }

library/core/src/alloc/mod.rs

@@ -43,6 +43,7 @@ impl Error for AllocError {}
 // (we need this for downstream impl of trait Error)
 #[unstable(feature = "allocator_api", issue = "32838")]
 impl fmt::Display for AllocError {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str("memory allocation failed")
     }

library/core/src/any.rs

@@ -630,6 +630,7 @@ impl TypeId {
     #[must_use]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_const_unstable(feature = "const_type_id", issue = "77125")]
+    #[inline]
     pub const fn of<T: ?Sized + 'static>() -> TypeId {
         let t: u128 = intrinsics::type_id::<T>();
         TypeId { t }

library/core/src/ascii.rs

@@ -90,6 +90,7 @@ pub struct EscapeDefault(escape::EscapeIterInner<4>);
 /// assert_eq!(b'd', escaped.next().unwrap());
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
+#[inline]
 pub fn escape_default(c: u8) -> EscapeDefault {
     let mut data = [Char::Null; 4];
     let range = escape::escape_ascii_into(&mut data, c);

library/core/src/ascii/ascii_char.rs

@@ -559,6 +559,7 @@ impl [AsciiChar] {
 
 #[unstable(feature = "ascii_char", issue = "110998")]
 impl fmt::Display for AsciiChar {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         <str as fmt::Display>::fmt(self.as_str(), f)
     }

library/core/src/cell.rs

@@ -722,6 +722,7 @@ impl Debug for BorrowError {
 
 #[stable(feature = "try_borrow", since = "1.13.0")]
 impl Display for BorrowError {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         Display::fmt("already mutably borrowed", f)
     }
@@ -749,6 +750,7 @@ impl Debug for BorrowMutError {
 
 #[stable(feature = "try_borrow", since = "1.13.0")]
 impl Display for BorrowMutError {
+    #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         Display::fmt("already borrowed", f)
     }