Don't trigger unnecessary_box_returns when the size depends on generics

The lint fired on return types such as `Box<[T; N]>`, suggesting to return the
array unboxed. The size of such a type depends on generic parameters and cannot
be computed here: `approx_ty_size` falls back to `0` for an array with a const-
generic length or a generic element type, so the size check always passed.

Use the type's layout directly and only lint when it can actually be computed.
This keeps the existing behaviour for concrete types (and for generic types with
a known layout such as `Box<Vec<T>>`) while no longer suggesting to unbox a value
whose size is unknown and potentially large.

Author: mistaste

clippy_lints/src/unnecessary_box_returns.rs

@@ -1,10 +1,10 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::ty::approx_ty_size;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::{FnDecl, FnRetTy, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::layout::LayoutOf;
 use rustc_session::impl_lint_pass;
 use rustc_span::Symbol;
 
@@ -81,8 +81,13 @@ impl UnnecessaryBoxReturns {
 
         // It's sometimes useful to return Box<T> if T is unsized, so don't lint those.
         // Also, don't lint if we know that T is very large, in which case returning
-        // a Box<T> may be beneficial.
-        if boxed_ty.is_sized(cx.tcx, cx.typing_env()) && approx_ty_size(cx, boxed_ty) <= self.maximum_size {
+        // a Box<T> may be beneficial. When the size depends on generic parameters
+        // (e.g. `[T; N]`) it cannot be determined here, so don't lint that either, as
+        // the `Box` may be a deliberate choice to avoid copying a large value.
+        if boxed_ty.is_sized(cx.tcx, cx.typing_env())
+            && let Ok(layout) = cx.layout_of(boxed_ty)
+            && layout.size.bytes() <= self.maximum_size
+        {
             span_lint_and_then(
                 cx,
                 UNNECESSARY_BOX_RETURNS,

tests/ui/unnecessary_box_returns.rs

@@ -71,6 +71,16 @@ impl HasHuge {
     }
 }
 
+// don't lint (issue #17202): the size of `[T; N]` depends on a const generic parameter
+fn const_generic_array<const N: usize, T>(value: Box<[T; N]>) -> Box<[T; N]> {
+    value
+}
+
+// don't lint (issue #17202): the size of `[T; 10]` depends on the generic element type
+fn generic_element_array<T>(value: Box<[T; 10]>) -> Box<[T; 10]> {
+    value
+}
+
 fn main() {
     // don't lint: this is a closure
     let a = || -> Box<usize> { Box::new(5) };