[WIP] Also lint Box::new in unused_allocation

compiler/rustc_hir/src/lang_items.rs

@@ -276,6 +276,7 @@ language_item_table! {
     EhCatchTypeinfo,         sym::eh_catch_typeinfo,   eh_catch_typeinfo,          Target::Static,         GenericRequirement::None;
 
     OwnedBox,                sym::owned_box,           owned_box,                  Target::Struct,         GenericRequirement::Minimum(1);
+    OwnedBoxNew,             sym::owned_box_new,       owned_box_new,              Target::Method(MethodKind::Inherent), GenericRequirement::None;
 
     PhantomData,             sym::phantom_data,        phantom_data,               Target::Struct,         GenericRequirement::Exact(1);
 

compiler/rustc_lint/src/unused.rs

@@ -1149,18 +1149,17 @@ declare_lint! {
     /// ### Example
     ///
     /// ```rust
-    /// #![feature(box_syntax)]
     /// fn main() {
-    ///     let a = (box [1, 2, 3]).len();
+    ///     let a = (Box::new([1, 2, 3])).len();
     /// }
     /// ```
     ///
     /// {{produces}}
     ///
     /// ### Explanation
     ///
-    /// When a `box` expression is immediately coerced to a reference, then
-    /// the allocation is unnecessary, and a reference (using `&` or `&mut`)
+    /// When a `Box::new()` expression is immediately coerced to a reference,
+    /// then the allocation is unnecessary, and a reference (using `&` or `&mut`)
     /// should be used instead to avoid the allocation.
     pub(super) UNUSED_ALLOCATION,
     Warn,
@@ -1171,14 +1170,35 @@ declare_lint_pass!(UnusedAllocation => [UNUSED_ALLOCATION]);
 
 impl<'tcx> LateLintPass<'tcx> for UnusedAllocation {
     fn check_expr(&mut self, cx: &LateContext<'_>, e: &hir::Expr<'_>) {
-        match e.kind {
-            hir::ExprKind::Box(_) => {}
+        let span = match e.kind {
+            hir::ExprKind::Box(_) => {
+                // Ideally, we'd underline the `box` part of the expression here,
+                // but at this point we have lost the span of the `box` keyword.
+                // Constructing a span from the inner and the entire expression's
+                // span won't work in many cases, so we just return the entire
+                // span of the `box foo`.
+                e.span
+            }
+            hir::ExprKind::Call(ref callee, _) => {
+                // Look for Box::new(foo)
+                if let hir::ExprKind::Path(ref qpath) = callee.kind &&
+                    // `Res::Local` indicates a closure
+                    let Res::Def(_, def_id) = cx.qpath_res(qpath, callee.hir_id) &&
+                    let Some(owned_box_new_def_id) = cx.tcx.lang_items().owned_box_new() &&
+                    def_id == owned_box_new_def_id
+                {
+                    // We have a Box::new() call here
+                    callee.span
+                } else {
+                    return
+                }
+            }
             _ => return,
-        }
+        };
 
         for adj in cx.typeck_results().expr_adjustments(e) {
             if let adjustment::Adjust::Borrow(adjustment::AutoBorrow::Ref(_, m)) = adj.kind {
-                cx.struct_span_lint(UNUSED_ALLOCATION, e.span, |lint| {
+                cx.struct_span_lint(UNUSED_ALLOCATION, span, |lint| {
                     lint.build(match m {
                         adjustment::AutoBorrowMutability::Not => fluent::lint::unused_allocation,
                         adjustment::AutoBorrowMutability::Mut { .. } => {

compiler/rustc_span/src/symbol.rs

@@ -1037,6 +1037,7 @@ symbols! {
         out,
         overlapping_marker_traits,
         owned_box,
+        owned_box_new,
         packed,
         panic,
         panic_2015,

library/alloc/src/boxed.rs

@@ -207,6 +207,7 @@ impl<T> Box<T> {
     /// let five = Box::new(5);
     /// ```
     #[cfg(all(not(no_global_oom_handling)))]
+    #[lang = "owned_box_new"]
     #[inline(always)]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[must_use]

library/alloc/src/tests.rs

@@ -25,13 +25,13 @@ fn any_move() {
 
     match a.downcast::<i32>() {
         Ok(a) => {
-            assert!(a == Box::new(8));
+            assert!(*a == 8);
         }
         Err(..) => panic!(),
     }
     match b.downcast::<Test>() {
         Ok(a) => {
-            assert!(a == Box::new(Test));
+            assert!(*a == Test);
         }
         Err(..) => panic!(),
     }

src/test/ui/iterators/into-iter-on-arrays-lint.fixed

@@ -2,7 +2,7 @@
 // run-rustfix
 // rustfix-only-machine-applicable
 
-#[allow(unused_must_use)]
+#[allow(unused_must_use, unused_allocation)]
 fn main() {
     let small = [1, 2];
     let big = [0u8; 33];

src/test/ui/iterators/into-iter-on-arrays-lint.rs

@@ -2,7 +2,7 @@
 // run-rustfix
 // rustfix-only-machine-applicable
 
-#[allow(unused_must_use)]
+#[allow(unused_must_use, unused_allocation)]
 fn main() {
     let small = [1, 2];
     let big = [0u8; 33];

src/test/ui/lint/unused/unused-allocation.rs

@@ -0,0 +1,10 @@
+#![feature(box_syntax)]
+#![deny(unused_allocation)]
+
+fn main() {
+    let foo = (box [1, 2, 3]).len(); //~ ERROR: unnecessary allocation
+    let one = (box vec![1]).pop(); //~ ERROR: unnecessary allocation
+
+    let foo = Box::new([1, 2, 3]).len(); //~ ERROR: unnecessary allocation
+    let one = Box::new(vec![1]).pop(); //~ ERROR: unnecessary allocation
+}

src/test/ui/lint/unused/unused-allocation.stderr

@@ -0,0 +1,32 @@
+error: unnecessary allocation, use `&` instead
+  --> $DIR/unused-allocation.rs:5:15
+   |
+LL |     let foo = (box [1, 2, 3]).len();
+   |               ^^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/unused-allocation.rs:2:9
+   |
+LL | #![deny(unused_allocation)]
+   |         ^^^^^^^^^^^^^^^^^
+
+error: unnecessary allocation, use `&mut` instead
+  --> $DIR/unused-allocation.rs:6:15
+   |
+LL |     let one = (box vec![1]).pop();
+   |               ^^^^^^^^^^^^^
+
+error: unnecessary allocation, use `&` instead
+  --> $DIR/unused-allocation.rs:8:15
+   |
+LL |     let foo = Box::new([1, 2, 3]).len();
+   |               ^^^^^^^^
+
+error: unnecessary allocation, use `&mut` instead
+  --> $DIR/unused-allocation.rs:9:15
+   |
+LL |     let one = Box::new(vec![1]).pop();
+   |               ^^^^^^^^
+
+error: aborting due to 4 previous errors
+

src/test/ui/self/arbitrary_self_types_trait.rs

@@ -1,4 +1,5 @@
 // run-pass
+#![allow(unused_allocation)]
 
 use std::rc::Rc;
 

src/test/ui/structs-enums/align-struct.rs

@@ -1,5 +1,6 @@
 // run-pass
 #![allow(dead_code)]
+#![allow(unused_allocation)]
 
 use std::mem;