mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Port of pcwalton removal of #[unsafe_destructor] check.

Browse Source 
Earlier commits impose rules on lifetimes that make generic
destructors safe; thus we no longer need the `#[unsafe_destructor]`
attribute nor its associated check.

----

So remove the check for the unsafe_destructor attribute.

And remove outdated compile-fail tests from when lifetime-parameteric
dtors were disallowed/unsafe.

In addition, when one uses the attribute without the associated
feature, report that the attribute is deprecated.

However, I do not think this is a breaking-change, because the
attribute and feature are still currently accepted by the compiler.
(After the next snapshot that has this commit, we can remove the
feature itself and the attribute as well.)

----

I consider this to:

Fix #22196

(techincally there is still the post snapshot work of removing the
last remants of the feature and the attribute, but the ticket can
still be closed in my opinion).
This commit is contained in:
Felix S. Klock II 2014-10-27 12:57:14 +01:00
parent 01f2c67c96
commit 64c48f390c
8 changed files with 12 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
src/librustc_typeck/check/wf.rs
View File

@ -23,7 +23,6 @@ use util::ppaux::{Repr, UserString};
use std::collections::HashSet;
use syntax::ast;
use syntax::ast_util::local_def;
use syntax::attr;
use syntax::codemap::Span;
use syntax::parse::token::{self, special_idents};
use syntax::visit;
@ -250,22 +249,6 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> {
&fcx.inh.param_env.free_substs,
&trait_ref);
// There are special rules that apply to drop.
if
fcx.tcx().lang_items.drop_trait() == Some(trait_ref.def_id) &&
!attr::contains_name(&item.attrs, "unsafe_destructor")
{
match self_ty.sty {
ty::ty_struct(def_id, _) |
ty::ty_enum(def_id, _) => {
check_struct_safe_for_destructor(fcx, item.span, def_id);
}
_ => {
// Coherence already reports an error in this case.
}
}
}
if fcx.tcx().lang_items.copy_trait() == Some(trait_ref.def_id) {
// This is checked in coherence.
return
@ -761,22 +744,3 @@ fn filter_to_trait_obligations<'tcx>(bounds: ty::InstantiatedPredicates<'tcx>)
}
result
}
///////////////////////////////////////////////////////////////////////////
// Special drop trait checking
fn check_struct_safe_for_destructor<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
span: Span,
struct_did: ast::DefId) {
let struct_tpt = ty::lookup_item_type(fcx.tcx(), struct_did);
if struct_tpt.generics.has_type_params(subst::TypeSpace)
|| struct_tpt.generics.has_region_params(subst::TypeSpace)
{
span_err!(fcx.tcx().sess, span, E0141,
"cannot implement a destructor on a structure \
with type parameters");
span_note!(fcx.tcx().sess, span,
"use \"#[unsafe_destructor]\" on the implementation \
to force the compiler to allow this");
}
}

18
src/libsyntax/feature_gate.rs
View File

