Auto merge of #8374 - Alexendoo:bless-revisions, r=camsteffen

[rust.git] / tests / ui / escape_analysis.rs

diff --git a/tests/ui/escape_analysis.rs b/tests/ui/escape_analysis.rs
index 1f2f46b03cd0e2598dca52f6d72022754741c48f..13e2b6c7a2e765a5a3d7269504368b6bc3bf8db0 100644 (file)
--- a/tests/ui/escape_analysis.rs
+++ b/tests/ui/escape_analysis.rs
@@ -1,24 +1,18 @@
-// Copyright 2014-2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-
 #![feature(box_syntax)]
-
-#![allow(warnings, clippy)]
-
-#![warn(boxed_local)]
+#![allow(
+    clippy::borrowed_box,
+    clippy::needless_pass_by_value,
+    clippy::unused_unit,
+    clippy::redundant_clone,
+    clippy::match_single_binding
+)]
+#![warn(clippy::boxed_local)]
 
 #[derive(Clone)]
 struct A;
 
 impl A {
-    fn foo(&self){}
+    fn foo(&self) {}
 }
 
 trait Z {
@@ -31,10 +25,9 @@ fn bar(&self) {
     }
 }
 
-fn main() {
-}
+fn main() {}
 
-fn ok_box_trait(boxed_trait: &Box<Z>) {
+fn ok_box_trait(boxed_trait: &Box<dyn Z>) {
     let boxed_local = boxed_trait;
     // done
 }
@@ -70,8 +63,7 @@ fn warn_pass() {
 }
 
 fn nowarn_return() -> Box<A> {
-    let fx = box A;
-    fx // moved out, "escapes"
+    box A // moved out, "escapes"
 }
 
 fn nowarn_move() {
@@ -88,11 +80,9 @@ fn nowarn_pass() {
     take_box(&bx); // fn needs &Box
 }
 
-
 fn take_box(x: &Box<A>) {}
 fn take_ref(x: &A) {}
 
-
 fn nowarn_ref_take() {
     // false positive, should actually warn
     let x = box A;
@@ -103,14 +93,15 @@ fn nowarn_ref_take() {
 fn nowarn_match() {
     let x = box A; // moved into a match
     match x {
-        y => drop(y)
+        y => drop(y),
     }
 }
 
 fn warn_match() {
     let x = box A;
-    match &x { // not moved
-        ref y => ()
+    match &x {
+        // not moved
+        y => (),
     }
 }
 
@@ -118,12 +109,12 @@ fn nowarn_large_array() {
     // should not warn, is large array
     // and should not be on stack
     let x = box [1; 10000];
-    match &x { // not moved
-        ref y => ()
+    match &x {
+        // not moved
+        y => (),
     }
 }
 
-
 /// ICE regression test
 pub trait Foo {
     type Item;
@@ -137,5 +128,77 @@ pub struct PeekableSeekable<I: Foo> {
     _peeked: I::Item,
 }
 
-pub fn new(_needs_name: Box<PeekableSeekable<&()>>) -> () {
+pub fn new(_needs_name: Box<PeekableSeekable<&()>>) -> () {}
+
+/// Regression for #916, #1123
+///
+/// This shouldn't warn for `boxed_local`as the implementation of a trait
+/// can't change much about the trait definition.
+trait BoxedAction {
+    fn do_sth(self: Box<Self>);
+}
+
+impl BoxedAction for u64 {
+    fn do_sth(self: Box<Self>) {
+        println!("{}", *self)
+    }
+}
+
+/// Regression for #1478
+///
+/// This shouldn't warn for `boxed_local`as self itself is a box type.
+trait MyTrait {
+    fn do_sth(self);
+}
+
+impl<T> MyTrait for Box<T> {
+    fn do_sth(self) {}
+}
+
+// Issue #3739 - capture in closures
+mod issue_3739 {
+    use super::A;
+
+    fn consume<T>(_: T) {}
+    fn borrow<T>(_: &T) {}
+
+    fn closure_consume(x: Box<A>) {
+        let _ = move || {
+            consume(x);
+        };
+    }
+
+    fn closure_borrow(x: Box<A>) {
+        let _ = || {
+            borrow(&x);
+        };
+    }
+}
+
+/// Issue #5542
+///
+/// This shouldn't warn for `boxed_local` as it is intended to called from non-Rust code.
+pub extern "C" fn do_not_warn_me(_c_pointer: Box<String>) -> () {}
+
+#[rustfmt::skip] // Forces rustfmt to not add ABI
+pub extern fn do_not_warn_me_no_abi(_c_pointer: Box<String>) -> () {}
+
+// Issue #4804 - default implementation in trait
+mod issue4804 {
+    trait DefaultTraitImplTest {
+        // don't warn on `self`
+        fn default_impl(self: Box<Self>) -> u32 {
+            5
+        }
+
+        // warn on `x: Box<u32>`
+        fn default_impl_x(self: Box<Self>, x: Box<u32>) -> u32 {
+            4
+        }
+    }
+
+    trait WarnTrait {
+        // warn on `x: Box<u32>`
+        fn foo(x: Box<u32>) {}
+    }
 }