From da7529afa66c68d33944e68298e78f6203f92699 Mon Sep 17 00:00:00 2001 From: Seo Sanghyeon Date: Tue, 7 Apr 2015 21:05:22 +0900 Subject: [PATCH 01/33] Split check_cast to a separate file --- src/librustc_typeck/check/cast.rs | 179 ++++++++++++++++++++++++++++++ src/librustc_typeck/check/mod.rs | 157 +------------------------- 2 files changed, 184 insertions(+), 152 deletions(-) create mode 100644 src/librustc_typeck/check/cast.rs diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs new file mode 100644 index 0000000000000..b35e3c800fcb0 --- /dev/null +++ b/src/librustc_typeck/check/cast.rs @@ -0,0 +1,179 @@ +// Copyright 2015 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! Code for type-checking cast expressions. + +use super::coercion; +use super::demand; +use super::FnCtxt; +use super::structurally_resolved_type; + +use lint; +use middle::infer; +use middle::ty; +use middle::ty::Ty; +use syntax::ast; +use syntax::codemap::Span; + +/// Reifies a cast check to be checked once we have full type information for +/// a function context. +pub struct CastCheck<'tcx> { + expr: ast::Expr, + expr_ty: Ty<'tcx>, + cast_ty: Ty<'tcx>, + span: Span, +} + +impl<'tcx> CastCheck<'tcx> { + pub fn new(expr: ast::Expr, expr_ty: Ty<'tcx>, cast_ty: Ty<'tcx>, span: Span) + -> CastCheck<'tcx> { + CastCheck { + expr: expr, + expr_ty: expr_ty, + cast_ty: cast_ty, + span: span, + } + } +} + +pub fn check_cast<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, cast: &CastCheck<'tcx>) { + fn cast_through_integer_err<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, + span: Span, + t_1: Ty<'tcx>, + t_e: Ty<'tcx>) { + fcx.type_error_message(span, |actual| { + format!("illegal cast; cast through an \ + integer first: `{}` as `{}`", + actual, + fcx.infcx().ty_to_string(t_1)) + }, t_e, None); + } + + let span = cast.span; + let e = &cast.expr; + let t_e = structurally_resolved_type(fcx, span, cast.expr_ty); + let t_1 = structurally_resolved_type(fcx, span, cast.cast_ty); + + // Check for trivial casts. + if !ty::type_has_ty_infer(t_1) { + if let Ok(()) = coercion::mk_assignty(fcx, e, t_e, t_1) { + if ty::type_is_numeric(t_1) && ty::type_is_numeric(t_e) { + fcx.tcx().sess.add_lint(lint::builtin::TRIVIAL_NUMERIC_CASTS, + e.id, + span, + format!("trivial numeric cast: `{}` as `{}`. Cast can be \ + replaced by coercion, this might require type \ + ascription or a temporary variable", + fcx.infcx().ty_to_string(t_e), + fcx.infcx().ty_to_string(t_1))); + } else { + fcx.tcx().sess.add_lint(lint::builtin::TRIVIAL_CASTS, + e.id, + span, + format!("trivial cast: `{}` as `{}`. Cast can be \ + replaced by coercion, this might require type \ + ascription or a temporary variable", + fcx.infcx().ty_to_string(t_e), + fcx.infcx().ty_to_string(t_1))); + } + return; + } + } + + let t_e_is_bare_fn_item = ty::type_is_bare_fn_item(t_e); + let t_e_is_scalar = ty::type_is_scalar(t_e); + let t_e_is_integral = ty::type_is_integral(t_e); + let t_e_is_float = ty::type_is_floating_point(t_e); + let t_e_is_c_enum = ty::type_is_c_like_enum(fcx.tcx(), t_e); + + let t_1_is_scalar = ty::type_is_scalar(t_1); + let t_1_is_char = ty::type_is_char(t_1); + let t_1_is_bare_fn = ty::type_is_bare_fn(t_1); + let t_1_is_float = ty::type_is_floating_point(t_1); + + // casts to scalars other than `char` and `bare fn` are trivial + let t_1_is_trivial = t_1_is_scalar && !t_1_is_char && !t_1_is_bare_fn; + + if t_e_is_bare_fn_item && t_1_is_bare_fn { + demand::coerce(fcx, e.span, t_1, &e); + } else if t_1_is_char { + let t_e = fcx.infcx().shallow_resolve(t_e); + if t_e.sty != ty::ty_uint(ast::TyU8) { + fcx.type_error_message(span, |actual| { + format!("only `u8` can be cast as `char`, not `{}`", actual) + }, t_e, None); + } + } else if t_1.sty == ty::ty_bool { + span_err!(fcx.tcx().sess, span, E0054, + "cannot cast as `bool`, compare with zero instead"); + } else if t_1_is_float && (t_e_is_scalar || t_e_is_c_enum) && !( + t_e_is_integral || t_e_is_float || t_e.sty == ty::ty_bool) { + // Casts to float must go through an integer or boolean + cast_through_integer_err(fcx, span, t_1, t_e) + } else if t_e_is_c_enum && t_1_is_trivial { + if ty::type_is_unsafe_ptr(t_1) { + // ... and likewise with C enum -> *T + cast_through_integer_err(fcx, span, t_1, t_e) + } + // casts from C-like enums are allowed + } else if ty::type_is_region_ptr(t_e) && ty::type_is_unsafe_ptr(t_1) { + fn types_compatible<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, sp: Span, + t1: Ty<'tcx>, t2: Ty<'tcx>) -> bool { + match t1.sty { + ty::ty_vec(_, Some(_)) => {} + _ => return false + } + if ty::type_needs_infer(t2) { + // This prevents this special case from going off when casting + // to a type that isn't fully specified; e.g. `as *_`. (Issue + // #14893.) + return false + } + + let el = ty::sequence_element_type(fcx.tcx(), t1); + infer::mk_eqty(fcx.infcx(), + false, + infer::Misc(sp), + el, + t2).is_ok() + } + + // Due to the limitations of LLVM global constants, + // region pointers end up pointing at copies of + // vector elements instead of the original values. + // To allow unsafe pointers to work correctly, we + // need to special-case obtaining an unsafe pointer + // from a region pointer to a vector. + + /* this cast is only allowed from &[T, ..n] to *T or + &T to *T. */ + match (&t_e.sty, &t_1.sty) { + (&ty::ty_rptr(_, ty::mt { ty: mt1, mutbl: ast::MutImmutable }), + &ty::ty_ptr(ty::mt { ty: mt2, mutbl: ast::MutImmutable })) + if types_compatible(fcx, e.span, mt1, mt2) => { + /* this case is allowed */ + } + _ => { + demand::coerce(fcx, e.span, t_1, &e); + } + } + } else if !(t_e_is_scalar && t_1_is_trivial) { + /* + If more type combinations should be supported than are + supported here, then file an enhancement issue and + record the issue number in this comment. + */ + fcx.type_error_message(span, |actual| { + format!("non-scalar cast: `{}` as `{}`", + actual, + fcx.infcx().ty_to_string(t_1)) + }, t_e, None); + } +} diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 156fbfede9c98..f9bf3eaf3ddf6 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -139,6 +139,7 @@ pub mod demand; pub mod method; mod upvar; pub mod wf; +mod cast; mod closure; mod callee; mod compare_method; @@ -185,7 +186,7 @@ pub struct Inherited<'a, 'tcx: 'a> { // back and process them. deferred_call_resolutions: RefCell>>>, - deferred_cast_checks: RefCell>>, + deferred_cast_checks: RefCell>>, } trait DeferredCallResolution<'tcx> { @@ -194,15 +195,6 @@ trait DeferredCallResolution<'tcx> { type DeferredCallResolutionHandler<'tcx> = Box+'tcx>; -/// Reifies a cast check to be checked once we have full type information for -/// a function context. -struct CastCheck<'tcx> { - expr: ast::Expr, - expr_ty: Ty<'tcx>, - cast_ty: Ty<'tcx>, - span: Span, -} - /// When type-checking an expression, we propagate downward /// whatever type hint we are able in the form of an `Expectation`. #[derive(Copy, Clone)] @@ -1071,141 +1063,6 @@ fn report_cast_to_unsized_type<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, } -fn check_cast<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, cast: &CastCheck<'tcx>) { - fn cast_through_integer_err<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, - span: Span, - t_1: Ty<'tcx>, - t_e: Ty<'tcx>) { - fcx.type_error_message(span, |actual| { - format!("illegal cast; cast through an \ - integer first: `{}` as `{}`", - actual, - fcx.infcx().ty_to_string(t_1)) - }, t_e, None); - } - - let span = cast.span; - let e = &cast.expr; - let t_e = structurally_resolved_type(fcx, span, cast.expr_ty); - let t_1 = structurally_resolved_type(fcx, span, cast.cast_ty); - - // Check for trivial casts. - if !ty::type_has_ty_infer(t_1) { - if let Ok(()) = coercion::mk_assignty(fcx, e, t_e, t_1) { - if ty::type_is_numeric(t_1) && ty::type_is_numeric(t_e) { - fcx.tcx().sess.add_lint(lint::builtin::TRIVIAL_NUMERIC_CASTS, - e.id, - span, - format!("trivial numeric cast: `{}` as `{}`. Cast can be \ - replaced by coercion, this might require type \ - ascription or a temporary variable", - fcx.infcx().ty_to_string(t_e), - fcx.infcx().ty_to_string(t_1))); - } else { - fcx.tcx().sess.add_lint(lint::builtin::TRIVIAL_CASTS, - e.id, - span, - format!("trivial cast: `{}` as `{}`. Cast can be \ - replaced by coercion, this might require type \ - ascription or a temporary variable", - fcx.infcx().ty_to_string(t_e), - fcx.infcx().ty_to_string(t_1))); - } - return; - } - } - - let t_e_is_bare_fn_item = ty::type_is_bare_fn_item(t_e); - let t_e_is_scalar = ty::type_is_scalar(t_e); - let t_e_is_integral = ty::type_is_integral(t_e); - let t_e_is_float = ty::type_is_floating_point(t_e); - let t_e_is_c_enum = ty::type_is_c_like_enum(fcx.tcx(), t_e); - - let t_1_is_scalar = ty::type_is_scalar(t_1); - let t_1_is_char = ty::type_is_char(t_1); - let t_1_is_bare_fn = ty::type_is_bare_fn(t_1); - let t_1_is_float = ty::type_is_floating_point(t_1); - - // casts to scalars other than `char` and `bare fn` are trivial - let t_1_is_trivial = t_1_is_scalar && !t_1_is_char && !t_1_is_bare_fn; - - if t_e_is_bare_fn_item && t_1_is_bare_fn { - demand::coerce(fcx, e.span, t_1, &e); - } else if t_1_is_char { - let t_e = fcx.infcx().shallow_resolve(t_e); - if t_e.sty != ty::ty_uint(ast::TyU8) { - fcx.type_error_message(span, |actual| { - format!("only `u8` can be cast as `char`, not `{}`", actual) - }, t_e, None); - } - } else if t_1.sty == ty::ty_bool { - span_err!(fcx.tcx().sess, span, E0054, - "cannot cast as `bool`, compare with zero instead"); - } else if t_1_is_float && (t_e_is_scalar || t_e_is_c_enum) && !( - t_e_is_integral || t_e_is_float || t_e.sty == ty::ty_bool) { - // Casts to float must go through an integer or boolean - cast_through_integer_err(fcx, span, t_1, t_e) - } else if t_e_is_c_enum && t_1_is_trivial { - if ty::type_is_unsafe_ptr(t_1) { - // ... and likewise with C enum -> *T - cast_through_integer_err(fcx, span, t_1, t_e) - } - // casts from C-like enums are allowed - } else if ty::type_is_region_ptr(t_e) && ty::type_is_unsafe_ptr(t_1) { - fn types_compatible<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, sp: Span, - t1: Ty<'tcx>, t2: Ty<'tcx>) -> bool { - match t1.sty { - ty::ty_vec(_, Some(_)) => {} - _ => return false - } - if ty::type_needs_infer(t2) { - // This prevents this special case from going off when casting - // to a type that isn't fully specified; e.g. `as *_`. (Issue - // #14893.) - return false - } - - let el = ty::sequence_element_type(fcx.tcx(), t1); - infer::mk_eqty(fcx.infcx(), - false, - infer::Misc(sp), - el, - t2).is_ok() - } - - // Due to the limitations of LLVM global constants, - // region pointers end up pointing at copies of - // vector elements instead of the original values. - // To allow unsafe pointers to work correctly, we - // need to special-case obtaining an unsafe pointer - // from a region pointer to a vector. - - /* this cast is only allowed from &[T, ..n] to *T or - &T to *T. */ - match (&t_e.sty, &t_1.sty) { - (&ty::ty_rptr(_, ty::mt { ty: mt1, mutbl: ast::MutImmutable }), - &ty::ty_ptr(ty::mt { ty: mt2, mutbl: ast::MutImmutable })) - if types_compatible(fcx, e.span, mt1, mt2) => { - /* this case is allowed */ - } - _ => { - demand::coerce(fcx, e.span, t_1, &e); - } - } - } else if !(t_e_is_scalar && t_1_is_trivial) { - /* - If more type combinations should be supported than are - supported here, then file an enhancement issue and - record the issue number in this comment. - */ - fcx.type_error_message(span, |actual| { - format!("non-scalar cast: `{}` as `{}`", - actual, - fcx.infcx().ty_to_string(t_1)) - }, t_e, None); - } -} - impl<'a, 'tcx> AstConv<'tcx> for FnCtxt<'a, 'tcx> { fn tcx(&self) -> &ty::ctxt<'tcx> { self.ccx.tcx } @@ -1925,7 +1782,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { fn check_casts(&self) { let mut deferred_cast_checks = self.inh.deferred_cast_checks.borrow_mut(); for check in deferred_cast_checks.iter() { - check_cast(self, check); + cast::check_cast(self, check); } deferred_cast_checks.clear(); @@ -3531,12 +3388,8 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, // Defer other checks until we're done type checking. let mut deferred_cast_checks = fcx.inh.deferred_cast_checks.borrow_mut(); - deferred_cast_checks.push(CastCheck { - expr: (**e).clone(), - expr_ty: t_e, - cast_ty: t_1, - span: expr.span, - }); + let cast_check = cast::CastCheck::new((**e).clone(), t_e, t_1, expr.span); + deferred_cast_checks.push(cast_check); } } ast::ExprVec(ref args) => { From f4c2228be05887aeaee741c37715f6a1f2b51a5d Mon Sep 17 00:00:00 2001 From: Seo Sanghyeon Date: Tue, 7 Apr 2015 22:45:10 +0900 Subject: [PATCH 02/33] Check casts from float --- src/librustc_typeck/check/cast.rs | 6 ++++++ src/test/compile-fail/unsupported-cast.rs | 5 +++-- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs index b35e3c800fcb0..b7aebff9ac096 100644 --- a/src/librustc_typeck/check/cast.rs +++ b/src/librustc_typeck/check/cast.rs @@ -94,9 +94,11 @@ pub fn check_cast<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, cast: &CastCheck<'tcx>) { let t_e_is_c_enum = ty::type_is_c_like_enum(fcx.tcx(), t_e); let t_1_is_scalar = ty::type_is_scalar(t_1); + let t_1_is_integral = ty::type_is_integral(t_1); let t_1_is_char = ty::type_is_char(t_1); let t_1_is_bare_fn = ty::type_is_bare_fn(t_1); let t_1_is_float = ty::type_is_floating_point(t_1); + let t_1_is_c_enum = ty::type_is_c_like_enum(fcx.tcx(), t_1); // casts to scalars other than `char` and `bare fn` are trivial let t_1_is_trivial = t_1_is_scalar && !t_1_is_char && !t_1_is_bare_fn; @@ -113,6 +115,10 @@ pub fn check_cast<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, cast: &CastCheck<'tcx>) { } else if t_1.sty == ty::ty_bool { span_err!(fcx.tcx().sess, span, E0054, "cannot cast as `bool`, compare with zero instead"); + } else if t_e_is_float && (t_1_is_scalar || t_1_is_c_enum) && !( + t_1_is_integral || t_1_is_float) { + // Casts from float must go through an integer + cast_through_integer_err(fcx, span, t_1, t_e) } else if t_1_is_float && (t_e_is_scalar || t_e_is_c_enum) && !( t_e_is_integral || t_e_is_float || t_e.sty == ty::ty_bool) { // Casts to float must go through an integer or boolean diff --git a/src/test/compile-fail/unsupported-cast.rs b/src/test/compile-fail/unsupported-cast.rs index ca17c898ec37c..b4246f2ed87f3 100644 --- a/src/test/compile-fail/unsupported-cast.rs +++ b/src/test/compile-fail/unsupported-cast.rs @@ -8,8 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// ignore-test FIXME: #13993 -// error-pattern:unsupported cast +// error-pattern:illegal cast + +#![feature(libc)] extern crate libc; From d18b405faf09514febc4163d96e85e57e137df81 Mon Sep 17 00:00:00 2001 From: Seo Sanghyeon Date: Wed, 8 Apr 2015 00:45:57 +0900 Subject: [PATCH 03/33] Check casts from fat pointer --- src/librustc_typeck/check/cast.rs | 5 +++++ src/librustc_typeck/check/mod.rs | 10 ++++++++++ src/test/compile-fail/fat-ptr-cast.rs | 14 ++++++++++++++ 3 files changed, 29 insertions(+) create mode 100644 src/test/compile-fail/fat-ptr-cast.rs diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs index b7aebff9ac096..045b88e2357cd 100644 --- a/src/librustc_typeck/check/cast.rs +++ b/src/librustc_typeck/check/cast.rs @@ -170,6 +170,11 @@ pub fn check_cast<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, cast: &CastCheck<'tcx>) { demand::coerce(fcx, e.span, t_1, &e); } } + } else if fcx.type_is_fat_ptr(t_e, span) && !fcx.type_is_fat_ptr(t_1, span) { + fcx.type_error_message(span, |actual| { + format!("illegal cast; cast from fat pointer: `{}` as `{}`", + actual, fcx.infcx().ty_to_string(t_1)) + }, t_e, None); } else if !(t_e_is_scalar && t_1_is_trivial) { /* If more type combinations should be supported than are diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index f9bf3eaf3ddf6..cab6f76d0271b 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1559,6 +1559,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { span) } + pub fn type_is_fat_ptr(&self, ty: Ty<'tcx>, span: Span) -> bool { + match ty.sty { + ty::ty_ptr(ty::mt { ty: t, .. }) | + ty::ty_rptr(_, ty::mt { ty: t, .. }) => { + !self.type_is_known_to_be_sized(t, span) + } + _ => false + } + } + pub fn register_builtin_bound(&self, ty: Ty<'tcx>, builtin_bound: ty::BuiltinBound, diff --git a/src/test/compile-fail/fat-ptr-cast.rs b/src/test/compile-fail/fat-ptr-cast.rs new file mode 100644 index 0000000000000..839ebbd279a99 --- /dev/null +++ b/src/test/compile-fail/fat-ptr-cast.rs @@ -0,0 +1,14 @@ +// Copyright 2015 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn main() { + let a: &[i32] = &[1, 2, 3]; + a as *const [i32] as usize; //~ ERROR cast from fat pointer +} From df95719391b2ee94c09162060052755e75f431dc Mon Sep 17 00:00:00 2001 From: Kevin Ballard Date: Tue, 7 Apr 2015 12:36:39 -0700 Subject: [PATCH 04/33] Add Clone impls for extern "C" and unsafe fns We only implemented Clone on `extern "Rust" fn`s (for up to 8 parameters). This didn't cover `extern "C"` or `unsafe` (or `unsafe extern "C"`) `fn`s, but there's no reason why they shouldn't be cloneable as well. The new impls are marked unstable because the existing impl for `extern "Rust" fn`s is. Fixes #24161. --- src/libcore/clone.rs | 21 +++++++++++++++++++++ src/test/run-pass/issue-24161.rs | 19 +++++++++++++++++++ 2 files changed, 40 insertions(+) create mode 100644 src/test/run-pass/issue-24161.rs diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs index 85e5bde48598e..91747d7405ff6 100644 --- a/src/libcore/clone.rs +++ b/src/libcore/clone.rs @@ -97,6 +97,27 @@ macro_rules! extern_fn_clone { #[inline] fn clone(&self) -> extern "Rust" fn($($A),*) -> ReturnType { *self } } + + #[unstable(feature = "core", reason = "brand new")] + impl<$($A,)* ReturnType> Clone for extern "C" fn($($A),*) -> ReturnType { + /// Return a copy of a function pointer + #[inline] + fn clone(&self) -> extern "C" fn($($A),*) -> ReturnType { *self } + } + + #[unstable(feature = "core", reason = "brand new")] + impl<$($A,)* ReturnType> Clone for unsafe extern "Rust" fn($($A),*) -> ReturnType { + /// Return a copy of a function pointer + #[inline] + fn clone(&self) -> unsafe extern "Rust" fn($($A),*) -> ReturnType { *self } + } + + #[unstable(feature = "core", reason = "brand new")] + impl<$($A,)* ReturnType> Clone for unsafe extern "C" fn($($A),*) -> ReturnType { + /// Return a copy of a function pointer + #[inline] + fn clone(&self) -> unsafe extern "C" fn($($A),*) -> ReturnType { *self } + } ) } diff --git a/src/test/run-pass/issue-24161.rs b/src/test/run-pass/issue-24161.rs new file mode 100644 index 0000000000000..2445ef17ecf3b --- /dev/null +++ b/src/test/run-pass/issue-24161.rs @@ -0,0 +1,19 @@ +// Copyright 2015 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#[derive(Copy,Clone)] +struct Functions { + a: fn(u32) -> u32, + b: extern "C" fn(u32) -> u32, + c: unsafe fn(u32) -> u32, + d: unsafe extern "C" fn(u32) -> u32 +} + +pub fn main() {} From 334422184eebb108b54d7c0a19e186ebb06e89ee Mon Sep 17 00:00:00 2001 From: Hajime Morrita Date: Tue, 7 Apr 2015 13:19:17 -0700 Subject: [PATCH 05/33] Fix a typo --- src/doc/trpl/associated-types.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/doc/trpl/associated-types.md b/src/doc/trpl/associated-types.md index 7161cd33f89be..d59239016d881 100644 --- a/src/doc/trpl/associated-types.md +++ b/src/doc/trpl/associated-types.md @@ -198,5 +198,5 @@ let obj = Box::new(graph) as Box>; ``` The `N=Node` syntax allows us to provide a concrete type, `Node`, for the `N` -type parameter. Same with `E=Edge`. If we didn’t proide this constraint, we +type parameter. Same with `E=Edge`. If we didn’t provide this constraint, we couldn’t be sure which `impl` to match this trait object to. From 9a51c63a2fa4ad38f0ff90649b948d2e5b667d19 Mon Sep 17 00:00:00 2001 From: Ralph Giles Date: Tue, 7 Apr 2015 14:05:02 -0700 Subject: [PATCH 06/33] rustup: let RUSTUP_PREFIX env override default prefix. The idea here is if you don't want rust in /usr/local you can put something like this is your .profile: export RUSTUP_PREFIX=$HOME/.local/rust export PATH=$PATH:${RUSTUP_PREFIX}/bin export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:${RUSTUP_PREFIX}/lib Then when you run rustup, it will update the install in ${RUSTUP_PREFIX} without having to remember to pass an explicit --prefix argument every time. --- src/etc/rustup.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/etc/rustup.sh b/src/etc/rustup.sh index 918c0c66f76df..7c207385393c9 100755 --- a/src/etc/rustup.sh +++ b/src/etc/rustup.sh @@ -286,7 +286,7 @@ BOOL_OPTIONS="" VAL_OPTIONS="" flag uninstall "only uninstall from the installation prefix" -valopt prefix "" "set installation prefix" +valopt prefix "${RUSTUP_PREFIX}" "set installation prefix" valopt date "" "use the YYYY-MM-DD nightly instead of the current nightly" valopt channel "beta" "use the selected release channel [beta]" flag save "save the downloaded nightlies to ~/.rustup" From 5c3aa01045cee7d632e93cad4295fa12109e9550 Mon Sep 17 00:00:00 2001 From: Dave Huseby Date: Tue, 7 Apr 2015 16:03:14 -0700 Subject: [PATCH 07/33] disabling a test that is failing on bitrig. --- src/libstd/net/addr.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/libstd/net/addr.rs b/src/libstd/net/addr.rs index 886f252fb1926..18d8fcc8a5288 100644 --- a/src/libstd/net/addr.rs +++ b/src/libstd/net/addr.rs @@ -750,8 +750,9 @@ mod tests { assert!(tsa("localhost:23924").unwrap().contains(&a)); } + // FIXME: figure out why this fails on bitrig and fix it #[test] - #[cfg(not(windows))] + #[cfg(not(any(windows, target_os = "bitrig")))] fn to_socket_addr_str_bad() { assert!(tsa("1200::AB00:1234::2552:7777:1313:34300").is_err()); } From a329a61b9bf01bfc3f9f7316bb800b2bc8b76382 Mon Sep 17 00:00:00 2001 From: Richo Healey Date: Tue, 7 Apr 2015 00:40:22 -0700 Subject: [PATCH 08/33] alloc: impl fmt::Pointer for Rc, Arc and Box Closes #24091 --- src/liballoc/arc.rs | 7 +++++++ src/liballoc/boxed.rs | 10 +++++++++ src/liballoc/rc.rs | 7 +++++++ src/libcore/ptr.rs | 8 ++++++++ src/libsyntax/ptr.rs | 7 +++++++ src/test/run-pass/fmt-pointer-trait.rs | 28 ++++++++++++++++++++++++++ 6 files changed, 67 insertions(+) create mode 100644 src/test/run-pass/fmt-pointer-trait.rs diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 68bde1476118d..ff176d815916b 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -668,6 +668,13 @@ impl fmt::Debug for Arc { } } +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Pointer for Arc { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Pointer::fmt(&*self._ptr, f) + } +} + #[stable(feature = "rust1", since = "1.0.0")] impl Default for Arc { #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index 2801cf38cb755..4468e425a852d 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -275,6 +275,16 @@ impl fmt::Debug for Box { } } +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Pointer for Box { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + // It's not possible to extract the inner Uniq directly from the Box, + // instead we cast it to a *const which aliases the Unique + let ptr: *const T = &**self; + fmt::Pointer::fmt(&ptr, f) + } +} + #[stable(feature = "rust1", since = "1.0.0")] impl Deref for Box { type Target = T; diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 56822cfe28a35..67805d10a4a63 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -634,6 +634,13 @@ impl fmt::Debug for Rc { } } +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Pointer for Rc { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Pointer::fmt(&*self._ptr, f) + } +} + /// A weak version of `Rc`. /// /// Weak references do not count when determining if the inner value should be diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index ff51e25fcbf25..36b33e7581dd9 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -94,6 +94,7 @@ use mem; use clone::Clone; use intrinsics; use ops::Deref; +use core::fmt; use option::Option::{self, Some, None}; use marker::{PhantomData, Send, Sized, Sync}; use nonzero::NonZero; @@ -570,3 +571,10 @@ impl Deref for Unique { unsafe { mem::transmute(&*self.pointer) } } } + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Pointer for Unique { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Pointer::fmt(&*self.pointer, f) + } +} diff --git a/src/libsyntax/ptr.rs b/src/libsyntax/ptr.rs index 7e0bcd3e1dc3f..5032cd57eeb37 100644 --- a/src/libsyntax/ptr.rs +++ b/src/libsyntax/ptr.rs @@ -111,6 +111,13 @@ impl Display for P { } } +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Pointer for P { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Pointer::fmt(&self.ptr, f) + } +} + impl Hash for P { fn hash(&self, state: &mut H) { (**self).hash(state); diff --git a/src/test/run-pass/fmt-pointer-trait.rs b/src/test/run-pass/fmt-pointer-trait.rs new file mode 100644 index 0000000000000..be8ecde67836e --- /dev/null +++ b/src/test/run-pass/fmt-pointer-trait.rs @@ -0,0 +1,28 @@ +// Copyright 2015 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(libc)] +extern crate libc; +use std::ptr; +use std::rc::Rc; +use std::sync::Arc; + +fn main() { + let p: *const libc::c_void = ptr::null(); + let rc = Rc::new(1usize); + let arc = Arc::new(1usize); + let b = Box::new("hi"); + + let _ = format!("{:p}{:p}{:p}", + rc, arc, b); + + assert_eq!(format!("{:p}", p), + "0x0"); +} From e2ff1881b2c892aab0ed721a1ecdb4309053dcab Mon Sep 17 00:00:00 2001 From: Seo Sanghyeon Date: Wed, 8 Apr 2015 13:55:18 +0900 Subject: [PATCH 09/33] Address review comments --- src/librustc_typeck/check/cast.rs | 8 ++++---- src/librustc_typeck/check/mod.rs | 9 +++------ src/test/compile-fail/fat-ptr-cast.rs | 7 ++++++- 3 files changed, 13 insertions(+), 11 deletions(-) diff --git a/src/librustc_typeck/check/cast.rs b/src/librustc_typeck/check/cast.rs index 045b88e2357cd..3773ff7078e9c 100644 --- a/src/librustc_typeck/check/cast.rs +++ b/src/librustc_typeck/check/cast.rs @@ -115,12 +115,12 @@ pub fn check_cast<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, cast: &CastCheck<'tcx>) { } else if t_1.sty == ty::ty_bool { span_err!(fcx.tcx().sess, span, E0054, "cannot cast as `bool`, compare with zero instead"); - } else if t_e_is_float && (t_1_is_scalar || t_1_is_c_enum) && !( - t_1_is_integral || t_1_is_float) { + } else if t_e_is_float && (t_1_is_scalar || t_1_is_c_enum) && + !(t_1_is_integral || t_1_is_float) { // Casts from float must go through an integer cast_through_integer_err(fcx, span, t_1, t_e) - } else if t_1_is_float && (t_e_is_scalar || t_e_is_c_enum) && !( - t_e_is_integral || t_e_is_float || t_e.sty == ty::ty_bool) { + } else if t_1_is_float && (t_e_is_scalar || t_e_is_c_enum) && + !(t_e_is_integral || t_e_is_float || t_e.sty == ty::ty_bool) { // Casts to float must go through an integer or boolean cast_through_integer_err(fcx, span, t_1, t_e) } else if t_e_is_c_enum && t_1_is_trivial { diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index cab6f76d0271b..4ecef2235a911 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -1560,13 +1560,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } pub fn type_is_fat_ptr(&self, ty: Ty<'tcx>, span: Span) -> bool { - match ty.sty { - ty::ty_ptr(ty::mt { ty: t, .. }) | - ty::ty_rptr(_, ty::mt { ty: t, .. }) => { - !self.type_is_known_to_be_sized(t, span) - } - _ => false + if let Some(mt) = ty::deref(ty, true) { + return !self.type_is_known_to_be_sized(mt.ty, span); } + false } pub fn register_builtin_bound(&self, diff --git a/src/test/compile-fail/fat-ptr-cast.rs b/src/test/compile-fail/fat-ptr-cast.rs index 839ebbd279a99..ac5969410fc01 100644 --- a/src/test/compile-fail/fat-ptr-cast.rs +++ b/src/test/compile-fail/fat-ptr-cast.rs @@ -10,5 +10,10 @@ fn main() { let a: &[i32] = &[1, 2, 3]; - a as *const [i32] as usize; //~ ERROR cast from fat pointer + let b: Box<[i32]> = Box::new([1, 2, 3]); + let p = a as *const [i32]; + + a as usize; //~ ERROR cast from fat pointer + b as usize; //~ ERROR cast from fat pointer + p as usize; //~ ERROR cast from fat pointer } From 59e62deac96072369ca91b57cff08dbdcbc1dd70 Mon Sep 17 00:00:00 2001 From: Luke Gallagher Date: Wed, 8 Apr 2015 23:23:43 +1000 Subject: [PATCH 10/33] Add tests for #22289, #22370 and #22384 Closes #22289 Closes #22370 Closes #22384 --- src/test/compile-fail/issue-22289.rs | 13 +++++++++++++ src/test/compile-fail/issue-22370.rs | 18 ++++++++++++++++++ src/test/compile-fail/issue-22384.rs | 18 ++++++++++++++++++ 3 files changed, 49 insertions(+) create mode 100644 src/test/compile-fail/issue-22289.rs create mode 100644 src/test/compile-fail/issue-22370.rs create mode 100644 src/test/compile-fail/issue-22384.rs diff --git a/src/test/compile-fail/issue-22289.rs b/src/test/compile-fail/issue-22289.rs new file mode 100644 index 0000000000000..f4f6aaa94fe29 --- /dev/null +++ b/src/test/compile-fail/issue-22289.rs @@ -0,0 +1,13 @@ +// Copyright 2015 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +fn main() { + 0 as &std::any::Any; //~ ERROR non-scalar cast: `i32` as `&core::any::Any` +} diff --git a/src/test/compile-fail/issue-22370.rs b/src/test/compile-fail/issue-22370.rs new file mode 100644 index 0000000000000..4c6652d812c8c --- /dev/null +++ b/src/test/compile-fail/issue-22370.rs @@ -0,0 +1,18 @@ +// Copyright 2015 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// ignore-tidy-linelength + +trait A {} + +fn f(a: &A) {} +//~^ ERROR the type parameter `T` must be explicitly specified in an object type because its default value `Self` references the type `Self` + +fn main() {} diff --git a/src/test/compile-fail/issue-22384.rs b/src/test/compile-fail/issue-22384.rs new file mode 100644 index 0000000000000..368e2483533a4 --- /dev/null +++ b/src/test/compile-fail/issue-22384.rs @@ -0,0 +1,18 @@ +// Copyright 2015 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +trait Trait { + fn foo(); +} + +fn main() { + <::foobar as Trait>::foo(); + //~^ ERROR use of undeclared associated type `Copy::foobar` +} From 1e79870770c08973d018e71d309816b970c7abe1 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Wed, 8 Apr 2015 04:31:51 -0400 Subject: [PATCH 11/33] Modify the ExprUseVisitor to walk each part of an AutoRef, and in particular to treat an AutoUnsize as as kind of "instantaneous" borrow of the value being unsized. This prevents us from feeding uninitialized data. This caused a problem for the eager reborrow of comparison traits, because that wound up introducing a "double AutoRef", which was not being thoroughly checked before but turned out not to type check. Fortunately, we can just remove that "eager reborrow" as it is no longer needed now that `PartialEq` doesn't force both LHS and RHS to have the same type (and even if we did have this problem, the better way would be to lean on introducing a common supertype). --- src/librustc/middle/check_const.rs | 14 +- src/librustc/middle/expr_use_visitor.rs | 173 +++++++++++++++--- src/librustc/middle/mem_categorization.rs | 24 ++- src/librustc_borrowck/borrowck/check_loans.rs | 1 + src/librustc_borrowck/borrowck/mod.rs | 2 + src/librustc_typeck/check/op.rs | 32 +--- src/librustc_typeck/check/regionck.rs | 14 +- ...orrowck-use-uninitialized-in-cast-trait.rs | 20 ++ .../borrowck-use-uninitialized-in-cast.rs | 20 ++ 9 files changed, 226 insertions(+), 74 deletions(-) create mode 100644 src/test/compile-fail/borrowck-use-uninitialized-in-cast-trait.rs create mode 100644 src/test/compile-fail/borrowck-use-uninitialized-in-cast.rs diff --git a/src/librustc/middle/check_const.rs b/src/librustc/middle/check_const.rs index ce011f2561b79..ee9d1e015539e 100644 --- a/src/librustc/middle/check_const.rs +++ b/src/librustc/middle/check_const.rs @@ -662,7 +662,19 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for CheckCrateVisitor<'a, 'tcx> { cmt: mc::cmt<'tcx>, _loan_region: ty::Region, bk: ty::BorrowKind, - loan_cause: euv::LoanCause) { + loan_cause: euv::LoanCause) + { + // Kind of hacky, but we allow Unsafe coercions in constants. + // These occur when we convert a &T or *T to a *U, as well as + // when making a thin pointer (e.g., `*T`) into a fat pointer + // (e.g., `*Trait`). + match loan_cause { + euv::LoanCause::AutoUnsafe => { + return; + } + _ => { } + } + let mut cur = &cmt; let mut is_interior = false; loop { diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 2fa9c7c8fbebb..18e634a2dd630 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -99,6 +99,7 @@ pub enum LoanCause { ClosureCapture(Span), AddrOf, AutoRef, + AutoUnsafe, RefBinding, OverloadedOperator, ClosureInvocation, @@ -800,18 +801,8 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { return_if_err!(self.mc.cat_expr_unadjusted(expr)); self.delegate_consume(expr.id, expr.span, cmt_unadjusted); } - ty::AdjustDerefRef(ty::AutoDerefRef { - autoref: ref opt_autoref, - autoderefs: n - }) => { - self.walk_autoderefs(expr, n); - - match *opt_autoref { - None => { } - Some(ref r) => { - self.walk_autoref(expr, r, n); - } - } + ty::AdjustDerefRef(ref adj) => { + self.walk_autoderefref(expr, adj); } } } @@ -852,39 +843,165 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> { } } + fn walk_autoderefref(&mut self, + expr: &ast::Expr, + adj: &ty::AutoDerefRef<'tcx>) { + debug!("walk_autoderefref expr={} adj={}", + expr.repr(self.tcx()), + adj.repr(self.tcx())); + + self.walk_autoderefs(expr, adj.autoderefs); + + // Weird hacky special case: AutoUnsizeUniq, which converts + // from a ~T to a ~Trait etc, always comes in a stylized + // fashion. In particular, we want to consume the ~ pointer + // being dereferenced, not the dereferenced content (as the + // content is, at least for upcasts, unsized). + match adj.autoref { + Some(ty::AutoUnsizeUniq(_)) => { + assert!(adj.autoderefs == 1, + format!("Expected exactly 1 deref with Uniq AutoRefs, found: {}", + adj.autoderefs)); + let cmt_unadjusted = + return_if_err!(self.mc.cat_expr_unadjusted(expr)); + self.delegate_consume(expr.id, expr.span, cmt_unadjusted); + return; + } + _ => { } + } + + let autoref = adj.autoref.as_ref(); + let cmt_derefd = return_if_err!( + self.mc.cat_expr_autoderefd(expr, adj.autoderefs)); + self.walk_autoref(expr, &cmt_derefd, autoref); + } + + /// Walks the autoref `opt_autoref` applied to the autoderef'd + /// `expr`. `cmt_derefd` is the mem-categorized form of `expr` + /// after all relevant autoderefs have occurred. Because AutoRefs + /// can be recursive, this function is recursive: it first walks + /// deeply all the way down the autoref chain, and then processes + /// the autorefs on the way out. At each point, it returns the + /// `cmt` for the rvalue that will be produced by introduced an + /// autoref. fn walk_autoref(&mut self, expr: &ast::Expr, - autoref: &ty::AutoRef, - n: usize) { - debug!("walk_autoref expr={}", expr.repr(self.tcx())); + cmt_derefd: &mc::cmt<'tcx>, + opt_autoref: Option<&ty::AutoRef<'tcx>>) + -> mc::cmt<'tcx> + { + debug!("walk_autoref(expr.id={} cmt_derefd={} opt_autoref={:?})", + expr.id, + cmt_derefd.repr(self.tcx()), + opt_autoref); + + let autoref = match opt_autoref { + Some(autoref) => autoref, + None => { + // No recursive step here, this is a base case. + return cmt_derefd.clone(); + } + }; match *autoref { - ty::AutoPtr(r, m, _) => { - let cmt_derefd = return_if_err!( - self.mc.cat_expr_autoderefd(expr, n)); - debug!("walk_adjustment: cmt_derefd={}", - cmt_derefd.repr(self.tcx())); + ty::AutoPtr(r, m, ref baseref) => { + let cmt_base = self.walk_autoref_recursively(expr, cmt_derefd, baseref); + + debug!("walk_autoref: expr.id={} cmt_base={}", + expr.id, + cmt_base.repr(self.tcx())); self.delegate.borrow(expr.id, expr.span, - cmt_derefd, + cmt_base, r, ty::BorrowKind::from_mutbl(m), AutoRef); } - ty::AutoUnsize(_) | + + ty::AutoUnsize(_) => { + // Converting a `[T; N]` to `[T]` or `T` to `Trait` + // isn't really a borrow, move, etc, in and of itself. + // Also, no recursive step here, this is a base case. + + // It may seem a bit odd to return the cmt_derefd + // unmodified here, but in fact I think it's the right + // thing to do. Essentially the unsize transformation + // isn't really relevant to the borrowing rules -- + // it's best thought of as a kind of side-modifier to + // the autoref, adding additional data that is + // attached to the pointer that is produced, but not + // affecting the data being borrowed in any other + // way. To see what I mean, consider this example: + // + // fn foo<'a>(&'a self) -> &'a Trait { self } + // + // This is valid because the underlying `self` value + // lives for the lifetime 'a. If we were to treat the + // "unsizing" as e.g. producing an rvalue, that would + // only be valid for the temporary scope, which isn't + // enough to justify the return value, which have the + // lifetime 'a. + // + // Another option would be to add a variant for + // categorization (like downcast) that wraps + // cmt_derefd and represents the unsizing operation. + // But I don't think there is any particular use for + // this (yet). -nmatsakis + return cmt_derefd.clone(); + } + ty::AutoUnsizeUniq(_) => { - assert!(n == 1, format!("Expected exactly 1 deref with Uniq \ - AutoRefs, found: {}", n)); - let cmt_unadjusted = - return_if_err!(self.mc.cat_expr_unadjusted(expr)); - self.delegate_consume(expr.id, expr.span, cmt_unadjusted); + // these are handled via special case above + self.tcx().sess.span_bug(expr.span, "nexpected AutoUnsizeUniq"); } - ty::AutoUnsafe(..) => { + + ty::AutoUnsafe(m, ref baseref) => { + let cmt_base = self.walk_autoref_recursively(expr, cmt_derefd, baseref); + + debug!("walk_autoref: expr.id={} cmt_base={}", + expr.id, + cmt_base.repr(self.tcx())); + + // Converting from a &T to *T (or &mut T to *mut T) is + // treated as borrowing it for the enclosing temporary + // scope. + let r = ty::ReScope(region::CodeExtent::from_node_id(expr.id)); + + self.delegate.borrow(expr.id, + expr.span, + cmt_base, + r, + ty::BorrowKind::from_mutbl(m), + AutoUnsafe); } } + + // Construct the categorization for the result of the autoref. + // This is always an rvalue, since we are producing a new + // (temporary) indirection. + + let adj_ty = + ty::adjust_ty_for_autoref(self.tcx(), + expr.span, + cmt_derefd.ty, + opt_autoref); + + self.mc.cat_rvalue_node(expr.id, expr.span, adj_ty) } + fn walk_autoref_recursively(&mut self, + expr: &ast::Expr, + cmt_derefd: &mc::cmt<'tcx>, + autoref: &Option>>) + -> mc::cmt<'tcx> + { + // Shuffle from a ref to an optional box to an optional ref. + let autoref: Option<&ty::AutoRef<'tcx>> = autoref.as_ref().map(|b| &**b); + self.walk_autoref(expr, cmt_derefd, autoref) + } + + // When this returns true, it means that the expression *is* a // method-call (i.e. via the operator-overload). This true result // also implies that walk_overloaded_operator already took care of diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 85255d04df432..6c7dc61109fb5 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -833,6 +833,15 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { ret } + /// Returns the lifetime of a temporary created by expr with id `id`. + /// This could be `'static` if `id` is part of a constant expression. + pub fn temporary_scope(&self, id: ast::NodeId) -> ty::Region { + match self.typer.temporary_scope(id) { + Some(scope) => ty::ReScope(scope), + None => ty::ReStatic + } + } + pub fn cat_rvalue_node(&self, id: ast::NodeId, span: Span, @@ -848,17 +857,12 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> { _ => check_const::NOT_CONST }; + // Compute maximum lifetime of this rvalue. This is 'static if + // we can promote to a constant, otherwise equal to enclosing temp + // lifetime. let re = match qualif & check_const::NON_STATIC_BORROWS { - check_const::PURE_CONST => { - // Constant rvalues get promoted to 'static. - ty::ReStatic - } - _ => { - match self.typer.temporary_scope(id) { - Some(scope) => ty::ReScope(scope), - None => ty::ReStatic - } - } + check_const::PURE_CONST => ty::ReStatic, + _ => self.temporary_scope(id), }; let ret = self.cat_rvalue(id, span, re, expr_ty); debug!("cat_rvalue_node ret {}", ret.repr(self.tcx())); diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs index ce7b492c51af1..9776538de3fed 100644 --- a/src/librustc_borrowck/borrowck/check_loans.rs +++ b/src/librustc_borrowck/borrowck/check_loans.rs @@ -542,6 +542,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> { euv::OverloadedOperator(..) | euv::AddrOf(..) | euv::AutoRef(..) | + euv::AutoUnsafe(..) | euv::ClosureInvocation(..) | euv::ForLoop(..) | euv::RefBinding(..) | diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs index f8da075e4bdc2..c57cbcb929fbc 100644 --- a/src/librustc_borrowck/borrowck/mod.rs +++ b/src/librustc_borrowck/borrowck/mod.rs @@ -775,6 +775,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { euv::AddrOf | euv::RefBinding | euv::AutoRef | + euv::AutoUnsafe | euv::ForLoop | euv::MatchDiscriminant => { format!("cannot borrow {} as mutable", descr) @@ -822,6 +823,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> { BorrowViolation(euv::OverloadedOperator) | BorrowViolation(euv::AddrOf) | BorrowViolation(euv::AutoRef) | + BorrowViolation(euv::AutoUnsafe) | BorrowViolation(euv::RefBinding) | BorrowViolation(euv::MatchDiscriminant) => { "cannot borrow data mutably" diff --git a/src/librustc_typeck/check/op.rs b/src/librustc_typeck/check/op.rs index 49e88dc1483eb..7c1fea4e60f6e 100644 --- a/src/librustc_typeck/check/op.rs +++ b/src/librustc_typeck/check/op.rs @@ -20,7 +20,6 @@ use super::{ PreferMutLvalue, structurally_resolved_type, }; -use middle::infer; use middle::traits; use middle::ty::{self, Ty}; use syntax::ast; @@ -314,36 +313,9 @@ fn lookup_op_method<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>, let method = match trait_did { Some(trait_did) => { - // We do eager coercions to make using operators - // more ergonomic: - // - // - If the input is of type &'a T (resp. &'a mut T), - // then reborrow it to &'b T (resp. &'b mut T) where - // 'b <= 'a. This makes things like `x == y`, where - // `x` and `y` are both region pointers, work. We - // could also solve this with variance or different - // traits that don't force left and right to have same - // type. - let (adj_ty, adjustment) = match lhs_ty.sty { - ty::ty_rptr(r_in, mt) => { - let r_adj = fcx.infcx().next_region_var(infer::Autoref(lhs_expr.span)); - fcx.mk_subr(infer::Reborrow(lhs_expr.span), r_adj, *r_in); - let adjusted_ty = ty::mk_rptr(fcx.tcx(), fcx.tcx().mk_region(r_adj), mt); - let autoptr = ty::AutoPtr(r_adj, mt.mutbl, None); - let adjustment = ty::AutoDerefRef { autoderefs: 1, autoref: Some(autoptr) }; - (adjusted_ty, adjustment) - } - _ => { - (lhs_ty, ty::AutoDerefRef { autoderefs: 0, autoref: None }) - } - }; - - debug!("adjusted_ty={} adjustment={:?}", - adj_ty.repr(fcx.tcx()), - adjustment); - + let noop = ty::AutoDerefRef { autoderefs: 0, autoref: None }; method::lookup_in_trait_adjusted(fcx, expr.span, Some(lhs_expr), opname, - trait_did, adjustment, adj_ty, Some(other_tys)) + trait_did, noop, lhs_ty, Some(other_tys)) } None => None }; diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index 9171367468026..9554e6ad8aad3 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -1119,8 +1119,8 @@ fn link_pattern<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>, fn link_autoref(rcx: &Rcx, expr: &ast::Expr, autoderefs: usize, - autoref: &ty::AutoRef) { - + autoref: &ty::AutoRef) +{ debug!("link_autoref(autoref={:?})", autoref); let mc = mc::MemCategorizationContext::new(rcx.fcx); let expr_cmt = ignore_err!(mc.cat_expr_autoderefd(expr, autoderefs)); @@ -1128,11 +1128,15 @@ fn link_autoref(rcx: &Rcx, match *autoref { ty::AutoPtr(r, m, _) => { - link_region(rcx, expr.span, r, - ty::BorrowKind::from_mutbl(m), expr_cmt); + link_region(rcx, expr.span, r, ty::BorrowKind::from_mutbl(m), expr_cmt); + } + + ty::AutoUnsafe(m, _) => { + let r = ty::ReScope(CodeExtent::from_node_id(expr.id)); + link_region(rcx, expr.span, r, ty::BorrowKind::from_mutbl(m), expr_cmt); } - ty::AutoUnsafe(..) | ty::AutoUnsizeUniq(_) | ty::AutoUnsize(_) => {} + ty::AutoUnsizeUniq(_) | ty::AutoUnsize(_) => {} } } diff --git a/src/test/compile-fail/borrowck-use-uninitialized-in-cast-trait.rs b/src/test/compile-fail/borrowck-use-uninitialized-in-cast-trait.rs new file mode 100644 index 0000000000000..796b455f5c70a --- /dev/null +++ b/src/test/compile-fail/borrowck-use-uninitialized-in-cast-trait.rs @@ -0,0 +1,20 @@ +// Copyright 2015 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Variation on `borrowck-use-uninitialized-in-cast` in which we do a +// trait cast from an uninitialized source. Issue #20791. + +trait Foo { fn dummy(&self) { } } +impl Foo for i32 { } + +fn main() { + let x: &i32; + let y = x as *const Foo; //~ ERROR use of possibly uninitialized variable: `*x` +} diff --git a/src/test/compile-fail/borrowck-use-uninitialized-in-cast.rs b/src/test/compile-fail/borrowck-use-uninitialized-in-cast.rs new file mode 100644 index 0000000000000..a3d5af80b533b --- /dev/null +++ b/src/test/compile-fail/borrowck-use-uninitialized-in-cast.rs @@ -0,0 +1,20 @@ +// Copyright 2015 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Check that we detect unused values that are cast to other things. +// The problem was specified to casting to `*`, as creating unsafe +// pointers was not being fully checked. Issue #20791. + +// pretty-expanded FIXME #23616 + +fn main() { + let x: &i32; + let y = x as *const i32; //~ ERROR use of possibly uninitialized variable: `*x` +} From 45eb54c870df94805d8e71525fd30844137905cf Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 8 Apr 2015 12:06:29 -0700 Subject: [PATCH 12/33] configure: Remove obsolete --nightly flag --- configure | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-) diff --git a/configure b/configure index ef474fcf79dab..8c190a6f42b22 100755 --- a/configure +++ b/configure @@ -1,4 +1,4 @@ -#!/bin/sh +<#!/bin/sh msg() { echo "configure: $1" @@ -540,7 +540,6 @@ opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds" opt local-rust 0 "use an installed rustc rather than downloading a snapshot" opt llvm-static-stdcpp 0 "statically link to libstdc++ for LLVM" opt rpath 0 "build rpaths into rustc itself" -opt nightly 0 "build nightly packages" opt verify-install 1 "verify installed binaries work" # This is used by the automation to produce single-target nightlies opt dist-host-only 0 "only install bins for the host architecture" @@ -556,6 +555,7 @@ valopt llvm-root "" "set LLVM root" valopt jemalloc-root "" "set directory where libjemalloc_pic.a is located" valopt build "${DEFAULT_BUILD}" "GNUs ./configure syntax LLVM build triple" valopt android-cross-path "/opt/ndk_standalone" "Android NDK standalone path" +valopt release-channel "dev" "the name of the release channel to build" # Many of these are saved below during the "writing configuration" step # (others are conditionally saved). @@ -568,7 +568,6 @@ valopt_nosave local-rust-root "/usr/local" "set prefix for local rust binary" valopt_nosave host "${CFG_BUILD}" "GNUs ./configure syntax LLVM host triples" valopt_nosave target "${CFG_HOST}" "GNUs ./configure syntax LLVM target triples" valopt_nosave mandir "${CFG_PREFIX}/share/man" "install man pages in PATH" -valopt_nosave release-channel "dev" "the name of the release channel to build" # Temporarily support old triples until buildbots get updated CFG_BUILD=$(to_llvm_triple $CFG_BUILD) @@ -621,14 +620,6 @@ case "$CFG_RELEASE_CHANNEL" in ;; esac -# Continue supporting the old --enable-nightly flag to transition the bots -# XXX Remove me -if [ ! -z "$CFG_ENABLE_NIGHTLY" ] -then - CFG_RELEASE_CHANNEL=nightly -fi -putvar CFG_RELEASE_CHANNEL - # A magic value that allows the compiler to use unstable features # during the bootstrap even when doing so would normally be an error # because of feature staging or because the build turns on From bc9f16c59960cfb306178428956f8446337d27e7 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 8 Apr 2015 12:16:45 -0700 Subject: [PATCH 13/33] configure: Remove obsolete --disable-verify option rust-installer never verifies. --- configure | 1 - mk/install.mk | 10 ++-------- 2 files changed, 2 insertions(+), 9 deletions(-) diff --git a/configure b/configure index 8c190a6f42b22..51e9ad7d88e5f 100755 --- a/configure +++ b/configure @@ -540,7 +540,6 @@ opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds" opt local-rust 0 "use an installed rustc rather than downloading a snapshot" opt llvm-static-stdcpp 0 "statically link to libstdc++ for LLVM" opt rpath 0 "build rpaths into rustc itself" -opt verify-install 1 "verify installed binaries work" # This is used by the automation to produce single-target nightlies opt dist-host-only 0 "only install bins for the host architecture" opt inject-std-version 1 "inject the current compiler version of libstd into programs" diff --git a/mk/install.mk b/mk/install.mk index 8850cd778035f..cabc97a1e4912 100644 --- a/mk/install.mk +++ b/mk/install.mk @@ -8,12 +8,6 @@ # option. This file may not be copied, modified, or distributed # except according to those terms. -ifdef CFG_DISABLE_VERIFY_INSTALL -MAYBE_DISABLE_VERIFY=--disable-verify -else -MAYBE_DISABLE_VERIFY= -endif - install: ifeq (root user, $(USER) $(patsubst %,user,$(SUDO_USER))) # Build the dist as the original user @@ -22,9 +16,9 @@ else $(Q)$(MAKE) prepare_install endif ifeq ($(CFG_DISABLE_DOCS),) - $(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(DOC_PKG_NAME)-$(CFG_BUILD)/install.sh --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)" "$(MAYBE_DISABLE_VERIFY)" + $(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(DOC_PKG_NAME)-$(CFG_BUILD)/install.sh --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)" endif - $(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)" "$(MAYBE_DISABLE_VERIFY)" + $(Q)cd tmp/empty_dir && sh ../../tmp/dist/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix="$(DESTDIR)$(CFG_PREFIX)" --libdir="$(DESTDIR)$(CFG_LIBDIR)" --mandir="$(DESTDIR)$(CFG_MANDIR)" # Remove tmp files because it's a decent amount of disk space $(Q)rm -R tmp/dist From ed8eebd99b65c54d95ce4302ddff1633ed96549b Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 8 Apr 2015 13:17:46 -0700 Subject: [PATCH 14/33] configure: Rename --enable-debug to --enable-debug-assertions --- configure | 4 ++-- mk/main.mk | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/configure b/configure index 51e9ad7d88e5f..6564c8c26e431 100755 --- a/configure +++ b/configure @@ -1,4 +1,4 @@ -<#!/bin/sh +#!/bin/sh msg() { echo "configure: $1" @@ -534,7 +534,7 @@ opt optimize-llvm 1 "build optimized LLVM" opt optimize-tests 1 "build tests with optimizations" opt libcpp 1 "build with llvm with libc++ instead of libstdc++ when using clang" opt llvm-assertions 1 "build LLVM with assertions" -opt debug 1 "build with extra debug fun" +opt debug-assertions 1 "build with extra debug fun" opt fast-make 0 "use .gitmodules as timestamp for submodule deps" opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds" opt local-rust 0 "use an installed rustc rather than downloading a snapshot" diff --git a/mk/main.mk b/mk/main.mk index b9f2cf1cce89c..4428dcc43c877 100644 --- a/mk/main.mk +++ b/mk/main.mk @@ -126,10 +126,10 @@ endif CFG_JEMALLOC_FLAGS += $(JEMALLOC_FLAGS) -ifdef CFG_DISABLE_DEBUG +ifdef CFG_DISABLE_DEBUG_ASSERTIONS CFG_RUSTC_FLAGS += --cfg ndebug else - $(info cfg: enabling more debugging (CFG_ENABLE_DEBUG)) + $(info cfg: enabling more debugging (CFG_ENABLE_DEBUG_ASSERTIONS)) CFG_RUSTC_FLAGS += --cfg debug -C debug-assertions=on endif From 59e332bd2f3cd448b3976b919caeebede15a9694 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 8 Apr 2015 13:23:44 -0700 Subject: [PATCH 15/33] configure: Disable debug assertions by default --- configure | 2 +- mk/main.mk | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/configure b/configure index 6564c8c26e431..b301ad73c81bc 100755 --- a/configure +++ b/configure @@ -534,7 +534,7 @@ opt optimize-llvm 1 "build optimized LLVM" opt optimize-tests 1 "build tests with optimizations" opt libcpp 1 "build with llvm with libc++ instead of libstdc++ when using clang" opt llvm-assertions 1 "build LLVM with assertions" -opt debug-assertions 1 "build with extra debug fun" +opt debug-assertions 0 "build with extra debug fun" opt fast-make 0 "use .gitmodules as timestamp for submodule deps" opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds" opt local-rust 0 "use an installed rustc rather than downloading a snapshot" diff --git a/mk/main.mk b/mk/main.mk index 4428dcc43c877..0c80c3f84f0dc 100644 --- a/mk/main.mk +++ b/mk/main.mk @@ -126,11 +126,11 @@ endif CFG_JEMALLOC_FLAGS += $(JEMALLOC_FLAGS) -ifdef CFG_DISABLE_DEBUG_ASSERTIONS - CFG_RUSTC_FLAGS += --cfg ndebug -else +ifdef CFG_ENABLE_DEBUG_ASSERTIONS $(info cfg: enabling more debugging (CFG_ENABLE_DEBUG_ASSERTIONS)) CFG_RUSTC_FLAGS += --cfg debug -C debug-assertions=on +else + CFG_RUSTC_FLAGS += --cfg ndebug endif ifdef SAVE_TEMPS From 2cdfd372e2565a35374977da5c20ce6069c4aa41 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 8 Apr 2015 13:25:20 -0700 Subject: [PATCH 16/33] configure: Clarify help message for --enable-debug-assertions --- configure | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/configure b/configure index b301ad73c81bc..9ff1765775eec 100755 --- a/configure +++ b/configure @@ -534,7 +534,7 @@ opt optimize-llvm 1 "build optimized LLVM" opt optimize-tests 1 "build tests with optimizations" opt libcpp 1 "build with llvm with libc++ instead of libstdc++ when using clang" opt llvm-assertions 1 "build LLVM with assertions" -opt debug-assertions 0 "build with extra debug fun" +opt debug-assertions 0 "build with debugging assertions" opt fast-make 0 "use .gitmodules as timestamp for submodule deps" opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds" opt local-rust 0 "use an installed rustc rather than downloading a snapshot" From 8545d2ce5358b7b04d8be4531cf8b0ffb9a2e794 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 8 Apr 2015 13:27:12 -0700 Subject: [PATCH 17/33] configure: Disable LLVM asserts by default --- configure | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/configure b/configure index 9ff1765775eec..8620e1425d034 100755 --- a/configure +++ b/configure @@ -533,7 +533,7 @@ opt optimize-cxx 1 "build optimized C++ code" opt optimize-llvm 1 "build optimized LLVM" opt optimize-tests 1 "build tests with optimizations" opt libcpp 1 "build with llvm with libc++ instead of libstdc++ when using clang" -opt llvm-assertions 1 "build LLVM with assertions" +opt llvm-assertions 0 "build LLVM with assertions" opt debug-assertions 0 "build with debugging assertions" opt fast-make 0 "use .gitmodules as timestamp for submodule deps" opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds" @@ -1170,7 +1170,7 @@ do LLVM_DBG_OPTS="--enable-optimized" LLVM_INST_DIR=$LLVM_BUILD_DIR/Release fi - if [ ! -z "$CFG_DISABLE_LLVM_ASSERTIONS" ] + if [ -z "$CFG_ENABLE_LLVM_ASSERTIONS" ] then LLVM_ASSERTION_OPTS="--disable-assertions" else From 1b34f0aef0a843f4e5aa8b2d457162f9d58f52d8 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 8 Apr 2015 13:31:26 -0700 Subject: [PATCH 18/33] configure: Clarify --enable-debug-assertions status message --- mk/main.mk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mk/main.mk b/mk/main.mk index 0c80c3f84f0dc..98b9dda1251c7 100644 --- a/mk/main.mk +++ b/mk/main.mk @@ -127,7 +127,7 @@ endif CFG_JEMALLOC_FLAGS += $(JEMALLOC_FLAGS) ifdef CFG_ENABLE_DEBUG_ASSERTIONS - $(info cfg: enabling more debugging (CFG_ENABLE_DEBUG_ASSERTIONS)) + $(info cfg: enabling debug assertions (CFG_ENABLE_DEBUG_ASSERTIONS)) CFG_RUSTC_FLAGS += --cfg debug -C debug-assertions=on else CFG_RUSTC_FLAGS += --cfg ndebug From 7cbf8233539d74b9c6a3b1bdc67c66bfb9e0ce7e Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 8 Apr 2015 13:57:37 -0700 Subject: [PATCH 19/33] configure: Add --enable-debuginfo --- configure | 1 + mk/main.mk | 5 +++++ 2 files changed, 6 insertions(+) diff --git a/configure b/configure index 8620e1425d034..3fe9d543c5d38 100755 --- a/configure +++ b/configure @@ -535,6 +535,7 @@ opt optimize-tests 1 "build tests with optimizations" opt libcpp 1 "build with llvm with libc++ instead of libstdc++ when using clang" opt llvm-assertions 0 "build LLVM with assertions" opt debug-assertions 0 "build with debugging assertions" +opt debuginfo 0 "build with debugger metadata" opt fast-make 0 "use .gitmodules as timestamp for submodule deps" opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds" opt local-rust 0 "use an installed rustc rather than downloading a snapshot" diff --git a/mk/main.mk b/mk/main.mk index 98b9dda1251c7..ea00444453d00 100644 --- a/mk/main.mk +++ b/mk/main.mk @@ -133,6 +133,11 @@ else CFG_RUSTC_FLAGS += --cfg ndebug endif +ifdef CFG_ENABLE_DEBUGINFO + $(info cfg: enabling debuginfo (CFG_ENABLE_DEBUGINFO)) + CFG_RUSTC_FLAGS += -g +endif + ifdef SAVE_TEMPS CFG_RUSTC_FLAGS += --save-temps endif From 0cb937944664f7a52895c87f9007fcdface78a7e Mon Sep 17 00:00:00 2001 From: Keegan McAllister Date: Wed, 8 Apr 2015 12:52:58 -0700 Subject: [PATCH 20/33] Allow plugins to register LLVM passes --- src/librustc/plugin/registry.rs | 14 ++++++++++ src/librustc/session/mod.rs | 2 ++ src/librustc_driver/driver.rs | 4 ++- src/librustc_trans/back/write.rs | 15 ++++++++++ src/test/auxiliary/llvm_pass_plugin.rs | 28 +++++++++++++++++++ .../run-pass-fulldeps/llvm-pass-plugin.rs | 17 +++++++++++ 6 files changed, 79 insertions(+), 1 deletion(-) create mode 100644 src/test/auxiliary/llvm_pass_plugin.rs create mode 100644 src/test/run-pass-fulldeps/llvm-pass-plugin.rs diff --git a/src/librustc/plugin/registry.rs b/src/librustc/plugin/registry.rs index a73ed04ac0a41..322b5d3a8cf27 100644 --- a/src/librustc/plugin/registry.rs +++ b/src/librustc/plugin/registry.rs @@ -22,6 +22,7 @@ use syntax::ptr::P; use syntax::ast; use std::collections::HashMap; +use std::borrow::ToOwned; /// Structure used to register plugins. /// @@ -50,6 +51,9 @@ pub struct Registry<'a> { #[doc(hidden)] pub lint_groups: HashMap<&'static str, Vec>, + + #[doc(hidden)] + pub llvm_passes: Vec, } impl<'a> Registry<'a> { @@ -62,6 +66,7 @@ impl<'a> Registry<'a> { syntax_exts: vec!(), lint_passes: vec!(), lint_groups: HashMap::new(), + llvm_passes: vec!(), } } @@ -116,4 +121,13 @@ impl<'a> Registry<'a> { pub fn register_lint_group(&mut self, name: &'static str, to: Vec<&'static Lint>) { self.lint_groups.insert(name, to.into_iter().map(|x| LintId::of(x)).collect()); } + + /// Register an LLVM pass. + /// + /// Registration with LLVM itself is handled through static C++ objects with + /// constructors. This method simply adds a name to the list of passes to + /// execute. + pub fn register_llvm_pass(&mut self, name: &str) { + self.llvm_passes.push(name.to_owned()); + } } diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index 452840310aa41..148f484b0ed5c 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -52,6 +52,7 @@ pub struct Session { pub working_dir: PathBuf, pub lint_store: RefCell, pub lints: RefCell>>, + pub plugin_llvm_passes: RefCell>, pub crate_types: RefCell>, pub crate_metadata: RefCell>, pub features: RefCell, @@ -391,6 +392,7 @@ pub fn build_session_(sopts: config::Options, working_dir: env::current_dir().unwrap(), lint_store: RefCell::new(lint::LintStore::new()), lints: RefCell::new(NodeMap()), + plugin_llvm_passes: RefCell::new(Vec::new()), crate_types: RefCell::new(Vec::new()), crate_metadata: RefCell::new(Vec::new()), features: RefCell::new(feature_gate::Features::new()), diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index fe05b489229ad..e310798b20ab7 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -438,7 +438,7 @@ pub fn phase_2_configure_and_expand(sess: &Session, } }); - let Registry { syntax_exts, lint_passes, lint_groups, .. } = registry; + let Registry { syntax_exts, lint_passes, lint_groups, llvm_passes, .. } = registry; { let mut ls = sess.lint_store.borrow_mut(); @@ -449,6 +449,8 @@ pub fn phase_2_configure_and_expand(sess: &Session, for (name, to) in lint_groups { ls.register_group(Some(sess), true, name, to); } + + *sess.plugin_llvm_passes.borrow_mut() = llvm_passes; } // Lint plugins are registered; now we can process command line flags. diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs index cc588a365f6e6..de21d62651499 100644 --- a/src/librustc_trans/back/write.rs +++ b/src/librustc_trans/back/write.rs @@ -319,6 +319,8 @@ struct CodegenContext<'a> { lto_ctxt: Option<(&'a Session, &'a [String])>, // Handler to use for diagnostics produced during codegen. handler: &'a Handler, + // LLVM passes added by plugins. + plugin_passes: Vec, // LLVM optimizations for which we want to print remarks. remark: Passes, } @@ -328,6 +330,7 @@ impl<'a> CodegenContext<'a> { CodegenContext { lto_ctxt: Some((sess, reachable)), handler: sess.diagnostic().handler(), + plugin_passes: sess.plugin_llvm_passes.borrow().clone(), remark: sess.opts.cg.remark.clone(), } } @@ -461,6 +464,16 @@ unsafe fn optimize_and_codegen(cgcx: &CodegenContext, } } + for pass in &cgcx.plugin_passes { + let pass = CString::new(pass.clone()).unwrap(); + if !llvm::LLVMRustAddPass(mpm, pass.as_ptr()) { + cgcx.handler.err(&format!("a plugin asked for LLVM pass {:?} but LLVM \ + does not recognize it", pass)); + } + } + + cgcx.handler.abort_if_errors(); + // Finally, run the actual optimization passes time(config.time_passes, "llvm function passes", (), |()| llvm::LLVMRustRunFunctionPassManager(fpm, llmod)); @@ -907,6 +920,7 @@ fn run_work_multithreaded(sess: &Session, for i in 0..num_workers { let work_items_arc = work_items_arc.clone(); let diag_emitter = diag_emitter.clone(); + let plugin_passes = sess.plugin_llvm_passes.borrow().clone(); let remark = sess.opts.cg.remark.clone(); let (tx, rx) = channel(); @@ -921,6 +935,7 @@ fn run_work_multithreaded(sess: &Session, let cgcx = CodegenContext { lto_ctxt: None, handler: &diag_handler, + plugin_passes: plugin_passes, remark: remark, }; diff --git a/src/test/auxiliary/llvm_pass_plugin.rs b/src/test/auxiliary/llvm_pass_plugin.rs new file mode 100644 index 0000000000000..d61f47fd7ef27 --- /dev/null +++ b/src/test/auxiliary/llvm_pass_plugin.rs @@ -0,0 +1,28 @@ +// Copyright 2015 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// force-host + +#![feature(plugin_registrar)] +#![feature(rustc_private)] + +extern crate rustc; + +use rustc::plugin::Registry; + +#[plugin_registrar] +pub fn plugin_registrar(reg: &mut Registry) { + // This pass is built in to LLVM. + // + // Normally, we would name a pass that was registered through + // C++ static object constructors in the same .so file as the + // plugin registrar. + reg.register_llvm_pass("inline"); +} diff --git a/src/test/run-pass-fulldeps/llvm-pass-plugin.rs b/src/test/run-pass-fulldeps/llvm-pass-plugin.rs new file mode 100644 index 0000000000000..5dfef636f9f36 --- /dev/null +++ b/src/test/run-pass-fulldeps/llvm-pass-plugin.rs @@ -0,0 +1,17 @@ +// Copyright 2015 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// aux-build:llvm_pass_plugin.rs +// ignore-stage1 + +#![feature(plugin)] +#![plugin(llvm_pass_plugin)] + +pub fn main() { } From 1002155c755562b8932251b50dac149edf8c885b Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 8 Apr 2015 14:21:36 -0700 Subject: [PATCH 21/33] Add --enable-debug to control multiple perf options --- configure | 38 +++++++++++++++++++++++++++++++++----- 1 file changed, 33 insertions(+), 5 deletions(-) diff --git a/configure b/configure index 3fe9d543c5d38..4d2868ede5c95 100755 --- a/configure +++ b/configure @@ -523,19 +523,16 @@ fi BOOL_OPTIONS="" VAL_OPTIONS="" +opt debug 0 "debug mode" opt valgrind 0 "run tests with valgrind (memcheck by default)" opt helgrind 0 "run tests with helgrind instead of memcheck" opt valgrind-rpass 1 "run rpass-valgrind tests with valgrind" opt docs 1 "build standard library documentation" opt compiler-docs 0 "build compiler documentation" -opt optimize 1 "build optimized rust code" -opt optimize-cxx 1 "build optimized C++ code" -opt optimize-llvm 1 "build optimized LLVM" opt optimize-tests 1 "build tests with optimizations" opt libcpp 1 "build with llvm with libc++ instead of libstdc++ when using clang" opt llvm-assertions 0 "build LLVM with assertions" opt debug-assertions 0 "build with debugging assertions" -opt debuginfo 0 "build with debugger metadata" opt fast-make 0 "use .gitmodules as timestamp for submodule deps" opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds" opt local-rust 0 "use an installed rustc rather than downloading a snapshot" @@ -546,6 +543,14 @@ opt dist-host-only 0 "only install bins for the host architecture" opt inject-std-version 1 "inject the current compiler version of libstd into programs" opt llvm-version-check 1 "don't check if the LLVM version is supported, build anyway" +# Optimization and debugging options. These may be overridden by the release channel, etc. +opt_nosave optimize 1 "build optimized rust code" +opt_nosave optimize-cxx 1 "build optimized C++ code" +opt_nosave optimize-llvm 1 "build optimized LLVM" +opt_nosave llvm-assertions 0 "build LLVM with assertions" +opt_nosave debug-assertions 0 "build with debugging assertions" +opt_nosave debuginfo 0 "build with debugger metadata" + valopt localstatedir "/var/lib" "local state directory" valopt sysconfdir "/etc" "install system configuration files" @@ -620,6 +625,24 @@ case "$CFG_RELEASE_CHANNEL" in ;; esac +# Adjust perf and debug options for debug mode +if [ -n "$CFG_ENABLE_DEBUG" ]; then + msg "debug mode enabled, setting performance options" + CFG_DISABLE_OPTIMIZE=1 + CFG_DISABLE_OPTIMIZE_CXX=1 + CFG_DISABLE_OPTIMIZE_LLVM=1 + CFG_ENABLE_LLVM_ASSERTIONS=1 + CFG_ENABLE_DEBUG_ASSERTIONS=1 +fi + +# OK, now write the debugging options +if [ -n "$CFG_DISABLE_OPTIMIZE" ]; then putvar CFG_DISABLE_OPTIMIZE; fi +if [ -n "$CFG_DISABLE_OPTIMIZE_CXX" ]; then putvar CFG_DISABLE_OPTIMIZE_CXX; fi +if [ -n "$CFG_DISABLE_OPTIMIZE_LLVM" ]; then putvar CFG_DISABLE_OPTIMIZE_LLVM; fi +if [ -n "$CFG_ENABLE_LLVM_ASSERTIONS" ]; then putvar CFG_ENABLE_LLVM_ASSERTIONS; fi +if [ -n "$CFG_ENABLE_DEBUG_ASSERTIONS" ]; then putvar CFG_ENABLE_DEBUG_ASSERTIONS; fi +if [ -n "$CFG_ENABLE_DEBUGINFO" ]; then putvar CFG_ENABLE_DEBUGINFO; fi + # A magic value that allows the compiler to use unstable features # during the bootstrap even when doing so would normally be an error # because of feature staging or because the build turns on @@ -1425,6 +1448,11 @@ move_if_changed config.tmp config.mk rm -f config.tmp touch config.stamp -step_msg "complete" +if [ -z "$CFG_ENABLE_DEBUG" ]; then + step_msg "configured in release mode. for development consider --enable-debug" +else + step_msg "complete" +fi + msg "run \`make help\`" msg From 6d17c35cd5fb806eb81441a1cbea755b0efc41ad Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 8 Apr 2015 15:12:08 -0700 Subject: [PATCH 22/33] configure: Add --enable-debug-jemalloc --- configure | 3 +++ mk/rt.mk | 4 ++++ 2 files changed, 7 insertions(+) diff --git a/configure b/configure index 4d2868ede5c95..b23cfaf976f0e 100755 --- a/configure +++ b/configure @@ -550,6 +550,7 @@ opt_nosave optimize-llvm 1 "build optimized LLVM" opt_nosave llvm-assertions 0 "build LLVM with assertions" opt_nosave debug-assertions 0 "build with debugging assertions" opt_nosave debuginfo 0 "build with debugger metadata" +opt_nosave debug-jemalloc 0 "build jemalloc with --enable-debug --enable-fill" valopt localstatedir "/var/lib" "local state directory" valopt sysconfdir "/etc" "install system configuration files" @@ -633,6 +634,7 @@ if [ -n "$CFG_ENABLE_DEBUG" ]; then CFG_DISABLE_OPTIMIZE_LLVM=1 CFG_ENABLE_LLVM_ASSERTIONS=1 CFG_ENABLE_DEBUG_ASSERTIONS=1 + CFG_ENABLE_DEBUG_JEMALLOC=1 fi # OK, now write the debugging options @@ -642,6 +644,7 @@ if [ -n "$CFG_DISABLE_OPTIMIZE_LLVM" ]; then putvar CFG_DISABLE_OPTIMIZE_LLVM; f if [ -n "$CFG_ENABLE_LLVM_ASSERTIONS" ]; then putvar CFG_ENABLE_LLVM_ASSERTIONS; fi if [ -n "$CFG_ENABLE_DEBUG_ASSERTIONS" ]; then putvar CFG_ENABLE_DEBUG_ASSERTIONS; fi if [ -n "$CFG_ENABLE_DEBUGINFO" ]; then putvar CFG_ENABLE_DEBUGINFO; fi +if [ -n "$CFG_ENABLE_DEBUG_JEMALLOC" ]; then putvar CFG_ENABLE_DEBUG_JEMALLOC; fi # A magic value that allows the compiler to use unstable features # during the bootstrap even when doing so would normally be an error diff --git a/mk/rt.mk b/mk/rt.mk index 527485c502936..70abce8b46067 100644 --- a/mk/rt.mk +++ b/mk/rt.mk @@ -143,6 +143,10 @@ else ifeq ($(findstring android, $(OSTYPE_$(1))), android) JEMALLOC_ARGS_$(1) := --disable-tls endif +ifdef CFG_ENABLE_DEBUG_JEMALLOC + JEMALLOC_ARGS_$(1) += --enable-debug --enable-fill +endif + ################################################################################ # jemalloc ################################################################################ From 2a9e1011b1af99b00557f122b2bf4a645b274b90 Mon Sep 17 00:00:00 2001 From: Luke Gallagher Date: Thu, 9 Apr 2015 08:20:51 +1000 Subject: [PATCH 23/33] Remove `ignore-tidy-linelength` from tests that no longer need it --- src/test/compile-fail/bad-mid-path-type-params.rs | 2 -- src/test/compile-fail/bad-sized.rs | 2 -- src/test/compile-fail/coherence-default-trait-impl.rs | 2 -- src/test/compile-fail/coherence-orphan.rs | 1 - src/test/compile-fail/issue-8767.rs | 2 -- src/test/compile-fail/lint-stability.rs | 1 - src/test/compile-fail/lint-uppercase-variables.rs | 2 -- .../compile-fail/typeck-default-trait-impl-outside-crate.rs | 2 -- .../compile-fail/use-after-move-implicity-coerced-object.rs | 2 -- src/test/debuginfo/gdb-pretty-std.rs | 1 - 10 files changed, 17 deletions(-) diff --git a/src/test/compile-fail/bad-mid-path-type-params.rs b/src/test/compile-fail/bad-mid-path-type-params.rs index 7a7406115d393..20ac757354faf 100644 --- a/src/test/compile-fail/bad-mid-path-type-params.rs +++ b/src/test/compile-fail/bad-mid-path-type-params.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// ignore-tidy-linelength - struct S { contents: T, } diff --git a/src/test/compile-fail/bad-sized.rs b/src/test/compile-fail/bad-sized.rs index 1944acbe1f345..5878e9a9f649b 100644 --- a/src/test/compile-fail/bad-sized.rs +++ b/src/test/compile-fail/bad-sized.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// ignore-tidy-linelength - use std::cell::RefCell; trait Trait : ::std::marker::MarkerTrait {} diff --git a/src/test/compile-fail/coherence-default-trait-impl.rs b/src/test/compile-fail/coherence-default-trait-impl.rs index a5b317307379e..062a4a43b694b 100644 --- a/src/test/compile-fail/coherence-default-trait-impl.rs +++ b/src/test/compile-fail/coherence-default-trait-impl.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// ignore-tidy-linelength - #![feature(optin_builtin_traits)] use std::marker::MarkerTrait; diff --git a/src/test/compile-fail/coherence-orphan.rs b/src/test/compile-fail/coherence-orphan.rs index 2243a0507f2d1..78435f1a78a16 100644 --- a/src/test/compile-fail/coherence-orphan.rs +++ b/src/test/compile-fail/coherence-orphan.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// ignore-tidy-linelength // aux-build:coherence_orphan_lib.rs #![feature(optin_builtin_traits)] diff --git a/src/test/compile-fail/issue-8767.rs b/src/test/compile-fail/issue-8767.rs index 9abd8c9e3fcda..96c8ec4505856 100644 --- a/src/test/compile-fail/issue-8767.rs +++ b/src/test/compile-fail/issue-8767.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// ignore-tidy-linelength - impl B { //~ ERROR use of undeclared type name `B` } diff --git a/src/test/compile-fail/lint-stability.rs b/src/test/compile-fail/lint-stability.rs index 391b49e10686e..16f195b4ea268 100644 --- a/src/test/compile-fail/lint-stability.rs +++ b/src/test/compile-fail/lint-stability.rs @@ -12,7 +12,6 @@ // aux-build:inherited_stability.rs // aux-build:stability_cfg1.rs // aux-build:stability_cfg2.rs -// ignore-tidy-linelength #![deny(deprecated)] #![allow(dead_code)] diff --git a/src/test/compile-fail/lint-uppercase-variables.rs b/src/test/compile-fail/lint-uppercase-variables.rs index 517be0eb8acd9..1615af400713c 100644 --- a/src/test/compile-fail/lint-uppercase-variables.rs +++ b/src/test/compile-fail/lint-uppercase-variables.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// ignore-tidy-linelength - #![allow(dead_code)] #![deny(non_snake_case)] diff --git a/src/test/compile-fail/typeck-default-trait-impl-outside-crate.rs b/src/test/compile-fail/typeck-default-trait-impl-outside-crate.rs index a345bd1b65c0e..09b97dfb30f24 100644 --- a/src/test/compile-fail/typeck-default-trait-impl-outside-crate.rs +++ b/src/test/compile-fail/typeck-default-trait-impl-outside-crate.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// ignore-tidy-linelength - #![feature(optin_builtin_traits)] impl Copy for .. {} diff --git a/src/test/compile-fail/use-after-move-implicity-coerced-object.rs b/src/test/compile-fail/use-after-move-implicity-coerced-object.rs index 26d22b072eb48..addc572175231 100644 --- a/src/test/compile-fail/use-after-move-implicity-coerced-object.rs +++ b/src/test/compile-fail/use-after-move-implicity-coerced-object.rs @@ -8,8 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// ignore-tidy-linelength - #![feature(box_syntax)] use std::fmt; diff --git a/src/test/debuginfo/gdb-pretty-std.rs b/src/test/debuginfo/gdb-pretty-std.rs index dbf80a9bccce8..1da9a06b0eea4 100644 --- a/src/test/debuginfo/gdb-pretty-std.rs +++ b/src/test/debuginfo/gdb-pretty-std.rs @@ -10,7 +10,6 @@ // ignore-windows failing on win32 bot // ignore-freebsd: gdb package too new -// ignore-tidy-linelength // ignore-lldb // ignore-android: FIXME(#10381) // compile-flags:-g From 65e3f0325a64d8f1affa146b3575a4b7c90458d7 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Wed, 8 Apr 2015 15:48:46 -0700 Subject: [PATCH 24/33] std: Destabilize the internals of panic! Now that we have a `#[allow_internal_unstable]` attribute for macros there's no need for these two `begin_unwind` functions to be stable. Right now the `panic!` interface is the only one we wish to stabilize, so remove the stability markers from these functions. While this is a breaking change, it is highly unlikely to break any actual code. It is recommended to use the `panic!` macro instead if it breaks explicit calls into `std::rt`. [breaking-change] cc #24208 --- src/libstd/macros.rs | 1 + src/libstd/rt/unwind.rs | 3 --- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index b3d1adb44218a..3d10c151f80d6 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -37,6 +37,7 @@ /// ``` #[macro_export] #[stable(feature = "rust1", since = "1.0.0")] +#[allow_internal_unstable] macro_rules! panic { () => ({ panic!("explicit panic") diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index f71811b1eadf6..2f58a437eb472 100644 --- a/src/libstd/rt/unwind.rs +++ b/src/libstd/rt/unwind.rs @@ -495,7 +495,6 @@ pub extern fn rust_begin_unwind(msg: fmt::Arguments, /// on (e.g.) the inlining of other functions as possible), by moving /// the actual formatting into this shared place. #[inline(never)] #[cold] -#[stable(since = "1.0.0", feature = "rust1")] pub fn begin_unwind_fmt(msg: fmt::Arguments, file_line: &(&'static str, usize)) -> ! { use fmt::Write; @@ -511,7 +510,6 @@ pub fn begin_unwind_fmt(msg: fmt::Arguments, file_line: &(&'static str, usize)) /// This is the entry point of unwinding for panic!() and assert!(). #[inline(never)] #[cold] // avoid code bloat at the call sites as much as possible -#[stable(since = "1.0.0", feature = "rust1")] pub fn begin_unwind(msg: M, file_line: &(&'static str, usize)) -> ! { // Note that this should be the only allocation performed in this code path. // Currently this means that panic!() on OOM will invoke this code path, @@ -598,7 +596,6 @@ fn begin_unwind_inner(msg: Box, /// Only a limited number of callbacks can be registered, and this function /// returns whether the callback was successfully registered or not. It is not /// currently possible to unregister a callback once it has been registered. -#[unstable(feature = "std_misc")] pub unsafe fn register(f: Callback) -> bool { match CALLBACK_CNT.fetch_add(1, Ordering::SeqCst) { // The invocation code has knowledge of this window where the count has From 6b32072c0c958949a4b6946bb7adb29241804454 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Wed, 8 Apr 2015 16:38:38 -0700 Subject: [PATCH 25/33] std: Stabilize Clone::clone_from This method hasn't really changed since is inception, and it can often be a nice performance win for some situations. This method also imposes no burden on implementors or users of `Clone` as it's just a default method on the side. --- src/libcore/clone.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs index 85e5bde48598e..0ded6a4b364b1 100644 --- a/src/libcore/clone.rs +++ b/src/libcore/clone.rs @@ -44,8 +44,7 @@ pub trait Clone : Sized { /// but can be overridden to reuse the resources of `a` to avoid unnecessary /// allocations. #[inline(always)] - #[unstable(feature = "core", - reason = "this function is rarely used")] + #[stable(feature = "rust1", since = "1.0.0")] fn clone_from(&mut self, source: &Self) { *self = source.clone() } From 561fdec1350056d77245a17d59c7d740c95621d1 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Wed, 8 Apr 2015 16:41:14 -0700 Subject: [PATCH 26/33] std: Stabilize io::Error::from_raw_os_error This commit stabilizes the old `io::Error::from_os_error` after being renamed to use the `raw_os_error` terminology instead. This function is often useful when writing bindings to OS functions but only actually converting to an I/O error at a later point. --- src/libstd/io/error.rs | 12 +++++++++--- src/libstd/sys/unix/process2.rs | 2 +- src/libstd/sys/unix/thread.rs | 2 +- src/libstd/sys/windows/net.rs | 2 +- 4 files changed, 12 insertions(+), 6 deletions(-) diff --git a/src/libstd/io/error.rs b/src/libstd/io/error.rs index b84dcb8fb6206..7428d0a8e35ef 100644 --- a/src/libstd/io/error.rs +++ b/src/libstd/io/error.rs @@ -163,12 +163,18 @@ impl Error { /// `Error` for the error code. #[stable(feature = "rust1", since = "1.0.0")] pub fn last_os_error() -> Error { - Error::from_os_error(sys::os::errno() as i32) + Error::from_raw_os_error(sys::os::errno() as i32) } /// Creates a new instance of an `Error` from a particular OS error code. - #[unstable(feature = "io", - reason = "unclear whether this function is necessary")] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn from_raw_os_error(code: i32) -> Error { + Error { repr: Repr::Os(code) } + } + + /// Creates a new instance of an `Error` from a particular OS error code. + #[unstable(feature = "io", reason = "deprecated")] + #[deprecated(since = "1.0.0", reason = "renamed to from_raw_os_error")] pub fn from_os_error(code: i32) -> Error { Error { repr: Repr::Os(code) } } diff --git a/src/libstd/sys/unix/process2.rs b/src/libstd/sys/unix/process2.rs index c2a8b26aef4eb..60f00c80b4abd 100644 --- a/src/libstd/sys/unix/process2.rs +++ b/src/libstd/sys/unix/process2.rs @@ -193,7 +193,7 @@ impl Process { let errno = combine(&bytes[0.. 4]); assert!(p.wait().is_ok(), "wait() should either return Ok or panic"); - return Err(Error::from_os_error(errno)) + return Err(Error::from_raw_os_error(errno)) } Ok(0) => return Ok(p), Err(ref e) if e.kind() == ErrorKind::Interrupted => {} diff --git a/src/libstd/sys/unix/thread.rs b/src/libstd/sys/unix/thread.rs index eb61f21aacd5d..73d6cd73621ad 100644 --- a/src/libstd/sys/unix/thread.rs +++ b/src/libstd/sys/unix/thread.rs @@ -212,7 +212,7 @@ pub unsafe fn create(stack: usize, p: Thunk) -> io::Result { assert_eq!(pthread_attr_destroy(&mut attr), 0); return if ret != 0 { - Err(io::Error::from_os_error(ret)) + Err(io::Error::from_raw_os_error(ret)) } else { mem::forget(p); // ownership passed to pthread_create Ok(native) diff --git a/src/libstd/sys/windows/net.rs b/src/libstd/sys/windows/net.rs index 12a8ef99d764a..5ced8863e62a9 100644 --- a/src/libstd/sys/windows/net.rs +++ b/src/libstd/sys/windows/net.rs @@ -43,7 +43,7 @@ pub fn init() { /// Returns the last error from the Windows socket interface. fn last_error() -> io::Error { - io::Error::from_os_error(unsafe { c::WSAGetLastError() }) + io::Error::from_raw_os_error(unsafe { c::WSAGetLastError() }) } /// Checks if the signed integer is the Windows constant `SOCKET_ERROR` (-1) From ec7c800d2fc0dc5918d325ae68d88c9708d20259 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Wed, 8 Apr 2015 16:27:10 -0700 Subject: [PATCH 27/33] Remove pretty-expanded from failing tests This commit removes pretty-expanded from all tests that wind up calling panic! one way or another now that its internals are unstable. --- src/test/run-pass-fulldeps/rename-directory.rs | 1 - src/test/run-pass/argument-passing.rs | 1 - src/test/run-pass/arith-2.rs | 1 - src/test/run-pass/arith-unsigned.rs | 1 - src/test/run-pass/artificial-block.rs | 1 - src/test/run-pass/as-precedence.rs | 1 - src/test/run-pass/asm-in-out-operand.rs | 1 - src/test/run-pass/asm-out-assign.rs | 1 - src/test/run-pass/assign-assign.rs | 1 - src/test/run-pass/assignability-trait.rs | 1 - src/test/run-pass/associated-types-basic.rs | 1 - src/test/run-pass/associated-types-binding-in-trait.rs | 1 - src/test/run-pass/associated-types-bound.rs | 1 - src/test/run-pass/associated-types-constant-type.rs | 1 - src/test/run-pass/associated-types-doubleendediterator-object.rs | 1 - src/test/run-pass/associated-types-enum-field-named.rs | 1 - src/test/run-pass/associated-types-enum-field-numbered.rs | 1 - src/test/run-pass/associated-types-in-default-method.rs | 1 - src/test/run-pass/associated-types-in-fn.rs | 1 - src/test/run-pass/associated-types-in-impl-generics.rs | 1 - src/test/run-pass/associated-types-in-inherent-method.rs | 1 - src/test/run-pass/associated-types-issue-20220.rs | 1 - src/test/run-pass/associated-types-issue-21212.rs | 1 - src/test/run-pass/associated-types-iterator-binding.rs | 1 - ...ed-types-project-from-type-param-via-bound-in-where-clause.rs | 1 - .../associated-types-projection-from-known-type-in-impl.rs | 1 - src/test/run-pass/associated-types-projection-in-supertrait.rs | 1 - src/test/run-pass/associated-types-ref-in-struct-literal.rs | 1 - src/test/run-pass/associated-types-return.rs | 1 - src/test/run-pass/associated-types-simple.rs | 1 - src/test/run-pass/associated-types-stream.rs | 1 - src/test/run-pass/associated-types-struct-field-named.rs | 1 - src/test/run-pass/associated-types-struct-field-numbered.rs | 1 - src/test/run-pass/associated-types-sugar-path.rs | 1 - src/test/run-pass/attr-main-2.rs | 1 - src/test/run-pass/attr-no-drop-flag-size.rs | 1 - src/test/run-pass/auto-loop.rs | 1 - src/test/run-pass/auto-ref-sliceable.rs | 1 - src/test/run-pass/autobind.rs | 1 - src/test/run-pass/autoderef-method-on-trait.rs | 1 - src/test/run-pass/autoderef-method-priority.rs | 1 - src/test/run-pass/autoderef-method-twice-but-not-thrice.rs | 1 - src/test/run-pass/autoderef-method-twice.rs | 1 - src/test/run-pass/autoderef-method.rs | 1 - src/test/run-pass/autoref-intermediate-types-issue-3585.rs | 1 - src/test/run-pass/big-literals.rs | 1 - src/test/run-pass/binary-minus-without-space.rs | 1 - src/test/run-pass/bind-by-move.rs | 1 - src/test/run-pass/bind-field-short-with-modifiers.rs | 1 - src/test/run-pass/block-arg-call-as.rs | 1 - src/test/run-pass/block-expr-precedence.rs | 1 - src/test/run-pass/block-fn-coerce.rs | 1 - src/test/run-pass/bool-not.rs | 1 - src/test/run-pass/bool.rs | 1 - src/test/run-pass/borrow-tuple-fields.rs | 1 - src/test/run-pass/borrowck-borrow-from-expr-block.rs | 1 - src/test/run-pass/borrowck-closures-two-imm.rs | 1 - src/test/run-pass/borrowck-fixed-length-vecs.rs | 1 - src/test/run-pass/borrowck-freeze-frozen-mut.rs | 1 - src/test/run-pass/borrowck-macro-interaction-issue-6304.rs | 1 - src/test/run-pass/borrowck-move-by-capture-ok.rs | 1 - src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs | 1 - src/test/run-pass/borrowck-pat-reassign-no-binding.rs | 1 - src/test/run-pass/borrowck-rvalues-mutable.rs | 1 - src/test/run-pass/borrowck-scope-of-deref-issue-4666.rs | 1 - src/test/run-pass/borrowck-univariant-enum.rs | 1 - src/test/run-pass/borrowed-ptr-pattern-2.rs | 1 - src/test/run-pass/borrowed-ptr-pattern-3.rs | 1 - src/test/run-pass/borrowed-ptr-pattern-infallible.rs | 1 - src/test/run-pass/borrowed-ptr-pattern-option.rs | 1 - src/test/run-pass/borrowed-ptr-pattern.rs | 1 - src/test/run-pass/break.rs | 1 - src/test/run-pass/bug-7183-generics.rs | 1 - src/test/run-pass/builtin-superkinds-capabilities-transitive.rs | 1 - src/test/run-pass/builtin-superkinds-capabilities-xc.rs | 1 - src/test/run-pass/builtin-superkinds-capabilities.rs | 1 - src/test/run-pass/builtin-superkinds-self-type.rs | 1 - src/test/run-pass/by-value-self-in-mut-slot.rs | 1 - src/test/run-pass/call-closure-from-overloaded-op.rs | 1 - src/test/run-pass/capture-clauses-boxed-closures.rs | 1 - src/test/run-pass/capture-clauses-unboxed-closures.rs | 1 - src/test/run-pass/cast.rs | 1 - src/test/run-pass/cci_nested_exe.rs | 1 - src/test/run-pass/cell-does-not-clone.rs | 1 - src/test/run-pass/cfg-macros-foo.rs | 1 - src/test/run-pass/cfg-macros-notfoo.rs | 1 - src/test/run-pass/cfgs-on-items.rs | 1 - src/test/run-pass/char.rs | 1 - src/test/run-pass/check-static-mut-slices.rs | 1 - src/test/run-pass/check-static-slice.rs | 1 - src/test/run-pass/class-exports.rs | 1 - src/test/run-pass/class-method-cross-crate.rs | 1 - src/test/run-pass/class-methods-cross-crate.rs | 1 - src/test/run-pass/class-methods.rs | 1 - src/test/run-pass/class-poly-methods-cross-crate.rs | 1 - src/test/run-pass/class-poly-methods.rs | 1 - src/test/run-pass/classes-cross-crate.rs | 1 - src/test/run-pass/classes-simple-cross-crate.rs | 1 - src/test/run-pass/classes-simple-method.rs | 1 - src/test/run-pass/classes-simple.rs | 1 - src/test/run-pass/cleanup-rvalue-during-if-and-while.rs | 1 - src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs | 1 - src/test/run-pass/closure-inference.rs | 1 - src/test/run-pass/closure-inference2.rs | 1 - src/test/run-pass/cmp-default.rs | 1 - src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs | 1 - src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs | 1 - src/test/run-pass/coerce-reborrow-mut-vec-arg.rs | 1 - src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs | 1 - src/test/run-pass/compare-generic-enums.rs | 1 - src/test/run-pass/concat.rs | 1 - src/test/run-pass/conditional-compile.rs | 1 - src/test/run-pass/conditional-debug-macro-off.rs | 1 - src/test/run-pass/const-autoderef.rs | 1 - src/test/run-pass/const-big-enum.rs | 1 - src/test/run-pass/const-binops.rs | 1 - src/test/run-pass/const-block-cross-crate-fn.rs | 1 - src/test/run-pass/const-block-item-macro-codegen.rs | 1 - src/test/run-pass/const-block-item.rs | 1 - src/test/run-pass/const-block.rs | 1 - src/test/run-pass/const-cast-ptr-int.rs | 1 - src/test/run-pass/const-cast.rs | 1 - src/test/run-pass/const-const.rs | 1 - src/test/run-pass/const-contents.rs | 1 - src/test/run-pass/const-cross-crate-const.rs | 1 - src/test/run-pass/const-cross-crate-extern.rs | 1 - src/test/run-pass/const-deref.rs | 1 - src/test/run-pass/const-enum-byref-self.rs | 1 - src/test/run-pass/const-enum-byref.rs | 1 - src/test/run-pass/const-enum-cast.rs | 1 - src/test/run-pass/const-enum-ptr.rs | 1 - src/test/run-pass/const-enum-struct.rs | 1 - src/test/run-pass/const-enum-struct2.rs | 1 - src/test/run-pass/const-enum-structlike.rs | 1 - src/test/run-pass/const-enum-tuple.rs | 1 - src/test/run-pass/const-enum-tuple2.rs | 1 - src/test/run-pass/const-enum-tuplestruct.rs | 1 - src/test/run-pass/const-enum-tuplestruct2.rs | 1 - src/test/run-pass/const-enum-vec-index.rs | 1 - src/test/run-pass/const-enum-vec-ptr.rs | 1 - src/test/run-pass/const-enum-vector.rs | 1 - src/test/run-pass/const-extern-function.rs | 1 - src/test/run-pass/const-fn-val.rs | 1 - src/test/run-pass/const-negative.rs | 1 - src/test/run-pass/const-nullary-enum.rs | 1 - src/test/run-pass/const-nullary-univariant-enum.rs | 1 - src/test/run-pass/const-region-ptrs-noncopy.rs | 1 - src/test/run-pass/const-str-ptr.rs | 1 - src/test/run-pass/const-tuple-struct.rs | 1 - src/test/run-pass/consts-in-patterns.rs | 1 - src/test/run-pass/cross-crate-newtype-struct-pat.rs | 1 - src/test/run-pass/deep.rs | 1 - src/test/run-pass/deref-mut-on-ref.rs | 1 - src/test/run-pass/deref-on-ref.rs | 1 - src/test/run-pass/deref-rc.rs | 1 - src/test/run-pass/deriving-cmp-generic-enum.rs | 1 - src/test/run-pass/deriving-cmp-generic-struct-enum.rs | 1 - src/test/run-pass/deriving-cmp-generic-struct.rs | 1 - src/test/run-pass/deriving-cmp-generic-tuple-struct.rs | 1 - src/test/run-pass/deriving-cmp-shortcircuit.rs | 1 - src/test/run-pass/deriving-default-box.rs | 1 - src/test/run-pass/deriving-encodable-decodable-box.rs | 1 - src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs | 1 - src/test/run-pass/deriving-hash.rs | 1 - src/test/run-pass/deriving-rand.rs | 1 - src/test/run-pass/destructure-array-1.rs | 1 - src/test/run-pass/die-macro.rs | 1 - src/test/run-pass/div-mod.rs | 1 - src/test/run-pass/drop-struct-as-object.rs | 1 - src/test/run-pass/drop-with-type-ascription-1.rs | 1 - src/test/run-pass/drop-with-type-ascription-2.rs | 1 - src/test/run-pass/dropck_tarena_sound_drop.rs | 1 - src/test/run-pass/dst-deref-mut.rs | 1 - src/test/run-pass/dst-deref.rs | 1 - src/test/run-pass/dst-index.rs | 1 - src/test/run-pass/dst-raw.rs | 1 - src/test/run-pass/dst-struct-sole.rs | 1 - src/test/run-pass/dst-struct.rs | 1 - src/test/run-pass/dst-trait.rs | 1 - src/test/run-pass/else-if.rs | 1 - src/test/run-pass/empty-allocation-non-null.rs | 1 - src/test/run-pass/enum-alignment.rs | 1 - src/test/run-pass/enum-clike-ffi-as-int.rs | 1 - src/test/run-pass/enum-discr.rs | 1 - src/test/run-pass/enum-discrim-autosizing.rs | 1 - src/test/run-pass/enum-discrim-manual-sizing.rs | 1 - src/test/run-pass/enum-disr-val-pretty.rs | 1 - src/test/run-pass/enum-null-pointer-opt.rs | 1 - src/test/run-pass/enum-nullable-const-null-with-fields.rs | 1 - src/test/run-pass/enum-nullable-simplifycfg-misopt.rs | 1 - src/test/run-pass/env-home-dir.rs | 1 - src/test/run-pass/env-vars.rs | 1 - src/test/run-pass/eq-multidispatch.rs | 1 - src/test/run-pass/estr-uniq.rs | 1 - src/test/run-pass/exec-env.rs | 1 - src/test/run-pass/explicit-self-generic.rs | 1 - src/test/run-pass/explicit-self-objects-uniq.rs | 1 - src/test/run-pass/explicit-self.rs | 1 - src/test/run-pass/expr-block-fn.rs | 1 - src/test/run-pass/expr-block-generic-unique2.rs | 1 - src/test/run-pass/expr-block-generic.rs | 1 - src/test/run-pass/expr-block-slot.rs | 1 - src/test/run-pass/expr-block-unique.rs | 1 - src/test/run-pass/expr-block.rs | 1 - src/test/run-pass/expr-copy.rs | 1 - src/test/run-pass/expr-fn.rs | 1 - src/test/run-pass/expr-if-generic.rs | 1 - src/test/run-pass/expr-if-panic-all.rs | 1 - src/test/run-pass/expr-if-panic.rs | 1 - src/test/run-pass/expr-if-unique.rs | 1 - src/test/run-pass/expr-if.rs | 1 - src/test/run-pass/expr-match-generic-unique1.rs | 1 - src/test/run-pass/expr-match-generic-unique2.rs | 1 - src/test/run-pass/expr-match-generic.rs | 1 - src/test/run-pass/expr-match-panic-all.rs | 1 - src/test/run-pass/expr-match-panic.rs | 1 - src/test/run-pass/expr-match-unique.rs | 1 - src/test/run-pass/expr-match.rs | 1 - src/test/run-pass/ext-expand-inner-exprs.rs | 1 - src/test/run-pass/exterior.rs | 1 - src/test/run-pass/extern-call-direct.rs | 1 - src/test/run-pass/extern-compare-with-return-type.rs | 1 - src/test/run-pass/extern-methods.rs | 1 - src/test/run-pass/extern-pass-char.rs | 1 - src/test/run-pass/extern-pass-double.rs | 1 - src/test/run-pass/extern-pass-u32.rs | 1 - src/test/run-pass/extern-pass-u64.rs | 1 - src/test/run-pass/extern-return-TwoU16s.rs | 1 - src/test/run-pass/extern-return-TwoU32s.rs | 1 - src/test/run-pass/extern-return-TwoU64s.rs | 1 - src/test/run-pass/extern-return-TwoU8s.rs | 1 - src/test/run-pass/extern-take-value.rs | 1 - src/test/run-pass/extoption_env-not-defined.rs | 1 - src/test/run-pass/field-destruction-order.rs | 1 - src/test/run-pass/fixed_length_copy.rs | 1 - src/test/run-pass/float2.rs | 1 - src/test/run-pass/floatlits.rs | 1 - src/test/run-pass/fn-bare-assign.rs | 1 - src/test/run-pass/fn-bare-size.rs | 1 - src/test/run-pass/fn-bare-spawn.rs | 1 - src/test/run-pass/fn-item-type-cast.rs | 1 - src/test/run-pass/fn-pattern-expected-type.rs | 1 - src/test/run-pass/for-destruct.rs | 1 - src/test/run-pass/for-loop-goofiness.rs | 1 - src/test/run-pass/for-loop-into-iterator.rs | 1 - src/test/run-pass/for-loop-panic.rs | 1 - src/test/run-pass/foreach-external-iterators-break.rs | 1 - .../run-pass/foreach-external-iterators-hashmap-break-restart.rs | 1 - src/test/run-pass/foreach-external-iterators-hashmap.rs | 1 - src/test/run-pass/foreach-external-iterators-loop.rs | 1 - src/test/run-pass/foreach-external-iterators-nested.rs | 1 - src/test/run-pass/foreach-external-iterators.rs | 1 - src/test/run-pass/foreach-nested.rs | 1 - src/test/run-pass/foreign-fn-with-byval.rs | 1 - src/test/run-pass/format-nan.rs | 1 - src/test/run-pass/format-ref-cell.rs | 1 - src/test/run-pass/fsu-moves-and-copies.rs | 1 - src/test/run-pass/fun-call-variants.rs | 1 - src/test/run-pass/fun-indirect-call.rs | 1 - src/test/run-pass/func-arg-incomplete-pattern.rs | 1 - src/test/run-pass/func-arg-ref-pattern.rs | 1 - src/test/run-pass/func-arg-wild-pattern.rs | 1 - src/test/run-pass/generic-exterior-unique.rs | 1 - src/test/run-pass/generic-extern-mangle.rs | 1 - src/test/run-pass/generic-fn-infer.rs | 1 - src/test/run-pass/generic-object.rs | 1 - src/test/run-pass/generic-static-methods.rs | 1 - src/test/run-pass/generic-type.rs | 1 - src/test/run-pass/generic-unique.rs | 1 - src/test/run-pass/getopts_ref.rs | 1 - src/test/run-pass/global-scope.rs | 1 - src/test/run-pass/guards-not-exhaustive.rs | 1 - src/test/run-pass/guards.rs | 1 - src/test/run-pass/hrtb-fn-like-trait-object.rs | 1 - src/test/run-pass/hrtb-fn-like-trait.rs | 1 - src/test/run-pass/hrtb-trait-object-paren-notation.rs | 1 - src/test/run-pass/huge-largest-array.rs | 1 - src/test/run-pass/hygiene-dodging-1.rs | 1 - src/test/run-pass/hygienic-labels.rs | 1 - src/test/run-pass/i32-sub.rs | 1 - src/test/run-pass/i8-incr.rs | 1 - src/test/run-pass/if-let.rs | 1 - src/test/run-pass/impl-inherent-non-conflict.rs | 1 - src/test/run-pass/impl-inherent-prefer-over-trait.rs | 1 - src/test/run-pass/impl-not-adjacent-to-type.rs | 1 - src/test/run-pass/import-glob-crate.rs | 1 - src/test/run-pass/inferred-suffix-in-pattern-range.rs | 1 - src/test/run-pass/inherent-trait-method-order.rs | 1 - src/test/run-pass/init-res-into-things.rs | 1 - src/test/run-pass/inner-attrs-on-impl.rs | 1 - src/test/run-pass/inner-static.rs | 1 - src/test/run-pass/integer-literal-radix.rs | 1 - src/test/run-pass/intrinsic-alignment.rs | 1 - src/test/run-pass/intrinsic-assume.rs | 1 - src/test/run-pass/intrinsic-atomics-cc.rs | 1 - src/test/run-pass/intrinsic-atomics.rs | 1 - src/test/run-pass/intrinsic-move-val.rs | 1 - src/test/run-pass/intrinsic-return-address.rs | 1 - src/test/run-pass/intrinsic-unreachable.rs | 1 - src/test/run-pass/intrinsics-integer.rs | 1 - src/test/run-pass/intrinsics-math.rs | 1 - src/test/run-pass/issue-10392.rs | 1 - src/test/run-pass/issue-10734.rs | 1 - src/test/run-pass/issue-10802.rs | 1 - src/test/run-pass/issue-1112.rs | 1 - src/test/run-pass/issue-11552.rs | 1 - src/test/run-pass/issue-11577.rs | 1 - src/test/run-pass/issue-11677.rs | 1 - src/test/run-pass/issue-11940.rs | 1 - src/test/run-pass/issue-12285.rs | 1 - src/test/run-pass/issue-12677.rs | 1 - src/test/run-pass/issue-13204.rs | 1 - src/test/run-pass/issue-13323.rs | 1 - src/test/run-pass/issue-13507-2.rs | 1 - src/test/run-pass/issue-13867.rs | 1 - src/test/run-pass/issue-14308.rs | 1 - src/test/run-pass/issue-14456.rs | 1 - src/test/run-pass/issue-14865.rs | 1 - src/test/run-pass/issue-14936.rs | 1 - src/test/run-pass/issue-14940.rs | 1 - src/test/run-pass/issue-15080.rs | 1 - src/test/run-pass/issue-15104.rs | 1 - src/test/run-pass/issue-15129.rs | 1 - src/test/run-pass/issue-15149.rs | 1 - src/test/run-pass/issue-15673.rs | 1 - src/test/run-pass/issue-15689-1.rs | 1 - src/test/run-pass/issue-15734.rs | 1 - src/test/run-pass/issue-15793.rs | 1 - src/test/run-pass/issue-15858.rs | 1 - src/test/run-pass/issue-15881-model-lexer-dotdotdot.rs | 1 - src/test/run-pass/issue-16151.rs | 1 - src/test/run-pass/issue-16530.rs | 1 - src/test/run-pass/issue-16560.rs | 1 - src/test/run-pass/issue-16596.rs | 1 - src/test/run-pass/issue-16648.rs | 1 - src/test/run-pass/issue-16739.rs | 1 - src/test/run-pass/issue-16774.rs | 1 - src/test/run-pass/issue-1701.rs | 1 - src/test/run-pass/issue-17068.rs | 1 - src/test/run-pass/issue-17074.rs | 1 - src/test/run-pass/issue-17216.rs | 1 - src/test/run-pass/issue-17233.rs | 1 - src/test/run-pass/issue-17302.rs | 1 - src/test/run-pass/issue-17662.rs | 1 - src/test/run-pass/issue-17718-parse-const.rs | 1 - src/test/run-pass/issue-17718.rs | 1 - src/test/run-pass/issue-17734.rs | 1 - src/test/run-pass/issue-17877.rs | 1 - src/test/run-pass/issue-18352.rs | 1 - src/test/run-pass/issue-18412.rs | 1 - src/test/run-pass/issue-18652.rs | 1 - src/test/run-pass/issue-18767.rs | 1 - src/test/run-pass/issue-18859.rs | 1 - src/test/run-pass/issue-19244.rs | 1 - src/test/run-pass/issue-19811-escape-unicode.rs | 1 - src/test/run-pass/issue-21058.rs | 1 - src/test/run-pass/issue-21306.rs | 1 - src/test/run-pass/issue-21361.rs | 1 - src/test/run-pass/issue-21384.rs | 1 - src/test/run-pass/issue-21634.rs | 1 - src/test/run-pass/issue-21655.rs | 1 - src/test/run-pass/issue-21721.rs | 1 - src/test/run-pass/issue-22036.rs | 1 - src/test/run-pass/issue-2214.rs | 1 - src/test/run-pass/issue-22536-copy-mustnt-zero.rs | 1 - src/test/run-pass/issue-2311-2.rs | 1 - src/test/run-pass/issue-2312.rs | 1 - src/test/run-pass/issue-2428.rs | 1 - src/test/run-pass/issue-2611-3.rs | 1 - src/test/run-pass/issue-2735-2.rs | 1 - src/test/run-pass/issue-2735-3.rs | 1 - src/test/run-pass/issue-2748-b.rs | 1 - src/test/run-pass/issue-2895.rs | 1 - src/test/run-pass/issue-2936.rs | 1 - src/test/run-pass/issue-3091.rs | 1 - src/test/run-pass/issue-3290.rs | 1 - src/test/run-pass/issue-333.rs | 1 - src/test/run-pass/issue-3574.rs | 1 - src/test/run-pass/issue-3895.rs | 1 - src/test/run-pass/issue-3935.rs | 1 - src/test/run-pass/issue-3979-generics.rs | 1 - src/test/run-pass/issue-3979-xcrate.rs | 1 - src/test/run-pass/issue-3979.rs | 1 - src/test/run-pass/issue-4016.rs | 1 - src/test/run-pass/issue-4107.rs | 1 - src/test/run-pass/issue-4448.rs | 1 - src/test/run-pass/issue-4734.rs | 1 - src/test/run-pass/issue-5239-2.rs | 1 - src/test/run-pass/issue-5521.rs | 1 - src/test/run-pass/issue-5530.rs | 1 - src/test/run-pass/issue-5917.rs | 1 - src/test/run-pass/issue-5997.rs | 1 - src/test/run-pass/issue-6128.rs | 1 - src/test/run-pass/issue-6130.rs | 1 - src/test/run-pass/issue-6153.rs | 1 - src/test/run-pass/issue-6334.rs | 1 - src/test/run-pass/issue-6449.rs | 1 - src/test/run-pass/issue-6892.rs | 1 - src/test/run-pass/issue-7575.rs | 1 - src/test/run-pass/issue-7663.rs | 1 - src/test/run-pass/issue-7784.rs | 1 - src/test/run-pass/issue-8351-1.rs | 1 - src/test/run-pass/issue-8351-2.rs | 1 - src/test/run-pass/issue-8391.rs | 1 - src/test/run-pass/issue-8460.rs | 1 - src/test/run-pass/issue-8498.rs | 1 - src/test/run-pass/issue-8709.rs | 1 - src/test/run-pass/issue-8860.rs | 1 - src/test/run-pass/issue-8898.rs | 1 - src/test/run-pass/issue-9188.rs | 1 - src/test/run-pass/issue-9259.rs | 1 - src/test/run-pass/issue-9394-inherited-trait-calls.rs | 1 - src/test/run-pass/issue-979.rs | 1 - src/test/run-pass/issue-9918.rs | 1 - src/test/run-pass/iter-cloned-type-inference.rs | 1 - src/test/run-pass/kindck-owned-trait-contains-1.rs | 1 - src/test/run-pass/last-use-in-block.rs | 1 - src/test/run-pass/last-use-in-cap-clause.rs | 1 - src/test/run-pass/let-destruct-ref.rs | 1 - src/test/run-pass/let-var-hygiene.rs | 1 - src/test/run-pass/logging-enabled-debug.rs | 1 - src/test/run-pass/logging-enabled.rs | 1 - src/test/run-pass/loop-break-cont-1.rs | 1 - src/test/run-pass/loop-scope.rs | 1 - src/test/run-pass/macro-block-nonterminal.rs | 1 - src/test/run-pass/macro-crate-def-only.rs | 1 - src/test/run-pass/macro-crate-use.rs | 1 - src/test/run-pass/macro-deep_expansion.rs | 1 - src/test/run-pass/macro-interpolation.rs | 1 - src/test/run-pass/macro-method-issue-4621.rs | 1 - src/test/run-pass/macro-of-higher-order.rs | 1 - src/test/run-pass/macro-pat.rs | 1 - src/test/run-pass/macro-path.rs | 1 - src/test/run-pass/macro-with-attrs1.rs | 1 - src/test/run-pass/macro-with-attrs2.rs | 1 - src/test/run-pass/match-arm-statics.rs | 1 - src/test/run-pass/match-borrowed_str.rs | 1 - src/test/run-pass/match-bot-2.rs | 1 - src/test/run-pass/match-enum-struct-0.rs | 1 - src/test/run-pass/match-enum-struct-1.rs | 1 - src/test/run-pass/match-implicit-copy-unique.rs | 1 - src/test/run-pass/match-in-macro.rs | 1 - src/test/run-pass/match-pattern-bindings.rs | 1 - src/test/run-pass/match-pipe-binding.rs | 1 - src/test/run-pass/match-ref-binding-in-guard-3256.rs | 1 - src/test/run-pass/match-ref-binding-mut-option.rs | 1 - src/test/run-pass/match-ref-binding-mut.rs | 1 - src/test/run-pass/match-ref-binding.rs | 1 - src/test/run-pass/match-static-const-rename.rs | 1 - src/test/run-pass/match-str.rs | 1 - src/test/run-pass/match-struct-0.rs | 1 - src/test/run-pass/match-tag.rs | 1 - src/test/run-pass/match-vec-alternatives.rs | 1 - src/test/run-pass/match-vec-rvalue.rs | 1 - src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs | 1 - src/test/run-pass/method-projection.rs | 1 - src/test/run-pass/method-self-arg-aux1.rs | 1 - src/test/run-pass/method-self-arg-aux2.rs | 1 - src/test/run-pass/method-self-arg-trait.rs | 1 - src/test/run-pass/method-self-arg.rs | 1 - src/test/run-pass/method-two-trait-defer-resolution-1.rs | 1 - src/test/run-pass/method-two-trait-defer-resolution-2.rs | 1 - src/test/run-pass/method-where-clause.rs | 1 - src/test/run-pass/mod-inside-fn.rs | 1 - src/test/run-pass/monad.rs | 1 - src/test/run-pass/move-1-unique.rs | 1 - src/test/run-pass/move-2-unique.rs | 1 - src/test/run-pass/move-2.rs | 1 - src/test/run-pass/move-3-unique.rs | 1 - src/test/run-pass/move-4-unique.rs | 1 - src/test/run-pass/move-4.rs | 1 - src/test/run-pass/move-arg-2-unique.rs | 1 - src/test/run-pass/move-arg-2.rs | 1 - src/test/run-pass/move-arg.rs | 1 - src/test/run-pass/move-out-of-field.rs | 1 - src/test/run-pass/move-scalar.rs | 1 - src/test/run-pass/multi-let.rs | 1 - src/test/run-pass/multidispatch1.rs | 1 - src/test/run-pass/multidispatch2.rs | 1 - src/test/run-pass/mut-function-arguments.rs | 1 - src/test/run-pass/mut-in-ident-patterns.rs | 1 - .../run-pass/mutability-inherits-through-fixed-length-vec.rs | 1 - src/test/run-pass/negative.rs | 1 - src/test/run-pass/nested-class.rs | 1 - src/test/run-pass/nested-function-names-issue-8587.rs | 1 - src/test/run-pass/nested_item_main.rs | 1 - src/test/run-pass/new-unicode-escapes.rs | 1 - src/test/run-pass/newlambdas.rs | 1 - src/test/run-pass/newtype-polymorphic.rs | 1 - src/test/run-pass/newtype-struct-drop-run.rs | 1 - src/test/run-pass/no-landing-pads.rs | 1 - src/test/run-pass/non-legacy-modes.rs | 1 - src/test/run-pass/nul-characters.rs | 1 - src/test/run-pass/nullable-pointer-ffi-compat.rs | 1 - src/test/run-pass/nullable-pointer-iotareduction.rs | 1 - src/test/run-pass/nullable-pointer-size.rs | 1 - src/test/run-pass/nullary-or-pattern.rs | 1 - src/test/run-pass/numeric-method-autoexport.rs | 1 - src/test/run-pass/object-method-numbering.rs | 1 - src/test/run-pass/object-safety-sized-self-by-value-self.rs | 1 - src/test/run-pass/object-safety-sized-self-generic-method.rs | 1 - src/test/run-pass/object-safety-sized-self-return-Self.rs | 1 - src/test/run-pass/objects-coerce-freeze-borrored.rs | 1 - .../run-pass/objects-owned-object-borrowed-method-headerless.rs | 1 - src/test/run-pass/objects-owned-object-owned-method.rs | 1 - src/test/run-pass/once-move-out-on-heap.rs | 1 - src/test/run-pass/one-tuple.rs | 1 - src/test/run-pass/operator-associativity.rs | 1 - src/test/run-pass/option-unwrap.rs | 1 - src/test/run-pass/or-pattern.rs | 1 - src/test/run-pass/order-drop-with-match.rs | 1 - src/test/run-pass/out-pointer-aliasing.rs | 1 - src/test/run-pass/overloaded-autoderef-indexing.rs | 1 - src/test/run-pass/overloaded-autoderef-order.rs | 1 - src/test/run-pass/overloaded-autoderef-vtable.rs | 1 - src/test/run-pass/overloaded-autoderef-xcrate.rs | 1 - src/test/run-pass/overloaded-calls-object-one-arg.rs | 1 - src/test/run-pass/overloaded-calls-object-two-args.rs | 1 - src/test/run-pass/overloaded-calls-object-zero-args.rs | 1 - src/test/run-pass/overloaded-calls-simple.rs | 1 - src/test/run-pass/overloaded-calls-zero-args.rs | 1 - src/test/run-pass/overloaded-deref-count.rs | 1 - src/test/run-pass/overloaded-index-assoc-list.rs | 1 - src/test/run-pass/overloaded-index-autoderef.rs | 1 - src/test/run-pass/overloaded-index-in-field.rs | 1 - src/test/run-pass/overloaded-index.rs | 1 - src/test/run-pass/packed-struct-borrow-element.rs | 1 - src/test/run-pass/packed-struct-generic-layout.rs | 1 - src/test/run-pass/packed-struct-generic-size.rs | 1 - src/test/run-pass/packed-struct-layout.rs | 1 - src/test/run-pass/packed-struct-match.rs | 1 - src/test/run-pass/packed-struct-size-xc.rs | 1 - src/test/run-pass/packed-struct-size.rs | 1 - src/test/run-pass/packed-tuple-struct-layout.rs | 1 - src/test/run-pass/packed-tuple-struct-size.rs | 1 - src/test/run-pass/panic-in-dtor-drops-fields.rs | 1 - src/test/run-pass/pattern-bound-var-in-for-each.rs | 1 - src/test/run-pass/private-class-field.rs | 1 - src/test/run-pass/process-remove-from-env.rs | 1 - src/test/run-pass/range-type-infer.rs | 1 - src/test/run-pass/range.rs | 1 - src/test/run-pass/ranges-precedence.rs | 1 - src/test/run-pass/readalias.rs | 1 - src/test/run-pass/rec-extend.rs | 1 - src/test/run-pass/rec-tup.rs | 1 - src/test/run-pass/rec.rs | 1 - src/test/run-pass/record-pat.rs | 1 - src/test/run-pass/reexported-static-methods-cross-crate.rs | 1 - src/test/run-pass/regions-borrow-evec-fixed.rs | 1 - src/test/run-pass/regions-borrow-evec-uniq.rs | 1 - src/test/run-pass/regions-borrow-uniq.rs | 1 - src/test/run-pass/regions-bot.rs | 1 - .../run-pass/regions-close-over-type-parameter-successfully.rs | 1 - src/test/run-pass/regions-copy-closure.rs | 1 - src/test/run-pass/regions-dependent-addr-of.rs | 1 - src/test/run-pass/regions-early-bound-trait-param.rs | 1 - src/test/run-pass/regions-early-bound-used-in-bound-method.rs | 1 - src/test/run-pass/regions-early-bound-used-in-bound.rs | 1 - src/test/run-pass/regions-early-bound-used-in-type-param.rs | 1 - src/test/run-pass/regions-escape-into-other-fn.rs | 1 - src/test/run-pass/regions-infer-borrow-scope-addr-of.rs | 1 - src/test/run-pass/regions-infer-borrow-scope-view.rs | 1 - src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs | 1 - src/test/run-pass/regions-infer-borrow-scope.rs | 1 - src/test/run-pass/regions-infer-call-2.rs | 1 - src/test/run-pass/regions-infer-call.rs | 1 - src/test/run-pass/regions-infer-contravariance-due-to-ret.rs | 1 - .../run-pass/regions-lifetime-static-items-enclosing-scopes.rs | 1 - src/test/run-pass/regions-no-variance-from-fn-generics.rs | 1 - src/test/run-pass/regions-params.rs | 1 - src/test/run-pass/regions-refcell.rs | 1 - ...ns-relate-bound-regions-on-closures-to-inference-variables.rs | 1 - src/test/run-pass/regions-return-interior-of-option.rs | 1 - src/test/run-pass/regions-trait-object-1.rs | 1 - src/test/run-pass/repeat-expr-in-static.rs | 1 - src/test/run-pass/resolve-issue-2428.rs | 1 - src/test/run-pass/resource-in-struct.rs | 1 - src/test/run-pass/return-from-closure.rs | 1 - src/test/run-pass/segfault-no-out-of-stack.rs | 1 - src/test/run-pass/self-in-mut-slot-default-method.rs | 1 - src/test/run-pass/self-in-mut-slot-immediate-value.rs | 1 - src/test/run-pass/self-re-assign.rs | 1 - src/test/run-pass/self-shadowing-import.rs | 1 - src/test/run-pass/send_str_hashmap.rs | 1 - src/test/run-pass/send_str_treemap.rs | 1 - src/test/run-pass/sendfn-is-a-block.rs | 1 - src/test/run-pass/sepcomp-cci.rs | 1 - src/test/run-pass/sepcomp-extern.rs | 1 - src/test/run-pass/sepcomp-fns-backwards.rs | 1 - src/test/run-pass/sepcomp-fns.rs | 1 - src/test/run-pass/sepcomp-lib.rs | 1 - src/test/run-pass/sepcomp-statics.rs | 1 - src/test/run-pass/sepcomp-unwind.rs | 1 - src/test/run-pass/seq-compare.rs | 1 - src/test/run-pass/shift-various-types.rs | 1 - src/test/run-pass/shift.rs | 1 - src/test/run-pass/signed-shift-const-eval.rs | 1 - src/test/run-pass/sigpipe-should-be-ignored.rs | 1 - src/test/run-pass/simd-binop.rs | 1 - src/test/run-pass/simd-generics.rs | 1 - src/test/run-pass/simd-size-align.rs | 1 - src/test/run-pass/slice-2.rs | 1 - src/test/run-pass/slice-panic-1.rs | 1 - src/test/run-pass/slice-panic-2.rs | 1 - src/test/run-pass/slice.rs | 1 - src/test/run-pass/small-enum-range-edge.rs | 1 - src/test/run-pass/spawn-types.rs | 1 - src/test/run-pass/stable-addr-of.rs | 1 - src/test/run-pass/static-function-pointer-xc.rs | 1 - src/test/run-pass/static-function-pointer.rs | 1 - src/test/run-pass/static-impl.rs | 1 - src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs | 1 - src/test/run-pass/static-method-xcrate.rs | 1 - src/test/run-pass/static-methods-in-traits.rs | 1 - src/test/run-pass/static-mut-foreign.rs | 1 - src/test/run-pass/static-mut-xc.rs | 1 - src/test/run-pass/str-multiline.rs | 1 - src/test/run-pass/string-escapes.rs | 1 - src/test/run-pass/struct-aliases-xcrate.rs | 1 - src/test/run-pass/struct-aliases.rs | 1 - src/test/run-pass/struct-destructuring-cross-crate.rs | 1 - src/test/run-pass/struct-like-variant-match.rs | 1 - src/test/run-pass/struct-new-as-field-name.rs | 1 - src/test/run-pass/struct-order-of-eval-1.rs | 1 - src/test/run-pass/struct-order-of-eval-2.rs | 1 - src/test/run-pass/struct-order-of-eval-3.rs | 1 - src/test/run-pass/struct-order-of-eval-4.rs | 1 - src/test/run-pass/struct_variant_xc_match.rs | 1 - src/test/run-pass/supertrait-default-generics.rs | 1 - src/test/run-pass/swap-1.rs | 1 - src/test/run-pass/swap-2.rs | 1 - src/test/run-pass/syntax-extension-cfg.rs | 1 - src/test/run-pass/tag-align-dyn-u64.rs | 1 - src/test/run-pass/tag-align-dyn-variants.rs | 1 - src/test/run-pass/tag-align-u64.rs | 1 - src/test/run-pass/tag-variant-disr-val.rs | 1 - src/test/run-pass/tag.rs | 1 - src/test/run-pass/tail-direct.rs | 1 - src/test/run-pass/task-comm-5.rs | 1 - src/test/run-pass/task-comm-6.rs | 1 - src/test/run-pass/task-comm-chan-nil.rs | 1 - src/test/run-pass/terminate-in-initializer.rs | 1 - src/test/run-pass/trait-bounds.rs | 1 - src/test/run-pass/trait-default-method-bound-subst.rs | 1 - src/test/run-pass/trait-default-method-bound-subst2.rs | 1 - src/test/run-pass/trait-default-method-bound-subst3.rs | 1 - src/test/run-pass/trait-default-method-bound-subst4.rs | 1 - src/test/run-pass/trait-default-method-bound.rs | 1 - src/test/run-pass/trait-default-method-xc-2.rs | 1 - src/test/run-pass/trait-default-method-xc.rs | 1 - src/test/run-pass/trait-generic.rs | 1 - src/test/run-pass/trait-impl.rs | 1 - src/test/run-pass/trait-inheritance-auto-xc-2.rs | 1 - src/test/run-pass/trait-inheritance-auto-xc.rs | 1 - src/test/run-pass/trait-inheritance-auto.rs | 1 - src/test/run-pass/trait-inheritance-call-bound-inherited.rs | 1 - src/test/run-pass/trait-inheritance-call-bound-inherited2.rs | 1 - .../trait-inheritance-cast-without-call-to-supertrait.rs | 1 - src/test/run-pass/trait-inheritance-cast.rs | 1 - src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs | 1 - src/test/run-pass/trait-inheritance-cross-trait-call.rs | 1 - src/test/run-pass/trait-inheritance-diamond.rs | 1 - src/test/run-pass/trait-inheritance-multiple-inheritors.rs | 1 - src/test/run-pass/trait-inheritance-multiple-params.rs | 1 - src/test/run-pass/trait-inheritance-overloading-xc-exe.rs | 1 - src/test/run-pass/trait-inheritance-self-in-supertype.rs | 1 - src/test/run-pass/trait-inheritance-simple.rs | 1 - src/test/run-pass/trait-inheritance-static.rs | 1 - src/test/run-pass/trait-inheritance-static2.rs | 1 - src/test/run-pass/trait-inheritance-subst.rs | 1 - src/test/run-pass/trait-inheritance-subst2.rs | 1 - src/test/run-pass/trait-inheritance-visibility.rs | 1 - src/test/run-pass/trait-inheritance2.rs | 1 - src/test/run-pass/trait-object-generics.rs | 1 - src/test/run-pass/trait-object-with-lifetime-bound.rs | 1 - src/test/run-pass/trait-safety-ok-cc.rs | 1 - src/test/run-pass/trait-safety-ok.rs | 1 - src/test/run-pass/traits-assoc-type-in-supertrait.rs | 1 - src/test/run-pass/traits-conditional-dispatch.rs | 1 - src/test/run-pass/traits-conditional-model-fn.rs | 1 - src/test/run-pass/traits-default-method-macro.rs | 1 - src/test/run-pass/traits-multidispatch-infer-convert-target.rs | 1 - src/test/run-pass/traits-repeated-supertrait.rs | 1 - src/test/run-pass/trans-tag-static-padding.rs | 1 - src/test/run-pass/tup.rs | 1 - src/test/run-pass/tuple-index-fat-types.rs | 1 - src/test/run-pass/tuple-index.rs | 1 - src/test/run-pass/tydesc-name.rs | 1 - src/test/run-pass/type-id-higher-rank.rs | 1 - src/test/run-pass/type-namespace.rs | 1 - src/test/run-pass/type-sizes.rs | 1 - src/test/run-pass/typeck-macro-interaction-issue-8852.rs | 1 - src/test/run-pass/typeck_type_placeholder_1.rs | 1 - src/test/run-pass/typeid-intrinsic.rs | 1 - src/test/run-pass/typestate-multi-decl.rs | 1 - src/test/run-pass/u32-decr.rs | 1 - src/test/run-pass/u8-incr-decr.rs | 1 - src/test/run-pass/u8-incr.rs | 1 - src/test/run-pass/ufcs-polymorphic-paths.rs | 1 - src/test/run-pass/ufcs-trait-object.rs | 1 - src/test/run-pass/unboxed-closures-all-traits.rs | 1 - src/test/run-pass/unboxed-closures-blanket-fn-mut.rs | 1 - src/test/run-pass/unboxed-closures-blanket-fn.rs | 1 - src/test/run-pass/unboxed-closures-by-ref.rs | 1 - src/test/run-pass/unboxed-closures-call-fn-autoderef.rs | 1 - src/test/run-pass/unboxed-closures-call-sugar-autoderef.rs | 1 - src/test/run-pass/unboxed-closures-counter-not-moved.rs | 1 - src/test/run-pass/unboxed-closures-cross-crate.rs | 1 - src/test/run-pass/unboxed-closures-drop.rs | 1 - src/test/run-pass/unboxed-closures-extern-fn-hr.rs | 1 - src/test/run-pass/unboxed-closures-extern-fn.rs | 1 - src/test/run-pass/unboxed-closures-fn-as-fnmut-and-fnonce.rs | 1 - src/test/run-pass/unboxed-closures-fnmut-as-fnonce.rs | 1 - src/test/run-pass/unboxed-closures-infer-fnmut-calling-fnmut.rs | 1 - src/test/run-pass/unboxed-closures-infer-fnmut-move.rs | 1 - src/test/run-pass/unboxed-closures-infer-fnmut.rs | 1 - src/test/run-pass/unboxed-closures-infer-fnonce-move.rs | 1 - src/test/run-pass/unboxed-closures-infer-fnonce.rs | 1 - src/test/run-pass/unboxed-closures-infer-kind.rs | 1 - src/test/run-pass/unboxed-closures-infer-recursive-fn.rs | 1 - src/test/run-pass/unboxed-closures-infer-upvar.rs | 1 - src/test/run-pass/unboxed-closures-manual-impl.rs | 1 - .../unboxed-closures-move-some-upvars-in-by-ref-closure.rs | 1 - src/test/run-pass/unboxed-closures-simple.rs | 1 - src/test/run-pass/unboxed-closures-single-word-env.rs | 1 - src/test/run-pass/unboxed-closures-sugar-object.rs | 1 - src/test/run-pass/unboxed-closures-unique-type-id.rs | 1 - src/test/run-pass/unfold-cross-crate.rs | 1 - src/test/run-pass/uniq-self-in-mut-slot.rs | 1 - src/test/run-pass/unique-assign-copy.rs | 1 - src/test/run-pass/unique-assign-drop.rs | 1 - src/test/run-pass/unique-assign-generic.rs | 1 - src/test/run-pass/unique-assign.rs | 1 - src/test/run-pass/unique-autoderef-field.rs | 1 - src/test/run-pass/unique-autoderef-index.rs | 1 - src/test/run-pass/unique-cmp.rs | 1 - src/test/run-pass/unique-decl-init-copy.rs | 1 - src/test/run-pass/unique-decl-init.rs | 1 - src/test/run-pass/unique-decl-move.rs | 1 - src/test/run-pass/unique-decl.rs | 1 - src/test/run-pass/unique-deref.rs | 1 - src/test/run-pass/unique-destructure.rs | 1 - src/test/run-pass/unique-fn-arg-move.rs | 1 - src/test/run-pass/unique-fn-arg-mut.rs | 1 - src/test/run-pass/unique-fn-arg.rs | 1 - src/test/run-pass/unique-fn-ret.rs | 1 - src/test/run-pass/unique-in-vec-copy.rs | 1 - src/test/run-pass/unique-in-vec.rs | 1 - src/test/run-pass/unique-kinds.rs | 1 - src/test/run-pass/unique-move-drop.rs | 1 - src/test/run-pass/unique-move-temp.rs | 1 - src/test/run-pass/unique-move.rs | 1 - src/test/run-pass/unique-mutable.rs | 1 - src/test/run-pass/unique-pat-2.rs | 1 - src/test/run-pass/unique-pat.rs | 1 - src/test/run-pass/unique-rec.rs | 1 - src/test/run-pass/unique-send-2.rs | 1 - src/test/run-pass/unique-send.rs | 1 - src/test/run-pass/unique-swap.rs | 1 - src/test/run-pass/unit-like-struct-drop-run.rs | 1 - src/test/run-pass/unreachable-code-1.rs | 1 - src/test/run-pass/unreachable-code.rs | 1 - src/test/run-pass/unsafe-coercion.rs | 1 - src/test/run-pass/unsafe-pointer-assignability.rs | 1 - src/test/run-pass/unsized3.rs | 1 - src/test/run-pass/unwind-unique.rs | 1 - src/test/run-pass/variance-intersection-of-ref-and-opt-ref.rs | 1 - src/test/run-pass/variance-vec-covariant.rs | 1 - src/test/run-pass/vec-dst.rs | 1 - src/test/run-pass/vec-fixed-length.rs | 1 - src/test/run-pass/vec-growth.rs | 1 - src/test/run-pass/vec-macro-repeat.rs | 1 - src/test/run-pass/vec-macro-rvalue-scope.rs | 1 - src/test/run-pass/vec-macro-with-trailing-comma.rs | 1 - src/test/run-pass/vec-matching-autoslice.rs | 1 - src/test/run-pass/vec-matching-fixed.rs | 1 - src/test/run-pass/vec-matching-fold.rs | 1 - src/test/run-pass/vec-matching.rs | 1 - src/test/run-pass/vec-slice-drop.rs | 1 - src/test/run-pass/vec-slice.rs | 1 - src/test/run-pass/vec-tail-matching.rs | 1 - src/test/run-pass/vec-to_str.rs | 1 - src/test/run-pass/vec.rs | 1 - src/test/run-pass/vector-sort-panic-safe.rs | 1 - src/test/run-pass/wait-forked-but-failed-child.rs | 1 - src/test/run-pass/where-for-self.rs | 1 - src/test/run-pass/while-label.rs | 1 - src/test/run-pass/while-let.rs | 1 - src/test/run-pass/writealias.rs | 1 - src/test/run-pass/xcrate-address-insignificant.rs | 1 - src/test/run-pass/zero-size-type-destructors.rs | 1 - src/test/run-pass/zero_sized_subslice_match.rs | 1 - 792 files changed, 792 deletions(-) diff --git a/src/test/run-pass-fulldeps/rename-directory.rs b/src/test/run-pass-fulldeps/rename-directory.rs index a1e016bf2eaba..a0644e513a6e9 100644 --- a/src/test/run-pass-fulldeps/rename-directory.rs +++ b/src/test/run-pass-fulldeps/rename-directory.rs @@ -12,7 +12,6 @@ // because it needs TempDir, which is in extra // ignore-android -// pretty-expanded FIXME #23616 #![feature(rustc_private, path_ext)] diff --git a/src/test/run-pass/argument-passing.rs b/src/test/run-pass/argument-passing.rs index 7101cfb557967..d2a595804a4b2 100644 --- a/src/test/run-pass/argument-passing.rs +++ b/src/test/run-pass/argument-passing.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 struct X { x: isize diff --git a/src/test/run-pass/arith-2.rs b/src/test/run-pass/arith-2.rs index 0f4523c681884..c93049b87a764 100644 --- a/src/test/run-pass/arith-2.rs +++ b/src/test/run-pass/arith-2.rs @@ -10,7 +10,6 @@ -// pretty-expanded FIXME #23616 pub fn main() { let i32_c: isize = 0x10101010; diff --git a/src/test/run-pass/arith-unsigned.rs b/src/test/run-pass/arith-unsigned.rs index 8a0fc8adc1895..e5ff97e3cdbd2 100644 --- a/src/test/run-pass/arith-unsigned.rs +++ b/src/test/run-pass/arith-unsigned.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(type_limits)] diff --git a/src/test/run-pass/artificial-block.rs b/src/test/run-pass/artificial-block.rs index 3348a6754ee82..53eec3c28c0de 100644 --- a/src/test/run-pass/artificial-block.rs +++ b/src/test/run-pass/artificial-block.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn f() -> isize { { return 3; } } diff --git a/src/test/run-pass/as-precedence.rs b/src/test/run-pass/as-precedence.rs index 8e38128975bb9..d89607077dcbe 100644 --- a/src/test/run-pass/as-precedence.rs +++ b/src/test/run-pass/as-precedence.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn main() { assert_eq!(3 as usize * 3, 9); diff --git a/src/test/run-pass/asm-in-out-operand.rs b/src/test/run-pass/asm-in-out-operand.rs index 32924bcf74451..3eebc7acb0fd5 100644 --- a/src/test/run-pass/asm-in-out-operand.rs +++ b/src/test/run-pass/asm-in-out-operand.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(asm)] diff --git a/src/test/run-pass/asm-out-assign.rs b/src/test/run-pass/asm-out-assign.rs index 3cb7f6400daf4..d7913b473f85a 100644 --- a/src/test/run-pass/asm-out-assign.rs +++ b/src/test/run-pass/asm-out-assign.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(asm)] diff --git a/src/test/run-pass/assign-assign.rs b/src/test/run-pass/assign-assign.rs index 110f4720ceb68..186f91da07ccb 100644 --- a/src/test/run-pass/assign-assign.rs +++ b/src/test/run-pass/assign-assign.rs @@ -9,7 +9,6 @@ // except according to those terms. // Issue 483 - Assignment expressions result in nil -// pretty-expanded FIXME #23616 fn test_assign() { let mut x: isize; diff --git a/src/test/run-pass/assignability-trait.rs b/src/test/run-pass/assignability-trait.rs index 473f744a3ff61..f05a1520b8ef8 100644 --- a/src/test/run-pass/assignability-trait.rs +++ b/src/test/run-pass/assignability-trait.rs @@ -12,7 +12,6 @@ // making method calls, but only if there aren't any matches without // it. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures)] diff --git a/src/test/run-pass/associated-types-basic.rs b/src/test/run-pass/associated-types-basic.rs index d4ed2ee2d6e55..06521e0ec78e8 100644 --- a/src/test/run-pass/associated-types-basic.rs +++ b/src/test/run-pass/associated-types-basic.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/associated-types-binding-in-trait.rs b/src/test/run-pass/associated-types-binding-in-trait.rs index 39fc224148e8e..d82ba6add75c7 100644 --- a/src/test/run-pass/associated-types-binding-in-trait.rs +++ b/src/test/run-pass/associated-types-binding-in-trait.rs @@ -11,7 +11,6 @@ // Test a case where the associated type binding (to `bool`, in this // case) is derived from the trait definition. Issue #21636. -// pretty-expanded FIXME #23616 use std::vec; diff --git a/src/test/run-pass/associated-types-bound.rs b/src/test/run-pass/associated-types-bound.rs index 2301821f66358..4eacd120bc690 100644 --- a/src/test/run-pass/associated-types-bound.rs +++ b/src/test/run-pass/associated-types-bound.rs @@ -10,7 +10,6 @@ // Test equality constrai32s on associated types in a where clause. -// pretty-expanded FIXME #23616 pub trait ToI32 { fn to_i32(&self) -> i32; diff --git a/src/test/run-pass/associated-types-constant-type.rs b/src/test/run-pass/associated-types-constant-type.rs index 5729fab475b78..77ab616ca918b 100644 --- a/src/test/run-pass/associated-types-constant-type.rs +++ b/src/test/run-pass/associated-types-constant-type.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait SignedUnsigned { type Opposite; diff --git a/src/test/run-pass/associated-types-doubleendediterator-object.rs b/src/test/run-pass/associated-types-doubleendediterator-object.rs index 5dc289194ff3b..1661812520b3e 100644 --- a/src/test/run-pass/associated-types-doubleendediterator-object.rs +++ b/src/test/run-pass/associated-types-doubleendediterator-object.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/associated-types-enum-field-named.rs b/src/test/run-pass/associated-types-enum-field-named.rs index 8cf97fe62fea5..7014cc59b71db 100644 --- a/src/test/run-pass/associated-types-enum-field-named.rs +++ b/src/test/run-pass/associated-types-enum-field-named.rs @@ -10,7 +10,6 @@ // Test associated types appearing in struct-like enum variants. -// pretty-expanded FIXME #23616 use self::VarValue::*; diff --git a/src/test/run-pass/associated-types-enum-field-numbered.rs b/src/test/run-pass/associated-types-enum-field-numbered.rs index 3c57da6b4a3eb..c983fdefc0e35 100644 --- a/src/test/run-pass/associated-types-enum-field-numbered.rs +++ b/src/test/run-pass/associated-types-enum-field-numbered.rs @@ -10,7 +10,6 @@ // Test associated types appearing in tuple-like enum variants. -// pretty-expanded FIXME #23616 use self::VarValue::*; diff --git a/src/test/run-pass/associated-types-in-default-method.rs b/src/test/run-pass/associated-types-in-default-method.rs index 2a1b9bdd2faf6..74199f57fb634 100644 --- a/src/test/run-pass/associated-types-in-default-method.rs +++ b/src/test/run-pass/associated-types-in-default-method.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Get { type Value; diff --git a/src/test/run-pass/associated-types-in-fn.rs b/src/test/run-pass/associated-types-in-fn.rs index 40b10fbfcaca6..dcd7895fa99e6 100644 --- a/src/test/run-pass/associated-types-in-fn.rs +++ b/src/test/run-pass/associated-types-in-fn.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Get { type Value; diff --git a/src/test/run-pass/associated-types-in-impl-generics.rs b/src/test/run-pass/associated-types-in-impl-generics.rs index 99a9b7c23febd..5b81ac7090876 100644 --- a/src/test/run-pass/associated-types-in-impl-generics.rs +++ b/src/test/run-pass/associated-types-in-impl-generics.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Get { type Value; diff --git a/src/test/run-pass/associated-types-in-inherent-method.rs b/src/test/run-pass/associated-types-in-inherent-method.rs index 0012d9d759632..5eaf4c2bc8396 100644 --- a/src/test/run-pass/associated-types-in-inherent-method.rs +++ b/src/test/run-pass/associated-types-in-inherent-method.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Get { type Value; diff --git a/src/test/run-pass/associated-types-issue-20220.rs b/src/test/run-pass/associated-types-issue-20220.rs index 718ea542799bb..31336787e4c13 100644 --- a/src/test/run-pass/associated-types-issue-20220.rs +++ b/src/test/run-pass/associated-types-issue-20220.rs @@ -10,7 +10,6 @@ // Test references to `Self::Item` in the trait. Issue #20220. -// pretty-expanded FIXME #23616 use std::vec; diff --git a/src/test/run-pass/associated-types-issue-21212.rs b/src/test/run-pass/associated-types-issue-21212.rs index 057677a008785..cf4b82721112c 100644 --- a/src/test/run-pass/associated-types-issue-21212.rs +++ b/src/test/run-pass/associated-types-issue-21212.rs @@ -13,7 +13,6 @@ // where clauses in the environment which in turn required normalizing // `Self::Input`. -// pretty-expanded FIXME #23616 pub trait Parser { type Input; diff --git a/src/test/run-pass/associated-types-iterator-binding.rs b/src/test/run-pass/associated-types-iterator-binding.rs index 24c5a3e9a8375..181ce52eb4baf 100644 --- a/src/test/run-pass/associated-types-iterator-binding.rs +++ b/src/test/run-pass/associated-types-iterator-binding.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn pairwise_sub>(mut t: T) -> isize { let mut result = 0; diff --git a/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where-clause.rs b/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where-clause.rs index 151a9da948e83..dfd468884a167 100644 --- a/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where-clause.rs +++ b/src/test/run-pass/associated-types-project-from-type-param-via-bound-in-where-clause.rs @@ -12,7 +12,6 @@ // `Item` originates in a where-clause, not the declaration of // `T`. Issue #20300. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/associated-types-projection-from-known-type-in-impl.rs b/src/test/run-pass/associated-types-projection-from-known-type-in-impl.rs index 2518ccf1cb474..8054b3aa52a1d 100644 --- a/src/test/run-pass/associated-types-projection-from-known-type-in-impl.rs +++ b/src/test/run-pass/associated-types-projection-from-known-type-in-impl.rs @@ -10,7 +10,6 @@ // Test where the impl self type uses a projection from a constant type. -// pretty-expanded FIXME #23616 trait Int { diff --git a/src/test/run-pass/associated-types-projection-in-supertrait.rs b/src/test/run-pass/associated-types-projection-in-supertrait.rs index dbc2164c93a69..70c7602ffceb1 100644 --- a/src/test/run-pass/associated-types-projection-in-supertrait.rs +++ b/src/test/run-pass/associated-types-projection-in-supertrait.rs @@ -11,7 +11,6 @@ // Test that we are handle to correctly handle a projection type // that appears in a supertrait bound. Issue #20559. -// pretty-expanded FIXME #23616 trait A { diff --git a/src/test/run-pass/associated-types-ref-in-struct-literal.rs b/src/test/run-pass/associated-types-ref-in-struct-literal.rs index 945340008d876..3b7fb65a8b4aa 100644 --- a/src/test/run-pass/associated-types-ref-in-struct-literal.rs +++ b/src/test/run-pass/associated-types-ref-in-struct-literal.rs @@ -10,7 +10,6 @@ // Test associated type references in a struct literal. Issue #20535. -// pretty-expanded FIXME #23616 pub trait Foo { type Bar; diff --git a/src/test/run-pass/associated-types-return.rs b/src/test/run-pass/associated-types-return.rs index f190e81d8a6ad..5bba54e57b477 100644 --- a/src/test/run-pass/associated-types-return.rs +++ b/src/test/run-pass/associated-types-return.rs @@ -10,7 +10,6 @@ // Test equality constraints on associated types in a where clause. -// pretty-expanded FIXME #23616 pub trait Foo { type A; diff --git a/src/test/run-pass/associated-types-simple.rs b/src/test/run-pass/associated-types-simple.rs index 5a2761365bf30..776b2183d3908 100644 --- a/src/test/run-pass/associated-types-simple.rs +++ b/src/test/run-pass/associated-types-simple.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Get { type Value; diff --git a/src/test/run-pass/associated-types-stream.rs b/src/test/run-pass/associated-types-stream.rs index a2b7cf2106eb7..6adfaabcc23b4 100644 --- a/src/test/run-pass/associated-types-stream.rs +++ b/src/test/run-pass/associated-types-stream.rs @@ -11,7 +11,6 @@ // Test references to the trait `Stream` in the bounds for associated // types defined on `Stream`. Issue #20551. -// pretty-expanded FIXME #23616 trait Stream { type Car; diff --git a/src/test/run-pass/associated-types-struct-field-named.rs b/src/test/run-pass/associated-types-struct-field-named.rs index d1872e4fb55f4..00746c32e1c31 100644 --- a/src/test/run-pass/associated-types-struct-field-named.rs +++ b/src/test/run-pass/associated-types-struct-field-named.rs @@ -11,7 +11,6 @@ // Test that we correctly normalize the type of a struct field // which has an associated type. -// pretty-expanded FIXME #23616 pub trait UnifyKey { type Value; diff --git a/src/test/run-pass/associated-types-struct-field-numbered.rs b/src/test/run-pass/associated-types-struct-field-numbered.rs index 3d97c503dca5f..25e89892a29af 100644 --- a/src/test/run-pass/associated-types-struct-field-numbered.rs +++ b/src/test/run-pass/associated-types-struct-field-numbered.rs @@ -11,7 +11,6 @@ // Test that we correctly normalize the type of a struct field // which has an associated type. -// pretty-expanded FIXME #23616 pub trait UnifyKey { type Value; diff --git a/src/test/run-pass/associated-types-sugar-path.rs b/src/test/run-pass/associated-types-sugar-path.rs index 353b49b49cedf..1432369f7143d 100644 --- a/src/test/run-pass/associated-types-sugar-path.rs +++ b/src/test/run-pass/associated-types-sugar-path.rs @@ -10,7 +10,6 @@ // Test paths to associated types using the type-parameter-only sugar. -// pretty-expanded FIXME #23616 pub trait Foo { type A; diff --git a/src/test/run-pass/attr-main-2.rs b/src/test/run-pass/attr-main-2.rs index 4680f47fad6ce..b3c9ea541b712 100644 --- a/src/test/run-pass/attr-main-2.rs +++ b/src/test/run-pass/attr-main-2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(main)] diff --git a/src/test/run-pass/attr-no-drop-flag-size.rs b/src/test/run-pass/attr-no-drop-flag-size.rs index af8e4b7d4a1a7..893fb85b529a7 100644 --- a/src/test/run-pass/attr-no-drop-flag-size.rs +++ b/src/test/run-pass/attr-no-drop-flag-size.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unsafe_destructor)] #![feature(unsafe_no_drop_flag)] diff --git a/src/test/run-pass/auto-loop.rs b/src/test/run-pass/auto-loop.rs index 2e79183755a18..babc0db4c3190 100644 --- a/src/test/run-pass/auto-loop.rs +++ b/src/test/run-pass/auto-loop.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let mut sum = 0; diff --git a/src/test/run-pass/auto-ref-sliceable.rs b/src/test/run-pass/auto-ref-sliceable.rs index 6dab0e5197138..5b12edb427562 100644 --- a/src/test/run-pass/auto-ref-sliceable.rs +++ b/src/test/run-pass/auto-ref-sliceable.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 trait Pushable { fn push_val(&mut self, t: T); diff --git a/src/test/run-pass/autobind.rs b/src/test/run-pass/autobind.rs index 7d30b549ebea4..1f3d17ad55c08 100644 --- a/src/test/run-pass/autobind.rs +++ b/src/test/run-pass/autobind.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn f(x: Vec) -> T { return x.into_iter().next().unwrap(); } diff --git a/src/test/run-pass/autoderef-method-on-trait.rs b/src/test/run-pass/autoderef-method-on-trait.rs index d7eee85f50273..582fd020dd061 100644 --- a/src/test/run-pass/autoderef-method-on-trait.rs +++ b/src/test/run-pass/autoderef-method-on-trait.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/autoderef-method-priority.rs b/src/test/run-pass/autoderef-method-priority.rs index 6c52035b708de..c80a92a185a2e 100644 --- a/src/test/run-pass/autoderef-method-priority.rs +++ b/src/test/run-pass/autoderef-method-priority.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs index 809ab0a3521dd..2a782cfa176ee 100644 --- a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs +++ b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/autoderef-method-twice.rs b/src/test/run-pass/autoderef-method-twice.rs index 9c7828c893895..a1bcf65ab75fa 100644 --- a/src/test/run-pass/autoderef-method-twice.rs +++ b/src/test/run-pass/autoderef-method-twice.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/autoderef-method.rs b/src/test/run-pass/autoderef-method.rs index e63dd07eb0752..326218674ae3f 100644 --- a/src/test/run-pass/autoderef-method.rs +++ b/src/test/run-pass/autoderef-method.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs index 0f935776fc554..05f12fd089ad4 100644 --- a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs +++ b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/big-literals.rs b/src/test/run-pass/big-literals.rs index ab9d892ce2b60..19c0e7baaa0a1 100644 --- a/src/test/run-pass/big-literals.rs +++ b/src/test/run-pass/big-literals.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/binary-minus-without-space.rs b/src/test/run-pass/binary-minus-without-space.rs index 1fe9dde844a4f..01a9ec8093973 100644 --- a/src/test/run-pass/binary-minus-without-space.rs +++ b/src/test/run-pass/binary-minus-without-space.rs @@ -10,7 +10,6 @@ // Check that issue #954 stays fixed -// pretty-expanded FIXME #23616 pub fn main() { match -1 { -1 => {}, _ => panic!("wat") } diff --git a/src/test/run-pass/bind-by-move.rs b/src/test/run-pass/bind-by-move.rs index 5a6e801501fcf..9be7d63ab951d 100644 --- a/src/test/run-pass/bind-by-move.rs +++ b/src/test/run-pass/bind-by-move.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::sync::Arc; fn dispose(_x: Arc) { } diff --git a/src/test/run-pass/bind-field-short-with-modifiers.rs b/src/test/run-pass/bind-field-short-with-modifiers.rs index e61ff61a21622..b4c38bf450b1b 100644 --- a/src/test/run-pass/bind-field-short-with-modifiers.rs +++ b/src/test/run-pass/bind-field-short-with-modifiers.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { struct Foo { x: isize, y: isize } diff --git a/src/test/run-pass/block-arg-call-as.rs b/src/test/run-pass/block-arg-call-as.rs index 5944438e20d9a..73cba2e4e0a7c 100644 --- a/src/test/run-pass/block-arg-call-as.rs +++ b/src/test/run-pass/block-arg-call-as.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn asBlock(f: F) -> usize where F: FnOnce() -> usize { return f(); diff --git a/src/test/run-pass/block-expr-precedence.rs b/src/test/run-pass/block-expr-precedence.rs index 01bd8ce10cd09..ac8f501257361 100644 --- a/src/test/run-pass/block-expr-precedence.rs +++ b/src/test/run-pass/block-expr-precedence.rs @@ -13,7 +13,6 @@ // no-reformat -// pretty-expanded FIXME #23616 /* * diff --git a/src/test/run-pass/block-fn-coerce.rs b/src/test/run-pass/block-fn-coerce.rs index 0addd33c1e4a3..3e6109da39a26 100644 --- a/src/test/run-pass/block-fn-coerce.rs +++ b/src/test/run-pass/block-fn-coerce.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn force(f: F) -> isize where F: FnOnce() -> isize { return f(); } diff --git a/src/test/run-pass/bool-not.rs b/src/test/run-pass/bool-not.rs index c46684af6efda..fa0b86d0a0246 100644 --- a/src/test/run-pass/bool-not.rs +++ b/src/test/run-pass/bool-not.rs @@ -11,7 +11,6 @@ -// pretty-expanded FIXME #23616 pub fn main() { if !false { assert!((true)); } else { assert!((false)); } diff --git a/src/test/run-pass/bool.rs b/src/test/run-pass/bool.rs index a2b19d32054a5..53b568b06b5b6 100644 --- a/src/test/run-pass/bool.rs +++ b/src/test/run-pass/bool.rs @@ -10,7 +10,6 @@ // Basic boolean tests -// pretty-expanded FIXME #23616 use std::cmp::Ordering::{Equal, Greater, Less}; use std::ops::{BitAnd, BitOr, BitXor}; diff --git a/src/test/run-pass/borrow-tuple-fields.rs b/src/test/run-pass/borrow-tuple-fields.rs index 7cf61bd569dfb..f0d09688192c6 100644 --- a/src/test/run-pass/borrow-tuple-fields.rs +++ b/src/test/run-pass/borrow-tuple-fields.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct Foo(isize, isize); diff --git a/src/test/run-pass/borrowck-borrow-from-expr-block.rs b/src/test/run-pass/borrowck-borrow-from-expr-block.rs index 24c7285b1fb6f..7fdc65a96e238 100644 --- a/src/test/run-pass/borrowck-borrow-from-expr-block.rs +++ b/src/test/run-pass/borrowck-borrow-from-expr-block.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/borrowck-closures-two-imm.rs b/src/test/run-pass/borrowck-closures-two-imm.rs index 6ccb2203bca8e..5b15c8f0797fa 100644 --- a/src/test/run-pass/borrowck-closures-two-imm.rs +++ b/src/test/run-pass/borrowck-closures-two-imm.rs @@ -14,7 +14,6 @@ // that the main function can read the variable too while // the closures are in scope. Issue #6801. -// pretty-expanded FIXME #23616 fn a() -> i32 { let mut x = 3; diff --git a/src/test/run-pass/borrowck-fixed-length-vecs.rs b/src/test/run-pass/borrowck-fixed-length-vecs.rs index 3f38a8df04c57..0e33351894d14 100644 --- a/src/test/run-pass/borrowck-fixed-length-vecs.rs +++ b/src/test/run-pass/borrowck-fixed-length-vecs.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let x = [22]; diff --git a/src/test/run-pass/borrowck-freeze-frozen-mut.rs b/src/test/run-pass/borrowck-freeze-frozen-mut.rs index eaa78553d85c5..380bd398a7cb2 100644 --- a/src/test/run-pass/borrowck-freeze-frozen-mut.rs +++ b/src/test/run-pass/borrowck-freeze-frozen-mut.rs @@ -10,7 +10,6 @@ // Test that a `&mut` inside of an `&` is freezable. -// pretty-expanded FIXME #23616 struct MutSlice<'a, T:'a> { data: &'a mut [T] diff --git a/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs b/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs index b40504f37d4d9..fb30c85e70963 100644 --- a/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs +++ b/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs @@ -11,7 +11,6 @@ // Check that we do not ICE when compiling this // macro, which reuses the expression `$id` -// pretty-expanded FIXME #23616 #![feature(box_patterns)] #![feature(box_syntax)] diff --git a/src/test/run-pass/borrowck-move-by-capture-ok.rs b/src/test/run-pass/borrowck-move-by-capture-ok.rs index 7c03c6a9a489c..bbc668f5cabfe 100644 --- a/src/test/run-pass/borrowck-move-by-capture-ok.rs +++ b/src/test/run-pass/borrowck-move-by-capture-ok.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs index 4d37bcb5a4896..d55517c65d667 100644 --- a/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs +++ b/src/test/run-pass/borrowck-mut-vec-as-imm-slice.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn want_slice(v: &[isize]) -> isize { let mut sum = 0; diff --git a/src/test/run-pass/borrowck-pat-reassign-no-binding.rs b/src/test/run-pass/borrowck-pat-reassign-no-binding.rs index c3b69333dc555..e0a5db678d2f4 100644 --- a/src/test/run-pass/borrowck-pat-reassign-no-binding.rs +++ b/src/test/run-pass/borrowck-pat-reassign-no-binding.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let mut x = None; diff --git a/src/test/run-pass/borrowck-rvalues-mutable.rs b/src/test/run-pass/borrowck-rvalues-mutable.rs index 1b20f6c706162..045e8d952adaa 100644 --- a/src/test/run-pass/borrowck-rvalues-mutable.rs +++ b/src/test/run-pass/borrowck-rvalues-mutable.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct Counter { value: usize diff --git a/src/test/run-pass/borrowck-scope-of-deref-issue-4666.rs b/src/test/run-pass/borrowck-scope-of-deref-issue-4666.rs index 36a84a62d48fb..59a5fea769a6f 100644 --- a/src/test/run-pass/borrowck-scope-of-deref-issue-4666.rs +++ b/src/test/run-pass/borrowck-scope-of-deref-issue-4666.rs @@ -12,7 +12,6 @@ // limited to the deref operation itself, and does not infect the // block as a whole. -// pretty-expanded FIXME #23616 struct Box { x: usize diff --git a/src/test/run-pass/borrowck-univariant-enum.rs b/src/test/run-pass/borrowck-univariant-enum.rs index a5c68c5ecf976..2e8ddb0806472 100644 --- a/src/test/run-pass/borrowck-univariant-enum.rs +++ b/src/test/run-pass/borrowck-univariant-enum.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 use std::cell::Cell; diff --git a/src/test/run-pass/borrowed-ptr-pattern-2.rs b/src/test/run-pass/borrowed-ptr-pattern-2.rs index aaf962577ff24..3e47764ba0264 100644 --- a/src/test/run-pass/borrowed-ptr-pattern-2.rs +++ b/src/test/run-pass/borrowed-ptr-pattern-2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn foo(s: &String) -> bool { match &**s { diff --git a/src/test/run-pass/borrowed-ptr-pattern-3.rs b/src/test/run-pass/borrowed-ptr-pattern-3.rs index c8cc29b9bdacb..91228efb9c1cb 100644 --- a/src/test/run-pass/borrowed-ptr-pattern-3.rs +++ b/src/test/run-pass/borrowed-ptr-pattern-3.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn foo<'r>(s: &'r usize) -> bool { match s { diff --git a/src/test/run-pass/borrowed-ptr-pattern-infallible.rs b/src/test/run-pass/borrowed-ptr-pattern-infallible.rs index 69cb27dcf899e..6656eb41f2e3a 100644 --- a/src/test/run-pass/borrowed-ptr-pattern-infallible.rs +++ b/src/test/run-pass/borrowed-ptr-pattern-infallible.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let (&x, &y) = (&3, &'a'); diff --git a/src/test/run-pass/borrowed-ptr-pattern-option.rs b/src/test/run-pass/borrowed-ptr-pattern-option.rs index 14b6c32a11e51..e1e9381eeb8e7 100644 --- a/src/test/run-pass/borrowed-ptr-pattern-option.rs +++ b/src/test/run-pass/borrowed-ptr-pattern-option.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn select<'r>(x: &'r Option, y: &'r Option) -> &'r Option { match (x, y) { diff --git a/src/test/run-pass/borrowed-ptr-pattern.rs b/src/test/run-pass/borrowed-ptr-pattern.rs index 52322c41236b8..3042ff7743b70 100644 --- a/src/test/run-pass/borrowed-ptr-pattern.rs +++ b/src/test/run-pass/borrowed-ptr-pattern.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn foo(x: &T) -> T{ match x { diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs index 80934c48515dc..ea136e2dc4854 100644 --- a/src/test/run-pass/break.rs +++ b/src/test/run-pass/break.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let mut i = 0; diff --git a/src/test/run-pass/bug-7183-generics.rs b/src/test/run-pass/bug-7183-generics.rs index 5467ed10e98ea..80fd09114fc95 100644 --- a/src/test/run-pass/bug-7183-generics.rs +++ b/src/test/run-pass/bug-7183-generics.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Speak : Sized { fn say(&self, s:&str) -> String; diff --git a/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs b/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs index eb6d1028331be..c5064d56ca123 100644 --- a/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs +++ b/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs @@ -14,7 +14,6 @@ // a Send. Basically this just makes sure rustc is using // each_bound_trait_and_supertraits in type_contents correctly. -// pretty-expanded FIXME #23616 use std::sync::mpsc::{channel, Sender}; diff --git a/src/test/run-pass/builtin-superkinds-capabilities-xc.rs b/src/test/run-pass/builtin-superkinds-capabilities-xc.rs index 082f5944fd3da..183e6fe232cd3 100644 --- a/src/test/run-pass/builtin-superkinds-capabilities-xc.rs +++ b/src/test/run-pass/builtin-superkinds-capabilities-xc.rs @@ -14,7 +14,6 @@ // Tests "capabilities" granted by traits with super-builtin-kinds, // even when using them cross-crate. -// pretty-expanded FIXME #23616 extern crate trait_superkinds_in_metadata; diff --git a/src/test/run-pass/builtin-superkinds-capabilities.rs b/src/test/run-pass/builtin-superkinds-capabilities.rs index 594fb5ec70780..a4d5c943b1f68 100644 --- a/src/test/run-pass/builtin-superkinds-capabilities.rs +++ b/src/test/run-pass/builtin-superkinds-capabilities.rs @@ -12,7 +12,6 @@ // builtin-kinds, e.g., if a trait requires Send to implement, then // at usage site of that trait, we know we have the Send capability. -// pretty-expanded FIXME #23616 use std::sync::mpsc::{channel, Sender, Receiver}; diff --git a/src/test/run-pass/builtin-superkinds-self-type.rs b/src/test/run-pass/builtin-superkinds-self-type.rs index 924a8c023f8b6..c4dc7d78b06d5 100644 --- a/src/test/run-pass/builtin-superkinds-self-type.rs +++ b/src/test/run-pass/builtin-superkinds-self-type.rs @@ -11,7 +11,6 @@ // Tests the ability for the Self type in default methods to use // capabilities granted by builtin kinds as supertraits. -// pretty-expanded FIXME #23616 use std::sync::mpsc::{Sender, channel}; diff --git a/src/test/run-pass/by-value-self-in-mut-slot.rs b/src/test/run-pass/by-value-self-in-mut-slot.rs index 464c24fc8b032..5bbdec95b1576 100644 --- a/src/test/run-pass/by-value-self-in-mut-slot.rs +++ b/src/test/run-pass/by-value-self-in-mut-slot.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct X { a: isize diff --git a/src/test/run-pass/call-closure-from-overloaded-op.rs b/src/test/run-pass/call-closure-from-overloaded-op.rs index e3ee282ec2a4e..e35398a22917f 100644 --- a/src/test/run-pass/call-closure-from-overloaded-op.rs +++ b/src/test/run-pass/call-closure-from-overloaded-op.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn foo() -> isize { 22 } diff --git a/src/test/run-pass/capture-clauses-boxed-closures.rs b/src/test/run-pass/capture-clauses-boxed-closures.rs index 5bf6f5fb04891..45cec79e1a30e 100644 --- a/src/test/run-pass/capture-clauses-boxed-closures.rs +++ b/src/test/run-pass/capture-clauses-boxed-closures.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn each(x: &[T], mut f: F) where F: FnMut(&T) { for val in x { diff --git a/src/test/run-pass/capture-clauses-unboxed-closures.rs b/src/test/run-pass/capture-clauses-unboxed-closures.rs index 448ed76fe96b9..5e7d5aacb8d0d 100644 --- a/src/test/run-pass/capture-clauses-unboxed-closures.rs +++ b/src/test/run-pass/capture-clauses-unboxed-closures.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures)] diff --git a/src/test/run-pass/cast.rs b/src/test/run-pass/cast.rs index 03a73555f856a..bb60626a4bf02 100644 --- a/src/test/run-pass/cast.rs +++ b/src/test/run-pass/cast.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let i: isize = 'Q' as isize; diff --git a/src/test/run-pass/cci_nested_exe.rs b/src/test/run-pass/cci_nested_exe.rs index 665469883043c..e4f4a4f3a576c 100644 --- a/src/test/run-pass/cci_nested_exe.rs +++ b/src/test/run-pass/cci_nested_exe.rs @@ -10,7 +10,6 @@ // aux-build:cci_nested_lib.rs -// pretty-expanded FIXME #23616 #![feature(globs)] diff --git a/src/test/run-pass/cell-does-not-clone.rs b/src/test/run-pass/cell-does-not-clone.rs index c87a3e8bb93d6..c1fcf49654626 100644 --- a/src/test/run-pass/cell-does-not-clone.rs +++ b/src/test/run-pass/cell-does-not-clone.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::cell::Cell; diff --git a/src/test/run-pass/cfg-macros-foo.rs b/src/test/run-pass/cfg-macros-foo.rs index 5fa1bc47f877a..36b9ce1585cf8 100644 --- a/src/test/run-pass/cfg-macros-foo.rs +++ b/src/test/run-pass/cfg-macros-foo.rs @@ -13,7 +13,6 @@ // check that cfg correctly chooses between the macro impls (see also // cfg-macros-notfoo.rs) -// pretty-expanded FIXME #23616 #[cfg(foo)] #[macro_use] diff --git a/src/test/run-pass/cfg-macros-notfoo.rs b/src/test/run-pass/cfg-macros-notfoo.rs index 7cddac160319f..4e1b833add017 100644 --- a/src/test/run-pass/cfg-macros-notfoo.rs +++ b/src/test/run-pass/cfg-macros-notfoo.rs @@ -13,7 +13,6 @@ // check that cfg correctly chooses between the macro impls (see also // cfg-macros-foo.rs) -// pretty-expanded FIXME #23616 #[cfg(foo)] #[macro_use] diff --git a/src/test/run-pass/cfgs-on-items.rs b/src/test/run-pass/cfgs-on-items.rs index 5c22d5c869042..1b692d8bd51f4 100644 --- a/src/test/run-pass/cfgs-on-items.rs +++ b/src/test/run-pass/cfgs-on-items.rs @@ -11,7 +11,6 @@ // compile-flags: --cfg fooA --cfg fooB // fooA AND !bar -// pretty-expanded FIXME #23616 #[cfg(all(fooA, not(bar)))] fn foo1() -> isize { 1 } diff --git a/src/test/run-pass/char.rs b/src/test/run-pass/char.rs index 801b01918e103..d63512f8066cb 100644 --- a/src/test/run-pass/char.rs +++ b/src/test/run-pass/char.rs @@ -10,7 +10,6 @@ -// pretty-expanded FIXME #23616 pub fn main() { let c: char = 'x'; diff --git a/src/test/run-pass/check-static-mut-slices.rs b/src/test/run-pass/check-static-mut-slices.rs index 19c3458ef7b28..5959dd4c389c8 100644 --- a/src/test/run-pass/check-static-mut-slices.rs +++ b/src/test/run-pass/check-static-mut-slices.rs @@ -10,7 +10,6 @@ // Checks that mutable static items can have mutable slices -// pretty-expanded FIXME #23616 static mut TEST: &'static mut [isize] = &mut [1]; diff --git a/src/test/run-pass/check-static-slice.rs b/src/test/run-pass/check-static-slice.rs index 8a7ae1de9bc70..8408597f35409 100644 --- a/src/test/run-pass/check-static-slice.rs +++ b/src/test/run-pass/check-static-slice.rs @@ -11,7 +11,6 @@ // Check that the various ways of getting to a reference to a vec (both sized // and unsized) work properly. -// pretty-expanded FIXME #23616 const aa: [isize; 3] = [1, 2, 3]; const ab: &'static [isize; 3] = &aa; diff --git a/src/test/run-pass/class-exports.rs b/src/test/run-pass/class-exports.rs index 675acf1dd62e0..6783609b256c9 100644 --- a/src/test/run-pass/class-exports.rs +++ b/src/test/run-pass/class-exports.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 /* Test that exporting a class also exports its public fields and methods */ diff --git a/src/test/run-pass/class-method-cross-crate.rs b/src/test/run-pass/class-method-cross-crate.rs index a5c60e3a7b53c..6ab158dc37ca5 100644 --- a/src/test/run-pass/class-method-cross-crate.rs +++ b/src/test/run-pass/class-method-cross-crate.rs @@ -9,7 +9,6 @@ // except according to those terms. // aux-build:cci_class_2.rs -// pretty-expanded FIXME #23616 extern crate cci_class_2; use cci_class_2::kitties::cat; diff --git a/src/test/run-pass/class-methods-cross-crate.rs b/src/test/run-pass/class-methods-cross-crate.rs index 73abaf7d34bb8..666571007595c 100644 --- a/src/test/run-pass/class-methods-cross-crate.rs +++ b/src/test/run-pass/class-methods-cross-crate.rs @@ -9,7 +9,6 @@ // except according to those terms. // aux-build:cci_class_3.rs -// pretty-expanded FIXME #23616 extern crate cci_class_3; use cci_class_3::kitties::cat; diff --git a/src/test/run-pass/class-methods.rs b/src/test/run-pass/class-methods.rs index d454bdd73a1ac..93af906bd5a6c 100644 --- a/src/test/run-pass/class-methods.rs +++ b/src/test/run-pass/class-methods.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct cat { meows : usize, diff --git a/src/test/run-pass/class-poly-methods-cross-crate.rs b/src/test/run-pass/class-poly-methods-cross-crate.rs index 6537a931fa615..4d247bde190de 100644 --- a/src/test/run-pass/class-poly-methods-cross-crate.rs +++ b/src/test/run-pass/class-poly-methods-cross-crate.rs @@ -9,7 +9,6 @@ // except according to those terms. // aux-build:cci_class_6.rs -// pretty-expanded FIXME #23616 extern crate cci_class_6; use cci_class_6::kitties::cat; diff --git a/src/test/run-pass/class-poly-methods.rs b/src/test/run-pass/class-poly-methods.rs index 27f872d532c79..2528ff5128f9c 100644 --- a/src/test/run-pass/class-poly-methods.rs +++ b/src/test/run-pass/class-poly-methods.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 struct cat { info : Vec , diff --git a/src/test/run-pass/classes-cross-crate.rs b/src/test/run-pass/classes-cross-crate.rs index 36d7bd6b3ca48..3d99aa1ef1d08 100644 --- a/src/test/run-pass/classes-cross-crate.rs +++ b/src/test/run-pass/classes-cross-crate.rs @@ -9,7 +9,6 @@ // except according to those terms. // aux-build:cci_class_4.rs -// pretty-expanded FIXME #23616 extern crate cci_class_4; use cci_class_4::kitties::cat; diff --git a/src/test/run-pass/classes-simple-cross-crate.rs b/src/test/run-pass/classes-simple-cross-crate.rs index cfa13dbe622f7..db15001c62f19 100644 --- a/src/test/run-pass/classes-simple-cross-crate.rs +++ b/src/test/run-pass/classes-simple-cross-crate.rs @@ -9,7 +9,6 @@ // except according to those terms. // aux-build:cci_class.rs -// pretty-expanded FIXME #23616 extern crate cci_class; use cci_class::kitties::cat; diff --git a/src/test/run-pass/classes-simple-method.rs b/src/test/run-pass/classes-simple-method.rs index 0d9f859d2d14d..64ec2ea7e71ae 100644 --- a/src/test/run-pass/classes-simple-method.rs +++ b/src/test/run-pass/classes-simple-method.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct cat { meows : usize, diff --git a/src/test/run-pass/classes-simple.rs b/src/test/run-pass/classes-simple.rs index f520623a75ab5..c475fb2cff945 100644 --- a/src/test/run-pass/classes-simple.rs +++ b/src/test/run-pass/classes-simple.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct cat { meows : usize, diff --git a/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs b/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs index 1d0030fd3d362..d813a6d810236 100644 --- a/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs +++ b/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs @@ -12,7 +12,6 @@ // This test verifies that temporaries created for `while`'s and `if` // conditions are dropped after the condition is evaluated. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs b/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs index 3b5421e5aff4c..344ea63c7c74d 100644 --- a/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs +++ b/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs @@ -24,7 +24,6 @@ // It's unclear how likely such a bug is to recur, but it seems like a // scenario worth testing. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/closure-inference.rs b/src/test/run-pass/closure-inference.rs index 06b6e1b5abedd..630a510ca651e 100644 --- a/src/test/run-pass/closure-inference.rs +++ b/src/test/run-pass/closure-inference.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn foo(i: isize) -> isize { i + 1 } diff --git a/src/test/run-pass/closure-inference2.rs b/src/test/run-pass/closure-inference2.rs index 328a27b3f1e8a..2f24cd4ce4043 100644 --- a/src/test/run-pass/closure-inference2.rs +++ b/src/test/run-pass/closure-inference2.rs @@ -10,7 +10,6 @@ // Test a rather underspecified example: -// pretty-expanded FIXME #23616 pub fn main() { let f = {|i| i}; diff --git a/src/test/run-pass/cmp-default.rs b/src/test/run-pass/cmp-default.rs index 2b7557c7bc563..cd3f556864e64 100644 --- a/src/test/run-pass/cmp-default.rs +++ b/src/test/run-pass/cmp-default.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::cmp::Ordering; diff --git a/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs b/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs index 6000b358acf26..5258ad1af5150 100644 --- a/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs +++ b/src/test/run-pass/coerce-reborrow-imm-ptr-rcvr.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct SpeechMaker { speeches: usize diff --git a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs index 2e41ff3a56041..4e116ae146691 100644 --- a/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs +++ b/src/test/run-pass/coerce-reborrow-imm-vec-rcvr.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn bar(v: &mut [usize]) -> Vec { v.to_vec() diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs index 803f86e0fb101..ce0bc33905fe5 100644 --- a/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs +++ b/src/test/run-pass/coerce-reborrow-mut-vec-arg.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn reverse(v: &mut [usize]) { v.reverse(); diff --git a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs index a5fac127356c8..066b33e007b89 100644 --- a/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs +++ b/src/test/run-pass/coerce-reborrow-mut-vec-rcvr.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn bar(v: &mut [usize]) { v.reverse(); diff --git a/src/test/run-pass/compare-generic-enums.rs b/src/test/run-pass/compare-generic-enums.rs index 69945584876d0..228a73326e117 100644 --- a/src/test/run-pass/compare-generic-enums.rs +++ b/src/test/run-pass/compare-generic-enums.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 type an_int = isize; diff --git a/src/test/run-pass/concat.rs b/src/test/run-pass/concat.rs index 7441d1f21b0f9..9a2390a9e68d3 100644 --- a/src/test/run-pass/concat.rs +++ b/src/test/run-pass/concat.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { assert_eq!(format!(concat!("foo", "bar", "{}"), "baz"), "foobarbaz".to_string()); diff --git a/src/test/run-pass/conditional-compile.rs b/src/test/run-pass/conditional-compile.rs index e6660bb9ae880..5891d9f1aa019 100644 --- a/src/test/run-pass/conditional-compile.rs +++ b/src/test/run-pass/conditional-compile.rs @@ -9,7 +9,6 @@ // except according to those terms. // Crate use statements -// pretty-expanded FIXME #23616 #[cfg(bogus)] use flippity; diff --git a/src/test/run-pass/conditional-debug-macro-off.rs b/src/test/run-pass/conditional-debug-macro-off.rs index 192e647f5cb20..c6beb5ba35875 100644 --- a/src/test/run-pass/conditional-debug-macro-off.rs +++ b/src/test/run-pass/conditional-debug-macro-off.rs @@ -11,7 +11,6 @@ // compile-flags: -C debug-assertions=no // exec-env:RUST_LOG=conditional-debug-macro-off=4 -// pretty-expanded FIXME #23616 #![feature(rustc_private)] diff --git a/src/test/run-pass/const-autoderef.rs b/src/test/run-pass/const-autoderef.rs index 1349b7f814bb0..69173e35e2ce3 100644 --- a/src/test/run-pass/const-autoderef.rs +++ b/src/test/run-pass/const-autoderef.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 static A: [u8; 1] = ['h' as u8]; static B: u8 = (&A)[0]; diff --git a/src/test/run-pass/const-big-enum.rs b/src/test/run-pass/const-big-enum.rs index 158c695c548d2..125aefe036dc6 100644 --- a/src/test/run-pass/const-big-enum.rs +++ b/src/test/run-pass/const-big-enum.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum Foo { Bar(u32), diff --git a/src/test/run-pass/const-binops.rs b/src/test/run-pass/const-binops.rs index 1a95220cda59c..4b32ee352311d 100644 --- a/src/test/run-pass/const-binops.rs +++ b/src/test/run-pass/const-binops.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 macro_rules! assert_approx_eq { ($a:expr, $b:expr) => ({ diff --git a/src/test/run-pass/const-block-cross-crate-fn.rs b/src/test/run-pass/const-block-cross-crate-fn.rs index 853e8dc62bb70..6fa6feffbfa00 100644 --- a/src/test/run-pass/const-block-cross-crate-fn.rs +++ b/src/test/run-pass/const-block-cross-crate-fn.rs @@ -10,7 +10,6 @@ // aux-build:cci_const_block.rs -// pretty-expanded FIXME #23616 extern crate cci_const_block; diff --git a/src/test/run-pass/const-block-item-macro-codegen.rs b/src/test/run-pass/const-block-item-macro-codegen.rs index b9e8dbf41d77f..8a4b220a3763c 100644 --- a/src/test/run-pass/const-block-item-macro-codegen.rs +++ b/src/test/run-pass/const-block-item-macro-codegen.rs @@ -11,7 +11,6 @@ // General test that function items in static blocks // can be generated with a macro. -// pretty-expanded FIXME #23616 struct MyType { desc: &'static str, diff --git a/src/test/run-pass/const-block-item.rs b/src/test/run-pass/const-block-item.rs index 897e53822614d..b616b1f610325 100644 --- a/src/test/run-pass/const-block-item.rs +++ b/src/test/run-pass/const-block-item.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 mod foo { pub trait Value { diff --git a/src/test/run-pass/const-block.rs b/src/test/run-pass/const-block.rs index 1337a91fe05d6..e56d01d7ba8ce 100644 --- a/src/test/run-pass/const-block.rs +++ b/src/test/run-pass/const-block.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(dead_code)] #![allow(unused_unsafe)] diff --git a/src/test/run-pass/const-cast-ptr-int.rs b/src/test/run-pass/const-cast-ptr-int.rs index bbe3020ea1c65..e7674f893d377 100644 --- a/src/test/run-pass/const-cast-ptr-int.rs +++ b/src/test/run-pass/const-cast-ptr-int.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::ptr; diff --git a/src/test/run-pass/const-cast.rs b/src/test/run-pass/const-cast.rs index f660dc5fa450e..411df2b3e0759 100644 --- a/src/test/run-pass/const-cast.rs +++ b/src/test/run-pass/const-cast.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(libc)] diff --git a/src/test/run-pass/const-const.rs b/src/test/run-pass/const-const.rs index d75a5a7eb1c3b..b28017b85ad61 100644 --- a/src/test/run-pass/const-const.rs +++ b/src/test/run-pass/const-const.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 const a: isize = 1; const b: isize = a + 2; diff --git a/src/test/run-pass/const-contents.rs b/src/test/run-pass/const-contents.rs index 2dfb88dee0bb8..0d9d0e0e0aa73 100644 --- a/src/test/run-pass/const-contents.rs +++ b/src/test/run-pass/const-contents.rs @@ -10,7 +10,6 @@ // Issue #570 -// pretty-expanded FIXME #23616 static lsl : isize = 1 << 2; static add : isize = 1 + 2; diff --git a/src/test/run-pass/const-cross-crate-const.rs b/src/test/run-pass/const-cross-crate-const.rs index e36a55361ec28..d66c335db2e87 100644 --- a/src/test/run-pass/const-cross-crate-const.rs +++ b/src/test/run-pass/const-cross-crate-const.rs @@ -10,7 +10,6 @@ // aux-build:cci_const.rs -// pretty-expanded FIXME #23616 extern crate cci_const; static foo: &'static str = cci_const::foopy; diff --git a/src/test/run-pass/const-cross-crate-extern.rs b/src/test/run-pass/const-cross-crate-extern.rs index 98f42f91245cd..bbe31ceed33cf 100644 --- a/src/test/run-pass/const-cross-crate-extern.rs +++ b/src/test/run-pass/const-cross-crate-extern.rs @@ -10,7 +10,6 @@ // aux-build:cci_const.rs -// pretty-expanded FIXME #23616 extern crate cci_const; use cci_const::bar; diff --git a/src/test/run-pass/const-deref.rs b/src/test/run-pass/const-deref.rs index 1648332fe2c39..f5407f0c81523 100644 --- a/src/test/run-pass/const-deref.rs +++ b/src/test/run-pass/const-deref.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 const C: &'static isize = &1000; static D: isize = *C; diff --git a/src/test/run-pass/const-enum-byref-self.rs b/src/test/run-pass/const-enum-byref-self.rs index e99e1aac8afdb..57470c4a67e26 100644 --- a/src/test/run-pass/const-enum-byref-self.rs +++ b/src/test/run-pass/const-enum-byref-self.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { V, VV(isize) } static C: E = E::V; diff --git a/src/test/run-pass/const-enum-byref.rs b/src/test/run-pass/const-enum-byref.rs index 4905eaace6820..e3f1d5d35320c 100644 --- a/src/test/run-pass/const-enum-byref.rs +++ b/src/test/run-pass/const-enum-byref.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { V, VV(isize) } static C: E = E::V; diff --git a/src/test/run-pass/const-enum-cast.rs b/src/test/run-pass/const-enum-cast.rs index 3d73933c6f638..38f21f7e95962 100644 --- a/src/test/run-pass/const-enum-cast.rs +++ b/src/test/run-pass/const-enum-cast.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum A { A1, A2 } enum B { B1=0, B2=2 } diff --git a/src/test/run-pass/const-enum-ptr.rs b/src/test/run-pass/const-enum-ptr.rs index d34b5381df9bf..40a1c99e987db 100644 --- a/src/test/run-pass/const-enum-ptr.rs +++ b/src/test/run-pass/const-enum-ptr.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { V0, V1(isize) } static C: &'static E = &E::V0; diff --git a/src/test/run-pass/const-enum-struct.rs b/src/test/run-pass/const-enum-struct.rs index 71a9703ec311a..46c4f82eb98e1 100644 --- a/src/test/run-pass/const-enum-struct.rs +++ b/src/test/run-pass/const-enum-struct.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { V16(u16), V32(u32) } struct S { a: E, b: u16, c: u16 } diff --git a/src/test/run-pass/const-enum-struct2.rs b/src/test/run-pass/const-enum-struct2.rs index ca56cb5b01a99..e356ecb385b98 100644 --- a/src/test/run-pass/const-enum-struct2.rs +++ b/src/test/run-pass/const-enum-struct2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { V0, V16(u16) } struct S { a: E, b: u16, c: u16 } diff --git a/src/test/run-pass/const-enum-structlike.rs b/src/test/run-pass/const-enum-structlike.rs index 113f20e21e1df..6c8786dee6782 100644 --- a/src/test/run-pass/const-enum-structlike.rs +++ b/src/test/run-pass/const-enum-structlike.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { S0 { s: String }, diff --git a/src/test/run-pass/const-enum-tuple.rs b/src/test/run-pass/const-enum-tuple.rs index 2ab28f5fb2377..476defaa524a0 100644 --- a/src/test/run-pass/const-enum-tuple.rs +++ b/src/test/run-pass/const-enum-tuple.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { V16(u16), V32(u32) } static C: (E, u16, u16) = (E::V16(0xDEAD), 0x600D, 0xBAD); diff --git a/src/test/run-pass/const-enum-tuple2.rs b/src/test/run-pass/const-enum-tuple2.rs index fe1b2e051c479..61043ef75a4c5 100644 --- a/src/test/run-pass/const-enum-tuple2.rs +++ b/src/test/run-pass/const-enum-tuple2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { V0, V16(u16) } static C: (E, u16, u16) = (E::V0, 0x600D, 0xBAD); diff --git a/src/test/run-pass/const-enum-tuplestruct.rs b/src/test/run-pass/const-enum-tuplestruct.rs index 7f9de49404d3a..f574508522b26 100644 --- a/src/test/run-pass/const-enum-tuplestruct.rs +++ b/src/test/run-pass/const-enum-tuplestruct.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { V16(u16), V32(u32) } struct S(E, u16, u16); diff --git a/src/test/run-pass/const-enum-tuplestruct2.rs b/src/test/run-pass/const-enum-tuplestruct2.rs index 3d7b6c9f49f78..88cfc0dec7028 100644 --- a/src/test/run-pass/const-enum-tuplestruct2.rs +++ b/src/test/run-pass/const-enum-tuplestruct2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { V0, V16(u16) } struct S(E, u16, u16); diff --git a/src/test/run-pass/const-enum-vec-index.rs b/src/test/run-pass/const-enum-vec-index.rs index fcaf8b8844b07..2f1cd8dbf9b12 100644 --- a/src/test/run-pass/const-enum-vec-index.rs +++ b/src/test/run-pass/const-enum-vec-index.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { V1(isize), V0 } const C: &'static [E] = &[E::V0, E::V1(0xDEADBEE)]; diff --git a/src/test/run-pass/const-enum-vec-ptr.rs b/src/test/run-pass/const-enum-vec-ptr.rs index 936d72ac65e2f..de94527a60486 100644 --- a/src/test/run-pass/const-enum-vec-ptr.rs +++ b/src/test/run-pass/const-enum-vec-ptr.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { V1(isize), V0 } static C: &'static [E] = &[E::V0, E::V1(0xDEADBEE), E::V0]; diff --git a/src/test/run-pass/const-enum-vector.rs b/src/test/run-pass/const-enum-vector.rs index 6fdf0c3948fa0..8d43a76bc28c3 100644 --- a/src/test/run-pass/const-enum-vector.rs +++ b/src/test/run-pass/const-enum-vector.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { V1(isize), V0 } static C: [E; 3] = [E::V0, E::V1(0xDEADBEE), E::V0]; diff --git a/src/test/run-pass/const-extern-function.rs b/src/test/run-pass/const-extern-function.rs index ff829711a4c6c..214b0400e8631 100644 --- a/src/test/run-pass/const-extern-function.rs +++ b/src/test/run-pass/const-extern-function.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 extern fn foopy() {} diff --git a/src/test/run-pass/const-fn-val.rs b/src/test/run-pass/const-fn-val.rs index 3e1058dc27d99..85c92dda434a6 100644 --- a/src/test/run-pass/const-fn-val.rs +++ b/src/test/run-pass/const-fn-val.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn foo() -> isize { return 0xca7f000d; diff --git a/src/test/run-pass/const-negative.rs b/src/test/run-pass/const-negative.rs index 59b2c3e36aaf9..7f26a9773396d 100644 --- a/src/test/run-pass/const-negative.rs +++ b/src/test/run-pass/const-negative.rs @@ -10,7 +10,6 @@ // Issue #358 -// pretty-expanded FIXME #23616 static toplevel_mod: isize = -1; diff --git a/src/test/run-pass/const-nullary-enum.rs b/src/test/run-pass/const-nullary-enum.rs index fcad89470d7c5..b3f6549ef0167 100644 --- a/src/test/run-pass/const-nullary-enum.rs +++ b/src/test/run-pass/const-nullary-enum.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum Foo { Bar, diff --git a/src/test/run-pass/const-nullary-univariant-enum.rs b/src/test/run-pass/const-nullary-univariant-enum.rs index 51926ececc2b1..b1b7f782cd04a 100644 --- a/src/test/run-pass/const-nullary-univariant-enum.rs +++ b/src/test/run-pass/const-nullary-univariant-enum.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #[derive(Copy, Clone)] enum Foo { diff --git a/src/test/run-pass/const-region-ptrs-noncopy.rs b/src/test/run-pass/const-region-ptrs-noncopy.rs index 8932853fbf485..9a1f747ce59fb 100644 --- a/src/test/run-pass/const-region-ptrs-noncopy.rs +++ b/src/test/run-pass/const-region-ptrs-noncopy.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 type Big = [u64; 8]; struct Pair<'a> { a: isize, b: &'a Big } diff --git a/src/test/run-pass/const-str-ptr.rs b/src/test/run-pass/const-str-ptr.rs index c5ff134ff0e9b..1cdb98a8bc05b 100644 --- a/src/test/run-pass/const-str-ptr.rs +++ b/src/test/run-pass/const-str-ptr.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::{str, string}; diff --git a/src/test/run-pass/const-tuple-struct.rs b/src/test/run-pass/const-tuple-struct.rs index ccf1b06bacb5f..ddc50fc6646f2 100644 --- a/src/test/run-pass/const-tuple-struct.rs +++ b/src/test/run-pass/const-tuple-struct.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct Bar(isize, isize); diff --git a/src/test/run-pass/consts-in-patterns.rs b/src/test/run-pass/consts-in-patterns.rs index c2f7cf4d62568..36e6e160a3bd2 100644 --- a/src/test/run-pass/consts-in-patterns.rs +++ b/src/test/run-pass/consts-in-patterns.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 const FOO: isize = 10; const BAR: isize = 3; diff --git a/src/test/run-pass/cross-crate-newtype-struct-pat.rs b/src/test/run-pass/cross-crate-newtype-struct-pat.rs index 986108c5d8fa6..7eae9017420d7 100644 --- a/src/test/run-pass/cross-crate-newtype-struct-pat.rs +++ b/src/test/run-pass/cross-crate-newtype-struct-pat.rs @@ -10,7 +10,6 @@ // aux-build:newtype_struct_xc.rs -// pretty-expanded FIXME #23616 extern crate newtype_struct_xc; diff --git a/src/test/run-pass/deep.rs b/src/test/run-pass/deep.rs index 16636fadbf8dc..f8e690cf29e07 100644 --- a/src/test/run-pass/deep.rs +++ b/src/test/run-pass/deep.rs @@ -11,7 +11,6 @@ -// pretty-expanded FIXME #23616 fn f(x: isize) -> isize { if x == 1 { return 1; } else { let y: isize = 1 + f(x - 1); return y; } diff --git a/src/test/run-pass/deref-mut-on-ref.rs b/src/test/run-pass/deref-mut-on-ref.rs index 8820003d3b24d..98441d7daaad7 100644 --- a/src/test/run-pass/deref-mut-on-ref.rs +++ b/src/test/run-pass/deref-mut-on-ref.rs @@ -10,7 +10,6 @@ // Test that `&mut T` implements `DerefMut` -// pretty-expanded FIXME #23616 use std::ops::{Deref, DerefMut}; diff --git a/src/test/run-pass/deref-on-ref.rs b/src/test/run-pass/deref-on-ref.rs index 84bfbd82297a7..383c8197f9473 100644 --- a/src/test/run-pass/deref-on-ref.rs +++ b/src/test/run-pass/deref-on-ref.rs @@ -10,7 +10,6 @@ // Test that `&T` and `&mut T` implement `Deref` -// pretty-expanded FIXME #23616 use std::ops::Deref; diff --git a/src/test/run-pass/deref-rc.rs b/src/test/run-pass/deref-rc.rs index 761b29258f2af..b84d78b4f4fbd 100644 --- a/src/test/run-pass/deref-rc.rs +++ b/src/test/run-pass/deref-rc.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::rc::Rc; diff --git a/src/test/run-pass/deriving-cmp-generic-enum.rs b/src/test/run-pass/deriving-cmp-generic-enum.rs index 07ad8f706eb5c..b1cd1877a7667 100644 --- a/src/test/run-pass/deriving-cmp-generic-enum.rs +++ b/src/test/run-pass/deriving-cmp-generic-enum.rs @@ -10,7 +10,6 @@ // no-pretty-expanded FIXME #15189 -// pretty-expanded FIXME #23616 #[derive(PartialEq, Eq, PartialOrd, Ord)] enum E { diff --git a/src/test/run-pass/deriving-cmp-generic-struct-enum.rs b/src/test/run-pass/deriving-cmp-generic-struct-enum.rs index 5f7d184f1949d..14f7862ef21fc 100644 --- a/src/test/run-pass/deriving-cmp-generic-struct-enum.rs +++ b/src/test/run-pass/deriving-cmp-generic-struct-enum.rs @@ -10,7 +10,6 @@ // no-pretty-expanded FIXME #15189 -// pretty-expanded FIXME #23616 #[derive(PartialEq, Eq, PartialOrd, Ord)] enum ES { diff --git a/src/test/run-pass/deriving-cmp-generic-struct.rs b/src/test/run-pass/deriving-cmp-generic-struct.rs index ea0017380b275..5c7d806f519d1 100644 --- a/src/test/run-pass/deriving-cmp-generic-struct.rs +++ b/src/test/run-pass/deriving-cmp-generic-struct.rs @@ -10,7 +10,6 @@ // no-pretty-expanded FIXME #15189 -// pretty-expanded FIXME #23616 #[derive(PartialEq, Eq, PartialOrd, Ord)] struct S { diff --git a/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs b/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs index 702071676b90e..b7bfb91b278a0 100644 --- a/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs +++ b/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs @@ -10,7 +10,6 @@ // no-pretty-expanded FIXME #15189 -// pretty-expanded FIXME #23616 #[derive(PartialEq, Eq, PartialOrd, Ord)] struct TS(T,T); diff --git a/src/test/run-pass/deriving-cmp-shortcircuit.rs b/src/test/run-pass/deriving-cmp-shortcircuit.rs index 1669f3fdd3d9a..e22e4767d521f 100644 --- a/src/test/run-pass/deriving-cmp-shortcircuit.rs +++ b/src/test/run-pass/deriving-cmp-shortcircuit.rs @@ -12,7 +12,6 @@ // where possible, by having a type that panics when compared as the // second element, so this passes iff the instances shortcircuit. -// pretty-expanded FIXME #23616 use std::cmp::Ordering; diff --git a/src/test/run-pass/deriving-default-box.rs b/src/test/run-pass/deriving-default-box.rs index 574a620ef0290..dc31e71aad873 100644 --- a/src/test/run-pass/deriving-default-box.rs +++ b/src/test/run-pass/deriving-default-box.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/deriving-encodable-decodable-box.rs b/src/test/run-pass/deriving-encodable-decodable-box.rs index 6ccedb0ad982f..db5a1f3f000a8 100644 --- a/src/test/run-pass/deriving-encodable-decodable-box.rs +++ b/src/test/run-pass/deriving-encodable-decodable-box.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs b/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs index d216062bb2da3..7cc59edfcab0e 100644 --- a/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs +++ b/src/test/run-pass/deriving-encodable-decodable-cell-refcell.rs @@ -11,7 +11,6 @@ // This briefly tests the capability of `Cell` and `RefCell` to implement the // `Encodable` and `Decodable` traits via `#[derive(Encodable, Decodable)]` -// pretty-expanded FIXME #23616 #![feature(rustc_private)] diff --git a/src/test/run-pass/deriving-hash.rs b/src/test/run-pass/deriving-hash.rs index ce7ba9f25eb07..287750e5051c7 100644 --- a/src/test/run-pass/deriving-hash.rs +++ b/src/test/run-pass/deriving-hash.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(hash)] diff --git a/src/test/run-pass/deriving-rand.rs b/src/test/run-pass/deriving-rand.rs index b960c2ddd4a43..bc11b55d3105f 100644 --- a/src/test/run-pass/deriving-rand.rs +++ b/src/test/run-pass/deriving-rand.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(rand)] diff --git a/src/test/run-pass/destructure-array-1.rs b/src/test/run-pass/destructure-array-1.rs index e2c96085714ba..0d24f0bd0d7b3 100644 --- a/src/test/run-pass/destructure-array-1.rs +++ b/src/test/run-pass/destructure-array-1.rs @@ -11,7 +11,6 @@ // Ensure that we can do a destructuring bind of a fixed-size array, // even when the element type has a destructor. -// pretty-expanded FIXME #23616 #![feature(slice_patterns)] diff --git a/src/test/run-pass/die-macro.rs b/src/test/run-pass/die-macro.rs index 6a81ebe67ba80..0816e258e84a0 100644 --- a/src/test/run-pass/die-macro.rs +++ b/src/test/run-pass/die-macro.rs @@ -10,7 +10,6 @@ // Just testing that panic!() type checks in statement or expr -// pretty-expanded FIXME #23616 #![allow(unreachable_code)] diff --git a/src/test/run-pass/div-mod.rs b/src/test/run-pass/div-mod.rs index 237cfe19dc49b..b6cae71df865d 100644 --- a/src/test/run-pass/div-mod.rs +++ b/src/test/run-pass/div-mod.rs @@ -11,7 +11,6 @@ -// pretty-expanded FIXME #23616 pub fn main() { let x: isize = 15; diff --git a/src/test/run-pass/drop-struct-as-object.rs b/src/test/run-pass/drop-struct-as-object.rs index efb98160a3e61..33d5c72772c57 100644 --- a/src/test/run-pass/drop-struct-as-object.rs +++ b/src/test/run-pass/drop-struct-as-object.rs @@ -11,7 +11,6 @@ // Test that destructor on a struct runs successfully after the struct // is boxed and converted to an object. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/drop-with-type-ascription-1.rs b/src/test/run-pass/drop-with-type-ascription-1.rs index ea9edff4945fe..9dd458344cb5a 100644 --- a/src/test/run-pass/drop-with-type-ascription-1.rs +++ b/src/test/run-pass/drop-with-type-ascription-1.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(str_words)] diff --git a/src/test/run-pass/drop-with-type-ascription-2.rs b/src/test/run-pass/drop-with-type-ascription-2.rs index 3d4af80e30bb5..cb3712dea3224 100644 --- a/src/test/run-pass/drop-with-type-ascription-2.rs +++ b/src/test/run-pass/drop-with-type-ascription-2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(collections)] diff --git a/src/test/run-pass/dropck_tarena_sound_drop.rs b/src/test/run-pass/dropck_tarena_sound_drop.rs index df29b8e10c7aa..6ccf6c2fd644d 100644 --- a/src/test/run-pass/dropck_tarena_sound_drop.rs +++ b/src/test/run-pass/dropck_tarena_sound_drop.rs @@ -16,7 +16,6 @@ // shows a similar setup, but restricts `f` so that the struct `C<'a>` // is force-fed a lifetime equal to that of the borrowed arena. -// pretty-expanded FIXME #23616 #![allow(unstable)] #![feature(unsafe_destructor, rustc_private)] diff --git a/src/test/run-pass/dst-deref-mut.rs b/src/test/run-pass/dst-deref-mut.rs index 3b2b7493fd0fa..b031c82a07f3d 100644 --- a/src/test/run-pass/dst-deref-mut.rs +++ b/src/test/run-pass/dst-deref-mut.rs @@ -10,7 +10,6 @@ // Test that a custom deref with a fat pointer return type does not ICE -// pretty-expanded FIXME #23616 use std::ops::{Deref, DerefMut}; diff --git a/src/test/run-pass/dst-deref.rs b/src/test/run-pass/dst-deref.rs index c8e658beef81b..c4666d05fbfe3 100644 --- a/src/test/run-pass/dst-deref.rs +++ b/src/test/run-pass/dst-deref.rs @@ -10,7 +10,6 @@ // Test that a custom deref with a fat pointer return type does not ICE -// pretty-expanded FIXME #23616 use std::ops::Deref; diff --git a/src/test/run-pass/dst-index.rs b/src/test/run-pass/dst-index.rs index df4cd74740cdd..34a187fa6f2d2 100644 --- a/src/test/run-pass/dst-index.rs +++ b/src/test/run-pass/dst-index.rs @@ -11,7 +11,6 @@ // Test that overloaded index expressions with DST result types // work and don't ICE. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/dst-raw.rs b/src/test/run-pass/dst-raw.rs index 5e0e5bd03fe6f..d899de9164071 100644 --- a/src/test/run-pass/dst-raw.rs +++ b/src/test/run-pass/dst-raw.rs @@ -10,7 +10,6 @@ // Test DST raw pointers -// pretty-expanded FIXME #23616 trait Trait { fn foo(&self) -> isize; diff --git a/src/test/run-pass/dst-struct-sole.rs b/src/test/run-pass/dst-struct-sole.rs index 9bf286c434219..d440fb2a216ec 100644 --- a/src/test/run-pass/dst-struct-sole.rs +++ b/src/test/run-pass/dst-struct-sole.rs @@ -10,7 +10,6 @@ // As dst-struct.rs, but the unsized field is the only field in the struct. -// pretty-expanded FIXME #23616 struct Fat { ptr: T diff --git a/src/test/run-pass/dst-struct.rs b/src/test/run-pass/dst-struct.rs index 5198dd43d6db8..8b6db23026b8a 100644 --- a/src/test/run-pass/dst-struct.rs +++ b/src/test/run-pass/dst-struct.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/dst-trait.rs b/src/test/run-pass/dst-trait.rs index 370bc2882271f..4d2b50c08e2f5 100644 --- a/src/test/run-pass/dst-trait.rs +++ b/src/test/run-pass/dst-trait.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/else-if.rs b/src/test/run-pass/else-if.rs index 79c2f45067884..afc1d200b274b 100644 --- a/src/test/run-pass/else-if.rs +++ b/src/test/run-pass/else-if.rs @@ -10,7 +10,6 @@ -// pretty-expanded FIXME #23616 pub fn main() { if 1 == 2 { diff --git a/src/test/run-pass/empty-allocation-non-null.rs b/src/test/run-pass/empty-allocation-non-null.rs index cec528fa0401c..af6e321e40aa6 100644 --- a/src/test/run-pass/empty-allocation-non-null.rs +++ b/src/test/run-pass/empty-allocation-non-null.rs @@ -10,7 +10,6 @@ // FIXME (#22405): Replace `Box::new` with `box` here when/if possible. -// pretty-expanded FIXME #23616 pub fn main() { assert!(Some(Box::new(())).is_some()); diff --git a/src/test/run-pass/enum-alignment.rs b/src/test/run-pass/enum-alignment.rs index df779d0d713fd..827894f8f32c9 100644 --- a/src/test/run-pass/enum-alignment.rs +++ b/src/test/run-pass/enum-alignment.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/enum-clike-ffi-as-int.rs b/src/test/run-pass/enum-clike-ffi-as-int.rs index f129a51534143..8be3634c88add 100644 --- a/src/test/run-pass/enum-clike-ffi-as-int.rs +++ b/src/test/run-pass/enum-clike-ffi-as-int.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 /*! * C-like enums have to be represented as LLVM ints, not wrapped in a diff --git a/src/test/run-pass/enum-discr.rs b/src/test/run-pass/enum-discr.rs index 5c01d544cf533..1ff6370136076 100644 --- a/src/test/run-pass/enum-discr.rs +++ b/src/test/run-pass/enum-discr.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum Animal { Cat = 0, diff --git a/src/test/run-pass/enum-discrim-autosizing.rs b/src/test/run-pass/enum-discrim-autosizing.rs index 239f9821b925b..99e44735d0f03 100644 --- a/src/test/run-pass/enum-discrim-autosizing.rs +++ b/src/test/run-pass/enum-discrim-autosizing.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem::size_of; diff --git a/src/test/run-pass/enum-discrim-manual-sizing.rs b/src/test/run-pass/enum-discrim-manual-sizing.rs index b23cfa9f32b8e..edad5cc1652da 100644 --- a/src/test/run-pass/enum-discrim-manual-sizing.rs +++ b/src/test/run-pass/enum-discrim-manual-sizing.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem::size_of; diff --git a/src/test/run-pass/enum-disr-val-pretty.rs b/src/test/run-pass/enum-disr-val-pretty.rs index 9a2f45d00790e..cf66725178011 100644 --- a/src/test/run-pass/enum-disr-val-pretty.rs +++ b/src/test/run-pass/enum-disr-val-pretty.rs @@ -10,7 +10,6 @@ // pp-exact -// pretty-expanded FIXME #23616 enum color { red = 1, green, blue, imaginary = -1, } diff --git a/src/test/run-pass/enum-null-pointer-opt.rs b/src/test/run-pass/enum-null-pointer-opt.rs index 9fc799a97f6b9..499d131947a38 100644 --- a/src/test/run-pass/enum-null-pointer-opt.rs +++ b/src/test/run-pass/enum-null-pointer-opt.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/enum-nullable-const-null-with-fields.rs b/src/test/run-pass/enum-nullable-const-null-with-fields.rs index 3a7c7ea9a714b..1342c4e104de5 100644 --- a/src/test/run-pass/enum-nullable-const-null-with-fields.rs +++ b/src/test/run-pass/enum-nullable-const-null-with-fields.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::result::Result; use std::result::Result::Ok; diff --git a/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs b/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs index 99554aafb0427..c8a1047cfa818 100644 --- a/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs +++ b/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/env-home-dir.rs b/src/test/run-pass/env-home-dir.rs index 7fb96112125af..efe72729817e8 100644 --- a/src/test/run-pass/env-home-dir.rs +++ b/src/test/run-pass/env-home-dir.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(path)] diff --git a/src/test/run-pass/env-vars.rs b/src/test/run-pass/env-vars.rs index 33bc6c596dbd0..d86f63c9cb91d 100644 --- a/src/test/run-pass/env-vars.rs +++ b/src/test/run-pass/env-vars.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::env::*; diff --git a/src/test/run-pass/eq-multidispatch.rs b/src/test/run-pass/eq-multidispatch.rs index 3ca254021e5b9..bf8b089a830c2 100644 --- a/src/test/run-pass/eq-multidispatch.rs +++ b/src/test/run-pass/eq-multidispatch.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #[derive(PartialEq)] struct Bar; diff --git a/src/test/run-pass/estr-uniq.rs b/src/test/run-pass/estr-uniq.rs index 0b24658a8f331..4dfb15418405d 100644 --- a/src/test/run-pass/estr-uniq.rs +++ b/src/test/run-pass/estr-uniq.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(dead_assignment)] diff --git a/src/test/run-pass/exec-env.rs b/src/test/run-pass/exec-env.rs index a24930732474f..d17056e6d799d 100644 --- a/src/test/run-pass/exec-env.rs +++ b/src/test/run-pass/exec-env.rs @@ -10,7 +10,6 @@ // exec-env:TEST_EXEC_ENV=22 -// pretty-expanded FIXME #23616 use std::env; diff --git a/src/test/run-pass/explicit-self-generic.rs b/src/test/run-pass/explicit-self-generic.rs index ee50d3bdf0ee8..1b50d3028b1e2 100644 --- a/src/test/run-pass/explicit-self-generic.rs +++ b/src/test/run-pass/explicit-self-generic.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/explicit-self-objects-uniq.rs b/src/test/run-pass/explicit-self-objects-uniq.rs index 08ea638f93a56..4021ae89e3629 100644 --- a/src/test/run-pass/explicit-self-objects-uniq.rs +++ b/src/test/run-pass/explicit-self-objects-uniq.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/explicit-self.rs b/src/test/run-pass/explicit-self.rs index b81090555ea64..d2a0d60eb6614 100644 --- a/src/test/run-pass/explicit-self.rs +++ b/src/test/run-pass/explicit-self.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/expr-block-fn.rs b/src/test/run-pass/expr-block-fn.rs index c88721471b64c..67e41aad6971b 100644 --- a/src/test/run-pass/expr-block-fn.rs +++ b/src/test/run-pass/expr-block-fn.rs @@ -10,7 +10,6 @@ -// pretty-expanded FIXME #23616 fn test_fn() { fn ten() -> isize { return 10; } diff --git a/src/test/run-pass/expr-block-generic-unique2.rs b/src/test/run-pass/expr-block-generic-unique2.rs index bd2936773953b..5477a9227aa1d 100644 --- a/src/test/run-pass/expr-block-generic-unique2.rs +++ b/src/test/run-pass/expr-block-generic-unique2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/expr-block-generic.rs b/src/test/run-pass/expr-block-generic.rs index d26c6e62f536e..8795962bebdd8 100644 --- a/src/test/run-pass/expr-block-generic.rs +++ b/src/test/run-pass/expr-block-generic.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn test_generic(expected: T, eq: F) where F: FnOnce(T, T) -> bool { let actual: T = { expected.clone() }; diff --git a/src/test/run-pass/expr-block-slot.rs b/src/test/run-pass/expr-block-slot.rs index 57b5a426f5c5c..d9b4c95bc24d1 100644 --- a/src/test/run-pass/expr-block-slot.rs +++ b/src/test/run-pass/expr-block-slot.rs @@ -10,7 +10,6 @@ // Regression test for issue #377 -// pretty-expanded FIXME #23616 struct A { a: isize } struct V { v: isize } diff --git a/src/test/run-pass/expr-block-unique.rs b/src/test/run-pass/expr-block-unique.rs index 496a575c6c8b5..7ad024186015b 100644 --- a/src/test/run-pass/expr-block-unique.rs +++ b/src/test/run-pass/expr-block-unique.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/expr-block.rs b/src/test/run-pass/expr-block.rs index 64f86237ab3bb..38be041938b3c 100644 --- a/src/test/run-pass/expr-block.rs +++ b/src/test/run-pass/expr-block.rs @@ -13,7 +13,6 @@ // Tests for standalone blocks as expressions -// pretty-expanded FIXME #23616 fn test_basic() { let rs: bool = { true }; assert!((rs)); } diff --git a/src/test/run-pass/expr-copy.rs b/src/test/run-pass/expr-copy.rs index ca394f991f29b..99e74a6b8564d 100644 --- a/src/test/run-pass/expr-copy.rs +++ b/src/test/run-pass/expr-copy.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn f(arg: &mut A) { arg.a = 100; diff --git a/src/test/run-pass/expr-fn.rs b/src/test/run-pass/expr-fn.rs index 0c9151cec7df4..aeca388d317b6 100644 --- a/src/test/run-pass/expr-fn.rs +++ b/src/test/run-pass/expr-fn.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn test_int() { fn f() -> isize { 10 } diff --git a/src/test/run-pass/expr-if-generic.rs b/src/test/run-pass/expr-if-generic.rs index 47e79de6b1124..94c6b70bb62f3 100644 --- a/src/test/run-pass/expr-if-generic.rs +++ b/src/test/run-pass/expr-if-generic.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn test_generic(expected: T, not_expected: T, eq: F) where T: Clone, diff --git a/src/test/run-pass/expr-if-panic-all.rs b/src/test/run-pass/expr-if-panic-all.rs index 1e631c204798a..43110533b6dc6 100644 --- a/src/test/run-pass/expr-if-panic-all.rs +++ b/src/test/run-pass/expr-if-panic-all.rs @@ -10,7 +10,6 @@ // When all branches of an if expression result in panic, the entire if // expression results in panic. -// pretty-expanded FIXME #23616 pub fn main() { let _x = if true { diff --git a/src/test/run-pass/expr-if-panic.rs b/src/test/run-pass/expr-if-panic.rs index e8594db80393b..c7f10b66ca3c7 100644 --- a/src/test/run-pass/expr-if-panic.rs +++ b/src/test/run-pass/expr-if-panic.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn test_if_panic() { let x = if false { panic!() } else { 10 }; diff --git a/src/test/run-pass/expr-if-unique.rs b/src/test/run-pass/expr-if-unique.rs index 99c5053588b1c..12000fd54e7e7 100644 --- a/src/test/run-pass/expr-if-unique.rs +++ b/src/test/run-pass/expr-if-unique.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/expr-if.rs b/src/test/run-pass/expr-if.rs index 345f17707c408..e8458e320113b 100644 --- a/src/test/run-pass/expr-if.rs +++ b/src/test/run-pass/expr-if.rs @@ -13,7 +13,6 @@ // Tests for if as expressions -// pretty-expanded FIXME #23616 fn test_if() { let rs: bool = if true { true } else { false }; assert!((rs)); } diff --git a/src/test/run-pass/expr-match-generic-unique1.rs b/src/test/run-pass/expr-match-generic-unique1.rs index 7cd0f6a758999..738fcecb2e0db 100644 --- a/src/test/run-pass/expr-match-generic-unique1.rs +++ b/src/test/run-pass/expr-match-generic-unique1.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/expr-match-generic-unique2.rs b/src/test/run-pass/expr-match-generic-unique2.rs index 95f47d005d3d6..88ea241524109 100644 --- a/src/test/run-pass/expr-match-generic-unique2.rs +++ b/src/test/run-pass/expr-match-generic-unique2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/expr-match-generic.rs b/src/test/run-pass/expr-match-generic.rs index f8e82de9a0a36..509106289d079 100644 --- a/src/test/run-pass/expr-match-generic.rs +++ b/src/test/run-pass/expr-match-generic.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 type compare = extern "Rust" fn(T, T) -> bool; diff --git a/src/test/run-pass/expr-match-panic-all.rs b/src/test/run-pass/expr-match-panic-all.rs index 664ead10aae09..e712d552a8107 100644 --- a/src/test/run-pass/expr-match-panic-all.rs +++ b/src/test/run-pass/expr-match-panic-all.rs @@ -13,7 +13,6 @@ // When all branches of a match expression result in panic, the entire // match expression results in panic. -// pretty-expanded FIXME #23616 pub fn main() { let _x = diff --git a/src/test/run-pass/expr-match-panic.rs b/src/test/run-pass/expr-match-panic.rs index 40e7a6175cf86..89dc7b09c7b15 100644 --- a/src/test/run-pass/expr-match-panic.rs +++ b/src/test/run-pass/expr-match-panic.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn test_simple() { let r = match true { true => { true } false => { panic!() } }; diff --git a/src/test/run-pass/expr-match-unique.rs b/src/test/run-pass/expr-match-unique.rs index 51eda4c7663a8..e752c20a51242 100644 --- a/src/test/run-pass/expr-match-unique.rs +++ b/src/test/run-pass/expr-match-unique.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/expr-match.rs b/src/test/run-pass/expr-match.rs index 2282391ef6fb4..580ee52ed3645 100644 --- a/src/test/run-pass/expr-match.rs +++ b/src/test/run-pass/expr-match.rs @@ -13,7 +13,6 @@ // Tests for using match as an expression -// pretty-expanded FIXME #23616 fn test_basic() { let mut rs: bool = match true { true => { true } false => { false } }; diff --git a/src/test/run-pass/ext-expand-inner-exprs.rs b/src/test/run-pass/ext-expand-inner-exprs.rs index 46cd73e11527c..90ca31e80be3a 100644 --- a/src/test/run-pass/ext-expand-inner-exprs.rs +++ b/src/test/run-pass/ext-expand-inner-exprs.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 static FOO : &'static str = concat!(concat!("hel", "lo"), "world"); diff --git a/src/test/run-pass/exterior.rs b/src/test/run-pass/exterior.rs index 9a039e8bc3539..3474e2eefb7c7 100644 --- a/src/test/run-pass/exterior.rs +++ b/src/test/run-pass/exterior.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 use std::cell::Cell; diff --git a/src/test/run-pass/extern-call-direct.rs b/src/test/run-pass/extern-call-direct.rs index 38cd4a8d79d0d..ec6b6c8d39fad 100644 --- a/src/test/run-pass/extern-call-direct.rs +++ b/src/test/run-pass/extern-call-direct.rs @@ -10,7 +10,6 @@ // Test direct calls to extern fns. -// pretty-expanded FIXME #23616 extern fn f(x: usize) -> usize { x * 2 } diff --git a/src/test/run-pass/extern-compare-with-return-type.rs b/src/test/run-pass/extern-compare-with-return-type.rs index 09411c9c6eb29..6535ae2fca946 100644 --- a/src/test/run-pass/extern-compare-with-return-type.rs +++ b/src/test/run-pass/extern-compare-with-return-type.rs @@ -10,7 +10,6 @@ // Tests that we can compare various kinds of extern fn signatures. -// pretty-expanded FIXME #23616 extern fn voidret1() {} extern fn voidret2() {} diff --git a/src/test/run-pass/extern-methods.rs b/src/test/run-pass/extern-methods.rs index 246f65931b70e..28a076113d1f0 100644 --- a/src/test/run-pass/extern-methods.rs +++ b/src/test/run-pass/extern-methods.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/extern-pass-char.rs b/src/test/run-pass/extern-pass-char.rs index bbdf5cf64a127..e75aa2d72c925 100644 --- a/src/test/run-pass/extern-pass-char.rs +++ b/src/test/run-pass/extern-pass-char.rs @@ -10,7 +10,6 @@ // Test a function that takes/returns a u8. -// pretty-expanded FIXME #23616 #[link(name = "rust_test_helpers")] extern { diff --git a/src/test/run-pass/extern-pass-double.rs b/src/test/run-pass/extern-pass-double.rs index 24c461f43adf8..e92f9b6a1a172 100644 --- a/src/test/run-pass/extern-pass-double.rs +++ b/src/test/run-pass/extern-pass-double.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #[link(name = "rust_test_helpers")] extern { diff --git a/src/test/run-pass/extern-pass-u32.rs b/src/test/run-pass/extern-pass-u32.rs index f93d7a3ff9614..0753ea1bcfead 100644 --- a/src/test/run-pass/extern-pass-u32.rs +++ b/src/test/run-pass/extern-pass-u32.rs @@ -10,7 +10,6 @@ // Test a function that takes/returns a u32. -// pretty-expanded FIXME #23616 #[link(name = "rust_test_helpers")] extern { diff --git a/src/test/run-pass/extern-pass-u64.rs b/src/test/run-pass/extern-pass-u64.rs index 961a3dce16813..89faa3bb47141 100644 --- a/src/test/run-pass/extern-pass-u64.rs +++ b/src/test/run-pass/extern-pass-u64.rs @@ -10,7 +10,6 @@ // Test a call to a function that takes/returns a u64. -// pretty-expanded FIXME #23616 #[link(name = "rust_test_helpers")] extern { diff --git a/src/test/run-pass/extern-return-TwoU16s.rs b/src/test/run-pass/extern-return-TwoU16s.rs index f149a1346229a..3c58646e0c302 100644 --- a/src/test/run-pass/extern-return-TwoU16s.rs +++ b/src/test/run-pass/extern-return-TwoU16s.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub struct TwoU16s { one: u16, two: u16 diff --git a/src/test/run-pass/extern-return-TwoU32s.rs b/src/test/run-pass/extern-return-TwoU32s.rs index 4e9c44ef75eec..0eb6be2d687a4 100644 --- a/src/test/run-pass/extern-return-TwoU32s.rs +++ b/src/test/run-pass/extern-return-TwoU32s.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub struct TwoU32s { one: u32, two: u32 diff --git a/src/test/run-pass/extern-return-TwoU64s.rs b/src/test/run-pass/extern-return-TwoU64s.rs index fffd77fa89735..d5eab86351e10 100644 --- a/src/test/run-pass/extern-return-TwoU64s.rs +++ b/src/test/run-pass/extern-return-TwoU64s.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub struct TwoU64s { one: u64, two: u64 diff --git a/src/test/run-pass/extern-return-TwoU8s.rs b/src/test/run-pass/extern-return-TwoU8s.rs index fdf43d4332a9d..d8f476bcd0cbb 100644 --- a/src/test/run-pass/extern-return-TwoU8s.rs +++ b/src/test/run-pass/extern-return-TwoU8s.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub struct TwoU8s { one: u8, two: u8 diff --git a/src/test/run-pass/extern-take-value.rs b/src/test/run-pass/extern-take-value.rs index c016e4e62f56f..7ef87b9409d51 100644 --- a/src/test/run-pass/extern-take-value.rs +++ b/src/test/run-pass/extern-take-value.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 extern fn f() { } diff --git a/src/test/run-pass/extoption_env-not-defined.rs b/src/test/run-pass/extoption_env-not-defined.rs index aaa8f6cf26f1d..352f68da9854f 100644 --- a/src/test/run-pass/extoption_env-not-defined.rs +++ b/src/test/run-pass/extoption_env-not-defined.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { assert!(option_env!("__HOPEFULLY_DOESNT_EXIST__").is_none()); diff --git a/src/test/run-pass/field-destruction-order.rs b/src/test/run-pass/field-destruction-order.rs index aab32a7e7bd37..624167db36da3 100644 --- a/src/test/run-pass/field-destruction-order.rs +++ b/src/test/run-pass/field-destruction-order.rs @@ -21,7 +21,6 @@ // declarations, but we currently run them top-to-bottom. I don't think the // order really matters that much as long as we define what it is. -// pretty-expanded FIXME #23616 struct A; struct B; diff --git a/src/test/run-pass/fixed_length_copy.rs b/src/test/run-pass/fixed_length_copy.rs index 019537a2ab8b0..eefd94475358c 100644 --- a/src/test/run-pass/fixed_length_copy.rs +++ b/src/test/run-pass/fixed_length_copy.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let arr = [1,2,3]; diff --git a/src/test/run-pass/float2.rs b/src/test/run-pass/float2.rs index f84cbe5235467..e9f6e0f51b4ec 100644 --- a/src/test/run-pass/float2.rs +++ b/src/test/run-pass/float2.rs @@ -10,7 +10,6 @@ -// pretty-expanded FIXME #23616 pub fn main() { let a = 1.5e6f64; diff --git a/src/test/run-pass/floatlits.rs b/src/test/run-pass/floatlits.rs index d45c689bfdaa7..d133f3463a3f2 100644 --- a/src/test/run-pass/floatlits.rs +++ b/src/test/run-pass/floatlits.rs @@ -10,7 +10,6 @@ -// pretty-expanded FIXME #23616 pub fn main() { let f = 4.999999999999f64; diff --git a/src/test/run-pass/fn-bare-assign.rs b/src/test/run-pass/fn-bare-assign.rs index d83dc7858056f..2d3d4cbffd00d 100644 --- a/src/test/run-pass/fn-bare-assign.rs +++ b/src/test/run-pass/fn-bare-assign.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn f(i: isize, called: &mut bool) { assert_eq!(i, 10); diff --git a/src/test/run-pass/fn-bare-size.rs b/src/test/run-pass/fn-bare-size.rs index 117cf13584f18..3ed4f103af081 100644 --- a/src/test/run-pass/fn-bare-size.rs +++ b/src/test/run-pass/fn-bare-size.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/fn-bare-spawn.rs b/src/test/run-pass/fn-bare-spawn.rs index 0a3c891627068..e6ee77cb62bb6 100644 --- a/src/test/run-pass/fn-bare-spawn.rs +++ b/src/test/run-pass/fn-bare-spawn.rs @@ -10,7 +10,6 @@ // This is what the signature to spawn should look like with bare functions -// pretty-expanded FIXME #23616 fn spawn(val: T, f: fn(T)) { f(val); diff --git a/src/test/run-pass/fn-item-type-cast.rs b/src/test/run-pass/fn-item-type-cast.rs index f8b1582c51577..9a8a8d4782ed5 100644 --- a/src/test/run-pass/fn-item-type-cast.rs +++ b/src/test/run-pass/fn-item-type-cast.rs @@ -10,7 +10,6 @@ // Test explicit coercions from a fn item type to a fn pointer type. -// pretty-expanded FIXME #23616 fn foo(x: isize) -> isize { x * 2 } fn bar(x: isize) -> isize { x * 4 } diff --git a/src/test/run-pass/fn-pattern-expected-type.rs b/src/test/run-pass/fn-pattern-expected-type.rs index 352d0b13c6407..2e9607602fd62 100644 --- a/src/test/run-pass/fn-pattern-expected-type.rs +++ b/src/test/run-pass/fn-pattern-expected-type.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let f = |(x, y): (isize, isize)| { diff --git a/src/test/run-pass/for-destruct.rs b/src/test/run-pass/for-destruct.rs index 9d8c432e98209..963d34a2d2fbd 100644 --- a/src/test/run-pass/for-destruct.rs +++ b/src/test/run-pass/for-destruct.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct Pair { x: isize, y: isize } diff --git a/src/test/run-pass/for-loop-goofiness.rs b/src/test/run-pass/for-loop-goofiness.rs index 4b6b6dcf1d555..411183e4f74a7 100644 --- a/src/test/run-pass/for-loop-goofiness.rs +++ b/src/test/run-pass/for-loop-goofiness.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum BogusOption { None, diff --git a/src/test/run-pass/for-loop-into-iterator.rs b/src/test/run-pass/for-loop-into-iterator.rs index 109ca26056fff..7efd15f222e37 100644 --- a/src/test/run-pass/for-loop-into-iterator.rs +++ b/src/test/run-pass/for-loop-into-iterator.rs @@ -10,7 +10,6 @@ // Test that for loops can do what RFC #235 claims -// pretty-expanded FIXME #23616 fn main() { let mut v = vec![1]; diff --git a/src/test/run-pass/for-loop-panic.rs b/src/test/run-pass/for-loop-panic.rs index 908932fe396be..001ca1a02f632 100644 --- a/src/test/run-pass/for-loop-panic.rs +++ b/src/test/run-pass/for-loop-panic.rs @@ -9,6 +9,5 @@ // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let x: Vec = Vec::new(); for _ in &x { panic!("moop"); } } diff --git a/src/test/run-pass/foreach-external-iterators-break.rs b/src/test/run-pass/foreach-external-iterators-break.rs index bc041259895f9..bfc0d6cf9d542 100644 --- a/src/test/run-pass/foreach-external-iterators-break.rs +++ b/src/test/run-pass/foreach-external-iterators-break.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let x = [1; 100]; diff --git a/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs b/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs index cc02ee1459b5e..cedb960143146 100644 --- a/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs +++ b/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(collections)] diff --git a/src/test/run-pass/foreach-external-iterators-hashmap.rs b/src/test/run-pass/foreach-external-iterators-hashmap.rs index 065e4cfb7682b..79304fce5c166 100644 --- a/src/test/run-pass/foreach-external-iterators-hashmap.rs +++ b/src/test/run-pass/foreach-external-iterators-hashmap.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(collections)] diff --git a/src/test/run-pass/foreach-external-iterators-loop.rs b/src/test/run-pass/foreach-external-iterators-loop.rs index 60cfc9be0787a..7248537d6a1b6 100644 --- a/src/test/run-pass/foreach-external-iterators-loop.rs +++ b/src/test/run-pass/foreach-external-iterators-loop.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let x = [1; 100]; diff --git a/src/test/run-pass/foreach-external-iterators-nested.rs b/src/test/run-pass/foreach-external-iterators-nested.rs index a075c08b737e0..87aa3d84003c5 100644 --- a/src/test/run-pass/foreach-external-iterators-nested.rs +++ b/src/test/run-pass/foreach-external-iterators-nested.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let x = [1; 100]; diff --git a/src/test/run-pass/foreach-external-iterators.rs b/src/test/run-pass/foreach-external-iterators.rs index 2248132d828d1..d1fe98f5431f7 100644 --- a/src/test/run-pass/foreach-external-iterators.rs +++ b/src/test/run-pass/foreach-external-iterators.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let x = [1; 100]; diff --git a/src/test/run-pass/foreach-nested.rs b/src/test/run-pass/foreach-nested.rs index 075539b621ac7..60068185f5a52 100644 --- a/src/test/run-pass/foreach-nested.rs +++ b/src/test/run-pass/foreach-nested.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn two(mut it: F) where F: FnMut(isize) { it(0); it(1); } diff --git a/src/test/run-pass/foreign-fn-with-byval.rs b/src/test/run-pass/foreign-fn-with-byval.rs index 7883c22f909dd..d3d872620c38b 100644 --- a/src/test/run-pass/foreign-fn-with-byval.rs +++ b/src/test/run-pass/foreign-fn-with-byval.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #[derive(Copy, Clone)] pub struct S { diff --git a/src/test/run-pass/format-nan.rs b/src/test/run-pass/format-nan.rs index bdbbeaa9511cd..9bbd8cdb11d88 100644 --- a/src/test/run-pass/format-nan.rs +++ b/src/test/run-pass/format-nan.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { use std::f64; diff --git a/src/test/run-pass/format-ref-cell.rs b/src/test/run-pass/format-ref-cell.rs index ce26fbd4c00f9..0f16dfa1e8f15 100644 --- a/src/test/run-pass/format-ref-cell.rs +++ b/src/test/run-pass/format-ref-cell.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::cell::RefCell; diff --git a/src/test/run-pass/fsu-moves-and-copies.rs b/src/test/run-pass/fsu-moves-and-copies.rs index fecaf279d043d..dd58787a1de90 100644 --- a/src/test/run-pass/fsu-moves-and-copies.rs +++ b/src/test/run-pass/fsu-moves-and-copies.rs @@ -11,7 +11,6 @@ // Issue 4691: Ensure that functional-struct-updates operates // correctly and moves rather than copy when appropriate. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax, core)] diff --git a/src/test/run-pass/fun-call-variants.rs b/src/test/run-pass/fun-call-variants.rs index 0fe4bbcb7a228..3bb6df33f70a0 100644 --- a/src/test/run-pass/fun-call-variants.rs +++ b/src/test/run-pass/fun-call-variants.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn ho(f: F) -> isize where F: FnOnce(isize) -> isize { let n: isize = f(3); return n; } diff --git a/src/test/run-pass/fun-indirect-call.rs b/src/test/run-pass/fun-indirect-call.rs index 48dfcb73da45c..b28c64d06be2f 100644 --- a/src/test/run-pass/fun-indirect-call.rs +++ b/src/test/run-pass/fun-indirect-call.rs @@ -11,7 +11,6 @@ -// pretty-expanded FIXME #23616 fn f() -> isize { return 42; } diff --git a/src/test/run-pass/func-arg-incomplete-pattern.rs b/src/test/run-pass/func-arg-incomplete-pattern.rs index 2833723708523..6030da44e4ade 100644 --- a/src/test/run-pass/func-arg-incomplete-pattern.rs +++ b/src/test/run-pass/func-arg-incomplete-pattern.rs @@ -11,7 +11,6 @@ // Test that we do not leak when the arg pattern must drop part of the // argument (in this case, the `y` field). -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/func-arg-ref-pattern.rs b/src/test/run-pass/func-arg-ref-pattern.rs index fcc00afb00bdb..ab565e7abcace 100644 --- a/src/test/run-pass/func-arg-ref-pattern.rs +++ b/src/test/run-pass/func-arg-ref-pattern.rs @@ -14,7 +14,6 @@ // boxes. Make sure that we don't free the box as we match the // pattern. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_patterns)] diff --git a/src/test/run-pass/func-arg-wild-pattern.rs b/src/test/run-pass/func-arg-wild-pattern.rs index 4f74ca0ff7215..3ab3ee4db2d5b 100644 --- a/src/test/run-pass/func-arg-wild-pattern.rs +++ b/src/test/run-pass/func-arg-wild-pattern.rs @@ -11,7 +11,6 @@ // Test that we can compile code that uses a `_` in function argument // patterns. -// pretty-expanded FIXME #23616 fn foo((x, _): (isize, isize)) -> isize { x diff --git a/src/test/run-pass/generic-exterior-unique.rs b/src/test/run-pass/generic-exterior-unique.rs index 0e3ce3869bf7b..8dbe6de838869 100644 --- a/src/test/run-pass/generic-exterior-unique.rs +++ b/src/test/run-pass/generic-exterior-unique.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/generic-extern-mangle.rs b/src/test/run-pass/generic-extern-mangle.rs index 7a765703e23a0..67aea1f9f8ae8 100644 --- a/src/test/run-pass/generic-extern-mangle.rs +++ b/src/test/run-pass/generic-extern-mangle.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/generic-fn-infer.rs b/src/test/run-pass/generic-fn-infer.rs index e01f507372216..181e05183d2ec 100644 --- a/src/test/run-pass/generic-fn-infer.rs +++ b/src/test/run-pass/generic-fn-infer.rs @@ -13,7 +13,6 @@ // Issue #45: infer type parameters in function applications -// pretty-expanded FIXME #23616 fn id(x: T) -> T { return x; } diff --git a/src/test/run-pass/generic-object.rs b/src/test/run-pass/generic-object.rs index 44b32f62f9227..0a59a925a5ff6 100644 --- a/src/test/run-pass/generic-object.rs +++ b/src/test/run-pass/generic-object.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/generic-static-methods.rs b/src/test/run-pass/generic-static-methods.rs index 49f8d6a3adb52..7a496ebf8ce34 100644 --- a/src/test/run-pass/generic-static-methods.rs +++ b/src/test/run-pass/generic-static-methods.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 trait vec_utils { fn map_(x: &Self, f: F) -> Vec where F: FnMut(&T) -> U; diff --git a/src/test/run-pass/generic-type.rs b/src/test/run-pass/generic-type.rs index 73fc3a0d80236..8e7a3add34349 100644 --- a/src/test/run-pass/generic-type.rs +++ b/src/test/run-pass/generic-type.rs @@ -10,7 +10,6 @@ -// pretty-expanded FIXME #23616 struct Pair {x: T, y: T} diff --git a/src/test/run-pass/generic-unique.rs b/src/test/run-pass/generic-unique.rs index 9cf98364eb993..21e9a9a80d0ae 100644 --- a/src/test/run-pass/generic-unique.rs +++ b/src/test/run-pass/generic-unique.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/getopts_ref.rs b/src/test/run-pass/getopts_ref.rs index 52b06ab2928af..c9595d09e21b2 100644 --- a/src/test/run-pass/getopts_ref.rs +++ b/src/test/run-pass/getopts_ref.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(rustc_private)] diff --git a/src/test/run-pass/global-scope.rs b/src/test/run-pass/global-scope.rs index 64d9368a88be8..13da404c253b3 100644 --- a/src/test/run-pass/global-scope.rs +++ b/src/test/run-pass/global-scope.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 pub fn f() -> isize { return 1; } diff --git a/src/test/run-pass/guards-not-exhaustive.rs b/src/test/run-pass/guards-not-exhaustive.rs index f5f80914937d3..53c3eff5b81ee 100644 --- a/src/test/run-pass/guards-not-exhaustive.rs +++ b/src/test/run-pass/guards-not-exhaustive.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #[derive(Copy, Clone)] enum Q { R(Option) } diff --git a/src/test/run-pass/guards.rs b/src/test/run-pass/guards.rs index 11c67b8af8107..d79dbabac2d42 100644 --- a/src/test/run-pass/guards.rs +++ b/src/test/run-pass/guards.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #[derive(Copy, Clone)] struct Pair { x: isize, y: isize } diff --git a/src/test/run-pass/hrtb-fn-like-trait-object.rs b/src/test/run-pass/hrtb-fn-like-trait-object.rs index 858179fb5fe76..8e2e21bed0a7c 100644 --- a/src/test/run-pass/hrtb-fn-like-trait-object.rs +++ b/src/test/run-pass/hrtb-fn-like-trait-object.rs @@ -10,7 +10,6 @@ // A basic test of using a higher-ranked trait bound. -// pretty-expanded FIXME #23616 trait FnLike { fn call(&self, arg: A) -> R; diff --git a/src/test/run-pass/hrtb-fn-like-trait.rs b/src/test/run-pass/hrtb-fn-like-trait.rs index 8b4c2aec8452b..71e314b513251 100644 --- a/src/test/run-pass/hrtb-fn-like-trait.rs +++ b/src/test/run-pass/hrtb-fn-like-trait.rs @@ -10,7 +10,6 @@ // A basic test of using a higher-ranked trait bound. -// pretty-expanded FIXME #23616 trait FnLike { fn call(&self, arg: A) -> R; diff --git a/src/test/run-pass/hrtb-trait-object-paren-notation.rs b/src/test/run-pass/hrtb-trait-object-paren-notation.rs index 7741f1904f6ab..fefbd00476689 100644 --- a/src/test/run-pass/hrtb-trait-object-paren-notation.rs +++ b/src/test/run-pass/hrtb-trait-object-paren-notation.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures)] diff --git a/src/test/run-pass/huge-largest-array.rs b/src/test/run-pass/huge-largest-array.rs index 2345bb01d8ae9..f0bb31b8470f1 100644 --- a/src/test/run-pass/huge-largest-array.rs +++ b/src/test/run-pass/huge-largest-array.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem::size_of; diff --git a/src/test/run-pass/hygiene-dodging-1.rs b/src/test/run-pass/hygiene-dodging-1.rs index e5acc4a2edd68..83f09850f7776 100644 --- a/src/test/run-pass/hygiene-dodging-1.rs +++ b/src/test/run-pass/hygiene-dodging-1.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 mod x { pub fn g() -> usize {14} diff --git a/src/test/run-pass/hygienic-labels.rs b/src/test/run-pass/hygienic-labels.rs index 2d530275ea21f..df72a5410a2b2 100644 --- a/src/test/run-pass/hygienic-labels.rs +++ b/src/test/run-pass/hygienic-labels.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 macro_rules! loop_x { ($e: expr) => { diff --git a/src/test/run-pass/i32-sub.rs b/src/test/run-pass/i32-sub.rs index 2cc4e880bbf5e..075faba2fcb85 100644 --- a/src/test/run-pass/i32-sub.rs +++ b/src/test/run-pass/i32-sub.rs @@ -11,6 +11,5 @@ -// pretty-expanded FIXME #23616 pub fn main() { let mut x: i32 = -400; x = 0 - x; assert!((x == 400)); } diff --git a/src/test/run-pass/i8-incr.rs b/src/test/run-pass/i8-incr.rs index 5dd53a268b135..242cea264afb1 100644 --- a/src/test/run-pass/i8-incr.rs +++ b/src/test/run-pass/i8-incr.rs @@ -11,7 +11,6 @@ -// pretty-expanded FIXME #23616 pub fn main() { let mut x: i8 = -12; diff --git a/src/test/run-pass/if-let.rs b/src/test/run-pass/if-let.rs index c41d02f9b3365..13134abd8fdd9 100644 --- a/src/test/run-pass/if-let.rs +++ b/src/test/run-pass/if-let.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let x = Some(3); diff --git a/src/test/run-pass/impl-inherent-non-conflict.rs b/src/test/run-pass/impl-inherent-non-conflict.rs index 210bc34bcd1db..0d43f1ca70669 100644 --- a/src/test/run-pass/impl-inherent-non-conflict.rs +++ b/src/test/run-pass/impl-inherent-non-conflict.rs @@ -12,7 +12,6 @@ // with the same name, which can be called on values that have a // precise enough type to allow distinguishing between the methods. -// pretty-expanded FIXME #23616 struct Foo(T); diff --git a/src/test/run-pass/impl-inherent-prefer-over-trait.rs b/src/test/run-pass/impl-inherent-prefer-over-trait.rs index 26f12e9730b2a..f0195976aa832 100644 --- a/src/test/run-pass/impl-inherent-prefer-over-trait.rs +++ b/src/test/run-pass/impl-inherent-prefer-over-trait.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct Foo; diff --git a/src/test/run-pass/impl-not-adjacent-to-type.rs b/src/test/run-pass/impl-not-adjacent-to-type.rs index 2ba7375d67a64..beba056b72cdc 100644 --- a/src/test/run-pass/impl-not-adjacent-to-type.rs +++ b/src/test/run-pass/impl-not-adjacent-to-type.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 mod foo { pub struct Point { diff --git a/src/test/run-pass/import-glob-crate.rs b/src/test/run-pass/import-glob-crate.rs index eb9ec6fe985ac..b2a9b08b01b86 100644 --- a/src/test/run-pass/import-glob-crate.rs +++ b/src/test/run-pass/import-glob-crate.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(dead_assignment)] diff --git a/src/test/run-pass/inferred-suffix-in-pattern-range.rs b/src/test/run-pass/inferred-suffix-in-pattern-range.rs index fcbd4b332318e..22369c77ed33f 100644 --- a/src/test/run-pass/inferred-suffix-in-pattern-range.rs +++ b/src/test/run-pass/inferred-suffix-in-pattern-range.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let x = 2; diff --git a/src/test/run-pass/inherent-trait-method-order.rs b/src/test/run-pass/inherent-trait-method-order.rs index 042268435c7af..5489a61f7d0b9 100644 --- a/src/test/run-pass/inherent-trait-method-order.rs +++ b/src/test/run-pass/inherent-trait-method-order.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct Foo; diff --git a/src/test/run-pass/init-res-into-things.rs b/src/test/run-pass/init-res-into-things.rs index eb50fbed774e4..97b32189d0027 100644 --- a/src/test/run-pass/init-res-into-things.rs +++ b/src/test/run-pass/init-res-into-things.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/inner-attrs-on-impl.rs b/src/test/run-pass/inner-attrs-on-impl.rs index a807e582ff464..d8d9d5136e2d1 100644 --- a/src/test/run-pass/inner-attrs-on-impl.rs +++ b/src/test/run-pass/inner-attrs-on-impl.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 struct Foo; diff --git a/src/test/run-pass/inner-static.rs b/src/test/run-pass/inner-static.rs index 48f2006ed59ba..b93ca943e4714 100644 --- a/src/test/run-pass/inner-static.rs +++ b/src/test/run-pass/inner-static.rs @@ -10,7 +10,6 @@ // aux-build:inner_static.rs -// pretty-expanded FIXME #23616 extern crate inner_static; diff --git a/src/test/run-pass/integer-literal-radix.rs b/src/test/run-pass/integer-literal-radix.rs index b782925fa9357..ba9d22f06a976 100644 --- a/src/test/run-pass/integer-literal-radix.rs +++ b/src/test/run-pass/integer-literal-radix.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let a = 0xBEEF_isize; diff --git a/src/test/run-pass/intrinsic-alignment.rs b/src/test/run-pass/intrinsic-alignment.rs index 44dd191eb3ee3..fa97ef8fcd394 100644 --- a/src/test/run-pass/intrinsic-alignment.rs +++ b/src/test/run-pass/intrinsic-alignment.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(intrinsics, main)] diff --git a/src/test/run-pass/intrinsic-assume.rs b/src/test/run-pass/intrinsic-assume.rs index fc886d7e30165..ff7d799f64c5f 100644 --- a/src/test/run-pass/intrinsic-assume.rs +++ b/src/test/run-pass/intrinsic-assume.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/intrinsic-atomics-cc.rs b/src/test/run-pass/intrinsic-atomics-cc.rs index c5fe02b9190d4..abb85cc7f1949 100644 --- a/src/test/run-pass/intrinsic-atomics-cc.rs +++ b/src/test/run-pass/intrinsic-atomics-cc.rs @@ -10,7 +10,6 @@ // aux-build:cci_intrinsic.rs -// pretty-expanded FIXME #23616 extern crate cci_intrinsic; use cci_intrinsic::atomic_xchg; diff --git a/src/test/run-pass/intrinsic-atomics.rs b/src/test/run-pass/intrinsic-atomics.rs index 61a9f6109a3e8..4ccab55e94348 100644 --- a/src/test/run-pass/intrinsic-atomics.rs +++ b/src/test/run-pass/intrinsic-atomics.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/intrinsic-move-val.rs b/src/test/run-pass/intrinsic-move-val.rs index 98f069f77f3f0..2e75f2dccd1ba 100644 --- a/src/test/run-pass/intrinsic-move-val.rs +++ b/src/test/run-pass/intrinsic-move-val.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/intrinsic-return-address.rs b/src/test/run-pass/intrinsic-return-address.rs index 1ff910356eb98..63aed3f009fd7 100644 --- a/src/test/run-pass/intrinsic-return-address.rs +++ b/src/test/run-pass/intrinsic-return-address.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(intrinsics)] diff --git a/src/test/run-pass/intrinsic-unreachable.rs b/src/test/run-pass/intrinsic-unreachable.rs index 86a370a0942d9..a86fc110ae4eb 100644 --- a/src/test/run-pass/intrinsic-unreachable.rs +++ b/src/test/run-pass/intrinsic-unreachable.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/intrinsics-integer.rs b/src/test/run-pass/intrinsics-integer.rs index 15dbe796ef589..f1d731c8b1d7a 100644 --- a/src/test/run-pass/intrinsics-integer.rs +++ b/src/test/run-pass/intrinsics-integer.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(negate_unsigned)] #![feature(intrinsics)] diff --git a/src/test/run-pass/intrinsics-math.rs b/src/test/run-pass/intrinsics-math.rs index 841ff297a2ac7..8db29ebaa6d3e 100644 --- a/src/test/run-pass/intrinsics-math.rs +++ b/src/test/run-pass/intrinsics-math.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(intrinsics, core)] diff --git a/src/test/run-pass/issue-10392.rs b/src/test/run-pass/issue-10392.rs index 2d695c75d3044..1a5f423b0fd8b 100644 --- a/src/test/run-pass/issue-10392.rs +++ b/src/test/run-pass/issue-10392.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct A { foo: isize } struct B { a: isize, b: isize, c: isize } diff --git a/src/test/run-pass/issue-10734.rs b/src/test/run-pass/issue-10734.rs index 49694f2755c23..c99cad85ccb39 100644 --- a/src/test/run-pass/issue-10734.rs +++ b/src/test/run-pass/issue-10734.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unsafe_no_drop_flag)] diff --git a/src/test/run-pass/issue-10802.rs b/src/test/run-pass/issue-10802.rs index bb322635094e5..2256315a379ae 100644 --- a/src/test/run-pass/issue-10802.rs +++ b/src/test/run-pass/issue-10802.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/issue-1112.rs b/src/test/run-pass/issue-1112.rs index 3d131b51033dc..72d1a43e88318 100644 --- a/src/test/run-pass/issue-1112.rs +++ b/src/test/run-pass/issue-1112.rs @@ -11,7 +11,6 @@ // Issue #1112 // Alignment of interior pointers to dynamic-size types -// pretty-expanded FIXME #23616 struct X { a: T, diff --git a/src/test/run-pass/issue-11552.rs b/src/test/run-pass/issue-11552.rs index 1f91c6aaa4d0a..5193330a45a36 100644 --- a/src/test/run-pass/issue-11552.rs +++ b/src/test/run-pass/issue-11552.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_patterns)] diff --git a/src/test/run-pass/issue-11577.rs b/src/test/run-pass/issue-11577.rs index ecb7a3a3691ca..81588e8ef78db 100644 --- a/src/test/run-pass/issue-11577.rs +++ b/src/test/run-pass/issue-11577.rs @@ -1,4 +1,3 @@ -// pretty-expanded FIXME #23616 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at diff --git a/src/test/run-pass/issue-11677.rs b/src/test/run-pass/issue-11677.rs index a3eec42831f20..d4244d44439b0 100644 --- a/src/test/run-pass/issue-11677.rs +++ b/src/test/run-pass/issue-11677.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(dead_code)] diff --git a/src/test/run-pass/issue-11940.rs b/src/test/run-pass/issue-11940.rs index 8732def0a1a11..186446a345677 100644 --- a/src/test/run-pass/issue-11940.rs +++ b/src/test/run-pass/issue-11940.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 const TEST_STR: &'static str = "abcd"; diff --git a/src/test/run-pass/issue-12285.rs b/src/test/run-pass/issue-12285.rs index 3a5b7e86920d7..fb98909eb9765 100644 --- a/src/test/run-pass/issue-12285.rs +++ b/src/test/run-pass/issue-12285.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct S; diff --git a/src/test/run-pass/issue-12677.rs b/src/test/run-pass/issue-12677.rs index 493bdb30e35bc..e83a2e9727d99 100644 --- a/src/test/run-pass/issue-12677.rs +++ b/src/test/run-pass/issue-12677.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn main() { let s = "Hello"; diff --git a/src/test/run-pass/issue-13204.rs b/src/test/run-pass/issue-13204.rs index ec9d777974bb0..36f606e5d73c9 100644 --- a/src/test/run-pass/issue-13204.rs +++ b/src/test/run-pass/issue-13204.rs @@ -11,7 +11,6 @@ // Test that when instantiating trait default methods, typeck handles // lifetime parameters defined on the method bound correctly. -// pretty-expanded FIXME #23616 pub trait Foo { fn bar<'a, I: Iterator>(&self, it: I) -> usize { diff --git a/src/test/run-pass/issue-13323.rs b/src/test/run-pass/issue-13323.rs index 90d16aaf145af..68c6ce7a7b7ba 100644 --- a/src/test/run-pass/issue-13323.rs +++ b/src/test/run-pass/issue-13323.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/issue-13507-2.rs b/src/test/run-pass/issue-13507-2.rs index 0b35ccf26f3f7..91ec3e8540442 100644 --- a/src/test/run-pass/issue-13507-2.rs +++ b/src/test/run-pass/issue-13507-2.rs @@ -10,7 +10,6 @@ // aux-build:issue13507.rs -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/issue-13867.rs b/src/test/run-pass/issue-13867.rs index a902e141bb6ca..e21070e2eafa1 100644 --- a/src/test/run-pass/issue-13867.rs +++ b/src/test/run-pass/issue-13867.rs @@ -11,7 +11,6 @@ // Test that codegen works correctly when there are multiple refutable // patterns in match expression. -// pretty-expanded FIXME #23616 enum Foo { FooUint(usize), diff --git a/src/test/run-pass/issue-14308.rs b/src/test/run-pass/issue-14308.rs index f67d0946e9823..a61cb18faa65a 100644 --- a/src/test/run-pass/issue-14308.rs +++ b/src/test/run-pass/issue-14308.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct A(isize); struct B; diff --git a/src/test/run-pass/issue-14456.rs b/src/test/run-pass/issue-14456.rs index ab9633ca1fe90..7e24c8f73ab70 100644 --- a/src/test/run-pass/issue-14456.rs +++ b/src/test/run-pass/issue-14456.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(io, process_capture)] diff --git a/src/test/run-pass/issue-14865.rs b/src/test/run-pass/issue-14865.rs index e78736b77fd93..1ec268bb17037 100644 --- a/src/test/run-pass/issue-14865.rs +++ b/src/test/run-pass/issue-14865.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum X { Foo(usize), diff --git a/src/test/run-pass/issue-14936.rs b/src/test/run-pass/issue-14936.rs index 2361c385b4148..5f8e7cb8145e6 100644 --- a/src/test/run-pass/issue-14936.rs +++ b/src/test/run-pass/issue-14936.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(asm)] diff --git a/src/test/run-pass/issue-14940.rs b/src/test/run-pass/issue-14940.rs index a530384d368c0..b51afc1d02095 100644 --- a/src/test/run-pass/issue-14940.rs +++ b/src/test/run-pass/issue-14940.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(old_io, io)] diff --git a/src/test/run-pass/issue-15080.rs b/src/test/run-pass/issue-15080.rs index 4369dc6292c36..ecb83cca6f273 100644 --- a/src/test/run-pass/issue-15080.rs +++ b/src/test/run-pass/issue-15080.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(slice_patterns)] diff --git a/src/test/run-pass/issue-15104.rs b/src/test/run-pass/issue-15104.rs index db04e10cfe383..b55754ee59b35 100644 --- a/src/test/run-pass/issue-15104.rs +++ b/src/test/run-pass/issue-15104.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(slice_patterns)] diff --git a/src/test/run-pass/issue-15129.rs b/src/test/run-pass/issue-15129.rs index 54705c6bf1301..9bcfa6ea40a4e 100644 --- a/src/test/run-pass/issue-15129.rs +++ b/src/test/run-pass/issue-15129.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub enum T { T1(()), diff --git a/src/test/run-pass/issue-15149.rs b/src/test/run-pass/issue-15149.rs index ee348d9cb0ccf..f6ffd03c81aee 100644 --- a/src/test/run-pass/issue-15149.rs +++ b/src/test/run-pass/issue-15149.rs @@ -10,7 +10,6 @@ // no-prefer-dynamic -// pretty-expanded FIXME #23616 #![feature(fs, process, env, path, rand)] diff --git a/src/test/run-pass/issue-15673.rs b/src/test/run-pass/issue-15673.rs index c1ecd3eba48bd..c478ca041148a 100644 --- a/src/test/run-pass/issue-15673.rs +++ b/src/test/run-pass/issue-15673.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/issue-15689-1.rs b/src/test/run-pass/issue-15689-1.rs index 9fc1cce56b767..e3c16793c19cb 100644 --- a/src/test/run-pass/issue-15689-1.rs +++ b/src/test/run-pass/issue-15689-1.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #[derive(PartialEq)] enum Test<'a> { diff --git a/src/test/run-pass/issue-15734.rs b/src/test/run-pass/issue-15734.rs index 67ce6a1c44f0d..7f44c5a84cbaf 100644 --- a/src/test/run-pass/issue-15734.rs +++ b/src/test/run-pass/issue-15734.rs @@ -11,7 +11,6 @@ // If `Index` used an associated type for its output, this test would // work more smoothly. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/issue-15793.rs b/src/test/run-pass/issue-15793.rs index 21baf47ee6610..432174a1f52a0 100644 --- a/src/test/run-pass/issue-15793.rs +++ b/src/test/run-pass/issue-15793.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum NestedEnum { First, diff --git a/src/test/run-pass/issue-15858.rs b/src/test/run-pass/issue-15858.rs index 265db3fe1336a..4f084d7891f37 100644 --- a/src/test/run-pass/issue-15858.rs +++ b/src/test/run-pass/issue-15858.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unsafe_destructor)] diff --git a/src/test/run-pass/issue-15881-model-lexer-dotdotdot.rs b/src/test/run-pass/issue-15881-model-lexer-dotdotdot.rs index 6b75e4e47978e..2ec97e373b29b 100644 --- a/src/test/run-pass/issue-15881-model-lexer-dotdotdot.rs +++ b/src/test/run-pass/issue-15881-model-lexer-dotdotdot.rs @@ -10,7 +10,6 @@ // // regression test for the model lexer handling the DOTDOTDOT syntax (#15877) -// pretty-expanded FIXME #23616 pub fn main() { match 5_usize { diff --git a/src/test/run-pass/issue-16151.rs b/src/test/run-pass/issue-16151.rs index 242bcb69be60d..212dfaf3cb6c7 100644 --- a/src/test/run-pass/issue-16151.rs +++ b/src/test/run-pass/issue-16151.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/issue-16530.rs b/src/test/run-pass/issue-16530.rs index bf33221431ae0..77ec44161ea72 100644 --- a/src/test/run-pass/issue-16530.rs +++ b/src/test/run-pass/issue-16530.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(hash)] diff --git a/src/test/run-pass/issue-16560.rs b/src/test/run-pass/issue-16560.rs index 33842fab6989c..a9f7d86f95ee6 100644 --- a/src/test/run-pass/issue-16560.rs +++ b/src/test/run-pass/issue-16560.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures)] diff --git a/src/test/run-pass/issue-16596.rs b/src/test/run-pass/issue-16596.rs index 743dbbc9b9956..d70158743e720 100644 --- a/src/test/run-pass/issue-16596.rs +++ b/src/test/run-pass/issue-16596.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait MatrixRow { fn dummy(&self) { }} diff --git a/src/test/run-pass/issue-16648.rs b/src/test/run-pass/issue-16648.rs index f0ff9ce7554b5..384bd9df7cfed 100644 --- a/src/test/run-pass/issue-16648.rs +++ b/src/test/run-pass/issue-16648.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(slice_patterns)] diff --git a/src/test/run-pass/issue-16739.rs b/src/test/run-pass/issue-16739.rs index 99ddaba4e5514..f8cffdd38ca9b 100644 --- a/src/test/run-pass/issue-16739.rs +++ b/src/test/run-pass/issue-16739.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/issue-16774.rs b/src/test/run-pass/issue-16774.rs index 17d0969ce1c02..627717ab1cd14 100644 --- a/src/test/run-pass/issue-16774.rs +++ b/src/test/run-pass/issue-16774.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/issue-1701.rs b/src/test/run-pass/issue-1701.rs index b8c51f2cd3112..3a2e46c62b079 100644 --- a/src/test/run-pass/issue-1701.rs +++ b/src/test/run-pass/issue-1701.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum pattern { tabby, tortoiseshell, calico } enum breed { beagle, rottweiler, pug } diff --git a/src/test/run-pass/issue-17068.rs b/src/test/run-pass/issue-17068.rs index 55a6d4cdbace7..91264b4ac3f2b 100644 --- a/src/test/run-pass/issue-17068.rs +++ b/src/test/run-pass/issue-17068.rs @@ -10,7 +10,6 @@ // Test that regionck creates the right region links in the pattern // binding of a for loop -// pretty-expanded FIXME #23616 fn foo<'a>(v: &'a [usize]) -> &'a usize { for &ref x in v { return x; } diff --git a/src/test/run-pass/issue-17074.rs b/src/test/run-pass/issue-17074.rs index 08c313ab0a42b..ec2d8f79781cc 100644 --- a/src/test/run-pass/issue-17074.rs +++ b/src/test/run-pass/issue-17074.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 static X2: u64 = !0 as u16 as u64; static Y2: u64 = !0 as u32 as u64; diff --git a/src/test/run-pass/issue-17216.rs b/src/test/run-pass/issue-17216.rs index f17834e8d36dc..6a8f7d992a292 100644 --- a/src/test/run-pass/issue-17216.rs +++ b/src/test/run-pass/issue-17216.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unsafe_destructor)] diff --git a/src/test/run-pass/issue-17233.rs b/src/test/run-pass/issue-17233.rs index 756822d4f45fa..e9f0c73e29db3 100644 --- a/src/test/run-pass/issue-17233.rs +++ b/src/test/run-pass/issue-17233.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 const X1: &'static [u8] = &[b'1']; const X2: &'static [u8] = b"1"; diff --git a/src/test/run-pass/issue-17302.rs b/src/test/run-pass/issue-17302.rs index 35bd07c896bb6..59625581167d0 100644 --- a/src/test/run-pass/issue-17302.rs +++ b/src/test/run-pass/issue-17302.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 static mut DROPPED: [bool; 2] = [false, false]; diff --git a/src/test/run-pass/issue-17662.rs b/src/test/run-pass/issue-17662.rs index 36e12b96c8744..320d108cfae74 100644 --- a/src/test/run-pass/issue-17662.rs +++ b/src/test/run-pass/issue-17662.rs @@ -10,7 +10,6 @@ // aux-build:issue-17662.rs -// pretty-expanded FIXME #23616 extern crate issue_17662 as i; diff --git a/src/test/run-pass/issue-17718-parse-const.rs b/src/test/run-pass/issue-17718-parse-const.rs index 1fc8f3274d459..9be92d6597850 100644 --- a/src/test/run-pass/issue-17718-parse-const.rs +++ b/src/test/run-pass/issue-17718-parse-const.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 const FOO: usize = 3; diff --git a/src/test/run-pass/issue-17718.rs b/src/test/run-pass/issue-17718.rs index 13e082eada884..2b84ce71dd2a2 100644 --- a/src/test/run-pass/issue-17718.rs +++ b/src/test/run-pass/issue-17718.rs @@ -10,7 +10,6 @@ // aux-build:issue-17718.rs -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/issue-17734.rs b/src/test/run-pass/issue-17734.rs index 3cf9c62b40d49..0fc8eea778da9 100644 --- a/src/test/run-pass/issue-17734.rs +++ b/src/test/run-pass/issue-17734.rs @@ -10,7 +10,6 @@ // Test that generating drop glue for Box doesn't ICE -// pretty-expanded FIXME #23616 fn f(s: Box) -> Box { s diff --git a/src/test/run-pass/issue-17877.rs b/src/test/run-pass/issue-17877.rs index 41fab9d9d54e0..6c87e8d35fbf0 100644 --- a/src/test/run-pass/issue-17877.rs +++ b/src/test/run-pass/issue-17877.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(slice_patterns)] diff --git a/src/test/run-pass/issue-18352.rs b/src/test/run-pass/issue-18352.rs index 4e60a7d9b5fbb..cce6ba407a663 100644 --- a/src/test/run-pass/issue-18352.rs +++ b/src/test/run-pass/issue-18352.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 const X: &'static str = "12345"; diff --git a/src/test/run-pass/issue-18412.rs b/src/test/run-pass/issue-18412.rs index 41dacd3320379..1017fab5ae2e0 100644 --- a/src/test/run-pass/issue-18412.rs +++ b/src/test/run-pass/issue-18412.rs @@ -11,7 +11,6 @@ // Test that non-static methods can be assigned to local variables as // function pointers. -// pretty-expanded FIXME #23616 trait Foo { fn foo(&self) -> usize; diff --git a/src/test/run-pass/issue-18652.rs b/src/test/run-pass/issue-18652.rs index a3affb7bf86f0..8ab645e54addc 100644 --- a/src/test/run-pass/issue-18652.rs +++ b/src/test/run-pass/issue-18652.rs @@ -12,7 +12,6 @@ // once closure as an optimization by trans. This used to hit an // incorrect assert. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures)] diff --git a/src/test/run-pass/issue-18767.rs b/src/test/run-pass/issue-18767.rs index 8e51a900c0cae..264985b791e7f 100644 --- a/src/test/run-pass/issue-18767.rs +++ b/src/test/run-pass/issue-18767.rs @@ -11,7 +11,6 @@ // Test that regionck uses the right memcat for patterns in for loops // and doesn't ICE. -// pretty-expanded FIXME #23616 fn main() { for &&x in Some(&0_usize).iter() { diff --git a/src/test/run-pass/issue-18859.rs b/src/test/run-pass/issue-18859.rs index 16e6c99f0e31d..7c7501d3420d2 100644 --- a/src/test/run-pass/issue-18859.rs +++ b/src/test/run-pass/issue-18859.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 mod foo { pub mod bar { diff --git a/src/test/run-pass/issue-19244.rs b/src/test/run-pass/issue-19244.rs index f25450a891827..92ac2e37b90d2 100644 --- a/src/test/run-pass/issue-19244.rs +++ b/src/test/run-pass/issue-19244.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct MyStruct { field: usize } struct Nested { nested: MyStruct } diff --git a/src/test/run-pass/issue-19811-escape-unicode.rs b/src/test/run-pass/issue-19811-escape-unicode.rs index 5b415c63885e6..e6e9bf6e6367f 100644 --- a/src/test/run-pass/issue-19811-escape-unicode.rs +++ b/src/test/run-pass/issue-19811-escape-unicode.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(collections)] diff --git a/src/test/run-pass/issue-21058.rs b/src/test/run-pass/issue-21058.rs index d7a656be7afb0..c384757c5e4fb 100644 --- a/src/test/run-pass/issue-21058.rs +++ b/src/test/run-pass/issue-21058.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/issue-21306.rs b/src/test/run-pass/issue-21306.rs index cabda0b500bd5..bc2c7f09374fa 100644 --- a/src/test/run-pass/issue-21306.rs +++ b/src/test/run-pass/issue-21306.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::sync::Arc; diff --git a/src/test/run-pass/issue-21361.rs b/src/test/run-pass/issue-21361.rs index ef86634125ebd..b89e07ef31f0b 100644 --- a/src/test/run-pass/issue-21361.rs +++ b/src/test/run-pass/issue-21361.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn main() { let v = vec![1, 2, 3]; diff --git a/src/test/run-pass/issue-21384.rs b/src/test/run-pass/issue-21384.rs index 41a9ca840b178..e10fcd30b9961 100644 --- a/src/test/run-pass/issue-21384.rs +++ b/src/test/run-pass/issue-21384.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use ::std::ops::RangeFull; diff --git a/src/test/run-pass/issue-21634.rs b/src/test/run-pass/issue-21634.rs index fe540e1aabef8..2a146ae8fcf7b 100644 --- a/src/test/run-pass/issue-21634.rs +++ b/src/test/run-pass/issue-21634.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn main() { if let Ok(x) = "3.1415".parse::() { diff --git a/src/test/run-pass/issue-21655.rs b/src/test/run-pass/issue-21655.rs index cb87770c565c0..bf01873bea5e7 100644 --- a/src/test/run-pass/issue-21655.rs +++ b/src/test/run-pass/issue-21655.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn test(it: &mut Iterator) { for x in it { diff --git a/src/test/run-pass/issue-21721.rs b/src/test/run-pass/issue-21721.rs index c34ab1b0ea7ce..d1fc61ff6a5d4 100644 --- a/src/test/run-pass/issue-21721.rs +++ b/src/test/run-pass/issue-21721.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn main() { static NONE: Option<((), &'static u8)> = None; diff --git a/src/test/run-pass/issue-22036.rs b/src/test/run-pass/issue-22036.rs index e02ce5441a7d4..43fb286f0ec40 100644 --- a/src/test/run-pass/issue-22036.rs +++ b/src/test/run-pass/issue-22036.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait DigitCollection: Sized { type Iter: Iterator; diff --git a/src/test/run-pass/issue-2214.rs b/src/test/run-pass/issue-2214.rs index 38895e1414cee..775cfb0ee4219 100644 --- a/src/test/run-pass/issue-2214.rs +++ b/src/test/run-pass/issue-2214.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(libc)] diff --git a/src/test/run-pass/issue-22536-copy-mustnt-zero.rs b/src/test/run-pass/issue-22536-copy-mustnt-zero.rs index 8a0f04a2cf0e4..af99b11c2534f 100644 --- a/src/test/run-pass/issue-22536-copy-mustnt-zero.rs +++ b/src/test/run-pass/issue-22536-copy-mustnt-zero.rs @@ -11,7 +11,6 @@ // Regression test for Issue #22536: If a type implements Copy, then // moving it must not zero the original memory. -// pretty-expanded FIXME #23616 trait Resources { type Buffer: Copy; diff --git a/src/test/run-pass/issue-2311-2.rs b/src/test/run-pass/issue-2311-2.rs index c76bbaf968a65..a47c151255270 100644 --- a/src/test/run-pass/issue-2311-2.rs +++ b/src/test/run-pass/issue-2311-2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait clam { fn get(self) -> A; diff --git a/src/test/run-pass/issue-2312.rs b/src/test/run-pass/issue-2312.rs index fa056191e671e..6f479c621170e 100644 --- a/src/test/run-pass/issue-2312.rs +++ b/src/test/run-pass/issue-2312.rs @@ -10,7 +10,6 @@ // Testing that the B's are resolved -// pretty-expanded FIXME #23616 trait clam { fn get(self) -> A; } diff --git a/src/test/run-pass/issue-2428.rs b/src/test/run-pass/issue-2428.rs index 402eb0349ab23..a07050d4582f0 100644 --- a/src/test/run-pass/issue-2428.rs +++ b/src/test/run-pass/issue-2428.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let _foo = 100; diff --git a/src/test/run-pass/issue-2611-3.rs b/src/test/run-pass/issue-2611-3.rs index 8cf80333e9722..242528dcb1474 100644 --- a/src/test/run-pass/issue-2611-3.rs +++ b/src/test/run-pass/issue-2611-3.rs @@ -11,7 +11,6 @@ // Tests that impls are allowed to have looser, more permissive bounds // than the traits require. -// pretty-expanded FIXME #23616 trait A { fn b(&self, x: C) -> C; diff --git a/src/test/run-pass/issue-2735-2.rs b/src/test/run-pass/issue-2735-2.rs index 1506b2d6bf089..36d7f4583b09f 100644 --- a/src/test/run-pass/issue-2735-2.rs +++ b/src/test/run-pass/issue-2735-2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unsafe_destructor)] diff --git a/src/test/run-pass/issue-2735-3.rs b/src/test/run-pass/issue-2735-3.rs index 2282334d66d10..f438519b72f3b 100644 --- a/src/test/run-pass/issue-2735-3.rs +++ b/src/test/run-pass/issue-2735-3.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unsafe_destructor)] diff --git a/src/test/run-pass/issue-2748-b.rs b/src/test/run-pass/issue-2748-b.rs index 8f30d262f41f5..f1cbf11a347eb 100644 --- a/src/test/run-pass/issue-2748-b.rs +++ b/src/test/run-pass/issue-2748-b.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn thing<'r>(x: &'r [isize]) -> &'r [isize] { x } diff --git a/src/test/run-pass/issue-2895.rs b/src/test/run-pass/issue-2895.rs index 3f4c630cc2b0a..93d9300edf634 100644 --- a/src/test/run-pass/issue-2895.rs +++ b/src/test/run-pass/issue-2895.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/issue-2936.rs b/src/test/run-pass/issue-2936.rs index 5c63230f5d0ca..c277073a79dc9 100644 --- a/src/test/run-pass/issue-2936.rs +++ b/src/test/run-pass/issue-2936.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait bar { fn get_bar(&self) -> T; diff --git a/src/test/run-pass/issue-3091.rs b/src/test/run-pass/issue-3091.rs index 8e59e46fc3c4c..c67399a89e9c6 100644 --- a/src/test/run-pass/issue-3091.rs +++ b/src/test/run-pass/issue-3091.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let x = 1; diff --git a/src/test/run-pass/issue-3290.rs b/src/test/run-pass/issue-3290.rs index 3fa5b72c348f3..b09820146f5b8 100644 --- a/src/test/run-pass/issue-3290.rs +++ b/src/test/run-pass/issue-3290.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/issue-333.rs b/src/test/run-pass/issue-333.rs index b611f11a0a124..592ff0b02a4ad 100644 --- a/src/test/run-pass/issue-333.rs +++ b/src/test/run-pass/issue-333.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn quux(x: T) -> T { let f = id::; return f(x); } diff --git a/src/test/run-pass/issue-3574.rs b/src/test/run-pass/issue-3574.rs index 9a521ba376dc2..9aac52fa2f8a1 100644 --- a/src/test/run-pass/issue-3574.rs +++ b/src/test/run-pass/issue-3574.rs @@ -10,7 +10,6 @@ // rustc --test match_borrowed_str.rs.rs && ./match_borrowed_str.rs -// pretty-expanded FIXME #23616 fn compare(x: &str, y: &str) -> bool { match x { diff --git a/src/test/run-pass/issue-3895.rs b/src/test/run-pass/issue-3895.rs index ca6d9faf88f4a..ffe14dab30039 100644 --- a/src/test/run-pass/issue-3895.rs +++ b/src/test/run-pass/issue-3895.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { enum State { BadChar, BadSyntax } diff --git a/src/test/run-pass/issue-3935.rs b/src/test/run-pass/issue-3935.rs index 1e200e01628a5..45ff20fc0a9c3 100644 --- a/src/test/run-pass/issue-3935.rs +++ b/src/test/run-pass/issue-3935.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #[derive(PartialEq)] struct Bike { diff --git a/src/test/run-pass/issue-3979-generics.rs b/src/test/run-pass/issue-3979-generics.rs index 61708acf7f317..6ba566012c3be 100644 --- a/src/test/run-pass/issue-3979-generics.rs +++ b/src/test/run-pass/issue-3979-generics.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::ops::Add; diff --git a/src/test/run-pass/issue-3979-xcrate.rs b/src/test/run-pass/issue-3979-xcrate.rs index 0784877849ad1..acacc48856646 100644 --- a/src/test/run-pass/issue-3979-xcrate.rs +++ b/src/test/run-pass/issue-3979-xcrate.rs @@ -9,7 +9,6 @@ // except according to those terms. // aux-build:issue_3979_traits.rs -// pretty-expanded FIXME #23616 extern crate issue_3979_traits; use issue_3979_traits::{Positioned, Movable}; diff --git a/src/test/run-pass/issue-3979.rs b/src/test/run-pass/issue-3979.rs index 341866e4982ff..184682255d936 100644 --- a/src/test/run-pass/issue-3979.rs +++ b/src/test/run-pass/issue-3979.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Positioned { fn SetX(&mut self, isize); diff --git a/src/test/run-pass/issue-4016.rs b/src/test/run-pass/issue-4016.rs index 122de97c99c1c..bc3fa162e02bd 100644 --- a/src/test/run-pass/issue-4016.rs +++ b/src/test/run-pass/issue-4016.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(rustc_private)] diff --git a/src/test/run-pass/issue-4107.rs b/src/test/run-pass/issue-4107.rs index 18025c315c95c..fa5ed26847b57 100644 --- a/src/test/run-pass/issue-4107.rs +++ b/src/test/run-pass/issue-4107.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let _id: &Mat2 = &Matrix::identity(1.0); diff --git a/src/test/run-pass/issue-4448.rs b/src/test/run-pass/issue-4448.rs index d5d3122f6834b..eb411ff441778 100644 --- a/src/test/run-pass/issue-4448.rs +++ b/src/test/run-pass/issue-4448.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::sync::mpsc::channel; use std::thread; diff --git a/src/test/run-pass/issue-4734.rs b/src/test/run-pass/issue-4734.rs index 82925852a6a3d..88a3b24d14fc8 100644 --- a/src/test/run-pass/issue-4734.rs +++ b/src/test/run-pass/issue-4734.rs @@ -11,7 +11,6 @@ // Ensures that destructors are run for expressions of the form "e;" where // `e` is a type which requires a destructor. -// pretty-expanded FIXME #23616 #![allow(path_statement)] diff --git a/src/test/run-pass/issue-5239-2.rs b/src/test/run-pass/issue-5239-2.rs index d8491070bd8b5..5e58d76d5e0ff 100644 --- a/src/test/run-pass/issue-5239-2.rs +++ b/src/test/run-pass/issue-5239-2.rs @@ -10,7 +10,6 @@ // Regression test for issue #5239 -// pretty-expanded FIXME #23616 pub fn main() { let _f = |ref x: isize| { *x }; diff --git a/src/test/run-pass/issue-5521.rs b/src/test/run-pass/issue-5521.rs index 4ad729f1bc60a..136f7aa956c0d 100644 --- a/src/test/run-pass/issue-5521.rs +++ b/src/test/run-pass/issue-5521.rs @@ -11,7 +11,6 @@ // aux-build:issue-5521.rs -// pretty-expanded FIXME #23616 extern crate issue_5521 as foo; diff --git a/src/test/run-pass/issue-5530.rs b/src/test/run-pass/issue-5530.rs index 50b9ca6e797d8..bd7d7af71df85 100644 --- a/src/test/run-pass/issue-5530.rs +++ b/src/test/run-pass/issue-5530.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum Enum { Foo { foo: usize }, diff --git a/src/test/run-pass/issue-5917.rs b/src/test/run-pass/issue-5917.rs index 7f741182f4223..112ad0185d8cb 100644 --- a/src/test/run-pass/issue-5917.rs +++ b/src/test/run-pass/issue-5917.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct T (&'static [isize]); static t : T = T (&[5, 4, 3]); diff --git a/src/test/run-pass/issue-5997.rs b/src/test/run-pass/issue-5997.rs index 48923bc82b4e0..0c41acf04aae6 100644 --- a/src/test/run-pass/issue-5997.rs +++ b/src/test/run-pass/issue-5997.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn f() -> bool { enum E { V(T) } diff --git a/src/test/run-pass/issue-6128.rs b/src/test/run-pass/issue-6128.rs index baf829bc269b6..5fb24fe3ef1ac 100644 --- a/src/test/run-pass/issue-6128.rs +++ b/src/test/run-pass/issue-6128.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax, collections)] diff --git a/src/test/run-pass/issue-6130.rs b/src/test/run-pass/issue-6130.rs index 6f158339169cb..f124b851f0925 100644 --- a/src/test/run-pass/issue-6130.rs +++ b/src/test/run-pass/issue-6130.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![deny(type_limits)] diff --git a/src/test/run-pass/issue-6153.rs b/src/test/run-pass/issue-6153.rs index c280ea31ebc47..16e7060f4b9f1 100644 --- a/src/test/run-pass/issue-6153.rs +++ b/src/test/run-pass/issue-6153.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn swap(f: F) -> Vec where F: FnOnce(Vec) -> Vec { let x = vec!(1, 2, 3); diff --git a/src/test/run-pass/issue-6334.rs b/src/test/run-pass/issue-6334.rs index 2f2dca8fe226c..fca1c296dddcc 100644 --- a/src/test/run-pass/issue-6334.rs +++ b/src/test/run-pass/issue-6334.rs @@ -11,7 +11,6 @@ // Tests that everything still compiles and runs fine even when // we reorder the bounds. -// pretty-expanded FIXME #23616 trait A { fn a(&self) -> usize; diff --git a/src/test/run-pass/issue-6449.rs b/src/test/run-pass/issue-6449.rs index 3b33a0ac86f69..09a4e288404f2 100644 --- a/src/test/run-pass/issue-6449.rs +++ b/src/test/run-pass/issue-6449.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum Foo { Bar(isize), diff --git a/src/test/run-pass/issue-6892.rs b/src/test/run-pass/issue-6892.rs index 4469dcc0ced81..75420ad6ff1c5 100644 --- a/src/test/run-pass/issue-6892.rs +++ b/src/test/run-pass/issue-6892.rs @@ -11,7 +11,6 @@ // Ensures that destructors are run for expressions of the form "let _ = e;" // where `e` is a type which requires a destructor. -// pretty-expanded FIXME #23616 struct Foo; struct Bar { x: isize } diff --git a/src/test/run-pass/issue-7575.rs b/src/test/run-pass/issue-7575.rs index 727ed91eadc6c..508ebf3f69d1a 100644 --- a/src/test/run-pass/issue-7575.rs +++ b/src/test/run-pass/issue-7575.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Foo { fn new() -> bool { false } diff --git a/src/test/run-pass/issue-7663.rs b/src/test/run-pass/issue-7663.rs index 007127aeae186..7aac8d4456334 100644 --- a/src/test/run-pass/issue-7663.rs +++ b/src/test/run-pass/issue-7663.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unused_imports, dead_code)] diff --git a/src/test/run-pass/issue-7784.rs b/src/test/run-pass/issue-7784.rs index e2016feeb0ad7..224fe627e32d9 100644 --- a/src/test/run-pass/issue-7784.rs +++ b/src/test/run-pass/issue-7784.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(advanced_slice_patterns)] #![feature(slice_patterns)] diff --git a/src/test/run-pass/issue-8351-1.rs b/src/test/run-pass/issue-8351-1.rs index a11e14fb33367..ed78b37604e86 100644 --- a/src/test/run-pass/issue-8351-1.rs +++ b/src/test/run-pass/issue-8351-1.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { Foo{f: isize}, diff --git a/src/test/run-pass/issue-8351-2.rs b/src/test/run-pass/issue-8351-2.rs index 7cf221926a6d3..1ed93915b8a03 100644 --- a/src/test/run-pass/issue-8351-2.rs +++ b/src/test/run-pass/issue-8351-2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { Foo{f: isize, b: bool}, diff --git a/src/test/run-pass/issue-8391.rs b/src/test/run-pass/issue-8391.rs index bd2e2871bdb49..b832c410443c4 100644 --- a/src/test/run-pass/issue-8391.rs +++ b/src/test/run-pass/issue-8391.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn main() { let x = match Some(1) { diff --git a/src/test/run-pass/issue-8460.rs b/src/test/run-pass/issue-8460.rs index 7d8c4ab210d00..2469dec994727 100644 --- a/src/test/run-pass/issue-8460.rs +++ b/src/test/run-pass/issue-8460.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/issue-8498.rs b/src/test/run-pass/issue-8498.rs index 825729b1e2a81..fae3352f9cc5f 100644 --- a/src/test/run-pass/issue-8498.rs +++ b/src/test/run-pass/issue-8498.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { match &[(Box::new(5),Box::new(7))] { diff --git a/src/test/run-pass/issue-8709.rs b/src/test/run-pass/issue-8709.rs index 6467262929810..44759cef2864f 100644 --- a/src/test/run-pass/issue-8709.rs +++ b/src/test/run-pass/issue-8709.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 macro_rules! sty { ($t:ty) => (stringify!($t)) diff --git a/src/test/run-pass/issue-8860.rs b/src/test/run-pass/issue-8860.rs index 8024eaeda83cb..ff562aac1614b 100644 --- a/src/test/run-pass/issue-8860.rs +++ b/src/test/run-pass/issue-8860.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 static mut DROP: isize = 0; static mut DROP_S: isize = 0; diff --git a/src/test/run-pass/issue-8898.rs b/src/test/run-pass/issue-8898.rs index a4cad1b263952..065cef2c60d7d 100644 --- a/src/test/run-pass/issue-8898.rs +++ b/src/test/run-pass/issue-8898.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn assert_repr_eq(obj : T, expected : String) { assert_eq!(expected, format!("{:?}", obj)); diff --git a/src/test/run-pass/issue-9188.rs b/src/test/run-pass/issue-9188.rs index 0bd8a8e0d9df2..e2272837efb7a 100644 --- a/src/test/run-pass/issue-9188.rs +++ b/src/test/run-pass/issue-9188.rs @@ -10,7 +10,6 @@ // aux-build:issue_9188.rs -// pretty-expanded FIXME #23616 extern crate issue_9188; diff --git a/src/test/run-pass/issue-9259.rs b/src/test/run-pass/issue-9259.rs index 209c6b139612f..996548de81738 100644 --- a/src/test/run-pass/issue-9259.rs +++ b/src/test/run-pass/issue-9259.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct A<'a> { a: &'a [String], diff --git a/src/test/run-pass/issue-9394-inherited-trait-calls.rs b/src/test/run-pass/issue-9394-inherited-trait-calls.rs index 148d0760e5c02..7d2c435b38429 100644 --- a/src/test/run-pass/issue-9394-inherited-trait-calls.rs +++ b/src/test/run-pass/issue-9394-inherited-trait-calls.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Base: Base2 + Base3{ fn foo(&self) -> String; diff --git a/src/test/run-pass/issue-979.rs b/src/test/run-pass/issue-979.rs index 3283dc44f3083..979abcef7b8d2 100644 --- a/src/test/run-pass/issue-979.rs +++ b/src/test/run-pass/issue-979.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unsafe_destructor)] diff --git a/src/test/run-pass/issue-9918.rs b/src/test/run-pass/issue-9918.rs index e81a07fa68325..a766e6b707e30 100644 --- a/src/test/run-pass/issue-9918.rs +++ b/src/test/run-pass/issue-9918.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { assert_eq!((0 + 0u8) as char, '\0'); diff --git a/src/test/run-pass/iter-cloned-type-inference.rs b/src/test/run-pass/iter-cloned-type-inference.rs index d1f63564979c8..59f7569d8c62b 100644 --- a/src/test/run-pass/iter-cloned-type-inference.rs +++ b/src/test/run-pass/iter-cloned-type-inference.rs @@ -11,7 +11,6 @@ // Test to see that the element type of .cloned() can be inferred // properly. Previously this would fail to deduce the type of `sum`. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/kindck-owned-trait-contains-1.rs b/src/test/run-pass/kindck-owned-trait-contains-1.rs index 84156385ef438..9df72f4760a1f 100644 --- a/src/test/run-pass/kindck-owned-trait-contains-1.rs +++ b/src/test/run-pass/kindck-owned-trait-contains-1.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/last-use-in-block.rs b/src/test/run-pass/last-use-in-block.rs index 28fe3bf0bd1fd..a2b01f29ae127 100644 --- a/src/test/run-pass/last-use-in-block.rs +++ b/src/test/run-pass/last-use-in-block.rs @@ -10,7 +10,6 @@ // Issue #1818 -// pretty-expanded FIXME #23616 fn lp(s: String, mut f: F) -> T where F: FnMut(String) -> T { while false { diff --git a/src/test/run-pass/last-use-in-cap-clause.rs b/src/test/run-pass/last-use-in-cap-clause.rs index f9c8fe0f2d2d5..f196899f69d68 100644 --- a/src/test/run-pass/last-use-in-cap-clause.rs +++ b/src/test/run-pass/last-use-in-cap-clause.rs @@ -10,7 +10,6 @@ // Make sure #1399 stays fixed -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/let-destruct-ref.rs b/src/test/run-pass/let-destruct-ref.rs index 0b38d16941bae..c9504f87c4904 100644 --- a/src/test/run-pass/let-destruct-ref.rs +++ b/src/test/run-pass/let-destruct-ref.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let x = 3_usize; diff --git a/src/test/run-pass/let-var-hygiene.rs b/src/test/run-pass/let-var-hygiene.rs index c1e80aaf2d7b0..d9087f58befe7 100644 --- a/src/test/run-pass/let-var-hygiene.rs +++ b/src/test/run-pass/let-var-hygiene.rs @@ -9,7 +9,6 @@ // except according to those terms. // shouldn't affect evaluation of $ex: -// pretty-expanded FIXME #23616 macro_rules! bad_macro { ($ex:expr) => ({let _x = 9; $ex}) diff --git a/src/test/run-pass/logging-enabled-debug.rs b/src/test/run-pass/logging-enabled-debug.rs index 59f5b0af35913..3ae4884ce47fc 100644 --- a/src/test/run-pass/logging-enabled-debug.rs +++ b/src/test/run-pass/logging-enabled-debug.rs @@ -11,7 +11,6 @@ // compile-flags:-C debug-assertions=no // exec-env:RUST_LOG=logging-enabled-debug=debug -// pretty-expanded FIXME #23616 #![feature(rustc_private)] diff --git a/src/test/run-pass/logging-enabled.rs b/src/test/run-pass/logging-enabled.rs index 294d4d1217952..2975835a27149 100644 --- a/src/test/run-pass/logging-enabled.rs +++ b/src/test/run-pass/logging-enabled.rs @@ -10,7 +10,6 @@ // exec-env:RUST_LOG=logging_enabled=info -// pretty-expanded FIXME #23616 #![feature(rustc_private)] diff --git a/src/test/run-pass/loop-break-cont-1.rs b/src/test/run-pass/loop-break-cont-1.rs index eaf69dbae00f9..5abac0e65a360 100644 --- a/src/test/run-pass/loop-break-cont-1.rs +++ b/src/test/run-pass/loop-break-cont-1.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let _i = 0_usize; diff --git a/src/test/run-pass/loop-scope.rs b/src/test/run-pass/loop-scope.rs index 70f2830555a4b..0c1e7916cdb18 100644 --- a/src/test/run-pass/loop-scope.rs +++ b/src/test/run-pass/loop-scope.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let x = vec!(10, 20, 30); diff --git a/src/test/run-pass/macro-block-nonterminal.rs b/src/test/run-pass/macro-block-nonterminal.rs index 496534a5362f3..21b284f420f20 100644 --- a/src/test/run-pass/macro-block-nonterminal.rs +++ b/src/test/run-pass/macro-block-nonterminal.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 macro_rules! do_block{ ($val:block) => {$val} diff --git a/src/test/run-pass/macro-crate-def-only.rs b/src/test/run-pass/macro-crate-def-only.rs index 58b09fa492192..28be058b9a376 100644 --- a/src/test/run-pass/macro-crate-def-only.rs +++ b/src/test/run-pass/macro-crate-def-only.rs @@ -10,7 +10,6 @@ // aux-build:macro_crate_def_only.rs -// pretty-expanded FIXME #23616 #[macro_use] #[no_link] extern crate macro_crate_def_only; diff --git a/src/test/run-pass/macro-crate-use.rs b/src/test/run-pass/macro-crate-use.rs index 557f982713a17..c7255f67fa684 100644 --- a/src/test/run-pass/macro-crate-use.rs +++ b/src/test/run-pass/macro-crate-use.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn increment(x: usize) -> usize { x + 1 diff --git a/src/test/run-pass/macro-deep_expansion.rs b/src/test/run-pass/macro-deep_expansion.rs index fd21ed0150ab0..3e8548ff49d2b 100644 --- a/src/test/run-pass/macro-deep_expansion.rs +++ b/src/test/run-pass/macro-deep_expansion.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 macro_rules! foo2 { () => { diff --git a/src/test/run-pass/macro-interpolation.rs b/src/test/run-pass/macro-interpolation.rs index e6b5d50b36e6d..6dcd1538ebce2 100644 --- a/src/test/run-pass/macro-interpolation.rs +++ b/src/test/run-pass/macro-interpolation.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 macro_rules! overly_complicated { ($fnname:ident, $arg:ident, $ty:ty, $body:block, $val:expr, $pat:pat, $res:path) => diff --git a/src/test/run-pass/macro-method-issue-4621.rs b/src/test/run-pass/macro-method-issue-4621.rs index cb1540459771b..64648cae5e6cc 100644 --- a/src/test/run-pass/macro-method-issue-4621.rs +++ b/src/test/run-pass/macro-method-issue-4621.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct A; diff --git a/src/test/run-pass/macro-of-higher-order.rs b/src/test/run-pass/macro-of-higher-order.rs index ebd58f772284a..52e19b37d7935 100644 --- a/src/test/run-pass/macro-of-higher-order.rs +++ b/src/test/run-pass/macro-of-higher-order.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 macro_rules! higher_order { (subst $lhs:tt => $rhs:tt) => ({ diff --git a/src/test/run-pass/macro-pat.rs b/src/test/run-pass/macro-pat.rs index 659113d4e0c95..48e521de57e90 100644 --- a/src/test/run-pass/macro-pat.rs +++ b/src/test/run-pass/macro-pat.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 macro_rules! mypat { () => ( diff --git a/src/test/run-pass/macro-path.rs b/src/test/run-pass/macro-path.rs index 2e8806229778e..7aecc1dc20348 100644 --- a/src/test/run-pass/macro-path.rs +++ b/src/test/run-pass/macro-path.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 mod m { pub type t = isize; diff --git a/src/test/run-pass/macro-with-attrs1.rs b/src/test/run-pass/macro-with-attrs1.rs index 0938c16c30492..99bf71b1f0126 100644 --- a/src/test/run-pass/macro-with-attrs1.rs +++ b/src/test/run-pass/macro-with-attrs1.rs @@ -10,7 +10,6 @@ // compile-flags: --cfg foo -// pretty-expanded FIXME #23616 #[cfg(foo)] macro_rules! foo { () => (1) } diff --git a/src/test/run-pass/macro-with-attrs2.rs b/src/test/run-pass/macro-with-attrs2.rs index cf48c325f1f24..062c8d55d5296 100644 --- a/src/test/run-pass/macro-with-attrs2.rs +++ b/src/test/run-pass/macro-with-attrs2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #[cfg(foo)] macro_rules! foo { () => (1) } diff --git a/src/test/run-pass/match-arm-statics.rs b/src/test/run-pass/match-arm-statics.rs index 1b4dfb869d413..43ff69fe75e6c 100644 --- a/src/test/run-pass/match-arm-statics.rs +++ b/src/test/run-pass/match-arm-statics.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct NewBool(bool); diff --git a/src/test/run-pass/match-borrowed_str.rs b/src/test/run-pass/match-borrowed_str.rs index 574c4b9f00eab..b027e62494c23 100644 --- a/src/test/run-pass/match-borrowed_str.rs +++ b/src/test/run-pass/match-borrowed_str.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unnecessary_allocation)] diff --git a/src/test/run-pass/match-bot-2.rs b/src/test/run-pass/match-bot-2.rs index 4fa951b34794b..88c514a724f2f 100644 --- a/src/test/run-pass/match-bot-2.rs +++ b/src/test/run-pass/match-bot-2.rs @@ -9,7 +9,6 @@ // except according to those terms. // n.b. This was only ever failing with optimization disabled. -// pretty-expanded FIXME #23616 fn a() -> isize { match return 1 { 2 => 3, _ => panic!() } } pub fn main() { a(); } diff --git a/src/test/run-pass/match-enum-struct-0.rs b/src/test/run-pass/match-enum-struct-0.rs index 06d19cec185bb..1754dc0c960f8 100644 --- a/src/test/run-pass/match-enum-struct-0.rs +++ b/src/test/run-pass/match-enum-struct-0.rs @@ -10,7 +10,6 @@ // regression test for issue #5625 -// pretty-expanded FIXME #23616 enum E { Foo{f : isize}, diff --git a/src/test/run-pass/match-enum-struct-1.rs b/src/test/run-pass/match-enum-struct-1.rs index e4766f32a57f3..ebf2db36700c3 100644 --- a/src/test/run-pass/match-enum-struct-1.rs +++ b/src/test/run-pass/match-enum-struct-1.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum E { Foo{f : isize}, diff --git a/src/test/run-pass/match-implicit-copy-unique.rs b/src/test/run-pass/match-implicit-copy-unique.rs index d481c02eb410a..d75bdaf4da8ea 100644 --- a/src/test/run-pass/match-implicit-copy-unique.rs +++ b/src/test/run-pass/match-implicit-copy-unique.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/match-in-macro.rs b/src/test/run-pass/match-in-macro.rs index 27bbbc936ae5c..e096c97e16f16 100644 --- a/src/test/run-pass/match-in-macro.rs +++ b/src/test/run-pass/match-in-macro.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum Foo { B { b1: isize, bb1: isize}, diff --git a/src/test/run-pass/match-pattern-bindings.rs b/src/test/run-pass/match-pattern-bindings.rs index d230f18f2bd84..9f687ab99e800 100644 --- a/src/test/run-pass/match-pattern-bindings.rs +++ b/src/test/run-pass/match-pattern-bindings.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn main() { let value = Some(1); diff --git a/src/test/run-pass/match-pipe-binding.rs b/src/test/run-pass/match-pipe-binding.rs index 70d3639a785fa..bda90d3aaecb4 100644 --- a/src/test/run-pass/match-pipe-binding.rs +++ b/src/test/run-pass/match-pipe-binding.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn test1() { // from issue 6338 diff --git a/src/test/run-pass/match-ref-binding-in-guard-3256.rs b/src/test/run-pass/match-ref-binding-in-guard-3256.rs index 1e2ebf42a9911..dc3c759078f3d 100644 --- a/src/test/run-pass/match-ref-binding-in-guard-3256.rs +++ b/src/test/run-pass/match-ref-binding-in-guard-3256.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::sync::Mutex; diff --git a/src/test/run-pass/match-ref-binding-mut-option.rs b/src/test/run-pass/match-ref-binding-mut-option.rs index 41f00e58ff769..f429e7b58e382 100644 --- a/src/test/run-pass/match-ref-binding-mut-option.rs +++ b/src/test/run-pass/match-ref-binding-mut-option.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let mut v = Some(22); diff --git a/src/test/run-pass/match-ref-binding-mut.rs b/src/test/run-pass/match-ref-binding-mut.rs index 26c91e1703caf..abc418ddd5169 100644 --- a/src/test/run-pass/match-ref-binding-mut.rs +++ b/src/test/run-pass/match-ref-binding-mut.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct Rec { f: isize diff --git a/src/test/run-pass/match-ref-binding.rs b/src/test/run-pass/match-ref-binding.rs index 826edb30b36f4..eab7ed529b1f6 100644 --- a/src/test/run-pass/match-ref-binding.rs +++ b/src/test/run-pass/match-ref-binding.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn destructure(x: Option) -> isize { match x { diff --git a/src/test/run-pass/match-static-const-rename.rs b/src/test/run-pass/match-static-const-rename.rs index 21b806f80dee4..08f3182900fc2 100644 --- a/src/test/run-pass/match-static-const-rename.rs +++ b/src/test/run-pass/match-static-const-rename.rs @@ -16,7 +16,6 @@ // around this problem locally by renaming the constant in the `use` // form to an uppercase identifier that placates the lint. -// pretty-expanded FIXME #23616 #![deny(non_upper_case_globals)] diff --git a/src/test/run-pass/match-str.rs b/src/test/run-pass/match-str.rs index 5d8958c6b9e87..e6def65e53a6f 100644 --- a/src/test/run-pass/match-str.rs +++ b/src/test/run-pass/match-str.rs @@ -10,7 +10,6 @@ // Issue #53 -// pretty-expanded FIXME #23616 pub fn main() { match "test" { "not-test" => panic!(), "test" => (), _ => panic!() } diff --git a/src/test/run-pass/match-struct-0.rs b/src/test/run-pass/match-struct-0.rs index 450b310b8f408..e9e45df460df1 100644 --- a/src/test/run-pass/match-struct-0.rs +++ b/src/test/run-pass/match-struct-0.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct Foo{ f : isize, diff --git a/src/test/run-pass/match-tag.rs b/src/test/run-pass/match-tag.rs index 82d29f9050bfc..e4a0d4e95f3c7 100644 --- a/src/test/run-pass/match-tag.rs +++ b/src/test/run-pass/match-tag.rs @@ -11,7 +11,6 @@ -// pretty-expanded FIXME #23616 enum color { rgb(isize, isize, isize), diff --git a/src/test/run-pass/match-vec-alternatives.rs b/src/test/run-pass/match-vec-alternatives.rs index f9b49281bab0c..43e0b442251bd 100644 --- a/src/test/run-pass/match-vec-alternatives.rs +++ b/src/test/run-pass/match-vec-alternatives.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(advanced_slice_patterns)] #![feature(slice_patterns)] diff --git a/src/test/run-pass/match-vec-rvalue.rs b/src/test/run-pass/match-vec-rvalue.rs index e368aeb976934..a10f9b1d7d61b 100644 --- a/src/test/run-pass/match-vec-rvalue.rs +++ b/src/test/run-pass/match-vec-rvalue.rs @@ -11,7 +11,6 @@ // Tests that matching rvalues with drops does not crash. -// pretty-expanded FIXME #23616 pub fn main() { match vec!(1, 2, 3) { diff --git a/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs b/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs index 7cc762c934826..25e0b272fd2e5 100644 --- a/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs +++ b/src/test/run-pass/method-mut-self-modifies-mut-slice-lvalue.rs @@ -12,7 +12,6 @@ // type is `&mut [u8]`, passes in a pointer to the lvalue and not a // temporary. Issue #19147. -// pretty-expanded FIXME #23616 #![feature(core, old_io)] diff --git a/src/test/run-pass/method-projection.rs b/src/test/run-pass/method-projection.rs index 3db7268207086..41d92cc75937b 100644 --- a/src/test/run-pass/method-projection.rs +++ b/src/test/run-pass/method-projection.rs @@ -13,7 +13,6 @@ /////////////////////////////////////////////////////////////////////////// -// pretty-expanded FIXME #23616 trait MakeString { fn make_string(&self) -> String; diff --git a/src/test/run-pass/method-self-arg-aux1.rs b/src/test/run-pass/method-self-arg-aux1.rs index 768e7f94862ac..acda78af5c32d 100644 --- a/src/test/run-pass/method-self-arg-aux1.rs +++ b/src/test/run-pass/method-self-arg-aux1.rs @@ -10,7 +10,6 @@ // Test method calls with self as an argument (cross-crate) -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/method-self-arg-aux2.rs b/src/test/run-pass/method-self-arg-aux2.rs index b40333c67c6ac..0aea4139b0c37 100644 --- a/src/test/run-pass/method-self-arg-aux2.rs +++ b/src/test/run-pass/method-self-arg-aux2.rs @@ -10,7 +10,6 @@ // Test method calls with self as an argument (cross-crate) -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/method-self-arg-trait.rs b/src/test/run-pass/method-self-arg-trait.rs index f0ca0a70acc96..2ba3e78ef1504 100644 --- a/src/test/run-pass/method-self-arg-trait.rs +++ b/src/test/run-pass/method-self-arg-trait.rs @@ -10,7 +10,6 @@ // Test method calls with self as an argument -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/method-self-arg.rs b/src/test/run-pass/method-self-arg.rs index dfc121192228d..543133a3268f8 100644 --- a/src/test/run-pass/method-self-arg.rs +++ b/src/test/run-pass/method-self-arg.rs @@ -10,7 +10,6 @@ // Test method calls with self as an argument -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/method-two-trait-defer-resolution-1.rs b/src/test/run-pass/method-two-trait-defer-resolution-1.rs index d0e0427f37808..ff80ee1986815 100644 --- a/src/test/run-pass/method-two-trait-defer-resolution-1.rs +++ b/src/test/run-pass/method-two-trait-defer-resolution-1.rs @@ -11,7 +11,6 @@ // Test that we pick which version of `foo` to run based on the // type that is (ultimately) inferred for `x`. -// pretty-expanded FIXME #23616 trait foo { fn foo(&self) -> i32; diff --git a/src/test/run-pass/method-two-trait-defer-resolution-2.rs b/src/test/run-pass/method-two-trait-defer-resolution-2.rs index 2ceff22adb9eb..e1b64f250d8e1 100644 --- a/src/test/run-pass/method-two-trait-defer-resolution-2.rs +++ b/src/test/run-pass/method-two-trait-defer-resolution-2.rs @@ -19,7 +19,6 @@ // translate the call as `Foo::foo(&x)` and let the specific impl get // chosen later. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/method-where-clause.rs b/src/test/run-pass/method-where-clause.rs index f2ff0abfad8b8..078dbe0e79e7f 100644 --- a/src/test/run-pass/method-where-clause.rs +++ b/src/test/run-pass/method-where-clause.rs @@ -11,7 +11,6 @@ // Test that we can use method notation to call methods based on a // where clause type, and not only type parameters. -// pretty-expanded FIXME #23616 trait Foo { fn foo(&self) -> i32; diff --git a/src/test/run-pass/mod-inside-fn.rs b/src/test/run-pass/mod-inside-fn.rs index 836f2960d7174..6b922634aade1 100644 --- a/src/test/run-pass/mod-inside-fn.rs +++ b/src/test/run-pass/mod-inside-fn.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn f() -> isize { mod m { diff --git a/src/test/run-pass/monad.rs b/src/test/run-pass/monad.rs index 9ccb8f2e6fdd9..e309fa14302ca 100644 --- a/src/test/run-pass/monad.rs +++ b/src/test/run-pass/monad.rs @@ -10,7 +10,6 @@ -// pretty-expanded FIXME #23616 trait vec_monad { fn bind(&self, f: F ) -> Vec where F: FnMut(&A) -> Vec ; diff --git a/src/test/run-pass/move-1-unique.rs b/src/test/run-pass/move-1-unique.rs index ab9770b13d451..34a3bdf876538 100644 --- a/src/test/run-pass/move-1-unique.rs +++ b/src/test/run-pass/move-1-unique.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/move-2-unique.rs b/src/test/run-pass/move-2-unique.rs index c65e58a7b6502..e4dc82f9801d1 100644 --- a/src/test/run-pass/move-2-unique.rs +++ b/src/test/run-pass/move-2-unique.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/move-2.rs b/src/test/run-pass/move-2.rs index 054b57b2f432e..0c89c89eb8aa0 100644 --- a/src/test/run-pass/move-2.rs +++ b/src/test/run-pass/move-2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/move-3-unique.rs b/src/test/run-pass/move-3-unique.rs index 6036fa26ccf99..360593ffe4882 100644 --- a/src/test/run-pass/move-3-unique.rs +++ b/src/test/run-pass/move-3-unique.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/move-4-unique.rs b/src/test/run-pass/move-4-unique.rs index 79a1b294da9bb..9f80ecf297935 100644 --- a/src/test/run-pass/move-4-unique.rs +++ b/src/test/run-pass/move-4-unique.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/move-4.rs b/src/test/run-pass/move-4.rs index 16ef95023542b..1346860d51d7b 100644 --- a/src/test/run-pass/move-4.rs +++ b/src/test/run-pass/move-4.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/move-arg-2-unique.rs b/src/test/run-pass/move-arg-2-unique.rs index 7aec948c8d472..fa69731963a30 100644 --- a/src/test/run-pass/move-arg-2-unique.rs +++ b/src/test/run-pass/move-arg-2-unique.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/move-arg-2.rs b/src/test/run-pass/move-arg-2.rs index 69b66d81e4355..6e22deed269da 100644 --- a/src/test/run-pass/move-arg-2.rs +++ b/src/test/run-pass/move-arg-2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/move-arg.rs b/src/test/run-pass/move-arg.rs index 3d9eba8c09f20..0ff9a35874bfc 100644 --- a/src/test/run-pass/move-arg.rs +++ b/src/test/run-pass/move-arg.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn test(foo: isize) { assert!((foo == 10)); } diff --git a/src/test/run-pass/move-out-of-field.rs b/src/test/run-pass/move-out-of-field.rs index a0eba4685b887..262add090bde7 100644 --- a/src/test/run-pass/move-out-of-field.rs +++ b/src/test/run-pass/move-out-of-field.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::string::String; diff --git a/src/test/run-pass/move-scalar.rs b/src/test/run-pass/move-scalar.rs index a5b0a8b9bf482..798424d107e27 100644 --- a/src/test/run-pass/move-scalar.rs +++ b/src/test/run-pass/move-scalar.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { diff --git a/src/test/run-pass/multi-let.rs b/src/test/run-pass/multi-let.rs index 658b34e13f99b..1079857c1b387 100644 --- a/src/test/run-pass/multi-let.rs +++ b/src/test/run-pass/multi-let.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let x = 10; diff --git a/src/test/run-pass/multidispatch1.rs b/src/test/run-pass/multidispatch1.rs index fdf9f95b274d4..7137a4109b151 100644 --- a/src/test/run-pass/multidispatch1.rs +++ b/src/test/run-pass/multidispatch1.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::fmt::Debug; diff --git a/src/test/run-pass/multidispatch2.rs b/src/test/run-pass/multidispatch2.rs index 75c6c5ac7d165..1573c0234a6e4 100644 --- a/src/test/run-pass/multidispatch2.rs +++ b/src/test/run-pass/multidispatch2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::fmt::Debug; use std::default::Default; diff --git a/src/test/run-pass/mut-function-arguments.rs b/src/test/run-pass/mut-function-arguments.rs index 644e45575521e..f415a7f2d668c 100644 --- a/src/test/run-pass/mut-function-arguments.rs +++ b/src/test/run-pass/mut-function-arguments.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/mut-in-ident-patterns.rs b/src/test/run-pass/mut-in-ident-patterns.rs index 2a8f6f1fc31ea..32ff7efffa0dc 100644 --- a/src/test/run-pass/mut-in-ident-patterns.rs +++ b/src/test/run-pass/mut-in-ident-patterns.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Foo { fn foo(&self, mut x: isize) -> isize { diff --git a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs index bed3b87def58b..1766e65b9c734 100644 --- a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs +++ b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn test1() { let mut ints = [0; 32]; diff --git a/src/test/run-pass/negative.rs b/src/test/run-pass/negative.rs index c5b6a6a035bba..df074ddc06ac5 100644 --- a/src/test/run-pass/negative.rs +++ b/src/test/run-pass/negative.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { match -5 { diff --git a/src/test/run-pass/nested-class.rs b/src/test/run-pass/nested-class.rs index 86197d44a689d..1ad68cb9de052 100644 --- a/src/test/run-pass/nested-class.rs +++ b/src/test/run-pass/nested-class.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { struct b { diff --git a/src/test/run-pass/nested-function-names-issue-8587.rs b/src/test/run-pass/nested-function-names-issue-8587.rs index 28f3438f9862b..24b1f5ac75eae 100644 --- a/src/test/run-pass/nested-function-names-issue-8587.rs +++ b/src/test/run-pass/nested-function-names-issue-8587.rs @@ -13,7 +13,6 @@ // // Issue #8587 -// pretty-expanded FIXME #23616 pub struct X; diff --git a/src/test/run-pass/nested_item_main.rs b/src/test/run-pass/nested_item_main.rs index f7adfe36695d2..b24d517f7375c 100644 --- a/src/test/run-pass/nested_item_main.rs +++ b/src/test/run-pass/nested_item_main.rs @@ -10,7 +10,6 @@ // aux-build:nested_item.rs -// pretty-expanded FIXME #23616 extern crate nested_item; diff --git a/src/test/run-pass/new-unicode-escapes.rs b/src/test/run-pass/new-unicode-escapes.rs index 8c2d5e09adb47..bfad79e92d2c2 100644 --- a/src/test/run-pass/new-unicode-escapes.rs +++ b/src/test/run-pass/new-unicode-escapes.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(collections)] diff --git a/src/test/run-pass/newlambdas.rs b/src/test/run-pass/newlambdas.rs index c6fa7cc35fd9a..a6f39958632c2 100644 --- a/src/test/run-pass/newlambdas.rs +++ b/src/test/run-pass/newlambdas.rs @@ -10,7 +10,6 @@ // Tests for the new |args| expr lambda syntax -// pretty-expanded FIXME #23616 fn f(i: isize, f: F) -> isize where F: FnOnce(isize) -> isize { f(i) } diff --git a/src/test/run-pass/newtype-polymorphic.rs b/src/test/run-pass/newtype-polymorphic.rs index 424d518895cfb..91599608ceed6 100644 --- a/src/test/run-pass/newtype-polymorphic.rs +++ b/src/test/run-pass/newtype-polymorphic.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 #[derive(Clone)] struct myvec(Vec ); diff --git a/src/test/run-pass/newtype-struct-drop-run.rs b/src/test/run-pass/newtype-struct-drop-run.rs index 2d162ba7e336b..4407002aca8d6 100644 --- a/src/test/run-pass/newtype-struct-drop-run.rs +++ b/src/test/run-pass/newtype-struct-drop-run.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unsafe_destructor)] diff --git a/src/test/run-pass/no-landing-pads.rs b/src/test/run-pass/no-landing-pads.rs index da57c81a66978..d90e7ef5e473d 100644 --- a/src/test/run-pass/no-landing-pads.rs +++ b/src/test/run-pass/no-landing-pads.rs @@ -10,7 +10,6 @@ // compile-flags: -Z no-landing-pads -// pretty-expanded FIXME #23616 use std::thread; diff --git a/src/test/run-pass/non-legacy-modes.rs b/src/test/run-pass/non-legacy-modes.rs index 5f1c69bb4b654..58534ed96da83 100644 --- a/src/test/run-pass/non-legacy-modes.rs +++ b/src/test/run-pass/non-legacy-modes.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct X { repr: isize diff --git a/src/test/run-pass/nul-characters.rs b/src/test/run-pass/nul-characters.rs index 25c111daad597..cbea5e71f255f 100644 --- a/src/test/run-pass/nul-characters.rs +++ b/src/test/run-pass/nul-characters.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { diff --git a/src/test/run-pass/nullable-pointer-ffi-compat.rs b/src/test/run-pass/nullable-pointer-ffi-compat.rs index 22aa09c718a74..224111900d60c 100644 --- a/src/test/run-pass/nullable-pointer-ffi-compat.rs +++ b/src/test/run-pass/nullable-pointer-ffi-compat.rs @@ -20,7 +20,6 @@ // then we simply express the enum as just a pointer and not wrap it // in a struct. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/nullable-pointer-iotareduction.rs b/src/test/run-pass/nullable-pointer-iotareduction.rs index ad2716e00de56..ced2b24f36cfe 100644 --- a/src/test/run-pass/nullable-pointer-iotareduction.rs +++ b/src/test/run-pass/nullable-pointer-iotareduction.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/nullable-pointer-size.rs b/src/test/run-pass/nullable-pointer-size.rs index 6e3f438575e2a..b097d350c8d5e 100644 --- a/src/test/run-pass/nullable-pointer-size.rs +++ b/src/test/run-pass/nullable-pointer-size.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/nullary-or-pattern.rs b/src/test/run-pass/nullary-or-pattern.rs index f4cfc80827498..feb8726c0e4a8 100644 --- a/src/test/run-pass/nullary-or-pattern.rs +++ b/src/test/run-pass/nullary-or-pattern.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum blah { a, b, } diff --git a/src/test/run-pass/numeric-method-autoexport.rs b/src/test/run-pass/numeric-method-autoexport.rs index cb41949a722c2..d5f64c1c7b1aa 100644 --- a/src/test/run-pass/numeric-method-autoexport.rs +++ b/src/test/run-pass/numeric-method-autoexport.rs @@ -15,7 +15,6 @@ // necessary. Testing the methods of the impls is done within the source // file for each numeric type. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/object-method-numbering.rs b/src/test/run-pass/object-method-numbering.rs index 8b8c56aee8391..82d34fa9ae48b 100644 --- a/src/test/run-pass/object-method-numbering.rs +++ b/src/test/run-pass/object-method-numbering.rs @@ -11,7 +11,6 @@ // Test for using an object with an associated type binding as the // instantiation for a generic type with a bound. -// pretty-expanded FIXME #23616 trait SomeTrait { type SomeType; diff --git a/src/test/run-pass/object-safety-sized-self-by-value-self.rs b/src/test/run-pass/object-safety-sized-self-by-value-self.rs index b735743927c89..81acd94ebe516 100644 --- a/src/test/run-pass/object-safety-sized-self-by-value-self.rs +++ b/src/test/run-pass/object-safety-sized-self-by-value-self.rs @@ -11,7 +11,6 @@ // Check that a trait is still object-safe (and usable) if it has // methods with by-value self so long as they require `Self : Sized`. -// pretty-expanded FIXME #23616 trait Counter { fn tick(&mut self) -> u32; diff --git a/src/test/run-pass/object-safety-sized-self-generic-method.rs b/src/test/run-pass/object-safety-sized-self-generic-method.rs index 696c5a0970914..2e84117566e47 100644 --- a/src/test/run-pass/object-safety-sized-self-generic-method.rs +++ b/src/test/run-pass/object-safety-sized-self-generic-method.rs @@ -11,7 +11,6 @@ // Check that a trait is still object-safe (and usable) if it has // generic methods so long as they require `Self : Sized`. -// pretty-expanded FIXME #23616 trait Counter { fn tick(&mut self) -> u32; diff --git a/src/test/run-pass/object-safety-sized-self-return-Self.rs b/src/test/run-pass/object-safety-sized-self-return-Self.rs index 17c41f2194b69..eda541262bd94 100644 --- a/src/test/run-pass/object-safety-sized-self-return-Self.rs +++ b/src/test/run-pass/object-safety-sized-self-return-Self.rs @@ -11,7 +11,6 @@ // Check that a trait is still object-safe (and usable) if it has // methods that return `Self` so long as they require `Self : Sized`. -// pretty-expanded FIXME #23616 trait Counter { fn new() -> Self where Self : Sized; diff --git a/src/test/run-pass/objects-coerce-freeze-borrored.rs b/src/test/run-pass/objects-coerce-freeze-borrored.rs index 686924a31400a..f907b5723f41b 100644 --- a/src/test/run-pass/objects-coerce-freeze-borrored.rs +++ b/src/test/run-pass/objects-coerce-freeze-borrored.rs @@ -10,7 +10,6 @@ // Test that we can coerce an `@Object` to an `&Object` -// pretty-expanded FIXME #23616 trait Foo { fn foo(&self) -> usize; diff --git a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs index 9a1cdd2922f7a..176f67fd3a18a 100644 --- a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs +++ b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs @@ -12,7 +12,6 @@ // closed over do not contain managed values, and thus the boxes do // not have headers. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/objects-owned-object-owned-method.rs b/src/test/run-pass/objects-owned-object-owned-method.rs index 4357adbf65bfd..71ed995e76c82 100644 --- a/src/test/run-pass/objects-owned-object-owned-method.rs +++ b/src/test/run-pass/objects-owned-object-owned-method.rs @@ -12,7 +12,6 @@ // closed over contain managed values. This implies that the boxes // will have headers that must be skipped over. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/once-move-out-on-heap.rs b/src/test/run-pass/once-move-out-on-heap.rs index 7bf8b693d9bbf..6dd4c0ddce3c5 100644 --- a/src/test/run-pass/once-move-out-on-heap.rs +++ b/src/test/run-pass/once-move-out-on-heap.rs @@ -11,7 +11,6 @@ // Testing guarantees provided by once functions. -// pretty-expanded FIXME #23616 use std::sync::Arc; diff --git a/src/test/run-pass/one-tuple.rs b/src/test/run-pass/one-tuple.rs index 6520e42dbe3f8..68974b47d06a9 100644 --- a/src/test/run-pass/one-tuple.rs +++ b/src/test/run-pass/one-tuple.rs @@ -10,7 +10,6 @@ // Why one-tuples? Because macros. -// pretty-expanded FIXME #23616 pub fn main() { match ('c',) { diff --git a/src/test/run-pass/operator-associativity.rs b/src/test/run-pass/operator-associativity.rs index ccfdb83ab8aa1..78834ef914d59 100644 --- a/src/test/run-pass/operator-associativity.rs +++ b/src/test/run-pass/operator-associativity.rs @@ -12,6 +12,5 @@ // Testcase for issue #130, operator associativity. -// pretty-expanded FIXME #23616 pub fn main() { assert!((3 * 5 / 2 == 7)); } diff --git a/src/test/run-pass/option-unwrap.rs b/src/test/run-pass/option-unwrap.rs index 4902038667cd8..44f13a3eb1a52 100644 --- a/src/test/run-pass/option-unwrap.rs +++ b/src/test/run-pass/option-unwrap.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unsafe_destructor)] diff --git a/src/test/run-pass/or-pattern.rs b/src/test/run-pass/or-pattern.rs index 3ab78e8d05344..3bb0c71c58115 100644 --- a/src/test/run-pass/or-pattern.rs +++ b/src/test/run-pass/or-pattern.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum blah { a(isize, isize, usize), b(isize, isize), c, } diff --git a/src/test/run-pass/order-drop-with-match.rs b/src/test/run-pass/order-drop-with-match.rs index c8a2ba0af47cb..8f82e3aaba155 100644 --- a/src/test/run-pass/order-drop-with-match.rs +++ b/src/test/run-pass/order-drop-with-match.rs @@ -14,7 +14,6 @@ // in ORDER matching up to when it ran. // Correct order is: matched, inner, outer -// pretty-expanded FIXME #23616 static mut ORDER: [usize; 3] = [0, 0, 0]; static mut INDEX: usize = 0; diff --git a/src/test/run-pass/out-pointer-aliasing.rs b/src/test/run-pass/out-pointer-aliasing.rs index 0a58411041e64..790affd939f24 100644 --- a/src/test/run-pass/out-pointer-aliasing.rs +++ b/src/test/run-pass/out-pointer-aliasing.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #[derive(Copy, Clone)] pub struct Foo { diff --git a/src/test/run-pass/overloaded-autoderef-indexing.rs b/src/test/run-pass/overloaded-autoderef-indexing.rs index fdf42423b662b..67b8bc1d157ca 100644 --- a/src/test/run-pass/overloaded-autoderef-indexing.rs +++ b/src/test/run-pass/overloaded-autoderef-indexing.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::ops::Deref; diff --git a/src/test/run-pass/overloaded-autoderef-order.rs b/src/test/run-pass/overloaded-autoderef-order.rs index 6880032e69f66..7433494dec677 100644 --- a/src/test/run-pass/overloaded-autoderef-order.rs +++ b/src/test/run-pass/overloaded-autoderef-order.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::rc::Rc; use std::ops::Deref; diff --git a/src/test/run-pass/overloaded-autoderef-vtable.rs b/src/test/run-pass/overloaded-autoderef-vtable.rs index 38bf68b746946..ed11c8c0baecc 100644 --- a/src/test/run-pass/overloaded-autoderef-vtable.rs +++ b/src/test/run-pass/overloaded-autoderef-vtable.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::ops::Deref; diff --git a/src/test/run-pass/overloaded-autoderef-xcrate.rs b/src/test/run-pass/overloaded-autoderef-xcrate.rs index b97fb49112484..174e09cb14c7a 100644 --- a/src/test/run-pass/overloaded-autoderef-xcrate.rs +++ b/src/test/run-pass/overloaded-autoderef-xcrate.rs @@ -10,7 +10,6 @@ // aux-build:overloaded_autoderef_xc.rs -// pretty-expanded FIXME #23616 extern crate overloaded_autoderef_xc; diff --git a/src/test/run-pass/overloaded-calls-object-one-arg.rs b/src/test/run-pass/overloaded-calls-object-one-arg.rs index 291d2c6498f99..ec64f627c9462 100644 --- a/src/test/run-pass/overloaded-calls-object-one-arg.rs +++ b/src/test/run-pass/overloaded-calls-object-one-arg.rs @@ -11,7 +11,6 @@ // Tests calls to closure arguments where the closure takes 1 argument. // This is a bit tricky due to rust-call ABI. -// pretty-expanded FIXME #23616 fn foo(f: &mut FnMut(isize) -> isize) -> isize { f(22) diff --git a/src/test/run-pass/overloaded-calls-object-two-args.rs b/src/test/run-pass/overloaded-calls-object-two-args.rs index 42c71572a3a94..c38a62147a011 100644 --- a/src/test/run-pass/overloaded-calls-object-two-args.rs +++ b/src/test/run-pass/overloaded-calls-object-two-args.rs @@ -11,7 +11,6 @@ // Tests calls to closure arguments where the closure takes 2 arguments. // This is a bit tricky due to rust-call ABI. -// pretty-expanded FIXME #23616 fn foo(f: &mut FnMut(isize, isize) -> isize) -> isize { f(1, 2) diff --git a/src/test/run-pass/overloaded-calls-object-zero-args.rs b/src/test/run-pass/overloaded-calls-object-zero-args.rs index 9bc6c9f042835..08ab465ebb04c 100644 --- a/src/test/run-pass/overloaded-calls-object-zero-args.rs +++ b/src/test/run-pass/overloaded-calls-object-zero-args.rs @@ -11,7 +11,6 @@ // Tests calls to closure arguments where the closure takes 0 arguments. // This is a bit tricky due to rust-call ABI. -// pretty-expanded FIXME #23616 fn foo(f: &mut FnMut() -> isize) -> isize { f() diff --git a/src/test/run-pass/overloaded-calls-simple.rs b/src/test/run-pass/overloaded-calls-simple.rs index eeb705a2e3c99..6566f6c1260cd 100644 --- a/src/test/run-pass/overloaded-calls-simple.rs +++ b/src/test/run-pass/overloaded-calls-simple.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(lang_items, unboxed_closures, core)] diff --git a/src/test/run-pass/overloaded-calls-zero-args.rs b/src/test/run-pass/overloaded-calls-zero-args.rs index 8df4adf6713c4..621b2f9420938 100644 --- a/src/test/run-pass/overloaded-calls-zero-args.rs +++ b/src/test/run-pass/overloaded-calls-zero-args.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures, core)] diff --git a/src/test/run-pass/overloaded-deref-count.rs b/src/test/run-pass/overloaded-deref-count.rs index 5f6eb87ae1be4..a8a3b3014e099 100644 --- a/src/test/run-pass/overloaded-deref-count.rs +++ b/src/test/run-pass/overloaded-deref-count.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::cell::Cell; use std::ops::{Deref, DerefMut}; diff --git a/src/test/run-pass/overloaded-index-assoc-list.rs b/src/test/run-pass/overloaded-index-assoc-list.rs index d98b1d9deae62..455099f1eba8f 100644 --- a/src/test/run-pass/overloaded-index-assoc-list.rs +++ b/src/test/run-pass/overloaded-index-assoc-list.rs @@ -11,7 +11,6 @@ // Test overloading of the `[]` operator. In particular test that it // takes its argument *by reference*. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/overloaded-index-autoderef.rs b/src/test/run-pass/overloaded-index-autoderef.rs index 56d71edd56cd0..efa0051493414 100644 --- a/src/test/run-pass/overloaded-index-autoderef.rs +++ b/src/test/run-pass/overloaded-index-autoderef.rs @@ -10,7 +10,6 @@ // Test overloaded indexing combined with autoderef. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax, core)] diff --git a/src/test/run-pass/overloaded-index-in-field.rs b/src/test/run-pass/overloaded-index-in-field.rs index bc53836aca3ef..ff867e76810a6 100644 --- a/src/test/run-pass/overloaded-index-in-field.rs +++ b/src/test/run-pass/overloaded-index-in-field.rs @@ -11,7 +11,6 @@ // Test using overloaded indexing when the "map" is stored in a // field. This caused problems at some point. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/overloaded-index.rs b/src/test/run-pass/overloaded-index.rs index 4f8cf0e9e38ef..fa3c107697e67 100644 --- a/src/test/run-pass/overloaded-index.rs +++ b/src/test/run-pass/overloaded-index.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/packed-struct-borrow-element.rs b/src/test/run-pass/packed-struct-borrow-element.rs index 8819b20136105..4886874062178 100644 --- a/src/test/run-pass/packed-struct-borrow-element.rs +++ b/src/test/run-pass/packed-struct-borrow-element.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #[repr(packed)] struct Foo { diff --git a/src/test/run-pass/packed-struct-generic-layout.rs b/src/test/run-pass/packed-struct-generic-layout.rs index 5d518749d9aef..e03772ddf9ff7 100644 --- a/src/test/run-pass/packed-struct-generic-layout.rs +++ b/src/test/run-pass/packed-struct-generic-layout.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/packed-struct-generic-size.rs b/src/test/run-pass/packed-struct-generic-size.rs index 6c24b71971e38..4e1f62b28ab91 100644 --- a/src/test/run-pass/packed-struct-generic-size.rs +++ b/src/test/run-pass/packed-struct-generic-size.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/packed-struct-layout.rs b/src/test/run-pass/packed-struct-layout.rs index 5d2454be2fbd5..2ac07a5d7eafc 100644 --- a/src/test/run-pass/packed-struct-layout.rs +++ b/src/test/run-pass/packed-struct-layout.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/packed-struct-match.rs b/src/test/run-pass/packed-struct-match.rs index 3c3d632222e19..3cd254014c181 100644 --- a/src/test/run-pass/packed-struct-match.rs +++ b/src/test/run-pass/packed-struct-match.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #[repr(packed)] struct Foo { diff --git a/src/test/run-pass/packed-struct-size-xc.rs b/src/test/run-pass/packed-struct-size-xc.rs index b7ea720caf76d..372693433db6f 100644 --- a/src/test/run-pass/packed-struct-size-xc.rs +++ b/src/test/run-pass/packed-struct-size-xc.rs @@ -10,7 +10,6 @@ // aux-build:packed.rs -// pretty-expanded FIXME #23616 extern crate packed; diff --git a/src/test/run-pass/packed-struct-size.rs b/src/test/run-pass/packed-struct-size.rs index 3d748c404228b..754a357333979 100644 --- a/src/test/run-pass/packed-struct-size.rs +++ b/src/test/run-pass/packed-struct-size.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/packed-tuple-struct-layout.rs b/src/test/run-pass/packed-tuple-struct-layout.rs index 9d96adc29dd36..376aadc735b60 100644 --- a/src/test/run-pass/packed-tuple-struct-layout.rs +++ b/src/test/run-pass/packed-tuple-struct-layout.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/packed-tuple-struct-size.rs b/src/test/run-pass/packed-tuple-struct-size.rs index 7b7cd5929883d..b0c8684cfe3e5 100644 --- a/src/test/run-pass/packed-tuple-struct-size.rs +++ b/src/test/run-pass/packed-tuple-struct-size.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/panic-in-dtor-drops-fields.rs b/src/test/run-pass/panic-in-dtor-drops-fields.rs index 4226fba9d3e37..f84a823d3db22 100644 --- a/src/test/run-pass/panic-in-dtor-drops-fields.rs +++ b/src/test/run-pass/panic-in-dtor-drops-fields.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::thread; diff --git a/src/test/run-pass/pattern-bound-var-in-for-each.rs b/src/test/run-pass/pattern-bound-var-in-for-each.rs index 1ab578b933257..59ead3e3e989b 100644 --- a/src/test/run-pass/pattern-bound-var-in-for-each.rs +++ b/src/test/run-pass/pattern-bound-var-in-for-each.rs @@ -12,7 +12,6 @@ // pattern-bound var is an upvar (when translating // the for-each body) -// pretty-expanded FIXME #23616 fn foo(src: usize) { diff --git a/src/test/run-pass/private-class-field.rs b/src/test/run-pass/private-class-field.rs index d32ac4b90821f..8c92a05ba2a67 100644 --- a/src/test/run-pass/private-class-field.rs +++ b/src/test/run-pass/private-class-field.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct cat { meows : usize, diff --git a/src/test/run-pass/process-remove-from-env.rs b/src/test/run-pass/process-remove-from-env.rs index 6429352f44918..c6adda6067936 100644 --- a/src/test/run-pass/process-remove-from-env.rs +++ b/src/test/run-pass/process-remove-from-env.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(old_io)] diff --git a/src/test/run-pass/range-type-infer.rs b/src/test/run-pass/range-type-infer.rs index 2d664c00ed527..b6d4d09d69727 100644 --- a/src/test/run-pass/range-type-infer.rs +++ b/src/test/run-pass/range-type-infer.rs @@ -12,7 +12,6 @@ // good as the old one. Check out issue #21672, #21595 and #21649 for // more details. -// pretty-expanded FIXME #23616 fn main() { let xs = (0..8).map(|i| i == 1u64).collect::>(); diff --git a/src/test/run-pass/range.rs b/src/test/run-pass/range.rs index 4633f73b9a007..03a8af319e819 100644 --- a/src/test/run-pass/range.rs +++ b/src/test/run-pass/range.rs @@ -10,7 +10,6 @@ // Test range syntax. -// pretty-expanded FIXME #23616 fn foo() -> isize { 42 } diff --git a/src/test/run-pass/ranges-precedence.rs b/src/test/run-pass/ranges-precedence.rs index 870d7a0bc0873..807e23c81cf4f 100644 --- a/src/test/run-pass/ranges-precedence.rs +++ b/src/test/run-pass/ranges-precedence.rs @@ -11,7 +11,6 @@ // Test that the precedence of ranges is correct -// pretty-expanded FIXME #23616 struct Foo { foo: usize, diff --git a/src/test/run-pass/readalias.rs b/src/test/run-pass/readalias.rs index d3b9e56f7d079..29e45ce8a9ad5 100644 --- a/src/test/run-pass/readalias.rs +++ b/src/test/run-pass/readalias.rs @@ -11,7 +11,6 @@ -// pretty-expanded FIXME #23616 struct Point {x: isize, y: isize, z: isize} diff --git a/src/test/run-pass/rec-extend.rs b/src/test/run-pass/rec-extend.rs index 1071df84cd2bb..ffef77a4b8de4 100644 --- a/src/test/run-pass/rec-extend.rs +++ b/src/test/run-pass/rec-extend.rs @@ -11,7 +11,6 @@ -// pretty-expanded FIXME #23616 struct Point {x: isize, y: isize} diff --git a/src/test/run-pass/rec-tup.rs b/src/test/run-pass/rec-tup.rs index 1644a1694269a..810888b0d8e78 100644 --- a/src/test/run-pass/rec-tup.rs +++ b/src/test/run-pass/rec-tup.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #[derive(Copy, Clone)] struct Point {x: isize, y: isize} diff --git a/src/test/run-pass/rec.rs b/src/test/run-pass/rec.rs index a422aaba84b30..b47bda0931fed 100644 --- a/src/test/run-pass/rec.rs +++ b/src/test/run-pass/rec.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #[derive(Copy, Clone)] struct Rect {x: isize, y: isize, w: isize, h: isize} diff --git a/src/test/run-pass/record-pat.rs b/src/test/run-pass/record-pat.rs index 6b39cc196f1e6..99bec7ab7d1fb 100644 --- a/src/test/run-pass/record-pat.rs +++ b/src/test/run-pass/record-pat.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum t1 { a(isize), b(usize), } struct T2 {x: t1, y: isize} diff --git a/src/test/run-pass/reexported-static-methods-cross-crate.rs b/src/test/run-pass/reexported-static-methods-cross-crate.rs index 3efd913cf543c..4d10503838446 100644 --- a/src/test/run-pass/reexported-static-methods-cross-crate.rs +++ b/src/test/run-pass/reexported-static-methods-cross-crate.rs @@ -9,7 +9,6 @@ // except according to those terms. // aux-build:reexported_static_methods.rs -// pretty-expanded FIXME #23616 extern crate reexported_static_methods; diff --git a/src/test/run-pass/regions-borrow-evec-fixed.rs b/src/test/run-pass/regions-borrow-evec-fixed.rs index 7f3db86783060..6d1f2930abf32 100644 --- a/src/test/run-pass/regions-borrow-evec-fixed.rs +++ b/src/test/run-pass/regions-borrow-evec-fixed.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn foo(x: &[isize]) -> isize { x[0] diff --git a/src/test/run-pass/regions-borrow-evec-uniq.rs b/src/test/run-pass/regions-borrow-evec-uniq.rs index adf88037d2841..ec1f4eda28cc5 100644 --- a/src/test/run-pass/regions-borrow-evec-uniq.rs +++ b/src/test/run-pass/regions-borrow-evec-uniq.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn foo(x: &[isize]) -> isize { x[0] diff --git a/src/test/run-pass/regions-borrow-uniq.rs b/src/test/run-pass/regions-borrow-uniq.rs index 01a4e9c20ca5b..2a08940dab6ed 100644 --- a/src/test/run-pass/regions-borrow-uniq.rs +++ b/src/test/run-pass/regions-borrow-uniq.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/regions-bot.rs b/src/test/run-pass/regions-bot.rs index 269e30741f47a..4347cbe2dc9c2 100644 --- a/src/test/run-pass/regions-bot.rs +++ b/src/test/run-pass/regions-bot.rs @@ -10,7 +10,6 @@ // A very limited test of the "bottom" region -// pretty-expanded FIXME #23616 fn produce_static() -> &'static T { panic!(); } diff --git a/src/test/run-pass/regions-close-over-type-parameter-successfully.rs b/src/test/run-pass/regions-close-over-type-parameter-successfully.rs index cc417219ee3df..d048633519ae1 100644 --- a/src/test/run-pass/regions-close-over-type-parameter-successfully.rs +++ b/src/test/run-pass/regions-close-over-type-parameter-successfully.rs @@ -11,7 +11,6 @@ // A test where we (successfully) close over a reference into // an object. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/regions-copy-closure.rs b/src/test/run-pass/regions-copy-closure.rs index 9e3fe79197d5d..3c01a7f8923e8 100644 --- a/src/test/run-pass/regions-copy-closure.rs +++ b/src/test/run-pass/regions-copy-closure.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(unboxed_closures, core)] diff --git a/src/test/run-pass/regions-dependent-addr-of.rs b/src/test/run-pass/regions-dependent-addr-of.rs index 123806a4d9d17..a6a179c432c3c 100644 --- a/src/test/run-pass/regions-dependent-addr-of.rs +++ b/src/test/run-pass/regions-dependent-addr-of.rs @@ -11,7 +11,6 @@ // Test lifetimes are linked properly when we create dependent region pointers. // Issue #3148. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_patterns)] diff --git a/src/test/run-pass/regions-early-bound-trait-param.rs b/src/test/run-pass/regions-early-bound-trait-param.rs index 738f5dbb7b9ad..33889b27a872b 100644 --- a/src/test/run-pass/regions-early-bound-trait-param.rs +++ b/src/test/run-pass/regions-early-bound-trait-param.rs @@ -11,7 +11,6 @@ // Tests that you can use an early-bound lifetime parameter as // on of the generic parameters in a trait. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/regions-early-bound-used-in-bound-method.rs b/src/test/run-pass/regions-early-bound-used-in-bound-method.rs index 6ad8995123889..c7bc8dc0a515b 100644 --- a/src/test/run-pass/regions-early-bound-used-in-bound-method.rs +++ b/src/test/run-pass/regions-early-bound-used-in-bound-method.rs @@ -11,7 +11,6 @@ // Tests that you can use a fn lifetime parameter as part of // the value for a type parameter in a bound. -// pretty-expanded FIXME #23616 trait GetRef<'a> { fn get(&self) -> &'a isize; diff --git a/src/test/run-pass/regions-early-bound-used-in-bound.rs b/src/test/run-pass/regions-early-bound-used-in-bound.rs index 6ab95d6e497bc..3c8c78aa1169a 100644 --- a/src/test/run-pass/regions-early-bound-used-in-bound.rs +++ b/src/test/run-pass/regions-early-bound-used-in-bound.rs @@ -11,7 +11,6 @@ // Tests that you can use a fn lifetime parameter as part of // the value for a type parameter in a bound. -// pretty-expanded FIXME #23616 trait GetRef<'a, T> { fn get(&self) -> &'a T; diff --git a/src/test/run-pass/regions-early-bound-used-in-type-param.rs b/src/test/run-pass/regions-early-bound-used-in-type-param.rs index dc991e9493fe4..8d145fad004a6 100644 --- a/src/test/run-pass/regions-early-bound-used-in-type-param.rs +++ b/src/test/run-pass/regions-early-bound-used-in-type-param.rs @@ -11,7 +11,6 @@ // Tests that you can use a fn lifetime parameter as part of // the value for a type parameter in a bound. -// pretty-expanded FIXME #23616 trait Get { fn get(&self) -> T; diff --git a/src/test/run-pass/regions-escape-into-other-fn.rs b/src/test/run-pass/regions-escape-into-other-fn.rs index 3e2fec717f997..597333482fde3 100644 --- a/src/test/run-pass/regions-escape-into-other-fn.rs +++ b/src/test/run-pass/regions-escape-into-other-fn.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs b/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs index 5d171811732a1..5c80863ce859d 100644 --- a/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs +++ b/src/test/run-pass/regions-infer-borrow-scope-addr-of.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem::swap; diff --git a/src/test/run-pass/regions-infer-borrow-scope-view.rs b/src/test/run-pass/regions-infer-borrow-scope-view.rs index 9c200a370ad85..f9ba8e82ef715 100644 --- a/src/test/run-pass/regions-infer-borrow-scope-view.rs +++ b/src/test/run-pass/regions-infer-borrow-scope-view.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn view(x: &[T]) -> &[T] {x} diff --git a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs index 59221afcefffe..a89f6f4a7b56b 100644 --- a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs +++ b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/regions-infer-borrow-scope.rs b/src/test/run-pass/regions-infer-borrow-scope.rs index 3289da3cfd87e..01f4163731145 100644 --- a/src/test/run-pass/regions-infer-borrow-scope.rs +++ b/src/test/run-pass/regions-infer-borrow-scope.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/regions-infer-call-2.rs b/src/test/run-pass/regions-infer-call-2.rs index 7e6767b0de422..b994bc7b85553 100644 --- a/src/test/run-pass/regions-infer-call-2.rs +++ b/src/test/run-pass/regions-infer-call-2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn takes_two(x: &isize, y: &isize) -> isize { *x + *y } diff --git a/src/test/run-pass/regions-infer-call.rs b/src/test/run-pass/regions-infer-call.rs index bc752a1d504e3..76b93f2356b06 100644 --- a/src/test/run-pass/regions-infer-call.rs +++ b/src/test/run-pass/regions-infer-call.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn takes_two(x: &isize, y: &isize) -> isize { *x + *y } diff --git a/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs b/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs index 73cfbcddd9aa7..3c6bc13399960 100644 --- a/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs +++ b/src/test/run-pass/regions-infer-contravariance-due-to-ret.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct boxed_int<'a> { f: &'a isize, diff --git a/src/test/run-pass/regions-lifetime-static-items-enclosing-scopes.rs b/src/test/run-pass/regions-lifetime-static-items-enclosing-scopes.rs index 451c745358ae6..d1c1ec43b40f0 100644 --- a/src/test/run-pass/regions-lifetime-static-items-enclosing-scopes.rs +++ b/src/test/run-pass/regions-lifetime-static-items-enclosing-scopes.rs @@ -11,7 +11,6 @@ // This test verifies that temporary lifetime is correctly computed // for static objects in enclosing scopes. -// pretty-expanded FIXME #23616 use std::cmp::PartialEq; diff --git a/src/test/run-pass/regions-no-variance-from-fn-generics.rs b/src/test/run-pass/regions-no-variance-from-fn-generics.rs index 89bdbfaed9e0a..d385804da5790 100644 --- a/src/test/run-pass/regions-no-variance-from-fn-generics.rs +++ b/src/test/run-pass/regions-no-variance-from-fn-generics.rs @@ -12,7 +12,6 @@ // should not upset the variance inference for actual occurrences of // that lifetime in type expressions. -// pretty-expanded FIXME #23616 pub trait HasLife<'a> { fn dummy(&'a self) { } // just to induce a variance on 'a diff --git a/src/test/run-pass/regions-params.rs b/src/test/run-pass/regions-params.rs index 5002fcce96b96..dbd52bd6b60ed 100644 --- a/src/test/run-pass/regions-params.rs +++ b/src/test/run-pass/regions-params.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn region_identity(x: &usize) -> &usize { x } diff --git a/src/test/run-pass/regions-refcell.rs b/src/test/run-pass/regions-refcell.rs index 63525b36206a4..ca6a62c10c26b 100644 --- a/src/test/run-pass/regions-refcell.rs +++ b/src/test/run-pass/regions-refcell.rs @@ -12,7 +12,6 @@ // attempting to bootstrap librustc with new destructor lifetime // semantics. -// pretty-expanded FIXME #23616 use std::collections::HashMap; use std::cell::RefCell; diff --git a/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs b/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs index a36c1b30ead0b..465f43e36b94f 100644 --- a/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs +++ b/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs @@ -17,7 +17,6 @@ // changes were caught. However, those uses in the compiler could // easily get changed or refactored away in the future. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/regions-return-interior-of-option.rs b/src/test/run-pass/regions-return-interior-of-option.rs index e6ab4a81426c2..fe1c68ff4281a 100644 --- a/src/test/run-pass/regions-return-interior-of-option.rs +++ b/src/test/run-pass/regions-return-interior-of-option.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn get(opt: &Option) -> &T { match *opt { diff --git a/src/test/run-pass/regions-trait-object-1.rs b/src/test/run-pass/regions-trait-object-1.rs index d235298857939..542dc76061fef 100644 --- a/src/test/run-pass/regions-trait-object-1.rs +++ b/src/test/run-pass/regions-trait-object-1.rs @@ -12,7 +12,6 @@ // attempting to bootstrap libsyntax; it is adapted from // `syntax::ext::tt::generic_extension`. -// pretty-expanded FIXME #23616 pub struct E<'a> { pub f: &'a u8, diff --git a/src/test/run-pass/repeat-expr-in-static.rs b/src/test/run-pass/repeat-expr-in-static.rs index 5a4475ae947b6..a040d680f9da8 100644 --- a/src/test/run-pass/repeat-expr-in-static.rs +++ b/src/test/run-pass/repeat-expr-in-static.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 static FOO: [isize; 4] = [32; 4]; static BAR: [isize; 4] = [32, 32, 32, 32]; diff --git a/src/test/run-pass/resolve-issue-2428.rs b/src/test/run-pass/resolve-issue-2428.rs index bad5b83b5484c..d3bdd54624239 100644 --- a/src/test/run-pass/resolve-issue-2428.rs +++ b/src/test/run-pass/resolve-issue-2428.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 const foo: isize = 4 >> 1; enum bs { thing = foo } diff --git a/src/test/run-pass/resource-in-struct.rs b/src/test/run-pass/resource-in-struct.rs index a8426f90cc489..c1e1ff0658b6e 100644 --- a/src/test/run-pass/resource-in-struct.rs +++ b/src/test/run-pass/resource-in-struct.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unsafe_destructor)] diff --git a/src/test/run-pass/return-from-closure.rs b/src/test/run-pass/return-from-closure.rs index 4395f6fcb4b7c..76eddd05382fc 100644 --- a/src/test/run-pass/return-from-closure.rs +++ b/src/test/run-pass/return-from-closure.rs @@ -10,7 +10,6 @@ // just to make sure that `return` is only returning from the closure, // not the surrounding function. -// pretty-expanded FIXME #23616 static mut calls: usize = 0; diff --git a/src/test/run-pass/segfault-no-out-of-stack.rs b/src/test/run-pass/segfault-no-out-of-stack.rs index 6eb9600cf8b53..385c5326c978e 100644 --- a/src/test/run-pass/segfault-no-out-of-stack.rs +++ b/src/test/run-pass/segfault-no-out-of-stack.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(old_io)] diff --git a/src/test/run-pass/self-in-mut-slot-default-method.rs b/src/test/run-pass/self-in-mut-slot-default-method.rs index f8502137be129..877988e60a946 100644 --- a/src/test/run-pass/self-in-mut-slot-default-method.rs +++ b/src/test/run-pass/self-in-mut-slot-default-method.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/self-in-mut-slot-immediate-value.rs b/src/test/run-pass/self-in-mut-slot-immediate-value.rs index fa9ad9f6517a6..24014c289f919 100644 --- a/src/test/run-pass/self-in-mut-slot-immediate-value.rs +++ b/src/test/run-pass/self-in-mut-slot-immediate-value.rs @@ -11,7 +11,6 @@ // Assert that `mut self` on an immediate value doesn't // allow mutating the original - issue #10615. -// pretty-expanded FIXME #23616 #[derive(Copy, Clone)] struct Value { diff --git a/src/test/run-pass/self-re-assign.rs b/src/test/run-pass/self-re-assign.rs index b3c81cab3c1ce..7314a65b60c0a 100644 --- a/src/test/run-pass/self-re-assign.rs +++ b/src/test/run-pass/self-re-assign.rs @@ -11,7 +11,6 @@ // Ensure assigning an owned or managed variable to itself works. In particular, // that we do not glue_drop before we glue_take (#3290). -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/self-shadowing-import.rs b/src/test/run-pass/self-shadowing-import.rs index 5de1686ef9d8d..cd47a0e86bda4 100644 --- a/src/test/run-pass/self-shadowing-import.rs +++ b/src/test/run-pass/self-shadowing-import.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 mod a { pub mod b { diff --git a/src/test/run-pass/send_str_hashmap.rs b/src/test/run-pass/send_str_hashmap.rs index 16a695f08fe6e..2501ef94bea82 100644 --- a/src/test/run-pass/send_str_hashmap.rs +++ b/src/test/run-pass/send_str_hashmap.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(collections, into_cow)] diff --git a/src/test/run-pass/send_str_treemap.rs b/src/test/run-pass/send_str_treemap.rs index d56657ee4d517..146f5253508c6 100644 --- a/src/test/run-pass/send_str_treemap.rs +++ b/src/test/run-pass/send_str_treemap.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(collections, into_cow)] diff --git a/src/test/run-pass/sendfn-is-a-block.rs b/src/test/run-pass/sendfn-is-a-block.rs index 59b92ec6a48da..162b05f0bb3f5 100644 --- a/src/test/run-pass/sendfn-is-a-block.rs +++ b/src/test/run-pass/sendfn-is-a-block.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 fn test(f: F) -> usize where F: FnOnce(usize) -> usize { return f(22); diff --git a/src/test/run-pass/sepcomp-cci.rs b/src/test/run-pass/sepcomp-cci.rs index a4d74dbd55ae1..a1c5ad113c76d 100644 --- a/src/test/run-pass/sepcomp-cci.rs +++ b/src/test/run-pass/sepcomp-cci.rs @@ -14,7 +14,6 @@ // Test accessing cross-crate inlined items from multiple compilation units. -// pretty-expanded FIXME #23616 extern crate sepcomp_cci_lib; use sepcomp_cci_lib::{cci_fn, CCI_STATIC}; diff --git a/src/test/run-pass/sepcomp-extern.rs b/src/test/run-pass/sepcomp-extern.rs index 3ec27466f4ced..973c61712c3ed 100644 --- a/src/test/run-pass/sepcomp-extern.rs +++ b/src/test/run-pass/sepcomp-extern.rs @@ -14,7 +14,6 @@ // Test accessing external items from multiple compilation units. -// pretty-expanded FIXME #23616 #[link(name = "sepcomp_extern_lib")] extern { diff --git a/src/test/run-pass/sepcomp-fns-backwards.rs b/src/test/run-pass/sepcomp-fns-backwards.rs index cd101bb20642f..1ab8bc7f88c53 100644 --- a/src/test/run-pass/sepcomp-fns-backwards.rs +++ b/src/test/run-pass/sepcomp-fns-backwards.rs @@ -16,7 +16,6 @@ // Generate some code in the first compilation unit before declaring any // modules. This ensures that the first module doesn't go into the same // compilation unit as the top-level module. -// pretty-expanded FIXME #23616 fn pad() -> usize { 0 } diff --git a/src/test/run-pass/sepcomp-fns.rs b/src/test/run-pass/sepcomp-fns.rs index b76c24bfc18b5..a2356cf02a11f 100644 --- a/src/test/run-pass/sepcomp-fns.rs +++ b/src/test/run-pass/sepcomp-fns.rs @@ -18,7 +18,6 @@ // Generate some code in the first compilation unit before declaring any // modules. This ensures that the first module doesn't go into the same // compilation unit as the top-level module. -// pretty-expanded FIXME #23616 fn one() -> usize { 1 } diff --git a/src/test/run-pass/sepcomp-lib.rs b/src/test/run-pass/sepcomp-lib.rs index 00e83a570579d..abe842a332d8f 100644 --- a/src/test/run-pass/sepcomp-lib.rs +++ b/src/test/run-pass/sepcomp-lib.rs @@ -12,7 +12,6 @@ // Test linking against a library built with -C codegen-units > 1 -// pretty-expanded FIXME #23616 extern crate sepcomp_lib; use sepcomp_lib::a::one; diff --git a/src/test/run-pass/sepcomp-statics.rs b/src/test/run-pass/sepcomp-statics.rs index f10f25a58bf7e..8cda469a88bf5 100644 --- a/src/test/run-pass/sepcomp-statics.rs +++ b/src/test/run-pass/sepcomp-statics.rs @@ -13,7 +13,6 @@ // Test references to static items across compilation units. -// pretty-expanded FIXME #23616 fn pad() -> usize { 0 } diff --git a/src/test/run-pass/sepcomp-unwind.rs b/src/test/run-pass/sepcomp-unwind.rs index 9663679d09a7e..766e2b6b7228f 100644 --- a/src/test/run-pass/sepcomp-unwind.rs +++ b/src/test/run-pass/sepcomp-unwind.rs @@ -20,7 +20,6 @@ // In any case, this test should let us know if enabling parallel codegen ever // breaks unwinding. -// pretty-expanded FIXME #23616 use std::thread; diff --git a/src/test/run-pass/seq-compare.rs b/src/test/run-pass/seq-compare.rs index 743f54abcfa66..f1a21d90ab2dc 100644 --- a/src/test/run-pass/seq-compare.rs +++ b/src/test/run-pass/seq-compare.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { assert!(("hello".to_string() < "hellr".to_string())); diff --git a/src/test/run-pass/shift-various-types.rs b/src/test/run-pass/shift-various-types.rs index b0ab72c650d74..9238112a0818f 100644 --- a/src/test/run-pass/shift-various-types.rs +++ b/src/test/run-pass/shift-various-types.rs @@ -10,7 +10,6 @@ // Test that we can do shifts by any integral type. -// pretty-expanded FIXME #23616 struct Panolpy { i8: i8, diff --git a/src/test/run-pass/shift.rs b/src/test/run-pass/shift.rs index f1637fe1e0931..2f417e0e2f4e8 100644 --- a/src/test/run-pass/shift.rs +++ b/src/test/run-pass/shift.rs @@ -11,7 +11,6 @@ // Testing shifts for various combinations of integers // Issue #1570 -// pretty-expanded FIXME #23616 pub fn main() { test_misc(); diff --git a/src/test/run-pass/signed-shift-const-eval.rs b/src/test/run-pass/signed-shift-const-eval.rs index 7167236438088..9ea2dedcba17d 100644 --- a/src/test/run-pass/signed-shift-const-eval.rs +++ b/src/test/run-pass/signed-shift-const-eval.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum test { thing = -5 >> 1_usize } pub fn main() { diff --git a/src/test/run-pass/sigpipe-should-be-ignored.rs b/src/test/run-pass/sigpipe-should-be-ignored.rs index 4a05b487ae24e..7734a2e80c3c4 100644 --- a/src/test/run-pass/sigpipe-should-be-ignored.rs +++ b/src/test/run-pass/sigpipe-should-be-ignored.rs @@ -12,7 +12,6 @@ // doesn't die in a ball of fire, but rather it's gracefully handled. // ignore-aarch64 -// pretty-expanded FIXME #23616 use std::env; use std::io::prelude::*; diff --git a/src/test/run-pass/simd-binop.rs b/src/test/run-pass/simd-binop.rs index 9f7b78e4e3354..3ebf2a87361f6 100644 --- a/src/test/run-pass/simd-binop.rs +++ b/src/test/run-pass/simd-binop.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/simd-generics.rs b/src/test/run-pass/simd-generics.rs index 867f028a3fb3c..0e3d6b83a4be6 100644 --- a/src/test/run-pass/simd-generics.rs +++ b/src/test/run-pass/simd-generics.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(simd)] diff --git a/src/test/run-pass/simd-size-align.rs b/src/test/run-pass/simd-size-align.rs index 8324efc641727..025b2a77375e8 100644 --- a/src/test/run-pass/simd-size-align.rs +++ b/src/test/run-pass/simd-size-align.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(simd)] #![allow(non_camel_case_types)] diff --git a/src/test/run-pass/slice-2.rs b/src/test/run-pass/slice-2.rs index 7f34b94ad04b0..4762470a74735 100644 --- a/src/test/run-pass/slice-2.rs +++ b/src/test/run-pass/slice-2.rs @@ -10,7 +10,6 @@ // Test slicing expressions on slices and Vecs. -// pretty-expanded FIXME #23616 fn main() { let x: &[isize] = &[1, 2, 3, 4, 5]; diff --git a/src/test/run-pass/slice-panic-1.rs b/src/test/run-pass/slice-panic-1.rs index a4f737f74619c..854b03f917866 100644 --- a/src/test/run-pass/slice-panic-1.rs +++ b/src/test/run-pass/slice-panic-1.rs @@ -10,7 +10,6 @@ // Test that if a slicing expr[..] fails, the correct cleanups happen. -// pretty-expanded FIXME #23616 use std::thread; diff --git a/src/test/run-pass/slice-panic-2.rs b/src/test/run-pass/slice-panic-2.rs index f02a84b9070bf..42a19342884b0 100644 --- a/src/test/run-pass/slice-panic-2.rs +++ b/src/test/run-pass/slice-panic-2.rs @@ -10,7 +10,6 @@ // Test that if a slicing expr[..] fails, the correct cleanups happen. -// pretty-expanded FIXME #23616 use std::thread; diff --git a/src/test/run-pass/slice.rs b/src/test/run-pass/slice.rs index edc5f6b184624..60160bd668fa6 100644 --- a/src/test/run-pass/slice.rs +++ b/src/test/run-pass/slice.rs @@ -10,7 +10,6 @@ // Test slicing sugar. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/small-enum-range-edge.rs b/src/test/run-pass/small-enum-range-edge.rs index 9515da6fcbc8d..56abdf6e20a72 100644 --- a/src/test/run-pass/small-enum-range-edge.rs +++ b/src/test/run-pass/small-enum-range-edge.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 // this is for the wrapping_add call below. #![feature(core)] diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs index aab292a940afb..ae4fabd34d629 100644 --- a/src/test/run-pass/spawn-types.rs +++ b/src/test/run-pass/spawn-types.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 /* Make sure we can spawn tasks that take different types of diff --git a/src/test/run-pass/stable-addr-of.rs b/src/test/run-pass/stable-addr-of.rs index f93600195dc25..5ffceb2c6a8bc 100644 --- a/src/test/run-pass/stable-addr-of.rs +++ b/src/test/run-pass/stable-addr-of.rs @@ -10,7 +10,6 @@ // Issue #2040 -// pretty-expanded FIXME #23616 pub fn main() { let foo: isize = 1; diff --git a/src/test/run-pass/static-function-pointer-xc.rs b/src/test/run-pass/static-function-pointer-xc.rs index 55f3b0883b9d9..a09928bd2208f 100644 --- a/src/test/run-pass/static-function-pointer-xc.rs +++ b/src/test/run-pass/static-function-pointer-xc.rs @@ -9,7 +9,6 @@ // except according to those terms. // aux-build:static-function-pointer-aux.rs -// pretty-expanded FIXME #23616 extern crate static_function_pointer_aux as aux; diff --git a/src/test/run-pass/static-function-pointer.rs b/src/test/run-pass/static-function-pointer.rs index 67cc033f7cf75..be297524309d2 100644 --- a/src/test/run-pass/static-function-pointer.rs +++ b/src/test/run-pass/static-function-pointer.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn f(x: isize) -> isize { x } fn g(x: isize) -> isize { 2 * x } diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs index aff2797c1acce..84bb1b871b97e 100644 --- a/src/test/run-pass/static-impl.rs +++ b/src/test/run-pass/static-impl.rs @@ -10,7 +10,6 @@ -// pretty-expanded FIXME #23616 pub trait plus { fn plus(&self) -> isize; diff --git a/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs b/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs index 4ccb044bbd2ca..c2b3a9a72283b 100644 --- a/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs +++ b/src/test/run-pass/static-method-in-trait-with-tps-intracrate.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Deserializer { fn read_int(&self) -> isize; diff --git a/src/test/run-pass/static-method-xcrate.rs b/src/test/run-pass/static-method-xcrate.rs index d0b69b430a692..57609cec9f2b0 100644 --- a/src/test/run-pass/static-method-xcrate.rs +++ b/src/test/run-pass/static-method-xcrate.rs @@ -10,7 +10,6 @@ // aux-build:static-methods-crate.rs -// pretty-expanded FIXME #23616 extern crate static_methods_crate; diff --git a/src/test/run-pass/static-methods-in-traits.rs b/src/test/run-pass/static-methods-in-traits.rs index cb23feb05a59d..3fd3bbe936fff 100644 --- a/src/test/run-pass/static-methods-in-traits.rs +++ b/src/test/run-pass/static-methods-in-traits.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 mod a { pub trait Foo { diff --git a/src/test/run-pass/static-mut-foreign.rs b/src/test/run-pass/static-mut-foreign.rs index c6b919c9738d4..b916a1ae2be7d 100644 --- a/src/test/run-pass/static-mut-foreign.rs +++ b/src/test/run-pass/static-mut-foreign.rs @@ -12,7 +12,6 @@ // statics cannot. This ensures that there's some form of error if this is // attempted. -// pretty-expanded FIXME #23616 #![feature(libc)] diff --git a/src/test/run-pass/static-mut-xc.rs b/src/test/run-pass/static-mut-xc.rs index 0456d17bdc4b4..c819db9454796 100644 --- a/src/test/run-pass/static-mut-xc.rs +++ b/src/test/run-pass/static-mut-xc.rs @@ -14,7 +14,6 @@ // aux-build:static_mut_xc.rs -// pretty-expanded FIXME #23616 extern crate static_mut_xc; diff --git a/src/test/run-pass/str-multiline.rs b/src/test/run-pass/str-multiline.rs index 0d0d56fcafb0b..94e14290498b8 100644 --- a/src/test/run-pass/str-multiline.rs +++ b/src/test/run-pass/str-multiline.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let a: String = "this \ diff --git a/src/test/run-pass/string-escapes.rs b/src/test/run-pass/string-escapes.rs index e0fc1c4ce46a7..1d13e531004c8 100644 --- a/src/test/run-pass/string-escapes.rs +++ b/src/test/run-pass/string-escapes.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn main() { let x = "\\\\\ diff --git a/src/test/run-pass/struct-aliases-xcrate.rs b/src/test/run-pass/struct-aliases-xcrate.rs index 17cb8acea6fad..2ca9d599d84a0 100644 --- a/src/test/run-pass/struct-aliases-xcrate.rs +++ b/src/test/run-pass/struct-aliases-xcrate.rs @@ -9,7 +9,6 @@ // except according to those terms. // aux-build:xcrate_struct_aliases.rs -// pretty-expanded FIXME #23616 extern crate xcrate_struct_aliases; diff --git a/src/test/run-pass/struct-aliases.rs b/src/test/run-pass/struct-aliases.rs index 79e7960cfb27c..7107243d760a4 100644 --- a/src/test/run-pass/struct-aliases.rs +++ b/src/test/run-pass/struct-aliases.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct S { x: isize, diff --git a/src/test/run-pass/struct-destructuring-cross-crate.rs b/src/test/run-pass/struct-destructuring-cross-crate.rs index 5fed712bd663a..63e8d694ddb56 100644 --- a/src/test/run-pass/struct-destructuring-cross-crate.rs +++ b/src/test/run-pass/struct-destructuring-cross-crate.rs @@ -10,7 +10,6 @@ // aux-build:struct_destructuring_cross_crate.rs -// pretty-expanded FIXME #23616 extern crate struct_destructuring_cross_crate; diff --git a/src/test/run-pass/struct-like-variant-match.rs b/src/test/run-pass/struct-like-variant-match.rs index f072d315d72bf..175090eadd982 100644 --- a/src/test/run-pass/struct-like-variant-match.rs +++ b/src/test/run-pass/struct-like-variant-match.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum Foo { Bar { diff --git a/src/test/run-pass/struct-new-as-field-name.rs b/src/test/run-pass/struct-new-as-field-name.rs index 73f27448f81a4..7fb3a64e02b88 100644 --- a/src/test/run-pass/struct-new-as-field-name.rs +++ b/src/test/run-pass/struct-new-as-field-name.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct Foo { new: isize, diff --git a/src/test/run-pass/struct-order-of-eval-1.rs b/src/test/run-pass/struct-order-of-eval-1.rs index 49ec695a1228b..b5e4011bbea58 100644 --- a/src/test/run-pass/struct-order-of-eval-1.rs +++ b/src/test/run-pass/struct-order-of-eval-1.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct S { f0: String, f1: isize } diff --git a/src/test/run-pass/struct-order-of-eval-2.rs b/src/test/run-pass/struct-order-of-eval-2.rs index 45755608ff56a..7ec28f597edbe 100644 --- a/src/test/run-pass/struct-order-of-eval-2.rs +++ b/src/test/run-pass/struct-order-of-eval-2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct S { f0: String, diff --git a/src/test/run-pass/struct-order-of-eval-3.rs b/src/test/run-pass/struct-order-of-eval-3.rs index 37b6de8e17ef1..60f9c4465a01c 100644 --- a/src/test/run-pass/struct-order-of-eval-3.rs +++ b/src/test/run-pass/struct-order-of-eval-3.rs @@ -11,7 +11,6 @@ // Checks that functional-record-update order-of-eval is as expected // even when no Drop-implementations are involved. -// pretty-expanded FIXME #23616 use std::sync::atomic::{Ordering, AtomicUsize, ATOMIC_USIZE_INIT}; diff --git a/src/test/run-pass/struct-order-of-eval-4.rs b/src/test/run-pass/struct-order-of-eval-4.rs index 1b53895f7d1a7..23a7e1ea71b8b 100644 --- a/src/test/run-pass/struct-order-of-eval-4.rs +++ b/src/test/run-pass/struct-order-of-eval-4.rs @@ -11,7 +11,6 @@ // Checks that struct-literal expression order-of-eval is as expected // even when no Drop-implementations are involved. -// pretty-expanded FIXME #23616 use std::sync::atomic::{Ordering, AtomicUsize, ATOMIC_USIZE_INIT}; diff --git a/src/test/run-pass/struct_variant_xc_match.rs b/src/test/run-pass/struct_variant_xc_match.rs index f43dd2332a17a..3ceb65bcfdeb1 100644 --- a/src/test/run-pass/struct_variant_xc_match.rs +++ b/src/test/run-pass/struct_variant_xc_match.rs @@ -9,7 +9,6 @@ // except according to those terms. // aux-build:struct_variant_xc_aux.rs -// pretty-expanded FIXME #23616 extern crate struct_variant_xc_aux; diff --git a/src/test/run-pass/supertrait-default-generics.rs b/src/test/run-pass/supertrait-default-generics.rs index 351c4259b5ef3..e014ce1966bc5 100644 --- a/src/test/run-pass/supertrait-default-generics.rs +++ b/src/test/run-pass/supertrait-default-generics.rs @@ -10,7 +10,6 @@ // There is some other borrowck bug, so we make the stuff not mut. -// pretty-expanded FIXME #23616 use std::ops::Add; diff --git a/src/test/run-pass/swap-1.rs b/src/test/run-pass/swap-1.rs index e60c672f00f9b..d84ee104514d6 100644 --- a/src/test/run-pass/swap-1.rs +++ b/src/test/run-pass/swap-1.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem::swap; diff --git a/src/test/run-pass/swap-2.rs b/src/test/run-pass/swap-2.rs index 3891376e463c7..3dbd7f1a60126 100644 --- a/src/test/run-pass/swap-2.rs +++ b/src/test/run-pass/swap-2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem::swap; diff --git a/src/test/run-pass/syntax-extension-cfg.rs b/src/test/run-pass/syntax-extension-cfg.rs index 8766cba5dbb45..c1d8713b20e6b 100644 --- a/src/test/run-pass/syntax-extension-cfg.rs +++ b/src/test/run-pass/syntax-extension-cfg.rs @@ -10,7 +10,6 @@ // compile-flags: --cfg foo --cfg qux="foo" -// pretty-expanded FIXME #23616 pub fn main() { // check diff --git a/src/test/run-pass/tag-align-dyn-u64.rs b/src/test/run-pass/tag-align-dyn-u64.rs index a9f5875023f18..aaac1869af54f 100644 --- a/src/test/run-pass/tag-align-dyn-u64.rs +++ b/src/test/run-pass/tag-align-dyn-u64.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/tag-align-dyn-variants.rs b/src/test/run-pass/tag-align-dyn-variants.rs index 90b583e2e5072..1c3fb209e35a3 100644 --- a/src/test/run-pass/tag-align-dyn-variants.rs +++ b/src/test/run-pass/tag-align-dyn-variants.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/tag-align-u64.rs b/src/test/run-pass/tag-align-u64.rs index e922ac3b4668e..43485a5bfcb63 100644 --- a/src/test/run-pass/tag-align-u64.rs +++ b/src/test/run-pass/tag-align-u64.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/tag-variant-disr-val.rs b/src/test/run-pass/tag-variant-disr-val.rs index a063801032e3d..6dc69656759de 100644 --- a/src/test/run-pass/tag-variant-disr-val.rs +++ b/src/test/run-pass/tag-variant-disr-val.rs @@ -7,7 +7,6 @@ // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use color::{red, green, blue, black, white, imaginary, purple, orange}; diff --git a/src/test/run-pass/tag.rs b/src/test/run-pass/tag.rs index dbd65ee6bd483..e3cfceb0d426f 100644 --- a/src/test/run-pass/tag.rs +++ b/src/test/run-pass/tag.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 enum colour { red(isize, isize), green, } diff --git a/src/test/run-pass/tail-direct.rs b/src/test/run-pass/tail-direct.rs index 01fc18af34332..4a7a0acdfa891 100644 --- a/src/test/run-pass/tail-direct.rs +++ b/src/test/run-pass/tail-direct.rs @@ -11,7 +11,6 @@ -// pretty-expanded FIXME #23616 pub fn main() { assert!((even(42))); assert!((odd(45))); } diff --git a/src/test/run-pass/task-comm-5.rs b/src/test/run-pass/task-comm-5.rs index cd3d97b88bade..cd5cb677d460b 100644 --- a/src/test/run-pass/task-comm-5.rs +++ b/src/test/run-pass/task-comm-5.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::sync::mpsc::channel; diff --git a/src/test/run-pass/task-comm-6.rs b/src/test/run-pass/task-comm-6.rs index 80e777d242cfc..b8b5773ade546 100644 --- a/src/test/run-pass/task-comm-6.rs +++ b/src/test/run-pass/task-comm-6.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(dead_assignment)] diff --git a/src/test/run-pass/task-comm-chan-nil.rs b/src/test/run-pass/task-comm-chan-nil.rs index 77571504fea27..3b9ec42169150 100644 --- a/src/test/run-pass/task-comm-chan-nil.rs +++ b/src/test/run-pass/task-comm-chan-nil.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::sync::mpsc::channel; diff --git a/src/test/run-pass/terminate-in-initializer.rs b/src/test/run-pass/terminate-in-initializer.rs index ec9e7de40dce1..83eb351df530f 100644 --- a/src/test/run-pass/terminate-in-initializer.rs +++ b/src/test/run-pass/terminate-in-initializer.rs @@ -12,7 +12,6 @@ // Issue #787 // Don't try to clean up uninitialized locals -// pretty-expanded FIXME #23616 use std::thread; diff --git a/src/test/run-pass/trait-bounds.rs b/src/test/run-pass/trait-bounds.rs index 642119df15cbf..d501fef122cc7 100644 --- a/src/test/run-pass/trait-bounds.rs +++ b/src/test/run-pass/trait-bounds.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait connection { fn read(&self) -> isize; diff --git a/src/test/run-pass/trait-default-method-bound-subst.rs b/src/test/run-pass/trait-default-method-bound-subst.rs index e936989537e0f..b9936bcadd48d 100644 --- a/src/test/run-pass/trait-default-method-bound-subst.rs +++ b/src/test/run-pass/trait-default-method-bound-subst.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 trait A { fn g(&self, x: T, y: U) -> (T, U) { (x, y) } diff --git a/src/test/run-pass/trait-default-method-bound-subst2.rs b/src/test/run-pass/trait-default-method-bound-subst2.rs index 4fedbba81f41a..92b9449461ba1 100644 --- a/src/test/run-pass/trait-default-method-bound-subst2.rs +++ b/src/test/run-pass/trait-default-method-bound-subst2.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 trait A { fn g(&self, x: T) -> T { x } diff --git a/src/test/run-pass/trait-default-method-bound-subst3.rs b/src/test/run-pass/trait-default-method-bound-subst3.rs index 4f749cbd3fdbd..af7e8830332b0 100644 --- a/src/test/run-pass/trait-default-method-bound-subst3.rs +++ b/src/test/run-pass/trait-default-method-bound-subst3.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 trait A { fn g(&self, x: T, y: T) -> (T, T) { (x, y) } diff --git a/src/test/run-pass/trait-default-method-bound-subst4.rs b/src/test/run-pass/trait-default-method-bound-subst4.rs index 6774569cd252a..581a54e57f490 100644 --- a/src/test/run-pass/trait-default-method-bound-subst4.rs +++ b/src/test/run-pass/trait-default-method-bound-subst4.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 trait A { fn g(&self, x: usize) -> usize { x } diff --git a/src/test/run-pass/trait-default-method-bound.rs b/src/test/run-pass/trait-default-method-bound.rs index 4107540a47145..e0ea9651f6139 100644 --- a/src/test/run-pass/trait-default-method-bound.rs +++ b/src/test/run-pass/trait-default-method-bound.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 trait A { fn g(&self) -> isize { 10 } diff --git a/src/test/run-pass/trait-default-method-xc-2.rs b/src/test/run-pass/trait-default-method-xc-2.rs index d4ed727040016..833063d2a2d0e 100644 --- a/src/test/run-pass/trait-default-method-xc-2.rs +++ b/src/test/run-pass/trait-default-method-xc-2.rs @@ -12,7 +12,6 @@ // aux-build:trait_default_method_xc_aux_2.rs -// pretty-expanded FIXME #23616 extern crate trait_default_method_xc_aux as aux; extern crate trait_default_method_xc_aux_2 as aux2; diff --git a/src/test/run-pass/trait-default-method-xc.rs b/src/test/run-pass/trait-default-method-xc.rs index 65e8c53a25ec5..72e3fb256ca83 100644 --- a/src/test/run-pass/trait-default-method-xc.rs +++ b/src/test/run-pass/trait-default-method-xc.rs @@ -10,7 +10,6 @@ // aux-build:trait_default_method_xc_aux.rs -// pretty-expanded FIXME #23616 extern crate trait_default_method_xc_aux as aux; use aux::{A, TestEquality, Something}; diff --git a/src/test/run-pass/trait-generic.rs b/src/test/run-pass/trait-generic.rs index 6ef0dacee746a..4998236629153 100644 --- a/src/test/run-pass/trait-generic.rs +++ b/src/test/run-pass/trait-generic.rs @@ -10,7 +10,6 @@ -// pretty-expanded FIXME #23616 trait to_str { fn to_string_(&self) -> String; diff --git a/src/test/run-pass/trait-impl.rs b/src/test/run-pass/trait-impl.rs index 95fd7bda474ba..10025a76f798f 100644 --- a/src/test/run-pass/trait-impl.rs +++ b/src/test/run-pass/trait-impl.rs @@ -11,7 +11,6 @@ // Test calling methods on an impl for a bare trait. // aux-build:traitimpl.rs -// pretty-expanded FIXME #23616 extern crate traitimpl; use traitimpl::Bar; diff --git a/src/test/run-pass/trait-inheritance-auto-xc-2.rs b/src/test/run-pass/trait-inheritance-auto-xc-2.rs index 128be2993ec1d..270cf652ed7cb 100644 --- a/src/test/run-pass/trait-inheritance-auto-xc-2.rs +++ b/src/test/run-pass/trait-inheritance-auto-xc-2.rs @@ -10,7 +10,6 @@ // aux-build:trait_inheritance_auto_xc_2_aux.rs -// pretty-expanded FIXME #23616 extern crate trait_inheritance_auto_xc_2_aux as aux; diff --git a/src/test/run-pass/trait-inheritance-auto-xc.rs b/src/test/run-pass/trait-inheritance-auto-xc.rs index 827674c81adc1..eaca60c935a60 100644 --- a/src/test/run-pass/trait-inheritance-auto-xc.rs +++ b/src/test/run-pass/trait-inheritance-auto-xc.rs @@ -10,7 +10,6 @@ // aux-build:trait_inheritance_auto_xc_aux.rs -// pretty-expanded FIXME #23616 extern crate trait_inheritance_auto_xc_aux as aux; diff --git a/src/test/run-pass/trait-inheritance-auto.rs b/src/test/run-pass/trait-inheritance-auto.rs index 1b72736cde439..75c48d5171278 100644 --- a/src/test/run-pass/trait-inheritance-auto.rs +++ b/src/test/run-pass/trait-inheritance-auto.rs @@ -10,7 +10,6 @@ // Testing that this impl turns A into a Quux, because // A is already a Foo Bar Baz -// pretty-expanded FIXME #23616 impl Quux for T { } diff --git a/src/test/run-pass/trait-inheritance-call-bound-inherited.rs b/src/test/run-pass/trait-inheritance-call-bound-inherited.rs index c8df12392faf4..2fb2b9274c699 100644 --- a/src/test/run-pass/trait-inheritance-call-bound-inherited.rs +++ b/src/test/run-pass/trait-inheritance-call-bound-inherited.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Foo { fn f(&self) -> isize; } trait Bar : Foo { fn g(&self) -> isize; } diff --git a/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs b/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs index fcd6143579c12..87dc04f1c6671 100644 --- a/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs +++ b/src/test/run-pass/trait-inheritance-call-bound-inherited2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Foo { fn f(&self) -> isize; } trait Bar : Foo { fn g(&self) -> isize; } diff --git a/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs b/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs index 3996ae850e84e..dd61dc0f9fb83 100644 --- a/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs +++ b/src/test/run-pass/trait-inheritance-cast-without-call-to-supertrait.rs @@ -11,7 +11,6 @@ // Testing that we can cast to a subtrait and call subtrait // methods. Not testing supertrait methods -// pretty-expanded FIXME #23616 trait Foo { fn f(&self) -> isize; diff --git a/src/test/run-pass/trait-inheritance-cast.rs b/src/test/run-pass/trait-inheritance-cast.rs index 7784ed2f26ae9..0de2c586930e6 100644 --- a/src/test/run-pass/trait-inheritance-cast.rs +++ b/src/test/run-pass/trait-inheritance-cast.rs @@ -10,7 +10,6 @@ // Testing that supertrait methods can be called on subtrait object types -// pretty-expanded FIXME #23616 trait Foo { fn f(&self) -> isize; diff --git a/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs b/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs index c665c35b418c0..e1610c1db07fd 100644 --- a/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs +++ b/src/test/run-pass/trait-inheritance-cross-trait-call-xc.rs @@ -10,7 +10,6 @@ // aux-build:trait_inheritance_cross_trait_call_xc_aux.rs -// pretty-expanded FIXME #23616 extern crate trait_inheritance_cross_trait_call_xc_aux as aux; diff --git a/src/test/run-pass/trait-inheritance-cross-trait-call.rs b/src/test/run-pass/trait-inheritance-cross-trait-call.rs index 418986f961e58..27b0f66603f8c 100644 --- a/src/test/run-pass/trait-inheritance-cross-trait-call.rs +++ b/src/test/run-pass/trait-inheritance-cross-trait-call.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Foo { fn f(&self) -> isize; } trait Bar : Foo { fn g(&self) -> isize; } diff --git a/src/test/run-pass/trait-inheritance-diamond.rs b/src/test/run-pass/trait-inheritance-diamond.rs index 07b1a79110f63..43151bb0f9921 100644 --- a/src/test/run-pass/trait-inheritance-diamond.rs +++ b/src/test/run-pass/trait-inheritance-diamond.rs @@ -10,7 +10,6 @@ // B and C both require A, so D does as well, twice, but that's just fine -// pretty-expanded FIXME #23616 trait A { fn a(&self) -> isize; } trait B: A { fn b(&self) -> isize; } diff --git a/src/test/run-pass/trait-inheritance-multiple-inheritors.rs b/src/test/run-pass/trait-inheritance-multiple-inheritors.rs index b89246269542e..8125ce20912e5 100644 --- a/src/test/run-pass/trait-inheritance-multiple-inheritors.rs +++ b/src/test/run-pass/trait-inheritance-multiple-inheritors.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait A { fn a(&self) -> isize; } trait B: A { fn b(&self) -> isize; } diff --git a/src/test/run-pass/trait-inheritance-multiple-params.rs b/src/test/run-pass/trait-inheritance-multiple-params.rs index 37803edb752b1..c0f7a9d9c254a 100644 --- a/src/test/run-pass/trait-inheritance-multiple-params.rs +++ b/src/test/run-pass/trait-inheritance-multiple-params.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait A { fn a(&self) -> isize; } trait B: A { fn b(&self) -> isize; } diff --git a/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs b/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs index f44c6927c87e0..21d6c53a465cf 100644 --- a/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs +++ b/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs @@ -10,7 +10,6 @@ // aux-build:trait_inheritance_overloading_xc.rs -// pretty-expanded FIXME #23616 extern crate trait_inheritance_overloading_xc; use trait_inheritance_overloading_xc::{MyNum, MyInt}; diff --git a/src/test/run-pass/trait-inheritance-self-in-supertype.rs b/src/test/run-pass/trait-inheritance-self-in-supertype.rs index 87a36ba7b90cc..ac9485594eb3e 100644 --- a/src/test/run-pass/trait-inheritance-self-in-supertype.rs +++ b/src/test/run-pass/trait-inheritance-self-in-supertype.rs @@ -10,7 +10,6 @@ // Test for issue #4183: use of Self in supertraits. -// pretty-expanded FIXME #23616 use std::num::Float as StdFloat; diff --git a/src/test/run-pass/trait-inheritance-simple.rs b/src/test/run-pass/trait-inheritance-simple.rs index ff89b1ee5d30d..917e520339af4 100644 --- a/src/test/run-pass/trait-inheritance-simple.rs +++ b/src/test/run-pass/trait-inheritance-simple.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Foo { fn f(&self) -> isize; } trait Bar : Foo { fn g(&self) -> isize; } diff --git a/src/test/run-pass/trait-inheritance-static.rs b/src/test/run-pass/trait-inheritance-static.rs index 9ed5fd0aaa53f..8e56582951154 100644 --- a/src/test/run-pass/trait-inheritance-static.rs +++ b/src/test/run-pass/trait-inheritance-static.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub trait MyNum { fn from_int(isize) -> Self; diff --git a/src/test/run-pass/trait-inheritance-static2.rs b/src/test/run-pass/trait-inheritance-static2.rs index 9fe9d7fce7af5..62feecf045b54 100644 --- a/src/test/run-pass/trait-inheritance-static2.rs +++ b/src/test/run-pass/trait-inheritance-static2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/trait-inheritance-subst.rs b/src/test/run-pass/trait-inheritance-subst.rs index d35a937a5733d..6074c8a71b0d0 100644 --- a/src/test/run-pass/trait-inheritance-subst.rs +++ b/src/test/run-pass/trait-inheritance-subst.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub trait Add { fn add(&self, rhs: &RHS) -> Result; diff --git a/src/test/run-pass/trait-inheritance-subst2.rs b/src/test/run-pass/trait-inheritance-subst2.rs index e0be5759503c6..6a3639954350f 100644 --- a/src/test/run-pass/trait-inheritance-subst2.rs +++ b/src/test/run-pass/trait-inheritance-subst2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Panda { fn chomp(&self, bamboo: &T) -> T; diff --git a/src/test/run-pass/trait-inheritance-visibility.rs b/src/test/run-pass/trait-inheritance-visibility.rs index 8c8b9232dee8c..f00a4f2ecb6aa 100644 --- a/src/test/run-pass/trait-inheritance-visibility.rs +++ b/src/test/run-pass/trait-inheritance-visibility.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 mod traits { pub trait Foo { fn f(&self) -> isize; } diff --git a/src/test/run-pass/trait-inheritance2.rs b/src/test/run-pass/trait-inheritance2.rs index 9e721836d6319..2161c0f894f43 100644 --- a/src/test/run-pass/trait-inheritance2.rs +++ b/src/test/run-pass/trait-inheritance2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 trait Foo { fn f(&self) -> isize; } trait Bar { fn g(&self) -> isize; } diff --git a/src/test/run-pass/trait-object-generics.rs b/src/test/run-pass/trait-object-generics.rs index 63246b870cb59..15a8a2e83e340 100644 --- a/src/test/run-pass/trait-object-generics.rs +++ b/src/test/run-pass/trait-object-generics.rs @@ -10,7 +10,6 @@ // test for #8664 -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/trait-object-with-lifetime-bound.rs b/src/test/run-pass/trait-object-with-lifetime-bound.rs index 30a05ee1c562e..21b84221d06e0 100644 --- a/src/test/run-pass/trait-object-with-lifetime-bound.rs +++ b/src/test/run-pass/trait-object-with-lifetime-bound.rs @@ -11,7 +11,6 @@ // Uncovered during work on new scoping rules for safe destructors // as an important use case to support properly. -// pretty-expanded FIXME #23616 pub struct E<'a> { pub f: &'a u8, diff --git a/src/test/run-pass/trait-safety-ok-cc.rs b/src/test/run-pass/trait-safety-ok-cc.rs index ada79399561a9..abbc556f34e4c 100644 --- a/src/test/run-pass/trait-safety-ok-cc.rs +++ b/src/test/run-pass/trait-safety-ok-cc.rs @@ -12,7 +12,6 @@ // Simple smoke test that unsafe traits can be compiled across crates. -// pretty-expanded FIXME #23616 extern crate trait_safety_lib as lib; diff --git a/src/test/run-pass/trait-safety-ok.rs b/src/test/run-pass/trait-safety-ok.rs index 3cd23aeaf27a5..0ccc6cd152dfc 100644 --- a/src/test/run-pass/trait-safety-ok.rs +++ b/src/test/run-pass/trait-safety-ok.rs @@ -10,7 +10,6 @@ // Simple smoke test that unsafe traits can be compiled etc. -// pretty-expanded FIXME #23616 unsafe trait Foo { fn foo(&self) -> isize; diff --git a/src/test/run-pass/traits-assoc-type-in-supertrait.rs b/src/test/run-pass/traits-assoc-type-in-supertrait.rs index 751cd50441362..5cecacafc74b1 100644 --- a/src/test/run-pass/traits-assoc-type-in-supertrait.rs +++ b/src/test/run-pass/traits-assoc-type-in-supertrait.rs @@ -11,7 +11,6 @@ // Test case where an associated type is referenced from within the // supertrait definition. Issue #20220. -// pretty-expanded FIXME #23616 use std::vec::IntoIter; diff --git a/src/test/run-pass/traits-conditional-dispatch.rs b/src/test/run-pass/traits-conditional-dispatch.rs index 0a6b9da74f218..8d2faaf418b54 100644 --- a/src/test/run-pass/traits-conditional-dispatch.rs +++ b/src/test/run-pass/traits-conditional-dispatch.rs @@ -12,7 +12,6 @@ // blanket impl for T:Copy coexists with an impl for Box, because // Box does not impl Copy. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/traits-conditional-model-fn.rs b/src/test/run-pass/traits-conditional-model-fn.rs index 65a48844620de..d19f7143ed222 100644 --- a/src/test/run-pass/traits-conditional-model-fn.rs +++ b/src/test/run-pass/traits-conditional-model-fn.rs @@ -14,7 +14,6 @@ // aux-build:go_trait.rs -// pretty-expanded FIXME #23616 extern crate go_trait; diff --git a/src/test/run-pass/traits-default-method-macro.rs b/src/test/run-pass/traits-default-method-macro.rs index 1ec58eac58bbd..193038d9e50f3 100644 --- a/src/test/run-pass/traits-default-method-macro.rs +++ b/src/test/run-pass/traits-default-method-macro.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 trait Foo { fn bar(&self) -> String { diff --git a/src/test/run-pass/traits-multidispatch-infer-convert-target.rs b/src/test/run-pass/traits-multidispatch-infer-convert-target.rs index 1f1d1a46cf973..6634c1ad0a220 100644 --- a/src/test/run-pass/traits-multidispatch-infer-convert-target.rs +++ b/src/test/run-pass/traits-multidispatch-infer-convert-target.rs @@ -10,7 +10,6 @@ // Test that we can infer the Target based on the Self or vice versa. -// pretty-expanded FIXME #23616 use std::mem; diff --git a/src/test/run-pass/traits-repeated-supertrait.rs b/src/test/run-pass/traits-repeated-supertrait.rs index 509a6e36afdec..b059945ef74e3 100644 --- a/src/test/run-pass/traits-repeated-supertrait.rs +++ b/src/test/run-pass/traits-repeated-supertrait.rs @@ -13,7 +13,6 @@ // various methods in various ways successfully. // See also `compile-fail/trait-repeated-supertrait-ambig.rs`. -// pretty-expanded FIXME #23616 trait CompareTo { fn same_as(&self, t: T) -> bool; diff --git a/src/test/run-pass/trans-tag-static-padding.rs b/src/test/run-pass/trans-tag-static-padding.rs index 3e2297f008f02..ba01d51dc6a5d 100644 --- a/src/test/run-pass/trans-tag-static-padding.rs +++ b/src/test/run-pass/trans-tag-static-padding.rs @@ -21,7 +21,6 @@ // Last 7 bytes of Request struct are not occupied by any fields. -// pretty-expanded FIXME #23616 enum TestOption { TestNone, diff --git a/src/test/run-pass/tup.rs b/src/test/run-pass/tup.rs index 50687756e2abe..86ca37deb02d1 100644 --- a/src/test/run-pass/tup.rs +++ b/src/test/run-pass/tup.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 type point = (isize, isize); diff --git a/src/test/run-pass/tuple-index-fat-types.rs b/src/test/run-pass/tuple-index-fat-types.rs index 395531d1573a1..e4ea073bfc28a 100644 --- a/src/test/run-pass/tuple-index-fat-types.rs +++ b/src/test/run-pass/tuple-index-fat-types.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct Foo<'a>(&'a [isize]); diff --git a/src/test/run-pass/tuple-index.rs b/src/test/run-pass/tuple-index.rs index a70b49296fa19..26d918f236750 100644 --- a/src/test/run-pass/tuple-index.rs +++ b/src/test/run-pass/tuple-index.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct Point(isize, isize); diff --git a/src/test/run-pass/tydesc-name.rs b/src/test/run-pass/tydesc-name.rs index 4ba7e786ec8d2..1534c301c996c 100644 --- a/src/test/run-pass/tydesc-name.rs +++ b/src/test/run-pass/tydesc-name.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/type-id-higher-rank.rs b/src/test/run-pass/type-id-higher-rank.rs index ec5aa2863a0c5..3030833c7721d 100644 --- a/src/test/run-pass/type-id-higher-rank.rs +++ b/src/test/run-pass/type-id-higher-rank.rs @@ -11,7 +11,6 @@ // Test that type IDs correctly account for higher-rank lifetimes // Also acts as a regression test for an ICE (issue #19791) -// pretty-expanded FIXME #23616 #![feature(unboxed_closures, core)] diff --git a/src/test/run-pass/type-namespace.rs b/src/test/run-pass/type-namespace.rs index c03ddd0c649f5..36f8b2ca5b42a 100644 --- a/src/test/run-pass/type-namespace.rs +++ b/src/test/run-pass/type-namespace.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 struct A { a: isize } diff --git a/src/test/run-pass/type-sizes.rs b/src/test/run-pass/type-sizes.rs index 8c1251feea269..fc6499ce5d462 100644 --- a/src/test/run-pass/type-sizes.rs +++ b/src/test/run-pass/type-sizes.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem::size_of; diff --git a/src/test/run-pass/typeck-macro-interaction-issue-8852.rs b/src/test/run-pass/typeck-macro-interaction-issue-8852.rs index 2da8b0a508ae4..696e151a80e8b 100644 --- a/src/test/run-pass/typeck-macro-interaction-issue-8852.rs +++ b/src/test/run-pass/typeck-macro-interaction-issue-8852.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 enum T { A(isize), diff --git a/src/test/run-pass/typeck_type_placeholder_1.rs b/src/test/run-pass/typeck_type_placeholder_1.rs index 53e78db68b19d..113d52ffb35b9 100644 --- a/src/test/run-pass/typeck_type_placeholder_1.rs +++ b/src/test/run-pass/typeck_type_placeholder_1.rs @@ -11,7 +11,6 @@ // This test checks that the `_` type placeholder works // correctly for enabling type inference. -// pretty-expanded FIXME #23616 struct TestStruct { x: *const isize diff --git a/src/test/run-pass/typeid-intrinsic.rs b/src/test/run-pass/typeid-intrinsic.rs index 7a143ce588915..9741ed0fddec8 100644 --- a/src/test/run-pass/typeid-intrinsic.rs +++ b/src/test/run-pass/typeid-intrinsic.rs @@ -11,7 +11,6 @@ // aux-build:typeid-intrinsic.rs // aux-build:typeid-intrinsic2.rs -// pretty-expanded FIXME #23616 #![feature(hash, core)] diff --git a/src/test/run-pass/typestate-multi-decl.rs b/src/test/run-pass/typestate-multi-decl.rs index c7762a8464d6b..0749b52a1c601 100644 --- a/src/test/run-pass/typestate-multi-decl.rs +++ b/src/test/run-pass/typestate-multi-decl.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let (x, y) = (10, 20); diff --git a/src/test/run-pass/u32-decr.rs b/src/test/run-pass/u32-decr.rs index 4955ac8a4be63..b56b6f32c0291 100644 --- a/src/test/run-pass/u32-decr.rs +++ b/src/test/run-pass/u32-decr.rs @@ -11,7 +11,6 @@ -// pretty-expanded FIXME #23616 pub fn main() { let mut word: u32 = 200000; diff --git a/src/test/run-pass/u8-incr-decr.rs b/src/test/run-pass/u8-incr-decr.rs index 7c67d304edb68..d35ef015e6f0b 100644 --- a/src/test/run-pass/u8-incr-decr.rs +++ b/src/test/run-pass/u8-incr-decr.rs @@ -14,7 +14,6 @@ // These constants were chosen because they aren't used anywhere // in the rest of the generated code so they're easily grep-able. -// pretty-expanded FIXME #23616 pub fn main() { let mut x: u8 = 19; // 0x13 diff --git a/src/test/run-pass/u8-incr.rs b/src/test/run-pass/u8-incr.rs index e15576c3fabce..9554f9c2dfbca 100644 --- a/src/test/run-pass/u8-incr.rs +++ b/src/test/run-pass/u8-incr.rs @@ -11,7 +11,6 @@ -// pretty-expanded FIXME #23616 pub fn main() { let mut x: u8 = 12; diff --git a/src/test/run-pass/ufcs-polymorphic-paths.rs b/src/test/run-pass/ufcs-polymorphic-paths.rs index a6ea0f76dc2f9..db3581976bbc3 100644 --- a/src/test/run-pass/ufcs-polymorphic-paths.rs +++ b/src/test/run-pass/ufcs-polymorphic-paths.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(collections, rand, into_cow)] diff --git a/src/test/run-pass/ufcs-trait-object.rs b/src/test/run-pass/ufcs-trait-object.rs index b242018458dfc..457beeb3f37a3 100644 --- a/src/test/run-pass/ufcs-trait-object.rs +++ b/src/test/run-pass/ufcs-trait-object.rs @@ -11,7 +11,6 @@ // Test that when you use ufcs form to invoke a trait method (on a // trait object) everything works fine. -// pretty-expanded FIXME #23616 trait Foo { fn test(&self) -> i32; diff --git a/src/test/run-pass/unboxed-closures-all-traits.rs b/src/test/run-pass/unboxed-closures-all-traits.rs index 9ca8e5403a130..c28d4f463e572 100644 --- a/src/test/run-pass/unboxed-closures-all-traits.rs +++ b/src/test/run-pass/unboxed-closures-all-traits.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(lang_items, unboxed_closures)] diff --git a/src/test/run-pass/unboxed-closures-blanket-fn-mut.rs b/src/test/run-pass/unboxed-closures-blanket-fn-mut.rs index 37dccca1e2245..54c92900c89bb 100644 --- a/src/test/run-pass/unboxed-closures-blanket-fn-mut.rs +++ b/src/test/run-pass/unboxed-closures-blanket-fn-mut.rs @@ -10,7 +10,6 @@ // Test that you can supply `&F` where `F: FnMut()`. -// pretty-expanded FIXME #23616 #![feature(lang_items, unboxed_closures)] diff --git a/src/test/run-pass/unboxed-closures-blanket-fn.rs b/src/test/run-pass/unboxed-closures-blanket-fn.rs index 0f93966077bc3..eb474473094a2 100644 --- a/src/test/run-pass/unboxed-closures-blanket-fn.rs +++ b/src/test/run-pass/unboxed-closures-blanket-fn.rs @@ -10,7 +10,6 @@ // Test that you can supply `&F` where `F: Fn()`. -// pretty-expanded FIXME #23616 #![feature(lang_items, unboxed_closures)] diff --git a/src/test/run-pass/unboxed-closures-by-ref.rs b/src/test/run-pass/unboxed-closures-by-ref.rs index 7855cf6ba0c2a..e3ddfdbac00f8 100644 --- a/src/test/run-pass/unboxed-closures-by-ref.rs +++ b/src/test/run-pass/unboxed-closures-by-ref.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures)] diff --git a/src/test/run-pass/unboxed-closures-call-fn-autoderef.rs b/src/test/run-pass/unboxed-closures-call-fn-autoderef.rs index 6e92850ac2e59..64236ce563b0e 100644 --- a/src/test/run-pass/unboxed-closures-call-fn-autoderef.rs +++ b/src/test/run-pass/unboxed-closures-call-fn-autoderef.rs @@ -10,7 +10,6 @@ // Test that the call operator autoderefs when calling a bounded type parameter. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures)] diff --git a/src/test/run-pass/unboxed-closures-call-sugar-autoderef.rs b/src/test/run-pass/unboxed-closures-call-sugar-autoderef.rs index 402b4b0b85d4b..67ab84f0276cc 100644 --- a/src/test/run-pass/unboxed-closures-call-sugar-autoderef.rs +++ b/src/test/run-pass/unboxed-closures-call-sugar-autoderef.rs @@ -10,7 +10,6 @@ // Test that the call operator autoderefs when calling a bounded type parameter. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures)] diff --git a/src/test/run-pass/unboxed-closures-counter-not-moved.rs b/src/test/run-pass/unboxed-closures-counter-not-moved.rs index 792d17227766e..cb5f190bcd736 100644 --- a/src/test/run-pass/unboxed-closures-counter-not-moved.rs +++ b/src/test/run-pass/unboxed-closures-counter-not-moved.rs @@ -10,7 +10,6 @@ // Test that we mutate a counter on the stack only when we expect to. -// pretty-expanded FIXME #23616 fn call(f: F) where F : FnOnce() { f(); diff --git a/src/test/run-pass/unboxed-closures-cross-crate.rs b/src/test/run-pass/unboxed-closures-cross-crate.rs index 0c255c6bd6cb8..37dc760cedcfe 100644 --- a/src/test/run-pass/unboxed-closures-cross-crate.rs +++ b/src/test/run-pass/unboxed-closures-cross-crate.rs @@ -12,7 +12,6 @@ // Acts as a regression test for #16790, #18378 and #18543 // aux-build:unboxed-closures-cross-crate.rs -// pretty-expanded FIXME #23616 extern crate unboxed_closures_cross_crate as ubcc; diff --git a/src/test/run-pass/unboxed-closures-drop.rs b/src/test/run-pass/unboxed-closures-drop.rs index f0c6c0ff453ff..78f4905aef976 100644 --- a/src/test/run-pass/unboxed-closures-drop.rs +++ b/src/test/run-pass/unboxed-closures-drop.rs @@ -11,7 +11,6 @@ // A battery of tests to ensure destructors of unboxed closure environments // run at the right times. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures)] diff --git a/src/test/run-pass/unboxed-closures-extern-fn-hr.rs b/src/test/run-pass/unboxed-closures-extern-fn-hr.rs index 4af4b320d0e4e..e71757abd0e7d 100644 --- a/src/test/run-pass/unboxed-closures-extern-fn-hr.rs +++ b/src/test/run-pass/unboxed-closures-extern-fn-hr.rs @@ -10,7 +10,6 @@ // Checks that higher-ranked extern fn pointers implement the full range of Fn traits. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures, core)] diff --git a/src/test/run-pass/unboxed-closures-extern-fn.rs b/src/test/run-pass/unboxed-closures-extern-fn.rs index d711ebbe4b8c2..57acbae4ce6d8 100644 --- a/src/test/run-pass/unboxed-closures-extern-fn.rs +++ b/src/test/run-pass/unboxed-closures-extern-fn.rs @@ -10,7 +10,6 @@ // Checks that extern fn pointers implement the full range of Fn traits. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures)] #![feature(unboxed_closures)] diff --git a/src/test/run-pass/unboxed-closures-fn-as-fnmut-and-fnonce.rs b/src/test/run-pass/unboxed-closures-fn-as-fnmut-and-fnonce.rs index 9b71abf365331..5d6d372ea5c95 100644 --- a/src/test/run-pass/unboxed-closures-fn-as-fnmut-and-fnonce.rs +++ b/src/test/run-pass/unboxed-closures-fn-as-fnmut-and-fnonce.rs @@ -11,7 +11,6 @@ // Checks that the Fn trait hierarchy rules permit // any Fn trait to be used where Fn is implemented. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures, core)] diff --git a/src/test/run-pass/unboxed-closures-fnmut-as-fnonce.rs b/src/test/run-pass/unboxed-closures-fnmut-as-fnonce.rs index 6261058b86742..c19b5b273c7eb 100644 --- a/src/test/run-pass/unboxed-closures-fnmut-as-fnonce.rs +++ b/src/test/run-pass/unboxed-closures-fnmut-as-fnonce.rs @@ -11,7 +11,6 @@ // Checks that the Fn trait hierarchy rules permit // FnMut or FnOnce to be used where FnMut is implemented. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures, core)] diff --git a/src/test/run-pass/unboxed-closures-infer-fnmut-calling-fnmut.rs b/src/test/run-pass/unboxed-closures-infer-fnmut-calling-fnmut.rs index 798959f69d687..2da899ed95b5a 100644 --- a/src/test/run-pass/unboxed-closures-infer-fnmut-calling-fnmut.rs +++ b/src/test/run-pass/unboxed-closures-infer-fnmut-calling-fnmut.rs @@ -11,7 +11,6 @@ // Test that we are able to infer a suitable kind for this closure // that is just called (`FnMut`). -// pretty-expanded FIXME #23616 fn main() { let mut counter = 0; diff --git a/src/test/run-pass/unboxed-closures-infer-fnmut-move.rs b/src/test/run-pass/unboxed-closures-infer-fnmut-move.rs index 5b1e35a3e5c72..32fc3433e8477 100644 --- a/src/test/run-pass/unboxed-closures-infer-fnmut-move.rs +++ b/src/test/run-pass/unboxed-closures-infer-fnmut-move.rs @@ -11,7 +11,6 @@ // Test that we are able to infer a suitable kind for this `move` // closure that is just called (`FnMut`). -// pretty-expanded FIXME #23616 fn main() { let mut counter = 0; diff --git a/src/test/run-pass/unboxed-closures-infer-fnmut.rs b/src/test/run-pass/unboxed-closures-infer-fnmut.rs index cd7f26bba2676..a8469f4019ab1 100644 --- a/src/test/run-pass/unboxed-closures-infer-fnmut.rs +++ b/src/test/run-pass/unboxed-closures-infer-fnmut.rs @@ -11,7 +11,6 @@ // Test that we are able to infer a suitable kind for this closure // that is just called (`FnMut`). -// pretty-expanded FIXME #23616 fn main() { let mut counter = 0; diff --git a/src/test/run-pass/unboxed-closures-infer-fnonce-move.rs b/src/test/run-pass/unboxed-closures-infer-fnonce-move.rs index dc106614b53dd..dcda724c7b8fe 100644 --- a/src/test/run-pass/unboxed-closures-infer-fnonce-move.rs +++ b/src/test/run-pass/unboxed-closures-infer-fnonce-move.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unsafe_destructor)] diff --git a/src/test/run-pass/unboxed-closures-infer-fnonce.rs b/src/test/run-pass/unboxed-closures-infer-fnonce.rs index 036b32a44d255..275ba0520c568 100644 --- a/src/test/run-pass/unboxed-closures-infer-fnonce.rs +++ b/src/test/run-pass/unboxed-closures-infer-fnonce.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unsafe_destructor)] diff --git a/src/test/run-pass/unboxed-closures-infer-kind.rs b/src/test/run-pass/unboxed-closures-infer-kind.rs index edc01d91f58fc..fa668475f587a 100644 --- a/src/test/run-pass/unboxed-closures-infer-kind.rs +++ b/src/test/run-pass/unboxed-closures-infer-kind.rs @@ -11,7 +11,6 @@ // Test that we can infer the "kind" of an unboxed closure based on // the expected type. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures)] diff --git a/src/test/run-pass/unboxed-closures-infer-recursive-fn.rs b/src/test/run-pass/unboxed-closures-infer-recursive-fn.rs index e02784f917a97..e499ab5cca06c 100644 --- a/src/test/run-pass/unboxed-closures-infer-recursive-fn.rs +++ b/src/test/run-pass/unboxed-closures-infer-recursive-fn.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(core,unboxed_closures)] diff --git a/src/test/run-pass/unboxed-closures-infer-upvar.rs b/src/test/run-pass/unboxed-closures-infer-upvar.rs index e29632b007b3f..f2423145b1974 100644 --- a/src/test/run-pass/unboxed-closures-infer-upvar.rs +++ b/src/test/run-pass/unboxed-closures-infer-upvar.rs @@ -11,7 +11,6 @@ // Test that the type variable in the type(`Vec<_>`) of a closed over // variable does not interfere with type inference. -// pretty-expanded FIXME #23616 fn f(mut f: F) { f(); diff --git a/src/test/run-pass/unboxed-closures-manual-impl.rs b/src/test/run-pass/unboxed-closures-manual-impl.rs index 38f15d6e4499b..6a76fdb5ad7e4 100644 --- a/src/test/run-pass/unboxed-closures-manual-impl.rs +++ b/src/test/run-pass/unboxed-closures-manual-impl.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures, core)] diff --git a/src/test/run-pass/unboxed-closures-move-some-upvars-in-by-ref-closure.rs b/src/test/run-pass/unboxed-closures-move-some-upvars-in-by-ref-closure.rs index b69153b73a369..e2b286738e76d 100644 --- a/src/test/run-pass/unboxed-closures-move-some-upvars-in-by-ref-closure.rs +++ b/src/test/run-pass/unboxed-closures-move-some-upvars-in-by-ref-closure.rs @@ -11,7 +11,6 @@ // Test that in a by-ref once closure we move some variables even as // we capture others by mutable reference. -// pretty-expanded FIXME #23616 fn call(f: F) where F : FnOnce() { f(); diff --git a/src/test/run-pass/unboxed-closures-simple.rs b/src/test/run-pass/unboxed-closures-simple.rs index 1443d305bce94..ec3419816693e 100644 --- a/src/test/run-pass/unboxed-closures-simple.rs +++ b/src/test/run-pass/unboxed-closures-simple.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures)] diff --git a/src/test/run-pass/unboxed-closures-single-word-env.rs b/src/test/run-pass/unboxed-closures-single-word-env.rs index 65a26d14e120b..166054e88b7b3 100644 --- a/src/test/run-pass/unboxed-closures-single-word-env.rs +++ b/src/test/run-pass/unboxed-closures-single-word-env.rs @@ -11,7 +11,6 @@ // Ensures that single-word environments work right in unboxed closures. // These take a different path in codegen. -// pretty-expanded FIXME #23616 #![feature(unboxed_closures)] diff --git a/src/test/run-pass/unboxed-closures-sugar-object.rs b/src/test/run-pass/unboxed-closures-sugar-object.rs index 77beeb13fb029..49b9b7f061e72 100644 --- a/src/test/run-pass/unboxed-closures-sugar-object.rs +++ b/src/test/run-pass/unboxed-closures-sugar-object.rs @@ -10,7 +10,6 @@ // Test unboxed closure sugar used in object types. -// pretty-expanded FIXME #23616 #![allow(dead_code)] #![feature(unboxed_closures)] diff --git a/src/test/run-pass/unboxed-closures-unique-type-id.rs b/src/test/run-pass/unboxed-closures-unique-type-id.rs index 403b2ca9aaf39..de7eeb57de10d 100644 --- a/src/test/run-pass/unboxed-closures-unique-type-id.rs +++ b/src/test/run-pass/unboxed-closures-unique-type-id.rs @@ -19,7 +19,6 @@ // // compile-flags: -g -// pretty-expanded FIXME #23616 #![feature(unboxed_closures)] diff --git a/src/test/run-pass/unfold-cross-crate.rs b/src/test/run-pass/unfold-cross-crate.rs index fceccb499c7b0..5c699bf3044e6 100644 --- a/src/test/run-pass/unfold-cross-crate.rs +++ b/src/test/run-pass/unfold-cross-crate.rs @@ -10,7 +10,6 @@ // no-pretty-expanded FIXME #15189 -// pretty-expanded FIXME #23616 #![feature(core)] diff --git a/src/test/run-pass/uniq-self-in-mut-slot.rs b/src/test/run-pass/uniq-self-in-mut-slot.rs index a6408128c3a28..baca157a488b7 100644 --- a/src/test/run-pass/uniq-self-in-mut-slot.rs +++ b/src/test/run-pass/uniq-self-in-mut-slot.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-assign-copy.rs b/src/test/run-pass/unique-assign-copy.rs index 32a0713ca9397..3323b3c046b11 100644 --- a/src/test/run-pass/unique-assign-copy.rs +++ b/src/test/run-pass/unique-assign-copy.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-assign-drop.rs b/src/test/run-pass/unique-assign-drop.rs index 715fa548a7d76..37aa1f0a64bc6 100644 --- a/src/test/run-pass/unique-assign-drop.rs +++ b/src/test/run-pass/unique-assign-drop.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(dead_assignment)] #![allow(unknown_features)] diff --git a/src/test/run-pass/unique-assign-generic.rs b/src/test/run-pass/unique-assign-generic.rs index ca145479a381f..249b734a691e0 100644 --- a/src/test/run-pass/unique-assign-generic.rs +++ b/src/test/run-pass/unique-assign-generic.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-assign.rs b/src/test/run-pass/unique-assign.rs index e4e7b69671b82..8e97fdd4a6af9 100644 --- a/src/test/run-pass/unique-assign.rs +++ b/src/test/run-pass/unique-assign.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-autoderef-field.rs b/src/test/run-pass/unique-autoderef-field.rs index 8ee1b28ea2e7e..a711dbb685f19 100644 --- a/src/test/run-pass/unique-autoderef-field.rs +++ b/src/test/run-pass/unique-autoderef-field.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-autoderef-index.rs b/src/test/run-pass/unique-autoderef-index.rs index 9dc98cf2e3c47..c68ff1f0612f5 100644 --- a/src/test/run-pass/unique-autoderef-index.rs +++ b/src/test/run-pass/unique-autoderef-index.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-cmp.rs b/src/test/run-pass/unique-cmp.rs index be7e46c8699d7..3b0ad63aeffe9 100644 --- a/src/test/run-pass/unique-cmp.rs +++ b/src/test/run-pass/unique-cmp.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-decl-init-copy.rs b/src/test/run-pass/unique-decl-init-copy.rs index 0840f1308cc1f..9d749803ffb16 100644 --- a/src/test/run-pass/unique-decl-init-copy.rs +++ b/src/test/run-pass/unique-decl-init-copy.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-decl-init.rs b/src/test/run-pass/unique-decl-init.rs index 1d5a44f45abba..a00de08998f4e 100644 --- a/src/test/run-pass/unique-decl-init.rs +++ b/src/test/run-pass/unique-decl-init.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-decl-move.rs b/src/test/run-pass/unique-decl-move.rs index 203a30e76bc1a..f4ff44ffff52c 100644 --- a/src/test/run-pass/unique-decl-move.rs +++ b/src/test/run-pass/unique-decl-move.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-decl.rs b/src/test/run-pass/unique-decl.rs index 7404e8887ebce..bbf9b2f47a742 100644 --- a/src/test/run-pass/unique-decl.rs +++ b/src/test/run-pass/unique-decl.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let _: Box; diff --git a/src/test/run-pass/unique-deref.rs b/src/test/run-pass/unique-deref.rs index 44681742a7041..70b2617797dae 100644 --- a/src/test/run-pass/unique-deref.rs +++ b/src/test/run-pass/unique-deref.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-destructure.rs b/src/test/run-pass/unique-destructure.rs index 87bc6f6639d65..b368cbee2f632 100644 --- a/src/test/run-pass/unique-destructure.rs +++ b/src/test/run-pass/unique-destructure.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_patterns)] diff --git a/src/test/run-pass/unique-fn-arg-move.rs b/src/test/run-pass/unique-fn-arg-move.rs index e608ab9b6367a..d101cbd31290c 100644 --- a/src/test/run-pass/unique-fn-arg-move.rs +++ b/src/test/run-pass/unique-fn-arg-move.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-fn-arg-mut.rs b/src/test/run-pass/unique-fn-arg-mut.rs index f0d2abfe27cbc..ebe89b275d4f7 100644 --- a/src/test/run-pass/unique-fn-arg-mut.rs +++ b/src/test/run-pass/unique-fn-arg-mut.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-fn-arg.rs b/src/test/run-pass/unique-fn-arg.rs index 3d7ef31d020e7..97006d2a01a2d 100644 --- a/src/test/run-pass/unique-fn-arg.rs +++ b/src/test/run-pass/unique-fn-arg.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-fn-ret.rs b/src/test/run-pass/unique-fn-ret.rs index bb1948bf3c81b..d3be0cf01f1dd 100644 --- a/src/test/run-pass/unique-fn-ret.rs +++ b/src/test/run-pass/unique-fn-ret.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-in-vec-copy.rs b/src/test/run-pass/unique-in-vec-copy.rs index 129c0784cca5e..ab0e3ee809dbd 100644 --- a/src/test/run-pass/unique-in-vec-copy.rs +++ b/src/test/run-pass/unique-in-vec-copy.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-in-vec.rs b/src/test/run-pass/unique-in-vec.rs index dc94fa6ca4fce..41945821587ca 100644 --- a/src/test/run-pass/unique-in-vec.rs +++ b/src/test/run-pass/unique-in-vec.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs index 96d54193ac86d..b808ac2b00823 100644 --- a/src/test/run-pass/unique-kinds.rs +++ b/src/test/run-pass/unique-kinds.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-move-drop.rs b/src/test/run-pass/unique-move-drop.rs index e81095d548e07..530ba4789102e 100644 --- a/src/test/run-pass/unique-move-drop.rs +++ b/src/test/run-pass/unique-move-drop.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unused_variable)] #![allow(unknown_features)] diff --git a/src/test/run-pass/unique-move-temp.rs b/src/test/run-pass/unique-move-temp.rs index 634a1569acffd..4b937625201c0 100644 --- a/src/test/run-pass/unique-move-temp.rs +++ b/src/test/run-pass/unique-move-temp.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-move.rs b/src/test/run-pass/unique-move.rs index 29bf113926572..bed1d6e171a8b 100644 --- a/src/test/run-pass/unique-move.rs +++ b/src/test/run-pass/unique-move.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-mutable.rs b/src/test/run-pass/unique-mutable.rs index 106481e3189ee..8beec6a419833 100644 --- a/src/test/run-pass/unique-mutable.rs +++ b/src/test/run-pass/unique-mutable.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-pat-2.rs b/src/test/run-pass/unique-pat-2.rs index d16355af99fd5..c314b70e53662 100644 --- a/src/test/run-pass/unique-pat-2.rs +++ b/src/test/run-pass/unique-pat-2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_patterns)] diff --git a/src/test/run-pass/unique-pat.rs b/src/test/run-pass/unique-pat.rs index ae76179b5ec22..1312ea924b599 100644 --- a/src/test/run-pass/unique-pat.rs +++ b/src/test/run-pass/unique-pat.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_patterns)] diff --git a/src/test/run-pass/unique-rec.rs b/src/test/run-pass/unique-rec.rs index 7a09e241ca639..72975c27eeaf5 100644 --- a/src/test/run-pass/unique-rec.rs +++ b/src/test/run-pass/unique-rec.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs index 99a3b64105318..d80d0e82f4fe9 100644 --- a/src/test/run-pass/unique-send-2.rs +++ b/src/test/run-pass/unique-send-2.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-send.rs b/src/test/run-pass/unique-send.rs index c9649ef60d303..bc0f790b2b02d 100644 --- a/src/test/run-pass/unique-send.rs +++ b/src/test/run-pass/unique-send.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unique-swap.rs b/src/test/run-pass/unique-swap.rs index 454011a9ec31e..cfa076f1a0744 100644 --- a/src/test/run-pass/unique-swap.rs +++ b/src/test/run-pass/unique-swap.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/unit-like-struct-drop-run.rs b/src/test/run-pass/unit-like-struct-drop-run.rs index c2db63ed251a5..e31d4c811fc63 100644 --- a/src/test/run-pass/unit-like-struct-drop-run.rs +++ b/src/test/run-pass/unit-like-struct-drop-run.rs @@ -10,7 +10,6 @@ // Make sure the destructor is run for unit-like structs. -// pretty-expanded FIXME #23616 #![feature(alloc)] diff --git a/src/test/run-pass/unreachable-code-1.rs b/src/test/run-pass/unreachable-code-1.rs index 612beabb03586..c1c069236c88d 100644 --- a/src/test/run-pass/unreachable-code-1.rs +++ b/src/test/run-pass/unreachable-code-1.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unreachable_code)] #![allow(unused_variable)] diff --git a/src/test/run-pass/unreachable-code.rs b/src/test/run-pass/unreachable-code.rs index 4f58df66256be..e19fda5f872d2 100644 --- a/src/test/run-pass/unreachable-code.rs +++ b/src/test/run-pass/unreachable-code.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(path_statement)] #![allow(unreachable_code)] diff --git a/src/test/run-pass/unsafe-coercion.rs b/src/test/run-pass/unsafe-coercion.rs index d0c633e8278ea..8661ebb414ce5 100644 --- a/src/test/run-pass/unsafe-coercion.rs +++ b/src/test/run-pass/unsafe-coercion.rs @@ -10,7 +10,6 @@ // Check that safe fns are not a subtype of unsafe fns. -// pretty-expanded FIXME #23616 fn foo(x: i32) -> i32 { x * 22 diff --git a/src/test/run-pass/unsafe-pointer-assignability.rs b/src/test/run-pass/unsafe-pointer-assignability.rs index 75c7cabfcb6d3..c8ee0f83b9b0c 100644 --- a/src/test/run-pass/unsafe-pointer-assignability.rs +++ b/src/test/run-pass/unsafe-pointer-assignability.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn f(x: *const isize) { unsafe { diff --git a/src/test/run-pass/unsized3.rs b/src/test/run-pass/unsized3.rs index 8db294bdcc1c0..2977f579fc592 100644 --- a/src/test/run-pass/unsized3.rs +++ b/src/test/run-pass/unsized3.rs @@ -10,7 +10,6 @@ // Test structs with always-unsized fields. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax, core)] diff --git a/src/test/run-pass/unwind-unique.rs b/src/test/run-pass/unwind-unique.rs index 1d6ce626c28c5..07bfc8062f9d4 100644 --- a/src/test/run-pass/unwind-unique.rs +++ b/src/test/run-pass/unwind-unique.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/variance-intersection-of-ref-and-opt-ref.rs b/src/test/run-pass/variance-intersection-of-ref-and-opt-ref.rs index e21ea025d8ff4..af06fe381368b 100644 --- a/src/test/run-pass/variance-intersection-of-ref-and-opt-ref.rs +++ b/src/test/run-pass/variance-intersection-of-ref-and-opt-ref.rs @@ -13,7 +13,6 @@ // us from approximating the lifetimes of `field1` and `field2` to a // common intersection. -// pretty-expanded FIXME #23616 #![allow(dead_code)] #![feature(core)] diff --git a/src/test/run-pass/variance-vec-covariant.rs b/src/test/run-pass/variance-vec-covariant.rs index 2f554c3c4f3f5..89927b7b55b97 100644 --- a/src/test/run-pass/variance-vec-covariant.rs +++ b/src/test/run-pass/variance-vec-covariant.rs @@ -10,7 +10,6 @@ // Test that vec is now covariant in its argument type. -// pretty-expanded FIXME #23616 #![allow(dead_code)] #![feature(core)] diff --git a/src/test/run-pass/vec-dst.rs b/src/test/run-pass/vec-dst.rs index e88acb3838ba8..223907c01bea3 100644 --- a/src/test/run-pass/vec-dst.rs +++ b/src/test/run-pass/vec-dst.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![allow(unknown_features)] #![feature(box_syntax)] diff --git a/src/test/run-pass/vec-fixed-length.rs b/src/test/run-pass/vec-fixed-length.rs index 4dadf53c77222..fbaba9b8a6191 100644 --- a/src/test/run-pass/vec-fixed-length.rs +++ b/src/test/run-pass/vec-fixed-length.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::mem::size_of; diff --git a/src/test/run-pass/vec-growth.rs b/src/test/run-pass/vec-growth.rs index d5e6a9c424515..e51d898e1d46e 100644 --- a/src/test/run-pass/vec-growth.rs +++ b/src/test/run-pass/vec-growth.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let mut v = vec!(1); diff --git a/src/test/run-pass/vec-macro-repeat.rs b/src/test/run-pass/vec-macro-repeat.rs index 2a83ccaba82e2..d178041b85e1e 100644 --- a/src/test/run-pass/vec-macro-repeat.rs +++ b/src/test/run-pass/vec-macro-repeat.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { assert_eq!(vec![1; 3], vec![1, 1, 1]); diff --git a/src/test/run-pass/vec-macro-rvalue-scope.rs b/src/test/run-pass/vec-macro-rvalue-scope.rs index 5869558eacaff..305755347d04b 100644 --- a/src/test/run-pass/vec-macro-rvalue-scope.rs +++ b/src/test/run-pass/vec-macro-rvalue-scope.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 fn one() -> i32 { 1 } diff --git a/src/test/run-pass/vec-macro-with-trailing-comma.rs b/src/test/run-pass/vec-macro-with-trailing-comma.rs index 3018a746b4a9d..35af249ef5fad 100644 --- a/src/test/run-pass/vec-macro-with-trailing-comma.rs +++ b/src/test/run-pass/vec-macro-with-trailing-comma.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { assert_eq!(vec!(1), vec!(1,)); diff --git a/src/test/run-pass/vec-matching-autoslice.rs b/src/test/run-pass/vec-matching-autoslice.rs index 2b80ad81037f2..5728424e32bb1 100644 --- a/src/test/run-pass/vec-matching-autoslice.rs +++ b/src/test/run-pass/vec-matching-autoslice.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(slice_patterns)] diff --git a/src/test/run-pass/vec-matching-fixed.rs b/src/test/run-pass/vec-matching-fixed.rs index 1278eaf96a48c..1ed6ddc411076 100644 --- a/src/test/run-pass/vec-matching-fixed.rs +++ b/src/test/run-pass/vec-matching-fixed.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(advanced_slice_patterns)] #![feature(slice_patterns)] diff --git a/src/test/run-pass/vec-matching-fold.rs b/src/test/run-pass/vec-matching-fold.rs index c375fc85bc1d3..ee70ea58750d9 100644 --- a/src/test/run-pass/vec-matching-fold.rs +++ b/src/test/run-pass/vec-matching-fold.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(advanced_slice_patterns)] #![feature(slice_patterns)] diff --git a/src/test/run-pass/vec-matching.rs b/src/test/run-pass/vec-matching.rs index b81bdda613f7c..eedf27f857700 100644 --- a/src/test/run-pass/vec-matching.rs +++ b/src/test/run-pass/vec-matching.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(advanced_slice_patterns)] #![feature(slice_patterns)] diff --git a/src/test/run-pass/vec-slice-drop.rs b/src/test/run-pass/vec-slice-drop.rs index 1d749d4963c5e..f400869682fd2 100644 --- a/src/test/run-pass/vec-slice-drop.rs +++ b/src/test/run-pass/vec-slice-drop.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unsafe_destructor)] diff --git a/src/test/run-pass/vec-slice.rs b/src/test/run-pass/vec-slice.rs index 6baeb99df9e8c..a7e6cae93b34b 100644 --- a/src/test/run-pass/vec-slice.rs +++ b/src/test/run-pass/vec-slice.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let v = vec![1,2,3,4,5]; diff --git a/src/test/run-pass/vec-tail-matching.rs b/src/test/run-pass/vec-tail-matching.rs index 091e3f03e7ac7..75f970543a45a 100644 --- a/src/test/run-pass/vec-tail-matching.rs +++ b/src/test/run-pass/vec-tail-matching.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(slice_patterns)] diff --git a/src/test/run-pass/vec-to_str.rs b/src/test/run-pass/vec-to_str.rs index a9bb68395c425..f000ada770a40 100644 --- a/src/test/run-pass/vec-to_str.rs +++ b/src/test/run-pass/vec-to_str.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { assert_eq!(format!("{:?}", vec!(0, 1)), "[0, 1]".to_string()); diff --git a/src/test/run-pass/vec.rs b/src/test/run-pass/vec.rs index ce20d452c403c..c61b3d56dbfb9 100644 --- a/src/test/run-pass/vec.rs +++ b/src/test/run-pass/vec.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let v: Vec = vec!(10, 20); diff --git a/src/test/run-pass/vector-sort-panic-safe.rs b/src/test/run-pass/vector-sort-panic-safe.rs index eca7e62d67cbf..acb29d284b956 100644 --- a/src/test/run-pass/vector-sort-panic-safe.rs +++ b/src/test/run-pass/vector-sort-panic-safe.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(rand, core)] diff --git a/src/test/run-pass/wait-forked-but-failed-child.rs b/src/test/run-pass/wait-forked-but-failed-child.rs index 079c97013abee..998360f08ba0d 100644 --- a/src/test/run-pass/wait-forked-but-failed-child.rs +++ b/src/test/run-pass/wait-forked-but-failed-child.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(libc, old_io)] diff --git a/src/test/run-pass/where-for-self.rs b/src/test/run-pass/where-for-self.rs index eb95b13d3fa5b..1d477b87446d4 100644 --- a/src/test/run-pass/where-for-self.rs +++ b/src/test/run-pass/where-for-self.rs @@ -11,7 +11,6 @@ // Test that we can quantify lifetimes outside a constraint (i.e., including // the self type) in a where clause. -// pretty-expanded FIXME #23616 static mut COUNT: u32 = 1; diff --git a/src/test/run-pass/while-label.rs b/src/test/run-pass/while-label.rs index 076ba8f428f06..8cbb845836f3e 100644 --- a/src/test/run-pass/while-label.rs +++ b/src/test/run-pass/while-label.rs @@ -9,7 +9,6 @@ // except according to those terms. -// pretty-expanded FIXME #23616 pub fn main() { let mut i = 100; diff --git a/src/test/run-pass/while-let.rs b/src/test/run-pass/while-let.rs index b1e80c86ec72d..5a2ecdd45dbe5 100644 --- a/src/test/run-pass/while-let.rs +++ b/src/test/run-pass/while-let.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(collections)] diff --git a/src/test/run-pass/writealias.rs b/src/test/run-pass/writealias.rs index 10718e981ff59..7339fe47dc297 100644 --- a/src/test/run-pass/writealias.rs +++ b/src/test/run-pass/writealias.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 use std::sync::Mutex; diff --git a/src/test/run-pass/xcrate-address-insignificant.rs b/src/test/run-pass/xcrate-address-insignificant.rs index ac8b15d7bf589..8794ecd061b47 100644 --- a/src/test/run-pass/xcrate-address-insignificant.rs +++ b/src/test/run-pass/xcrate-address-insignificant.rs @@ -10,7 +10,6 @@ // aux-build:xcrate_address_insignificant.rs -// pretty-expanded FIXME #23616 extern crate xcrate_address_insignificant as foo; diff --git a/src/test/run-pass/zero-size-type-destructors.rs b/src/test/run-pass/zero-size-type-destructors.rs index dea9edf0582bd..a80faeaea7ea7 100644 --- a/src/test/run-pass/zero-size-type-destructors.rs +++ b/src/test/run-pass/zero-size-type-destructors.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(unsafe_no_drop_flag)] diff --git a/src/test/run-pass/zero_sized_subslice_match.rs b/src/test/run-pass/zero_sized_subslice_match.rs index b98f907774b97..697508ae48889 100644 --- a/src/test/run-pass/zero_sized_subslice_match.rs +++ b/src/test/run-pass/zero_sized_subslice_match.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// pretty-expanded FIXME #23616 #![feature(slice_patterns)] From a725426ec8464e17794b0e8d0a06d33ba6ea95f0 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Wed, 8 Apr 2015 18:01:46 -0700 Subject: [PATCH 28/33] Don't deoptimize llvm when --enable-debug libLTO fails to link here. --- configure | 1 - 1 file changed, 1 deletion(-) diff --git a/configure b/configure index b23cfaf976f0e..97c998a5cda3c 100755 --- a/configure +++ b/configure @@ -631,7 +631,6 @@ if [ -n "$CFG_ENABLE_DEBUG" ]; then msg "debug mode enabled, setting performance options" CFG_DISABLE_OPTIMIZE=1 CFG_DISABLE_OPTIMIZE_CXX=1 - CFG_DISABLE_OPTIMIZE_LLVM=1 CFG_ENABLE_LLVM_ASSERTIONS=1 CFG_ENABLE_DEBUG_ASSERTIONS=1 CFG_ENABLE_DEBUG_JEMALLOC=1 From 0a380a9318cb450fc54153c1327a35cf02fab8e6 Mon Sep 17 00:00:00 2001 From: Kevin Ballard Date: Tue, 7 Apr 2015 16:01:21 -0700 Subject: [PATCH 29/33] Implement io::Seek for io::BufReader where R: io::Seek Seeking the `BufReader` discards the internal buffer (and adjusts the offset appropriately when seeking with `SeekFrom::Current(_)`). --- src/libstd/io/buffered.rs | 111 +++++++++++++++++++++++++++++++++++++- 1 file changed, 109 insertions(+), 2 deletions(-) diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index 6fe35614a85b6..6d514418e1631 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -18,7 +18,7 @@ use io::prelude::*; use cmp; use error; use fmt; -use io::{self, DEFAULT_BUF_SIZE, Error, ErrorKind}; +use io::{self, DEFAULT_BUF_SIZE, Error, ErrorKind, SeekFrom}; use ptr; use iter; @@ -120,6 +120,52 @@ impl fmt::Debug for BufReader where R: fmt::Debug { } } +#[unstable(feature = "buf_seek", reason = "recently added")] +impl Seek for BufReader { + /// Seek to an offset, in bytes, in the underlying reader. + /// + /// The position used for seeking with `SeekFrom::Current(_)` is the + /// position the underlying reader would be at if the `BufReader` had no + /// internal buffer. + /// + /// Seeking always discards the internal buffer, even if the seek position + /// would otherwise fall within it. This guarantees that calling + /// `.unwrap()` immediately after a seek yields the underlying reader at + /// the same position. + /// + /// See `std::io::Seek` for more details. + /// + /// Note: In the edge case where you're seeking with `SeekFrom::Current(n)` + /// where `n` minus the internal buffer length underflows an `i64`, two + /// seeks will be performed instead of one. If the second seek returns + /// `Err`, the underlying reader will be left at the same position it would + /// have if you seeked to `SeekFrom::Current(0)`. + fn seek(&mut self, pos: SeekFrom) -> io::Result { + let result: u64; + if let SeekFrom::Current(n) = pos { + let remainder = (self.cap - self.pos) as i64; + // it should be safe to assume that remainder fits within an i64 as the alternative + // means we managed to allocate 8 ebibytes and that's absurd. + // But it's not out of the realm of possibility for some weird underlying reader to + // support seeking by i64::min_value() so we need to handle underflow when subtracting + // remainder. + if let Some(offset) = n.checked_sub(remainder) { + result = try!(self.inner.seek(SeekFrom::Current(offset))); + } else { + // seek backwards by our remainder, and then by the offset + try!(self.inner.seek(SeekFrom::Current(-remainder))); + self.pos = self.cap; // empty the buffer + result = try!(self.inner.seek(SeekFrom::Current(n))); + } + } else { + // Seeking with Start/End doesn't care about our buffer length. + result = try!(self.inner.seek(pos)); + } + self.pos = self.cap; // empty the buffer + Ok(result) + } +} + /// Wraps a Writer and buffers output to it /// /// It can be excessively inefficient to work directly with a `Write`. For @@ -478,7 +524,7 @@ impl fmt::Debug for BufStream where S: fmt::Debug { mod tests { use prelude::v1::*; use io::prelude::*; - use io::{self, BufReader, BufWriter, BufStream, Cursor, LineWriter}; + use io::{self, BufReader, BufWriter, BufStream, Cursor, LineWriter, SeekFrom}; use test; /// A dummy reader intended at testing short-reads propagation. @@ -533,6 +579,67 @@ mod tests { assert_eq!(reader.read(&mut buf).unwrap(), 0); } + #[test] + fn test_buffered_reader_seek() { + let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4]; + let mut reader = BufReader::with_capacity(2, io::Cursor::new(inner)); + + assert_eq!(reader.seek(SeekFrom::Start(3)).ok(), Some(3)); + assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..])); + assert_eq!(reader.seek(SeekFrom::Current(0)).ok(), Some(3)); + assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..])); + assert_eq!(reader.seek(SeekFrom::Current(1)).ok(), Some(4)); + assert_eq!(reader.fill_buf().ok(), Some(&[1, 2][..])); + reader.consume(1); + assert_eq!(reader.seek(SeekFrom::Current(-2)).ok(), Some(3)); + } + + #[test] + fn test_buffered_reader_seek_underflow() { + // gimmick reader that yields its position modulo 256 for each byte + struct PositionReader { + pos: u64 + } + impl Read for PositionReader { + fn read(&mut self, buf: &mut [u8]) -> io::Result { + let len = buf.len(); + for x in buf { + *x = self.pos as u8; + self.pos = self.pos.wrapping_add(1); + } + Ok(len) + } + } + impl Seek for PositionReader { + fn seek(&mut self, pos: SeekFrom) -> io::Result { + match pos { + SeekFrom::Start(n) => { + self.pos = n; + } + SeekFrom::Current(n) => { + self.pos = self.pos.wrapping_add(n as u64); + } + SeekFrom::End(n) => { + self.pos = u64::max_value().wrapping_add(n as u64); + } + } + Ok(self.pos) + } + } + + let mut reader = BufReader::with_capacity(5, PositionReader { pos: 0 }); + assert_eq!(reader.fill_buf().ok(), Some(&[0, 1, 2, 3, 4][..])); + assert_eq!(reader.seek(SeekFrom::End(-5)).ok(), Some(u64::max_value()-5)); + assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5)); + // the following seek will require two underlying seeks + let expected = 9223372036854775802; + assert_eq!(reader.seek(SeekFrom::Current(i64::min_value())).ok(), Some(expected)); + assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5)); + // seeking to 0 should empty the buffer. + assert_eq!(reader.seek(SeekFrom::Current(0)).ok(), Some(expected)); + assert_eq!(reader.get_ref().pos, expected); + } + #[test] fn test_buffered_writer() { let inner = Vec::new(); From 16052053ac2668b5540a55383924ce36e7018933 Mon Sep 17 00:00:00 2001 From: Kevin Ballard Date: Tue, 7 Apr 2015 17:29:33 -0700 Subject: [PATCH 30/33] Implement io::Seek for io::BufWriter where W: io::Seek Seeking the `BufWriter` writes out its internal buffer before seeking. --- src/libstd/io/buffered.rs | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index 6d514418e1631..bd44a9547b496 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -284,6 +284,16 @@ impl fmt::Debug for BufWriter where W: fmt::Debug { } } +#[unstable(feature = "buf_seek", reason = "recently added")] +impl Seek for BufWriter { + /// Seek to the offset, in bytes, in the underlying writer. + /// + /// Seeking always writes out the internal buffer before seeking. + fn seek(&mut self, pos: SeekFrom) -> io::Result { + self.flush_buf().and_then(|_| self.get_mut().seek(pos)) + } +} + #[unsafe_destructor] impl Drop for BufWriter { fn drop(&mut self) { @@ -683,6 +693,18 @@ mod tests { assert_eq!(w, [0, 1]); } + #[test] + fn test_buffered_writer_seek() { + let mut w = BufWriter::with_capacity(3, io::Cursor::new(Vec::new())); + w.write_all(&[0, 1, 2, 3, 4, 5]).unwrap(); + w.write_all(&[6, 7]).unwrap(); + assert_eq!(w.seek(SeekFrom::Current(0)).ok(), Some(8)); + assert_eq!(&w.get_ref().get_ref()[..], &[0, 1, 2, 3, 4, 5, 6, 7][..]); + assert_eq!(w.seek(SeekFrom::Start(2)).ok(), Some(2)); + w.write_all(&[8, 9]).unwrap(); + assert_eq!(&w.into_inner().unwrap().into_inner()[..], &[0, 1, 8, 9, 4, 5, 6, 7]); + } + // This is just here to make sure that we don't infinite loop in the // newtype struct autoderef weirdness #[test] From 613cf9a2a12a29a2454bc9d5bb83243cf0868955 Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Thu, 9 Apr 2015 18:25:48 +1200 Subject: [PATCH 31/33] Debug impls for a few things in syntax::codemap --- src/libsyntax/codemap.rs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index b563a5e7d6e84..56af43474a615 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -26,6 +26,8 @@ use std::num::ToPrimitive; use std::ops::{Add, Sub}; use std::rc::Rc; +use std::fmt; + use libc::c_uint; use serialize::{Encodable, Decodable, Encoder, Decoder}; @@ -199,6 +201,7 @@ pub fn original_sp(cm: &CodeMap, sp: Span, enclosing_sp: Span) -> Span { // /// A source code location used for error reporting +#[derive(Debug)] pub struct Loc { /// Information about the original source pub file: Rc, @@ -211,6 +214,7 @@ pub struct Loc { /// A source code location used as the result of lookup_char_pos_adj // Actually, *none* of the clients use the filename *or* file field; // perhaps they should just be removed. +#[derive(Debug)] pub struct LocWithOpt { pub filename: FileName, pub line: usize, @@ -219,7 +223,9 @@ pub struct LocWithOpt { } // used to be structural records. Better names, anyone? +#[derive(Debug)] pub struct FileMapAndLine { pub fm: Rc, pub line: usize } +#[derive(Debug)] pub struct FileMapAndBytePos { pub fm: Rc, pub pos: BytePos } @@ -449,6 +455,12 @@ impl Decodable for FileMap { } } +impl fmt::Debug for FileMap { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + write!(fmt, "FileMap({})", self.name) + } +} + impl FileMap { /// EFFECT: register a start-of-line offset in the /// table of line-beginnings. From 341870a2d1a3b51d3dc7e36c3a7bc5a704a9bd19 Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Thu, 9 Apr 2015 20:35:27 +1200 Subject: [PATCH 32/33] Fix the span for `for` expressions --- src/libsyntax/parse/parser.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 272bb5f650676..3cc16006b1b9c 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -2880,7 +2880,7 @@ impl<'a> Parser<'a> { try!(self.expect_keyword(keywords::In)); let expr = try!(self.parse_expr_res(RESTRICTION_NO_STRUCT_LITERAL)); let loop_block = try!(self.parse_block()); - let hi = self.span.hi; + let hi = self.last_span.hi; Ok(self.mk_expr(lo, hi, ExprForLoop(pat, expr, loop_block, opt_ident))) } From ea731797b821c3347be72fefcba32d48e04d27d0 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Fri, 10 Apr 2015 02:09:19 +0530 Subject: [PATCH 33/33] fixup windows std_misc --- src/test/run-pass/issue-13259-windows-tcb-trash.rs | 2 +- src/test/run-pass/x86stdcall2.rs | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/test/run-pass/issue-13259-windows-tcb-trash.rs b/src/test/run-pass/issue-13259-windows-tcb-trash.rs index 34960b264567d..9ebbddf5141b7 100644 --- a/src/test/run-pass/issue-13259-windows-tcb-trash.rs +++ b/src/test/run-pass/issue-13259-windows-tcb-trash.rs @@ -10,7 +10,7 @@ // pretty-expanded FIXME #23616 -#![feature(libc)] +#![feature(libc, std_misc)] extern crate libc; diff --git a/src/test/run-pass/x86stdcall2.rs b/src/test/run-pass/x86stdcall2.rs index 7b15531dacc33..62da9c9d14be2 100644 --- a/src/test/run-pass/x86stdcall2.rs +++ b/src/test/run-pass/x86stdcall2.rs @@ -10,6 +10,8 @@ // pretty-expanded FIXME #23616 +#![feature(std_misc)] + pub type HANDLE = u32; pub type DWORD = u32; pub type SIZE_T = u32;