@ -58,7 +58,6 @@ const KNOWN_FEATURES: &'static [(&'static str, &'static str, Status)] = &[
("log_syntax", "1.0.0", Active),
("trace_macros", "1.0.0", Active),
("concat_idents", "1.0.0", Active),
("unsafe_destructor", "1.0.0", Active),
("intrinsics", "1.0.0", Active),
("lang_items", "1.0.0", Active),
@ -92,6 +91,10 @@ const KNOWN_FEATURES: &'static [(&'static str, &'static str, Status)] = &[
("start", "1.0.0", Active),
("main", "1.0.0", Active),
// Deprecate after snapshot
// SNAP a923278
("unsafe_destructor", "1.0.0", Active),
// A temporary feature gate used to enable parser extensions needed
// to bootstrap fix for #5723.
("issue_5723_bootstrap", "1.0.0", Accepted),
@ -193,7 +196,6 @@ pub const KNOWN_ATTRIBUTES: &'static [(&'static str, AttributeType)] = &[
("repr", Normal),
("path", Normal),
("abi", Normal),
("unsafe_destructor", Normal),
("automatically_derived", Normal),
("no_mangle", Normal),
("no_link", Normal),
@ -205,7 +207,8 @@ pub const KNOWN_ATTRIBUTES: &'static [(&'static str, AttributeType)] = &[
("link_args", Normal),
("macro_escape", Normal),
("unsafe_destructor", Gated("unsafe_destructor",
"`#[unsafe_destructor]` does nothing anymore")),
("staged_api", Gated("staged_api",
"staged_api is for use by rustc only")),
("plugin", Gated("plugin",
@ -571,15 +574,6 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
_ => {}
}
if attr::contains_name(&i.attrs,
"unsafe_destructor") {
self.gate_feature("unsafe_destructor",
i.span,
"`#[unsafe_destructor]` allows too \
many unsafe patterns and may be \
removed in the future");
}
if attr::contains_name(&i.attrs[..],
"old_orphan_check") {
self.gate_feature(

8
src/test/compile-fail/gated-unsafe-destructor.rs
View File

@ -10,14 +10,18 @@
// Test that `#[unsafe_destructor]` attribute is gated by `unsafe_destructor`
// feature gate.
//
// (This test can be removed entirely when we remove the
// `unsafe_destructor` feature itself.)
struct D<'a>(&'a u32);
#[unsafe_destructor]
//~^ ERROR `#[unsafe_destructor]` does nothing anymore
//~| HELP: add #![feature(unsafe_destructor)] to the crate attributes to enable
// (but of couse there is no point in doing so)
impl<'a> Drop for D<'a> {
//~^ ERROR `#[unsafe_destructor]` allows too many unsafe patterns
fn drop(&mut self) { }
}
//~^ HELP: add #![feature(unsafe_destructor)] to the crate attributes to enable
pub fn main() { }

36
src/test/compile-fail/issue-13853-3.rs
View File

@ -1,36 +0,0 @@
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// 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.
#![crate_type = "lib"]
use std::marker::PhantomData;
enum NodeContents<'a> {
Children(Vec<Node<'a>>),
}
impl<'a> Drop for NodeContents<'a> {
//~^ ERROR cannot implement a destructor on a structure with type parameters
fn drop( &mut self ) {
}
}
struct Node<'a> {
contents: NodeContents<'a>,
marker: PhantomData<&'a ()>,
}
impl<'a> Node<'a> {
fn noName(contents: NodeContents<'a>) -> Node<'a> {
Node { contents: contents, marker: PhantomData }
}
}
fn main() {}

21
src/test/compile-fail/issue-13853-4.rs
View File

@ -1,21 +0,0 @@
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// 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.
struct AutoBuilder<'a> {
context: &'a isize
}
impl<'a> Drop for AutoBuilder<'a> {
//~^ ERROR cannot implement a destructor on a structure with type parameters
fn drop(&mut self) {
}
}
fn main() {}

24
src/test/compile-fail/issue-16465.rs
View File

@ -1,24 +0,0 @@
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// 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.
// Used to cause an ICE
struct Foo<T>{
x : T
}
type FooInt = Foo<isize>;
impl Drop for FooInt {
//~^ ERROR cannot implement a destructor on a structure with type parameters
fn drop(&mut self){}
}
fn main() {}

31
src/test/compile-fail/kindck-destructor-owned.rs
View File

@ -1,31 +0,0 @@
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// 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.
struct Bar<'a> {
f: &'a isize,
}
impl<'a> Drop for Bar<'a> {
//~^ ERROR E0141
fn drop(&mut self) {
}
}
struct Baz {
f: &'static isize,
}
impl Drop for Baz {
fn drop(&mut self) {
}
}
fn main() { }

23
src/test/compile-fail/unsafe-destructor-check-crash.rs
View File

@ -1,23 +0,0 @@
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// 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.
// Regression test for issue #15557
#![allow(dead_code)]
struct AReg1<'a>(&'a u32);
impl<'a> Drop for AReg1<'a> {
//~^ ERROR: cannot implement a destructor on a structure with type parameters
fn drop(&mut self) {}
}
fn main() {}