OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Auto merge of #77302 - RalfJung:rollup-n8gg3v6, r=RalfJung

Browse Source 
Rollup of 7 pull requests

Successful merges:

 - #76454 (UI to unit test for those using Cell/RefCell/UnsafeCell)
 - #76474 (Add option to pass a custom codegen backend from a driver)
 - #76711 (diag: improve closure/generic parameter mismatch)
 - #77170 (Remove `#[rustc_allow_const_fn_ptr]` and add `#![feature(const_fn_fn_ptr_basics)]`)
 - #77194 (Add doc alias for iterator fold)
 - #77288 (fix building libstd for Miri on macOS)
 - #77295 (Update unstable-book: Fix ABNF in inline assembly docs)

Failed merges:

r? `@ghost`
This commit is contained in:
bors 2020-09-28 18:02:45 +00:00
commit fc2daaae61
76 changed files with 940 additions and 882 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
compiler/rustc_attr/src/builtin.rs
View File

@ -145,8 +145,6 @@ pub struct ConstStability {
pub feature: Symbol,
/// whether the function has a `#[rustc_promotable]` attribute
pub promotable: bool,
/// whether the function has a `#[rustc_allow_const_fn_ptr]` attribute
pub allow_const_fn_ptr: bool,
}
/// The available stability levels.
@ -190,7 +188,6 @@ where
let mut stab: Option<Stability> = None;
let mut const_stab: Option<ConstStability> = None;
let mut promotable = false;
let mut allow_const_fn_ptr = false;
let diagnostic = &sess.parse_sess.span_diagnostic;
'outer: for attr in attrs_iter {
@ -200,7 +197,6 @@ where
sym::unstable,
sym::stable,
sym::rustc_promotable,
sym::rustc_allow_const_fn_ptr,
]
.iter()
.any(|&s| attr.has_name(s))
@ -215,9 +211,6 @@ where
if attr.has_name(sym::rustc_promotable) {
promotable = true;
}
if attr.has_name(sym::rustc_allow_const_fn_ptr) {
allow_const_fn_ptr = true;
}
// attributes with data
else if let Some(MetaItem { kind: MetaItemKind::List(ref metas), .. }) = meta {
let meta = meta.as_ref().unwrap();
@ -360,12 +353,8 @@ where
if sym::unstable == meta_name {
stab = Some(Stability { level, feature });
} else {
const_stab = Some(ConstStability {
level,
feature,
promotable: false,
allow_const_fn_ptr: false,
});
const_stab =
Some(ConstStability { level, feature, promotable: false });
}
}
(None, _, _) => {
@ -440,12 +429,8 @@ where
if sym::stable == meta_name {
stab = Some(Stability { level, feature });
} else {
const_stab = Some(ConstStability {
level,
feature,
promotable: false,
allow_const_fn_ptr: false,
});
const_stab =
Some(ConstStability { level, feature, promotable: false });
}
}
(None, _) => {
@ -464,18 +449,16 @@ where
}
// Merge the const-unstable info into the stability info
if promotable || allow_const_fn_ptr {
if promotable {
if let Some(ref mut stab) = const_stab {
stab.promotable = promotable;
stab.allow_const_fn_ptr = allow_const_fn_ptr;
} else {
struct_span_err!(
diagnostic,
item_sp,
E0717,
"rustc_promotable and rustc_allow_const_fn_ptr attributes \
must be paired with either a rustc_const_unstable or a rustc_const_stable \
attribute"
"`rustc_promotable` attribute must be paired with either a `rustc_const_unstable` \
or a `rustc_const_stable` attribute"
)
.emit();
}

12
compiler/rustc_driver/src/lib.rs
View File

@ -141,6 +141,9 @@ pub fn run_compiler(
callbacks: &mut (dyn Callbacks + Send),
file_loader: Option<Box<dyn FileLoader + Send + Sync>>,
emitter: Option<Box<dyn Write + Send>>,
make_codegen_backend: Option<
Box<dyn FnOnce(&config::Options) -> Box<dyn CodegenBackend> + Send>,
>,
) -> interface::Result<()> {
let mut args = Vec::new();
for arg in at_args {
@ -162,6 +165,11 @@ pub fn run_compiler(
let sopts = config::build_session_options(&matches);
let cfg = interface::parse_cfgspecs(matches.opt_strs("cfg"));
// We wrap `make_codegen_backend` in another `Option` such that `dummy_config` can take
// ownership of it when necessary, while also allowing the non-dummy config to take ownership
// when `dummy_config` is not used.
let mut make_codegen_backend = Some(make_codegen_backend);
let mut dummy_config = |sopts, cfg, diagnostic_output| {
let mut config = interface::Config {
opts: sopts,
@ -177,6 +185,7 @@ pub fn run_compiler(
lint_caps: Default::default(),
register_lints: None,
override_queries: None,
make_codegen_backend: make_codegen_backend.take().unwrap(),
registry: diagnostics_registry(),
};
callbacks.config(&mut config);
@ -253,6 +262,7 @@ pub fn run_compiler(
lint_caps: Default::default(),
register_lints: None,
override_queries: None,
make_codegen_backend: make_codegen_backend.unwrap(),
registry: diagnostics_registry(),
};
@ -1265,7 +1275,7 @@ pub fn main() -> ! {
})
})
.collect::<Vec<_>>();
run_compiler(&args, &mut callbacks, None, None)
run_compiler(&args, &mut callbacks, None, None, None)
});
// The extra `\t` is necessary to align this label with the others.
print_time_passes_entry(callbacks.time_passes, "\ttotal", start.elapsed());

3
compiler/rustc_feature/src/active.rs
View File

@ -587,6 +587,9 @@ declare_features! (
/// Allows basic arithmetic on floating point types in a `const fn`.
(active, const_fn_floating_point_arithmetic, "1.48.0", Some(57241), None),
/// Allows using and casting function pointers in a `const fn`.
(active, const_fn_fn_ptr_basics, "1.48.0", Some(57563), None),
// -------------------------------------------------------------------------
// feature-group-end: actual feature gates
// -------------------------------------------------------------------------

1
compiler/rustc_feature/src/builtin_attrs.rs
View File

@ -464,7 +464,6 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
// ==========================================================================
rustc_attr!(rustc_promotable, AssumedUsed, template!(Word), IMPL_DETAIL),
rustc_attr!(rustc_allow_const_fn_ptr, AssumedUsed, template!(Word), IMPL_DETAIL),
rustc_attr!(rustc_args_required_const, AssumedUsed, template!(List: "N"), INTERNAL_UNSTABLE),
// ==========================================================================

5
compiler/rustc_interface/src/interface.rs
View File

@ -154,6 +154,10 @@ pub struct Config {
pub override_queries:
Option<fn(&Session, &mut ty::query::Providers, &mut ty::query::Providers)>,
/// This is a callback from the driver that is called to create a codegen backend.
pub make_codegen_backend:
Option<Box<dyn FnOnce(&config::Options) -> Box<dyn CodegenBackend> + Send>>,
/// Registry of diagnostics codes.
pub registry: Registry,
}
@ -167,6 +171,7 @@ pub fn create_compiler_and_run<R>(config: Config, f: impl FnOnce(&Compiler) -> R
config.file_loader,
config.input_path.clone(),
config.lint_caps,
config.make_codegen_backend,
registry.clone(),
);

10
compiler/rustc_interface/src/util.rs
View File

@ -63,9 +63,17 @@ pub fn create_session(
file_loader: Option<Box<dyn FileLoader + Send + Sync + 'static>>,
input_path: Option<PathBuf>,
lint_caps: FxHashMap<lint::LintId, lint::Level>,
make_codegen_backend: Option<
Box<dyn FnOnce(&config::Options) -> Box<dyn CodegenBackend> + Send>,
>,
descriptions: Registry,
) -> (Lrc<Session>, Lrc<Box<dyn CodegenBackend>>) {
let codegen_backend = get_codegen_backend(&sopts);
let codegen_backend = if let Some(make_codegen_backend) = make_codegen_backend {
make_codegen_backend(&sopts)
} else {
get_codegen_backend(&sopts)
};
// target_override is documented to be called before init(), so this is okay
let target_override = codegen_backend.target_override(&sopts);

4
compiler/rustc_middle/src/query/mod.rs
View File

@ -457,10 +457,6 @@ rustc_queries! {
desc { |tcx| "checking if item is promotable: `{}`", tcx.def_path_str(key) }
}
query const_fn_is_allowed_fn_ptr(key: DefId) -> bool {
desc { |tcx| "checking if const fn allows `fn()` types: `{}`", tcx.def_path_str(key) }
}
/// Returns `true` if this is a foreign item (i.e., linked via `extern { ... }`).
query is_foreign_item(key: DefId) -> bool {
desc { |tcx| "checking if `{}` is a foreign item", tcx.def_path_str(key) }

12
compiler/rustc_middle/src/ty/error.rs
View File

@ -475,6 +475,18 @@ impl<T> Trait<T> for X {
#traits-as-parameters",
);
}
(ty::Param(p), ty::Closure(..) | ty::Generator(..)) => {
let generics = self.generics_of(body_owner_def_id);
let p_span = self.def_span(generics.type_param(p, self).def_id);
if !sp.contains(p_span) {
db.span_label(p_span, "this type parameter");
}
db.help(&format!(
"every closure has a distinct type and so could not always match the \
caller-chosen type of parameter `{}`",
p
));
}
(ty::Param(p), _) | (_, ty::Param(p)) => {
let generics = self.generics_of(body_owner_def_id);
let p_span = self.def_span(generics.type_param(p, self).def_id);

6
compiler/rustc_mir/src/const_eval/fn_queries.rs
View File

@ -151,17 +151,11 @@ fn is_promotable_const_fn(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
}
}
fn const_fn_is_allowed_fn_ptr(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
is_const_fn(tcx, def_id)
&& tcx.lookup_const_stability(def_id).map(|stab| stab.allow_const_fn_ptr).unwrap_or(false)
}
pub fn provide(providers: &mut Providers) {
*providers = Providers {
is_const_fn_raw,
is_const_impl_raw: |tcx, def_id| is_const_impl_raw(tcx, def_id.expect_local()),
is_promotable_const_fn,
const_fn_is_allowed_fn_ptr,
..*providers
};
}

28
compiler/rustc_mir/src/transform/check_consts/ops.rs
View File

@ -213,11 +213,21 @@ impl NonConstOp for FnPtrCast {
const STOPS_CONST_CHECKING: bool = true;
fn status_in_item(&self, ccx: &ConstCx<'_, '_>) -> Status {
mcf_status_in_item(ccx)
if ccx.const_kind() != hir::ConstContext::ConstFn {
Status::Allowed
} else {
Status::Unstable(sym::const_fn_fn_ptr_basics)
}
}
fn emit_error(&self, ccx: &ConstCx<'_, '_>, span: Span) {
mcf_emit_error(ccx, span, "function pointer casts are not allowed in const fn");
feature_err(
&ccx.tcx.sess.parse_sess,
sym::const_fn_fn_ptr_basics,
span,
&format!("function pointer casts are not allowed in {}s", ccx.const_kind()),
)
.emit()
}
}
@ -596,17 +606,21 @@ pub mod ty {
const STOPS_CONST_CHECKING: bool = true;
fn status_in_item(&self, ccx: &ConstCx<'_, '_>) -> Status {
// FIXME: This attribute a hack to allow the specialization of the `futures` API. See
// #59739. We should have a proper feature gate for this.
if ccx.tcx.has_attr(ccx.def_id.to_def_id(), sym::rustc_allow_const_fn_ptr) {
if ccx.const_kind() != hir::ConstContext::ConstFn {
Status::Allowed
} else {
mcf_status_in_item(ccx)
Status::Unstable(sym::const_fn_fn_ptr_basics)
}
}
fn emit_error(&self, ccx: &ConstCx<'_, '_>, span: Span) {
mcf_emit_error(ccx, span, "function pointers in const fn are unstable");
feature_err(
&ccx.tcx.sess.parse_sess,
sym::const_fn_fn_ptr_basics,
span,
&format!("function pointers cannot appear in {}s", ccx.const_kind()),
)
.emit()
}
}

2
compiler/rustc_span/src/symbol.rs
View File

@ -353,6 +353,7 @@ symbols! {
const_extern_fn,
const_fn,
const_fn_floating_point_arithmetic,
const_fn_fn_ptr_basics,
const_fn_transmute,
const_fn_union,
const_generics,
@ -884,7 +885,6 @@ symbols! {
rustc,
rustc_allocator,
rustc_allocator_nounwind,
rustc_allow_const_fn_ptr,
rustc_args_required_const,
rustc_attrs,
rustc_builtin_macro,

9
compiler/rustc_typeck/src/check/demand.rs
View File

@ -117,11 +117,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
ty
}
// Checks that the type of `expr` can be coerced to `expected`.
//
// N.B., this code relies on `self.diverges` to be accurate. In
// particular, assignments to `!` will be permitted if the
// diverges flag is currently "always".
/// Checks that the type of `expr` can be coerced to `expected`.
///
/// N.B., this code relies on `self.diverges` to be accurate. In particular, assignments to `!`
/// will be permitted if the diverges flag is currently "always".
pub fn demand_coerce_diag(
&self,
expr: &hir::Expr<'_>,

8
library/alloc/tests/boxed.rs
View File

@ -1,3 +1,4 @@
use std::cell::Cell;
use std::mem::MaybeUninit;
use std::ptr::NonNull;
@ -49,3 +50,10 @@ fn box_clone_from_ptr_stability() {
assert_eq!(copy.as_ptr() as usize, copy_raw);
}
}
#[test]
fn box_deref_lval() {
let x = Box::new(Cell::new(5));
x.set(1000);
assert_eq!(x.get(), 1000);
}

322
library/alloc/tests/fmt.rs
View File

@ -1,7 +1,327 @@
use std::fmt;
#![deny(warnings)]
use std::cell::RefCell;
use std::fmt::{self, Write};
#[test]
fn test_format() {
let s = fmt::format(format_args!("Hello, {}!", "world"));
assert_eq!(s, "Hello, world!");
}
struct A;
struct B;
struct C;
struct D;
impl fmt::LowerHex for A {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("aloha")
}
}
impl fmt::UpperHex for B {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("adios")
}
}
impl fmt::Display for C {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.pad_integral(true, "☃", "123")
}
}
impl fmt::Binary for D {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("aa")?;
f.write_char('☃')?;
f.write_str("bb")
}
}
macro_rules! t {
($a:expr, $b:expr) => {
assert_eq!($a, $b)
};
}
#[test]
fn test_format_macro_interface() {
// Various edge cases without formats
t!(format!(""), "");
t!(format!("hello"), "hello");
t!(format!("hello {{"), "hello {");
// default formatters should work
t!(format!("{}", 1.0f32), "1");
t!(format!("{}", 1.0f64), "1");
t!(format!("{}", "a"), "a");
t!(format!("{}", "a".to_string()), "a");
t!(format!("{}", false), "false");
t!(format!("{}", 'a'), "a");
// At least exercise all the formats
t!(format!("{}", true), "true");
t!(format!("{}", '☃'), "☃");
t!(format!("{}", 10), "10");
t!(format!("{}", 10_usize), "10");
t!(format!("{:?}", '☃'), "'☃'");
t!(format!("{:?}", 10), "10");
t!(format!("{:?}", 10_usize), "10");
t!(format!("{:?}", "true"), "\"true\"");
t!(format!("{:?}", "foo\nbar"), "\"foo\\nbar\"");
t!(
format!("{:?}", "foo\n\"bar\"\r\n\'baz\'\t\\qux\\"),
r#""foo\n\"bar\"\r\n\'baz\'\t\\qux\\""#
);
t!(format!("{:?}", "foo\0bar\x01baz\u{7f}q\u{75}x"), r#""foo\u{0}bar\u{1}baz\u{7f}qux""#);
t!(format!("{:o}", 10_usize), "12");
t!(format!("{:x}", 10_usize), "a");
t!(format!("{:X}", 10_usize), "A");
t!(format!("{}", "foo"), "foo");
t!(format!("{}", "foo".to_string()), "foo");
if cfg!(target_pointer_width = "32") {
t!(format!("{:#p}", 0x1234 as *const isize), "0x00001234");
t!(format!("{:#p}", 0x1234 as *mut isize), "0x00001234");
} else {
t!(format!("{:#p}", 0x1234 as *const isize), "0x0000000000001234");
t!(format!("{:#p}", 0x1234 as *mut isize), "0x0000000000001234");
}
t!(format!("{:p}", 0x1234 as *const isize), "0x1234");
t!(format!("{:p}", 0x1234 as *mut isize), "0x1234");
t!(format!("{:x}", A), "aloha");
t!(format!("{:X}", B), "adios");
t!(format!("foo {} ☃☃☃☃☃☃", "bar"), "foo bar ☃☃☃☃☃☃");
t!(format!("{1} {0}", 0, 1), "1 0");
t!(format!("{foo} {bar}", foo = 0, bar = 1), "0 1");
t!(format!("{foo} {1} {bar} {0}", 0, 1, foo = 2, bar = 3), "2 1 3 0");
t!(format!("{} {0}", "a"), "a a");
t!(format!("{_foo}", _foo = 6usize), "6");
t!(format!("{foo_bar}", foo_bar = 1), "1");
t!(format!("{}", 5 + 5), "10");
t!(format!("{:#4}", C), "☃123");
t!(format!("{:b}", D), "aa☃bb");
let a: &dyn fmt::Debug = &1;
t!(format!("{:?}", a), "1");
// Formatting strings and their arguments
t!(format!("{}", "a"), "a");
t!(format!("{:4}", "a"), "a ");
t!(format!("{:4}", "☃"), "☃ ");
t!(format!("{:>4}", "a"), " a");
t!(format!("{:<4}", "a"), "a ");
t!(format!("{:^5}", "a"), " a ");
t!(format!("{:^5}", "aa"), " aa ");
t!(format!("{:^4}", "a"), " a ");
t!(format!("{:^4}", "aa"), " aa ");
t!(format!("{:.4}", "a"), "a");
t!(format!("{:4.4}", "a"), "a ");
t!(format!("{:4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
t!(format!("{:<4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
t!(format!("{:>4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
t!(format!("{:^4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
t!(format!("{:>10.4}", "aaaaaaaaaaaaaaaaaa"), " aaaa");
t!(format!("{:2.4}", "aaaaa"), "aaaa");
t!(format!("{:2.4}", "aaaa"), "aaaa");
t!(format!("{:2.4}", "aaa"), "aaa");
t!(format!("{:2.4}", "aa"), "aa");
t!(format!("{:2.4}", "a"), "a ");
t!(format!("{:0>2}", "a"), "0a");
t!(format!("{:.*}", 4, "aaaaaaaaaaaaaaaaaa"), "aaaa");
t!(format!("{:.1$}", "aaaaaaaaaaaaaaaaaa", 4), "aaaa");
t!(format!("{:.a$}", "aaaaaaaaaaaaaaaaaa", a = 4), "aaaa");
t!(format!("{:._a$}", "aaaaaaaaaaaaaaaaaa", _a = 4), "aaaa");
t!(format!("{:1$}", "a", 4), "a ");
t!(format!("{1:0$}", 4, "a"), "a ");
t!(format!("{:a$}", "a", a = 4), "a ");
t!(format!("{:-#}", "a"), "a");
t!(format!("{:+#}", "a"), "a");
t!(format!("{:/^10.8}", "1234567890"), "/12345678/");
// Some float stuff
t!(format!("{:}", 1.0f32), "1");
t!(format!("{:}", 1.0f64), "1");
t!(format!("{:.3}", 1.0f64), "1.000");
t!(format!("{:10.3}", 1.0f64), " 1.000");
t!(format!("{:+10.3}", 1.0f64), " +1.000");
t!(format!("{:+10.3}", -1.0f64), " -1.000");
t!(format!("{:e}", 1.2345e6f32), "1.2345e6");
t!(format!("{:e}", 1.2345e6f64), "1.2345e6");
t!(format!("{:E}", 1.2345e6f64), "1.2345E6");
t!(format!("{:.3e}", 1.2345e6f64), "1.234e6");
t!(format!("{:10.3e}", 1.2345e6f64), " 1.234e6");
t!(format!("{:+10.3e}", 1.2345e6f64), " +1.234e6");
t!(format!("{:+10.3e}", -1.2345e6f64), " -1.234e6");
// Float edge cases
t!(format!("{}", -0.0), "0");
t!(format!("{:?}", -0.0), "-0.0");
t!(format!("{:?}", 0.0), "0.0");
// sign aware zero padding
t!(format!("{:<3}", 1), "1 ");
t!(format!("{:>3}", 1), " 1");
t!(format!("{:^3}", 1), " 1 ");
t!(format!("{:03}", 1), "001");
t!(format!("{:<03}", 1), "001");
t!(format!("{:>03}", 1), "001");
t!(format!("{:^03}", 1), "001");
t!(format!("{:+03}", 1), "+01");
t!(format!("{:<+03}", 1), "+01");
t!(format!("{:>+03}", 1), "+01");
t!(format!("{:^+03}", 1), "+01");
t!(format!("{:#05x}", 1), "0x001");
t!(format!("{:<#05x}", 1), "0x001");
t!(format!("{:>#05x}", 1), "0x001");
t!(format!("{:^#05x}", 1), "0x001");
t!(format!("{:05}", 1.2), "001.2");
t!(format!("{:<05}", 1.2), "001.2");
t!(format!("{:>05}", 1.2), "001.2");
t!(format!("{:^05}", 1.2), "001.2");
t!(format!("{:05}", -1.2), "-01.2");
t!(format!("{:<05}", -1.2), "-01.2");
t!(format!("{:>05}", -1.2), "-01.2");
t!(format!("{:^05}", -1.2), "-01.2");
t!(format!("{:+05}", 1.2), "+01.2");
t!(format!("{:<+05}", 1.2), "+01.2");
t!(format!("{:>+05}", 1.2), "+01.2");
t!(format!("{:^+05}", 1.2), "+01.2");
// Ergonomic format_args!
t!(format!("{0:x} {0:X}", 15), "f F");
t!(format!("{0:x} {0:X} {}", 15), "f F 15");
t!(format!("{:x}{0:X}{a:x}{:X}{1:x}{a:X}", 13, 14, a = 15), "dDfEeF");
t!(format!("{a:x} {a:X}", a = 15), "f F");
// And its edge cases
t!(
format!(
"{a:.0$} {b:.0$} {0:.0$}\n{a:.c$} {b:.c$} {c:.c$}",
4,
a = "abcdefg",
b = "hijklmn",
c = 3
),
"abcd hijk 4\nabc hij 3"
);
t!(format!("{a:.*} {0} {:.*}", 4, 3, "efgh", a = "abcdef"), "abcd 4 efg");
t!(format!("{:.a$} {a} {a:#x}", "aaaaaa", a = 2), "aa 2 0x2");
// Test that pointers don't get truncated.
{
let val = usize::MAX;
let exp = format!("{:#x}", val);
t!(format!("{:p}", val as *const isize), exp);
}
// Escaping
t!(format!("{{"), "{");
t!(format!("}}"), "}");
// make sure that format! doesn't move out of local variables
let a = Box::new(3);
format!("{}", a);
format!("{}", a);
// make sure that format! doesn't cause spurious unused-unsafe warnings when
// it's inside of an outer unsafe block
unsafe {
let a: isize = ::std::mem::transmute(3_usize);
format!("{}", a);
}
// test that trailing commas are acceptable
format!("{}", "test",);
format!("{foo}", foo = "test",);
}
// Basic test to make sure that we can invoke the `write!` macro with an
// fmt::Write instance.
#[test]
fn test_write() {
let mut buf = String::new();
let _ = write!(&mut buf, "{}", 3);
{
let w = &mut buf;
let _ = write!(w, "{foo}", foo = 4);
let _ = write!(w, "{}", "hello");
let _ = writeln!(w, "{}", "line");
let _ = writeln!(w, "{foo}", foo = "bar");
let _ = w.write_char('☃');
let _ = w.write_str("str");
}
t!(buf, "34helloline\nbar\n☃str");
}
// Just make sure that the macros are defined, there's not really a lot that we
// can do with them just yet (to test the output)
#[test]
fn test_print() {
print!("hi");
print!("{:?}", vec![0u8]);
println!("hello");
println!("this is a {}", "test");
println!("{foo}", foo = "bar");
}
// Just make sure that the macros are defined, there's not really a lot that we
// can do with them just yet (to test the output)
#[test]
fn test_format_args() {
let mut buf = String::new();
{
let w = &mut buf;
let _ = write!(w, "{}", format_args!("{}", 1));
let _ = write!(w, "{}", format_args!("test"));
let _ = write!(w, "{}", format_args!("{test}", test = 3));
}
let s = buf;
t!(s, "1test3");
let s = fmt::format(format_args!("hello {}", "world"));
t!(s, "hello world");
let s = format!("{}: {}", "args were", format_args!("hello {}", "world"));
t!(s, "args were: hello world");
}
#[test]
fn test_order() {
// Make sure format!() arguments are always evaluated in a left-to-right
// ordering
fn foo() -> isize {
static mut FOO: isize = 0;
unsafe {
FOO += 1;
FOO
}
}
assert_eq!(
format!("{} {} {a} {b} {} {c}", foo(), foo(), foo(), a = foo(), b = foo(), c = foo()),
"1 2 4 5 3 6".to_string()
);
}
#[test]
fn test_once() {
// Make sure each argument are evaluated only once even though it may be
// formatted multiple times
fn foo() -> isize {
static mut FOO: isize = 0;
unsafe {
FOO += 1;
FOO
}
}
assert_eq!(format!("{0} {0} {0} {a} {a} {a}", foo(), a = foo()), "1 1 1 2 2 2".to_string());
}
#[test]
fn test_refcell() {
let refcell = RefCell::new(5);
assert_eq!(format!("{:?}", refcell), "RefCell { value: 5 }");
let borrow = refcell.borrow_mut();
assert_eq!(format!("{:?}", refcell), "RefCell { value: <borrowed> }");
drop(borrow);
assert_eq!(format!("{:?}", refcell), "RefCell { value: 5 }");
}

80
library/alloc/tests/vec.rs
View File

@ -1,4 +1,5 @@
use std::borrow::Cow;
use std::cell::Cell;
use std::collections::TryReserveError::*;
use std::fmt::Debug;
use std::iter::InPlaceIterable;
@ -1831,3 +1832,82 @@ fn partialeq_vec_full() {
assert_partial_eq_valid!(vec2,vec3; array2,array3);
assert_partial_eq_valid!(vec2,vec3; arrayref2,arrayref3);
}
#[test]
fn test_vec_cycle() {
#[derive(Debug)]
struct C<'a> {
v: Vec<Cell<Option<&'a C<'a>>>>,
}
impl<'a> C<'a> {
fn new() -> C<'a> {
C { v: Vec::new() }
}
}
let mut c1 = C::new();
let mut c2 = C::new();
let mut c3 = C::new();
// Push
c1.v.push(Cell::new(None));
c1.v.push(Cell::new(None));
c2.v.push(Cell::new(None));
c2.v.push(Cell::new(None));
c3.v.push(Cell::new(None));
c3.v.push(Cell::new(None));
// Set
c1.v[0].set(Some(&c2));
c1.v[1].set(Some(&c3));
c2.v[0].set(Some(&c2));
c2.v[1].set(Some(&c3));
c3.v[0].set(Some(&c1));
c3.v[1].set(Some(&c2));
}
#[test]
fn test_vec_cycle_wrapped() {
struct Refs<'a> {
v: Vec<Cell<Option<&'a C<'a>>>>,
}
struct C<'a> {
refs: Refs<'a>,
}
impl<'a> Refs<'a> {
fn new() -> Refs<'a> {
Refs { v: Vec::new() }
}
}
impl<'a> C<'a> {
fn new() -> C<'a> {
C { refs: Refs::new() }
}
}
let mut c1 = C::new();
let mut c2 = C::new();
let mut c3 = C::new();
c1.refs.v.push(Cell::new(None));
c1.refs.v.push(Cell::new(None));
c2.refs.v.push(Cell::new(None));
c2.refs.v.push(Cell::new(None));
c3.refs.v.push(Cell::new(None));
c3.refs.v.push(Cell::new(None));
c1.refs.v[0].set(Some(&c2));
c1.refs.v[1].set(Some(&c3));
c2.refs.v[0].set(Some(&c2));
c2.refs.v[1].set(Some(&c3));
c3.refs.v[0].set(Some(&c1));
c3.refs.v[1].set(Some(&c2));
}

3
library/core/src/fmt/mod.rs
View File

@ -2238,5 +2238,6 @@ impl<T: ?Sized + Debug> Debug for UnsafeCell<T> {
}
}
// If you expected tests to be here, look instead at the ui/ifmt.rs test,
// If you expected tests to be here, look instead at the core/tests/fmt.rs file,
// it's a lot easier than creating all of the rt::Piece structures here.
// There are also tests in the alloc crate, for those that need allocations.

2
library/core/src/iter/traits/iterator.rs
View File

@ -1976,6 +1976,8 @@ pub trait Iterator {
/// // they're the same
/// assert_eq!(result, result2);
/// ```
#[doc(alias = "reduce")]
#[doc(alias = "inject")]
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn fold<B, F>(mut self, init: B, mut f: F) -> B

1
library/core/src/lib.rs
View File

@ -83,6 +83,7 @@
#![feature(const_fn_union)]
#![feature(const_fn)]
#![cfg_attr(not(bootstrap), feature(const_fn_floating_point_arithmetic))]
#![cfg_attr(not(bootstrap), feature(const_fn_fn_ptr_basics))]
#![feature(const_generics)]
#![feature(const_option)]
#![feature(const_precise_live_drops)]

8
library/core/src/task/wake.rs
View File

@ -129,13 +129,9 @@ impl RawWakerVTable {
/// associated task.
#[rustc_promotable]
#[stable(feature = "futures_api", since = "1.36.0")]
// `rustc_allow_const_fn_ptr` is a hack that should not be used anywhere else
// without first consulting with T-Lang.
//
// FIXME: remove whenever we have a stable way to accept fn pointers from const fn
// (see https://github.com/rust-rfcs/const-eval/issues/19#issuecomment-472799062)
#[rustc_allow_const_fn_ptr]
#[rustc_const_stable(feature = "futures_api", since = "1.36.0")]
#[cfg_attr(not(bootstrap), allow_internal_unstable(const_fn_fn_ptr_basics))]
#[cfg_attr(bootstrap, rustc_allow_const_fn_ptr)]
pub const fn new(
clone: unsafe fn(*const ()) -> RawWaker,
wake: unsafe fn(*const ()),

29
library/core/tests/array.rs
View File

@ -345,3 +345,32 @@ fn array_map_drop_safety() {
assert_eq!(DROPPED.load(Ordering::SeqCst), num_to_create);
panic!("test succeeded")
}
#[test]
fn cell_allows_array_cycle() {
use core::cell::Cell;
#[derive(Debug)]
struct B<'a> {
a: [Cell<Option<&'a B<'a>>>; 2],
}
impl<'a> B<'a> {
fn new() -> B<'a> {
B { a: [Cell::new(None), Cell::new(None)] }
}
}
let b1 = B::new();
let b2 = B::new();
let b3 = B::new();
b1.a[0].set(Some(&b2));
b1.a[1].set(Some(&b3));
b2.a[0].set(Some(&b2));
b2.a[1].set(Some(&b3));
b3.a[0].set(Some(&b1));
b3.a[1].set(Some(&b2));
}

55
library/core/tests/cell.rs
View File

@ -303,6 +303,53 @@ fn cell_into_inner() {
assert_eq!("Hello world".to_owned(), cell.into_inner());
}
#[test]
fn cell_exterior() {
#[derive(Copy, Clone)]
#[allow(dead_code)]
struct Point {
x: isize,
y: isize,
z: isize,
}
fn f(p: &Cell<Point>) {
assert_eq!(p.get().z, 12);
p.set(Point { x: 10, y: 11, z: 13 });
assert_eq!(p.get().z, 13);
}
let a = Point { x: 10, y: 11, z: 12 };
let b = &Cell::new(a);
assert_eq!(b.get().z, 12);
f(b);
assert_eq!(a.z, 12);
assert_eq!(b.get().z, 13);
}
#[test]
fn cell_does_not_clone() {
#[derive(Copy)]
#[allow(dead_code)]
struct Foo {
x: isize,
}
impl Clone for Foo {
fn clone(&self) -> Foo {
// Using Cell in any way should never cause clone() to be
// invoked -- after all, that would permit evil user code to
// abuse `Cell` and trigger crashes.
panic!();
}
}
let x = Cell::new(Foo { x: 22 });
let _y = x.get();
let _z = x.clone();
}
#[test]
fn refcell_default() {
let cell: RefCell<u64> = Default::default();
@ -367,3 +414,11 @@ fn refcell_replace_borrows() {
let _b = x.borrow();
x.replace(1);
}
#[test]
fn refcell_format() {
let name = RefCell::new("rust");
let what = RefCell::new("rocks");
let msg = format!("{name} {}", &*what.borrow(), name = &*name.borrow());
assert_eq!(msg, "rust rocks".to_string());
}

97
library/core/tests/iter.rs
View File

@ -376,6 +376,103 @@ fn test_zip_next_back_side_effects_exhausted() {
assert_eq!(b, vec![200, 300, 400]);
}
#[derive(Debug)]
struct CountClone(Cell<i32>);
fn count_clone() -> CountClone {
CountClone(Cell::new(0))
}
impl PartialEq<i32> for CountClone {
fn eq(&self, rhs: &i32) -> bool {
self.0.get() == *rhs
}
}
impl Clone for CountClone {
fn clone(&self) -> Self {
let ret = CountClone(self.0.clone());
let n = self.0.get();
self.0.set(n + 1);
ret
}
}
#[test]
fn test_zip_cloned_sideffectful() {
let xs = [count_clone(), count_clone(), count_clone(), count_clone()];
let ys = [count_clone(), count_clone()];
for _ in xs.iter().cloned().zip(ys.iter().cloned()) {}
assert_eq!(&xs, &[1, 1, 1, 0][..]);
assert_eq!(&ys, &[1, 1][..]);
let xs = [count_clone(), count_clone()];
let ys = [count_clone(), count_clone(), count_clone(), count_clone()];
for _ in xs.iter().cloned().zip(ys.iter().cloned()) {}
assert_eq!(&xs, &[1, 1][..]);
assert_eq!(&ys, &[1, 1, 0, 0][..]);
}
#[test]
fn test_zip_map_sideffectful() {
let mut xs = [0; 6];
let mut ys = [0; 4];
for _ in xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1)) {}
assert_eq!(&xs, &[1, 1, 1, 1, 1, 0]);
assert_eq!(&ys, &[1, 1, 1, 1]);
let mut xs = [0; 4];
let mut ys = [0; 6];
for _ in xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1)) {}
assert_eq!(&xs, &[1, 1, 1, 1]);
assert_eq!(&ys, &[1, 1, 1, 1, 0, 0]);
}
#[test]
fn test_zip_map_rev_sideffectful() {
let mut xs = [0; 6];
let mut ys = [0; 4];
{
let mut it = xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1));
it.next_back();
}
assert_eq!(&xs, &[0, 0, 0, 1, 1, 1]);
assert_eq!(&ys, &[0, 0, 0, 1]);
let mut xs = [0; 6];
let mut ys = [0; 4];
{
let mut it = xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1));
(&mut it).take(5).count();
it.next_back();
}
assert_eq!(&xs, &[1, 1, 1, 1, 1, 1]);
assert_eq!(&ys, &[1, 1, 1, 1]);
}
#[test]
fn test_zip_nested_sideffectful() {
let mut xs = [0; 6];
let ys = [0; 4];
{
// test that it has the side effect nested inside enumerate
let it = xs.iter_mut().map(|x| *x = 1).enumerate().zip(&ys);
it.count();
}
assert_eq!(&xs, &[1, 1, 1, 1, 1, 0]);
}
#[test]
fn test_zip_nth_back_side_effects_exhausted() {
let mut a = Vec::new();

30
library/core/tests/option.rs
View File

@ -1,3 +1,4 @@
use core::cell::Cell;
use core::clone::Clone;
use core::mem;
use core::ops::DerefMut;
@ -372,3 +373,32 @@ fn option_const() {
const IS_NONE: bool = OPTION.is_none();
assert!(!IS_NONE);
}
#[test]
fn test_unwrap_drop() {
struct Dtor<'a> {
x: &'a Cell<isize>,
}
impl<'a> std::ops::Drop for Dtor<'a> {
fn drop(&mut self) {
self.x.set(self.x.get() - 1);
}
}
fn unwrap<T>(o: Option<T>) -> T {
match o {
Some(v) => v,
None => panic!(),
}
}
let x = &Cell::new(1);
{
let b = Some(Dtor { x });
let _c = unwrap(b);
}
assert_eq!(x.get(), 0);
}

28
library/core/tests/slice.rs
View File

@ -1,3 +1,4 @@
use core::cell::Cell;
use core::result::Result::{Err, Ok};
#[test]
@ -1980,3 +1981,30 @@ fn test_is_sorted() {
assert!(!["c", "bb", "aaa"].is_sorted());
assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));
}
#[test]
fn test_slice_run_destructors() {
// Make sure that destructors get run on slice literals
struct Foo<'a> {
x: &'a Cell<isize>,
}
impl<'a> Drop for Foo<'a> {
fn drop(&mut self) {
self.x.set(self.x.get() + 1);
}
}
fn foo(x: &Cell<isize>) -> Foo<'_> {
Foo { x }
}
let x = &Cell::new(0);
{
let l = &[foo(x)];
assert_eq!(l[0].x.get(), 0);
}
assert_eq!(x.get(), 1);
}

1
library/proc_macro/src/lib.rs
View File

@ -21,6 +21,7 @@
#![feature(nll)]
#![feature(staged_api)]
#![feature(const_fn)]
#![cfg_attr(not(bootstrap), feature(const_fn_fn_ptr_basics))]
#![feature(allow_internal_unstable)]
#![feature(decl_macro)]
#![feature(extern_types)]

1
library/std/src/lib.rs
View File

@ -239,6 +239,7 @@
#![cfg_attr(not(bootstrap), feature(const_fn_floating_point_arithmetic))]
#![feature(const_fn_transmute)]
#![feature(const_fn)]
#![cfg_attr(not(bootstrap), feature(const_fn_fn_ptr_basics))]
#![feature(const_ip)]
#![feature(const_ipv6)]
#![feature(const_raw_ptr_deref)]

3
library/std/src/panic.rs
View File

@ -411,3 +411,6 @@ pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
pub fn resume_unwind(payload: Box<dyn Any + Send>) -> ! {
panicking::rust_panic_without_hook(payload)
}
#[cfg(test)]
mod tests;

23
src/test/ui/panics/panic-safe.rs → library/std/src/panic/tests.rs
View File

@ -1,16 +1,18 @@
// run-pass
#![allow(dead_code)]
use std::panic::{UnwindSafe, AssertUnwindSafe};
use std::cell::RefCell;
use std::sync::{Mutex, RwLock, Arc};
use std::rc::Rc;
use crate::cell::RefCell;
use crate::panic::{AssertUnwindSafe, UnwindSafe};
use crate::rc::Rc;
use crate::sync::{Arc, Mutex, RwLock};
struct Foo { a: i32 }
struct Foo {
a: i32,
}
fn assert<T: UnwindSafe + ?Sized>() {}
fn main() {
#[test]
fn panic_safety_traits() {
assert::<i32>();
assert::<&i32>();
assert::<*mut i32>();
@ -32,13 +34,16 @@ fn main() {
assert::<Arc<i32>>();
assert::<Box<[u8]>>();
trait Trait: UnwindSafe {}
assert::<Box<dyn Trait>>();
{
trait Trait: UnwindSafe {}
assert::<Box<dyn Trait>>();
}
fn bar<T>() {
assert::<Mutex<T>>();
assert::<RwLock<T>>();
}
fn baz<T: UnwindSafe>() {
assert::<Box<T>>();
assert::<Vec<T>>();

99
library/std/src/sys/unix/mod.rs
View File

@ -93,60 +93,61 @@ pub fn init() {
reset_sigpipe();
}
// In the case when all file descriptors are open, the poll has been
// observed to perform better than fcntl (on GNU/Linux).
#[cfg(not(any(
miri,
target_os = "emscripten",
target_os = "fuchsia",
// The poll on Darwin doesn't set POLLNVAL for closed fds.
target_os = "macos",
target_os = "ios",
target_os = "redox",
)))]
unsafe fn sanitize_standard_fds() {
use crate::sys::os::errno;
let pfds: &mut [_] = &mut [
libc::pollfd { fd: 0, events: 0, revents: 0 },
libc::pollfd { fd: 1, events: 0, revents: 0 },
libc::pollfd { fd: 2, events: 0, revents: 0 },
];
while libc::poll(pfds.as_mut_ptr(), 3, 0) == -1 {
if errno() == libc::EINTR {
continue;
}
libc::abort();
}
for pfd in pfds {
if pfd.revents & libc::POLLNVAL == 0 {
continue;
}
if libc::open("/dev/null\0".as_ptr().cast(), libc::O_RDWR, 0) == -1 {
// If the stream is closed but we failed to reopen it, abort the
// process. Otherwise we wouldn't preserve the safety of
// operations on the corresponding Rust object Stdin, Stdout, or
// Stderr.
libc::abort();
}
}
}
#[cfg(any(target_os = "macos", target_os = "ios", target_os = "redox"))]
unsafe fn sanitize_standard_fds() {
use crate::sys::os::errno;
for fd in 0..3 {
if libc::fcntl(fd, libc::F_GETFD) == -1 && errno() == libc::EBADF {
if libc::open("/dev/null\0".as_ptr().cast(), libc::O_RDWR, 0) == -1 {
cfg_if::cfg_if! {
if #[cfg(miri)] {
// The standard fds are always available in Miri.
unsafe fn sanitize_standard_fds() {}
} else if #[cfg(not(any(
target_os = "emscripten",
target_os = "fuchsia",
// The poll on Darwin doesn't set POLLNVAL for closed fds.
target_os = "macos",
target_os = "ios",
target_os = "redox",
)))] {
// In the case when all file descriptors are open, the poll has been
// observed to perform better than fcntl (on GNU/Linux).
unsafe fn sanitize_standard_fds() {
use crate::sys::os::errno;
let pfds: &mut [_] = &mut [
libc::pollfd { fd: 0, events: 0, revents: 0 },
libc::pollfd { fd: 1, events: 0, revents: 0 },
libc::pollfd { fd: 2, events: 0, revents: 0 },
];
while libc::poll(pfds.as_mut_ptr(), 3, 0) == -1 {
if errno() == libc::EINTR {
continue;
}
libc::abort();
}
for pfd in pfds {
if pfd.revents & libc::POLLNVAL == 0 {
continue;
}
if libc::open("/dev/null\0".as_ptr().cast(), libc::O_RDWR, 0) == -1 {
// If the stream is closed but we failed to reopen it, abort the
// process. Otherwise we wouldn't preserve the safety of
// operations on the corresponding Rust object Stdin, Stdout, or
// Stderr.
libc::abort();
}
}
}
} else if #[cfg(any(target_os = "macos", target_os = "ios", target_os = "redox"))] {
unsafe fn sanitize_standard_fds() {
use crate::sys::os::errno;
for fd in 0..3 {
if libc::fcntl(fd, libc::F_GETFD) == -1 && errno() == libc::EBADF {
if libc::open("/dev/null\0".as_ptr().cast(), libc::O_RDWR, 0) == -1 {
libc::abort();
}
}
}
}
} else {
unsafe fn sanitize_standard_fds() {}
}
}
#[cfg(any(
// The standard fds are always available in Miri.
miri,
target_os = "emscripten",
target_os = "fuchsia"))]
unsafe fn sanitize_standard_fds() {}
#[cfg(not(any(target_os = "emscripten", target_os = "fuchsia")))]
unsafe fn reset_sigpipe() {

2
src/doc/unstable-book/src/library-features/asm.md
View File

@ -410,7 +410,7 @@ reg_spec := <register class> / "<explicit register>"
operand_expr := expr / "_" / expr "=>" expr / expr "=>" "_"
reg_operand := dir_spec "(" reg_spec ")" operand_expr
operand := reg_operand / "const" const_expr / "sym" path
option := "pure" / "nomem" / "readonly" / "preserves_flags" / "noreturn" / "att_syntax"
option := "pure" / "nomem" / "readonly" / "preserves_flags" / "noreturn" / "nostack" / "att_syntax"
options := "options(" option *["," option] [","] ")"
asm := "asm!(" format_string *("," format_string) *("," [ident "="] operand) ["," options] [","] ")"
```

1
src/librustdoc/core.rs
View File

@ -419,6 +419,7 @@ pub fn run_core(
(rustc_interface::DEFAULT_QUERY_PROVIDERS.typeck)(tcx, def_id)
};
}),
make_codegen_backend: None,
registry: rustc_driver::diagnostics_registry(),
};

1
src/librustdoc/doctest.rs
View File

@ -95,6 +95,7 @@ pub fn run(options: Options) -> Result<(), ErrorReported> {
lint_caps,
register_lints: None,
override_queries: None,
make_codegen_backend: None,
registry: rustc_driver::diagnostics_registry(),
};

1
src/test/run-make-fulldeps/issue-19371/foo.rs
View File

@ -60,6 +60,7 @@ fn compile(code: String, output: PathBuf, sysroot: PathBuf) {
lint_caps: Default::default(),
register_lints: None,
override_queries: None,
make_codegen_backend: None,
registry: rustc_driver::diagnostics_registry(),
};

8
src/test/ui-fulldeps/compiler-calls.rs
View File

@ -26,7 +26,13 @@ fn main() {
let mut count = 1;
let args = vec!["compiler-calls".to_string(), "foo.rs".to_string()];
rustc_driver::catch_fatal_errors(|| {
rustc_driver::run_compiler(&args, &mut TestCalls { count: &mut count }, None, None).ok();
rustc_driver::run_compiler(
&args,
&mut TestCalls { count: &mut count },
None,
None,
None,
).ok();
}).ok();
assert_eq!(count, 2);
}

31
src/test/ui/array-slice-vec/arr_cycle.rs
View File

@ -1,31 +0,0 @@
// run-pass
use std::cell::Cell;
#[derive(Debug)]
struct B<'a> {
a: [Cell<Option<&'a B<'a>>>; 2]
}
impl<'a> B<'a> {
fn new() -> B<'a> {
B { a: [Cell::new(None), Cell::new(None)] }
}
}
fn f() {
let (b1, b2, b3);
b1 = B::new();
b2 = B::new();
b3 = B::new();
b1.a[0].set(Some(&b2));
b1.a[1].set(Some(&b3));
b2.a[0].set(Some(&b2));
b2.a[1].set(Some(&b3));
b3.a[0].set(Some(&b1));
b3.a[1].set(Some(&b2));
}
fn main() {
f();
}

31
src/test/ui/array-slice-vec/vec-slice-drop.rs
View File

@ -1,31 +0,0 @@
// run-pass
#![allow(non_camel_case_types)]
use std::cell::Cell;
// Make sure that destructors get run on slice literals
struct foo<'a> {
x: &'a Cell<isize>,
}
impl<'a> Drop for foo<'a> {
fn drop(&mut self) {
self.x.set(self.x.get() + 1);
}
}
fn foo(x: &Cell<isize>) -> foo {
foo {
x: x
}
}
pub fn main() {
let x = &Cell::new(0);
{
let l = &[foo(x)];
assert_eq!(l[0].x.get(), 0);
}
assert_eq!(x.get(), 1);
}

39
src/test/ui/array-slice-vec/vec_cycle.rs
View File

@ -1,39 +0,0 @@
// run-pass
use std::cell::Cell;
#[derive(Debug)]
struct C<'a> {
v: Vec<Cell<Option<&'a C<'a>>>>,
}
impl<'a> C<'a> {
fn new() -> C<'a> {
C { v: Vec::new() }
}
}
fn f() {
let (mut c1, mut c2, mut c3);
c1 = C::new();
c2 = C::new();
c3 = C::new();
c1.v.push(Cell::new(None));
c1.v.push(Cell::new(None));
c2.v.push(Cell::new(None));
c2.v.push(Cell::new(None));
c3.v.push(Cell::new(None));
c3.v.push(Cell::new(None));
c1.v[0].set(Some(&c2));
c1.v[1].set(Some(&c3));
c2.v[0].set(Some(&c2));
c2.v[1].set(Some(&c3));
c3.v[0].set(Some(&c1));
c3.v[1].set(Some(&c2));
}
fn main() {
f();
}

50
src/test/ui/array-slice-vec/vec_cycle_wrapped.rs
View File

@ -1,50 +0,0 @@
// run-pass
use std::cell::Cell;
#[derive(Debug)]
struct Refs<'a> {
v: Vec<Cell<Option<&'a C<'a>>>>,
}
#[derive(Debug)]
struct C<'a> {
refs: Refs<'a>,
}
impl<'a> Refs<'a> {
fn new() -> Refs<'a> {
Refs { v: Vec::new() }
}
}
impl<'a> C<'a> {
fn new() -> C<'a> {
C { refs: Refs::new() }
}
}
fn f() {
let (mut c1, mut c2, mut c3);
c1 = C::new();
c2 = C::new();
c3 = C::new();
c1.refs.v.push(Cell::new(None));
c1.refs.v.push(Cell::new(None));
c2.refs.v.push(Cell::new(None));
c2.refs.v.push(Cell::new(None));
c3.refs.v.push(Cell::new(None));
c3.refs.v.push(Cell::new(None));
c1.refs.v[0].set(Some(&c2));
c1.refs.v[1].set(Some(&c3));
c2.refs.v[0].set(Some(&c2));
c2.refs.v[1].set(Some(&c3));
c3.refs.v[0].set(Some(&c1));
c3.refs.v[1].set(Some(&c2));
}
fn main() {
f();
}

26
src/test/ui/cell-does-not-clone.rs
View File

@ -1,26 +0,0 @@
// run-pass
#![allow(dead_code)]
use std::cell::Cell;
#[derive(Copy)]
struct Foo {
x: isize
}
impl Clone for Foo {
fn clone(&self) -> Foo {
// Using Cell in any way should never cause clone() to be
// invoked -- after all, that would permit evil user code to
// abuse `Cell` and trigger crashes.
panic!();
}
}
pub fn main() {
let x = Cell::new(Foo { x: 22 });
let _y = x.get();
let _z = x.clone();
}

2
src/test/ui/consts/auxiliary/const_fn_lib.rs
View File

@ -1,6 +1,6 @@
// Crate that exports a const fn. Used for testing cross-crate.
#![feature(const_fn)]
#![feature(const_fn_fn_ptr_basics)]
#![crate_type="rlib"]
pub const fn foo() -> usize { 22 }

14
src/test/ui/consts/const-eval/const_fn_ptr.stderr
View File

@ -10,11 +10,23 @@ help: skipping check that does not even have a feature gate
|
LL | X_CONST(x)
| ^^^^^^^^^^
help: skipping check for `const_fn_fn_ptr_basics` feature
--> $DIR/const_fn_ptr.rs:19:14
|
LL | const fn foo(x: fn(usize) -> usize, y: usize) -> usize {
| ^
help: skipping check for `const_fn_fn_ptr_basics` feature
--> $DIR/const_fn_ptr.rs:20:5
|
LL | x(y)
| ^
help: skipping check that does not even have a feature gate
--> $DIR/const_fn_ptr.rs:20:5
|
LL | x(y)
| ^^^^
warning: 1 warning emitted
error: `-Zunleash-the-miri-inside-of-you` may not be used to circumvent feature gates, except when testing error paths in the CTFE engine
error: aborting due to previous error; 1 warning emitted

10
src/test/ui/consts/const-eval/const_fn_ptr_fail2.stderr
View File

@ -20,6 +20,16 @@ LL | assert_eq!(Z, 4);
warning: skipping const checks
|
help: skipping check for `const_fn_fn_ptr_basics` feature
--> $DIR/const_fn_ptr_fail2.rs:12:14
|
LL | const fn bar(x: fn(usize) -> usize, y: usize) -> usize {
| ^
help: skipping check for `const_fn_fn_ptr_basics` feature
--> $DIR/const_fn_ptr_fail2.rs:13:5
|
LL | x(y)
| ^
help: skipping check that does not even have a feature gate
--> $DIR/const_fn_ptr_fail2.rs:13:5
|

2
src/test/ui/consts/const-eval/issue-70804-fn-subtyping.rs
View File

@ -1,5 +1,5 @@
// check-pass
#![feature(const_fn)]
#![feature(const_fn_fn_ptr_basics)]
const fn nested(x: (for<'a> fn(&'a ()), String)) -> (fn(&'static ()), String) {
x

2
src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.rs
View File

@ -2,7 +2,7 @@
const extern fn unsize(x: &[u8; 3]) -> &[u8] { x }
const unsafe extern "C" fn closure() -> fn() { || {} }
//~^ ERROR function pointers in const fn are unstable
//~^ ERROR function pointer
const unsafe extern fn use_float() { 1.0 + 1.0; }
//~^ ERROR floating point arithmetic
const extern "C" fn ptr_cast(val: *const u8) { val as usize; }

7
src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr
View File

@ -1,11 +1,11 @@
error[E0723]: function pointers in const fn are unstable
error[E0658]: function pointers cannot appear in constant functions
--> $DIR/const-extern-fn-min-const-fn.rs:4:41
|
LL | const unsafe extern "C" fn closure() -> fn() { || {} }
| ^^^^
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable
= help: add `#![feature(const_fn_fn_ptr_basics)]` to the crate attributes to enable
error[E0658]: floating point arithmetic is not allowed in constant functions
--> $DIR/const-extern-fn-min-const-fn.rs:6:38
@ -27,5 +27,4 @@ LL | const extern "C" fn ptr_cast(val: *const u8) { val as usize; }
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0658, E0723.
For more information about an error, try `rustc --explain E0658`.
For more information about this error, try `rustc --explain E0658`.

2
src/test/ui/consts/issue-37550.rs
View File

@ -2,7 +2,7 @@
#![allow(dead_code)]
#![allow(unused_variables)]
#![feature(const_fn)]
#![feature(const_fn_fn_ptr_basics)]
const fn x() {
let t = true;

7
src/test/ui/consts/issue-56164.rs
View File

@ -1,12 +1,11 @@
#![feature(const_fn)]
#![feature(const_fn_fn_ptr_basics)]
const fn foo() { (||{})() }
//~^ ERROR calls in constant functions are limited to constant functions, tuple structs and tuple
// variants
//~^ ERROR calls in constant functions
const fn bad(input: fn()) {
input()
//~^ ERROR function pointers are not allowed in const fn
//~^ ERROR function pointer
}
fn main() {

2
src/test/ui/consts/issue-56164.stderr
View File

@ -5,7 +5,7 @@ LL | const fn foo() { (||{})() }
| ^^^^^^^^
error: function pointers are not allowed in const fn
--> $DIR/issue-56164.rs:8:5
--> $DIR/issue-56164.rs:7:5
|
LL | input()
| ^^^^^^^

8
src/test/ui/consts/min_const_fn/allow_const_fn_ptr.rs
View File

@ -1,12 +1,14 @@
#![feature(rustc_attrs, staged_api)]
#![feature(rustc_attrs, staged_api, allow_internal_unstable)]
#![feature(const_fn_fn_ptr_basics)]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_stable(since="1.0.0", feature = "mep")]
const fn error(_: fn()) {} //~ ERROR function pointers in const fn are unstable
const fn error(_: fn()) {}
//~^ ERROR const-stable function cannot use `#[feature(const_fn_fn_ptr_basics)]`
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_allow_const_fn_ptr]
#[rustc_const_stable(since="1.0.0", feature = "mep")]
#[allow_internal_unstable(const_fn_fn_ptr_basics)]
const fn compiles(_: fn()) {}
fn main() {}

12
src/test/ui/consts/min_const_fn/allow_const_fn_ptr.stderr
View File

@ -1,12 +1,14 @@
error[E0723]: function pointers in const fn are unstable
--> $DIR/allow_const_fn_ptr.rs:5:16
error: const-stable function cannot use `#[feature(const_fn_fn_ptr_basics)]`
--> $DIR/allow_const_fn_ptr.rs:6:16
|
LL | const fn error(_: fn()) {}
| ^
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable
= note: otherwise `#[allow_internal_unstable]` can be used to bypass stability checks
help: if it is not part of the public API, make this function unstably const
|
LL | #[rustc_const_unstable(feature = "...", issue = "...")]
|
error: aborting due to previous error
For more information about this error, try `rustc --explain E0723`.

11
src/test/ui/consts/min_const_fn/allow_const_fn_ptr_feature_gate.rs
View File

@ -1,11 +0,0 @@
#![feature(staged_api)]
#[stable(feature = "rust1", since = "1.0.0")]
const fn error(_: fn()) {}
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_allow_const_fn_ptr]
//~^ ERROR internal implementation detail
const fn compiles(_: fn()) {}
fn main() {}

11
src/test/ui/consts/min_const_fn/allow_const_fn_ptr_feature_gate.stderr
View File

@ -1,11 +0,0 @@
error[E0658]: internal implementation detail
--> $DIR/allow_const_fn_ptr_feature_gate.rs:7:1
|
LL | #[rustc_allow_const_fn_ptr]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: add `#![feature(rustc_attrs)]` to the crate attributes to enable
error: aborting due to previous error
For more information about this error, try `rustc --explain E0658`.

4
src/test/ui/consts/min_const_fn/allow_const_fn_ptr_run_pass.rs
View File

@ -1,11 +1,13 @@
// run-pass
#![feature(allow_internal_unstable)]
#![feature(const_fn_fn_ptr_basics)]
#![feature(rustc_attrs, staged_api)]
#![stable(feature = "rust1", since = "1.0.0")]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_allow_const_fn_ptr]
#[rustc_const_stable(since="1.0.0", feature = "mep")]
#[allow_internal_unstable(const_fn_fn_ptr_basics)]
const fn takes_fn_ptr(_: fn()) {}
const FN: fn() = || ();

8
src/test/ui/consts/min_const_fn/cast_errors.rs
View File

@ -2,12 +2,12 @@ fn main() {}
const fn unsize(x: &[u8; 3]) -> &[u8] { x }
const fn closure() -> fn() { || {} }
//~^ ERROR function pointers in const fn are unstable
//~^ ERROR function pointer
const fn closure2() {
(|| {}) as fn();
//~^ ERROR function pointers in const fn are unstable
//~^ ERROR function pointer
}
const fn reify(f: fn()) -> unsafe fn() { f }
//~^ ERROR function pointers in const fn are unstable
//~^ ERROR function pointer
const fn reify2() { main as unsafe fn(); }
//~^ ERROR function pointers in const fn are unstable
//~^ ERROR function pointer

18
src/test/ui/consts/min_const_fn/cast_errors.stderr
View File

@ -1,39 +1,39 @@
error[E0723]: function pointers in const fn are unstable
error[E0658]: function pointers cannot appear in constant functions
--> $DIR/cast_errors.rs:4:23
|
LL | const fn closure() -> fn() { || {} }
| ^^^^
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable
= help: add `#![feature(const_fn_fn_ptr_basics)]` to the crate attributes to enable
error[E0723]: function pointers in const fn are unstable
error[E0658]: function pointers cannot appear in constant functions
--> $DIR/cast_errors.rs:7:5
|
LL | (|| {}) as fn();
| ^^^^^^^^^^^^^^^
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable
= help: add `#![feature(const_fn_fn_ptr_basics)]` to the crate attributes to enable
error[E0723]: function pointers in const fn are unstable
error[E0658]: function pointers cannot appear in constant functions
--> $DIR/cast_errors.rs:10:28
|
LL | const fn reify(f: fn()) -> unsafe fn() { f }
| ^^^^^^^^^^^
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable
= help: add `#![feature(const_fn_fn_ptr_basics)]` to the crate attributes to enable
error[E0723]: function pointers in const fn are unstable
error[E0658]: function pointers cannot appear in constant functions
--> $DIR/cast_errors.rs:12:21
|
LL | const fn reify2() { main as unsafe fn(); }
| ^^^^^^^^^^^^^^^^^^^
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable
= help: add `#![feature(const_fn_fn_ptr_basics)]` to the crate attributes to enable
error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0723`.
For more information about this error, try `rustc --explain E0658`.

2
src/test/ui/consts/min_const_fn/cmp_fn_pointers.rs
View File

@ -1,4 +1,4 @@
const fn cmp(x: fn(), y: fn()) -> bool { //~ ERROR function pointers in const fn are unstable
const fn cmp(x: fn(), y: fn()) -> bool { //~ ERROR function pointer
unsafe { x == y }
}

6
src/test/ui/consts/min_const_fn/cmp_fn_pointers.stderr
View File

@ -1,12 +1,12 @@
error[E0723]: function pointers in const fn are unstable
error[E0658]: function pointers cannot appear in constant functions
--> $DIR/cmp_fn_pointers.rs:1:14
|
LL | const fn cmp(x: fn(), y: fn()) -> bool {
| ^
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable
= help: add `#![feature(const_fn_fn_ptr_basics)]` to the crate attributes to enable
error: aborting due to previous error
For more information about this error, try `rustc --explain E0723`.
For more information about this error, try `rustc --explain E0658`.

4
src/test/ui/consts/min_const_fn/min_const_fn.rs
View File

@ -128,6 +128,6 @@ const fn really_no_traits_i_mean_it() { (&() as &dyn std::fmt::Debug, ()).1 }
//~^ ERROR trait bounds other than `Sized`
const fn no_fn_ptrs(_x: fn()) {}
//~^ ERROR function pointers in const fn are unstable
//~^ ERROR function pointer
const fn no_fn_ptrs2() -> fn() { fn foo() {} foo }
//~^ ERROR function pointers in const fn are unstable
//~^ ERROR function pointer

8
src/test/ui/consts/min_const_fn/min_const_fn.stderr
View File

@ -209,23 +209,23 @@ LL | const fn really_no_traits_i_mean_it() { (&() as &dyn std::fmt::Debug, ()).1
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable
error[E0723]: function pointers in const fn are unstable
error[E0658]: function pointers cannot appear in constant functions
--> $DIR/min_const_fn.rs:130:21
|
LL | const fn no_fn_ptrs(_x: fn()) {}
| ^^
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable
= help: add `#![feature(const_fn_fn_ptr_basics)]` to the crate attributes to enable
error[E0723]: function pointers in const fn are unstable
error[E0658]: function pointers cannot appear in constant functions
--> $DIR/min_const_fn.rs:132:27
|
LL | const fn no_fn_ptrs2() -> fn() { fn foo() {} foo }
| ^^^^
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable
= help: add `#![feature(const_fn_fn_ptr_basics)]` to the crate attributes to enable
error: aborting due to 26 previous errors

6
src/test/ui/consts/min_const_fn/min_const_fn_fn_ptr.rs
View File

@ -1,3 +1,5 @@
// gate-test-const_fn_fn_ptr_basics
struct HasPtr {
field: fn(),
}
@ -9,9 +11,9 @@ fn field() {}
const fn no_inner_dyn_trait(_x: Hide) {}
const fn no_inner_dyn_trait2(x: Hide) {
x.0.field;
//~^ ERROR function pointers in const fn
//~^ ERROR function pointer
}
const fn no_inner_dyn_trait_ret() -> Hide { Hide(HasPtr { field }) }
//~^ ERROR function pointers in const fn
//~^ ERROR function pointer
fn main() {}

14
src/test/ui/consts/min_const_fn/min_const_fn_fn_ptr.stderr
View File

@ -1,21 +1,21 @@
error[E0723]: function pointers in const fn are unstable
--> $DIR/min_const_fn_fn_ptr.rs:11:5
error[E0658]: function pointers cannot appear in constant functions
--> $DIR/min_const_fn_fn_ptr.rs:13:5
|
LL | x.0.field;
| ^^^^^^^^^
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable
= help: add `#![feature(const_fn_fn_ptr_basics)]` to the crate attributes to enable
error[E0723]: function pointers in const fn are unstable
--> $DIR/min_const_fn_fn_ptr.rs:14:59
error[E0658]: function pointers cannot appear in constant functions
--> $DIR/min_const_fn_fn_ptr.rs:16:59
|
LL | const fn no_inner_dyn_trait_ret() -> Hide { Hide(HasPtr { field }) }
| ^^^^^
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable
= help: add `#![feature(const_fn_fn_ptr_basics)]` to the crate attributes to enable
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0723`.
For more information about this error, try `rustc --explain E0658`.

4
src/test/ui/consts/miri_unleashed/abi-mismatch.stderr
View File

@ -12,12 +12,12 @@ LL | static VAL: () = call_rust_fn(unsafe { std::mem::transmute(c_fn as extern "
warning: skipping const checks
|
help: skipping check for `const_fn` feature
help: skipping check for `const_fn_fn_ptr_basics` feature
--> $DIR/abi-mismatch.rs:9:23
|
LL | const fn call_rust_fn(my_fn: extern "Rust" fn()) {
| ^^^^^
help: skipping check for `const_fn` feature
help: skipping check for `const_fn_fn_ptr_basics` feature
--> $DIR/abi-mismatch.rs:10:5
|
LL | my_fn();

11
src/test/ui/deref-lval.rs
View File

@ -1,11 +0,0 @@
// run-pass
#![feature(box_syntax)]
use std::cell::Cell;
pub fn main() {
let x: Box<_> = box Cell::new(5);
x.set(1000);
println!("{}", x.get());
}

24
src/test/ui/exterior.rs
View File

@ -1,24 +0,0 @@
// run-pass
#![allow(dead_code)]
use std::cell::Cell;
#[derive(Copy, Clone)]
struct Point {x: isize, y: isize, z: isize}
fn f(p: &Cell<Point>) {
assert_eq!(p.get().z, 12);
p.set(Point {x: 10, y: 11, z: 13});
assert_eq!(p.get().z, 13);
}
pub fn main() {
let a: Point = Point {x: 10, y: 11, z: 12};
let b: &Cell<Point> = &Cell::new(a);
assert_eq!(b.get().z, 12);
f(b);
assert_eq!(a.z, 12);
assert_eq!(b.get().z, 13);
}

10
src/test/ui/format-ref-cell.rs
View File

@ -1,10 +0,0 @@
// run-pass
use std::cell::RefCell;
pub fn main() {
let name = RefCell::new("rust");
let what = RefCell::new("rocks");
let msg = format!("{name} {}", &*what.borrow(), name=&*name.borrow());
assert_eq!(msg, "rust rocks".to_string());
}

319
src/test/ui/ifmt.rs
View File

@ -1,319 +0,0 @@
// run-pass
#![deny(warnings)]
#![allow(unused_must_use)]
#![allow(unused_features)]
#![feature(box_syntax)]
use std::cell::RefCell;
use std::fmt::{self, Write};
use std::usize;
struct A;
struct B;
struct C;
struct D;
impl fmt::LowerHex for A {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str("aloha")
}
}
impl fmt::UpperHex for B {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str("adios")
}
}
impl fmt::Display for C {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.pad_integral(true, "☃", "123")
}
}
impl fmt::Binary for D {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str("aa")?;
f.write_char('☃')?;
f.write_str("bb")
}
}
macro_rules! t {
($a:expr, $b:expr) => { assert_eq!($a, $b) }
}
pub fn main() {
// Various edge cases without formats
t!(format!(""), "");
t!(format!("hello"), "hello");
t!(format!("hello {{"), "hello {");
// default formatters should work
t!(format!("{}", 1.0f32), "1");
t!(format!("{}", 1.0f64), "1");
t!(format!("{}", "a"), "a");
t!(format!("{}", "a".to_string()), "a");
t!(format!("{}", false), "false");
t!(format!("{}", 'a'), "a");
// At least exercise all the formats
t!(format!("{}", true), "true");
t!(format!("{}", '☃'), "☃");
t!(format!("{}", 10), "10");
t!(format!("{}", 10_usize), "10");
t!(format!("{:?}", '☃'), "'☃'");
t!(format!("{:?}", 10), "10");
t!(format!("{:?}", 10_usize), "10");
t!(format!("{:?}", "true"), "\"true\"");
t!(format!("{:?}", "foo\nbar"), "\"foo\\nbar\"");
t!(format!("{:?}", "foo\n\"bar\"\r\n\'baz\'\t\\qux\\"),
r#""foo\n\"bar\"\r\n\'baz\'\t\\qux\\""#);
t!(format!("{:?}", "foo\0bar\x01baz\u{7f}q\u{75}x"),
r#""foo\u{0}bar\u{1}baz\u{7f}qux""#);
t!(format!("{:o}", 10_usize), "12");
t!(format!("{:x}", 10_usize), "a");
t!(format!("{:X}", 10_usize), "A");
t!(format!("{}", "foo"), "foo");
t!(format!("{}", "foo".to_string()), "foo");
if cfg!(target_pointer_width = "32") {
t!(format!("{:#p}", 0x1234 as *const isize), "0x00001234");
t!(format!("{:#p}", 0x1234 as *mut isize), "0x00001234");
} else {
t!(format!("{:#p}", 0x1234 as *const isize), "0x0000000000001234");
t!(format!("{:#p}", 0x1234 as *mut isize), "0x0000000000001234");
}
t!(format!("{:p}", 0x1234 as *const isize), "0x1234");
t!(format!("{:p}", 0x1234 as *mut isize), "0x1234");
t!(format!("{:x}", A), "aloha");
t!(format!("{:X}", B), "adios");
t!(format!("foo {} ☃☃☃☃☃☃", "bar"), "foo bar ☃☃☃☃☃☃");
t!(format!("{1} {0}", 0, 1), "1 0");
t!(format!("{foo} {bar}", foo=0, bar=1), "0 1");
t!(format!("{foo} {1} {bar} {0}", 0, 1, foo=2, bar=3), "2 1 3 0");
t!(format!("{} {0}", "a"), "a a");
t!(format!("{_foo}", _foo = 6usize), "6");
t!(format!("{foo_bar}", foo_bar=1), "1");
t!(format!("{}", 5 + 5), "10");
t!(format!("{:#4}", C), "☃123");
t!(format!("{:b}", D), "aa☃bb");
let a: &dyn fmt::Debug = &1;
t!(format!("{:?}", a), "1");
// Formatting strings and their arguments
t!(format!("{}", "a"), "a");
t!(format!("{:4}", "a"), "a ");
t!(format!("{:4}", "☃"), "☃ ");
t!(format!("{:>4}", "a"), " a");
t!(format!("{:<4}", "a"), "a ");
t!(format!("{:^5}", "a"), " a ");
t!(format!("{:^5}", "aa"), " aa ");
t!(format!("{:^4}", "a"), " a ");
t!(format!("{:^4}", "aa"), " aa ");
t!(format!("{:.4}", "a"), "a");
t!(format!("{:4.4}", "a"), "a ");
t!(format!("{:4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
t!(format!("{:<4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
t!(format!("{:>4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
t!(format!("{:^4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
t!(format!("{:>10.4}", "aaaaaaaaaaaaaaaaaa"), " aaaa");
t!(format!("{:2.4}", "aaaaa"), "aaaa");
t!(format!("{:2.4}", "aaaa"), "aaaa");
t!(format!("{:2.4}", "aaa"), "aaa");
t!(format!("{:2.4}", "aa"), "aa");
t!(format!("{:2.4}", "a"), "a ");
t!(format!("{:0>2}", "a"), "0a");
t!(format!("{:.*}", 4, "aaaaaaaaaaaaaaaaaa"), "aaaa");
t!(format!("{:.1$}", "aaaaaaaaaaaaaaaaaa", 4), "aaaa");
t!(format!("{:.a$}", "aaaaaaaaaaaaaaaaaa", a=4), "aaaa");
t!(format!("{:._a$}", "aaaaaaaaaaaaaaaaaa", _a=4), "aaaa");
t!(format!("{:1$}", "a", 4), "a ");
t!(format!("{1:0$}", 4, "a"), "a ");
t!(format!("{:a$}", "a", a=4), "a ");
t!(format!("{:-#}", "a"), "a");
t!(format!("{:+#}", "a"), "a");
t!(format!("{:/^10.8}", "1234567890"), "/12345678/");
// Some float stuff
t!(format!("{:}", 1.0f32), "1");
t!(format!("{:}", 1.0f64), "1");
t!(format!("{:.3}", 1.0f64), "1.000");
t!(format!("{:10.3}", 1.0f64), " 1.000");
t!(format!("{:+10.3}", 1.0f64), " +1.000");
t!(format!("{:+10.3}", -1.0f64), " -1.000");
t!(format!("{:e}", 1.2345e6f32), "1.2345e6");
t!(format!("{:e}", 1.2345e6f64), "1.2345e6");
t!(format!("{:E}", 1.2345e6f64), "1.2345E6");
t!(format!("{:.3e}", 1.2345e6f64), "1.234e6");
t!(format!("{:10.3e}", 1.2345e6f64), " 1.234e6");
t!(format!("{:+10.3e}", 1.2345e6f64), " +1.234e6");
t!(format!("{:+10.3e}", -1.2345e6f64), " -1.234e6");
// Float edge cases
t!(format!("{}", -0.0), "0");
t!(format!("{:?}", -0.0), "-0.0");
t!(format!("{:?}", 0.0), "0.0");
// sign aware zero padding
t!(format!("{:<3}", 1), "1 ");
t!(format!("{:>3}", 1), " 1");
t!(format!("{:^3}", 1), " 1 ");
t!(format!("{:03}", 1), "001");
t!(format!("{:<03}", 1), "001");
t!(format!("{:>03}", 1), "001");
t!(format!("{:^03}", 1), "001");
t!(format!("{:+03}", 1), "+01");
t!(format!("{:<+03}", 1), "+01");
t!(format!("{:>+03}", 1), "+01");
t!(format!("{:^+03}", 1), "+01");
t!(format!("{:#05x}", 1), "0x001");
t!(format!("{:<#05x}", 1), "0x001");
t!(format!("{:>#05x}", 1), "0x001");
t!(format!("{:^#05x}", 1), "0x001");
t!(format!("{:05}", 1.2), "001.2");
t!(format!("{:<05}", 1.2), "001.2");
t!(format!("{:>05}", 1.2), "001.2");
t!(format!("{:^05}", 1.2), "001.2");
t!(format!("{:05}", -1.2), "-01.2");
t!(format!("{:<05}", -1.2), "-01.2");
t!(format!("{:>05}", -1.2), "-01.2");
t!(format!("{:^05}", -1.2), "-01.2");
t!(format!("{:+05}", 1.2), "+01.2");
t!(format!("{:<+05}", 1.2), "+01.2");
t!(format!("{:>+05}", 1.2), "+01.2");
t!(format!("{:^+05}", 1.2), "+01.2");
// Ergonomic format_args!
t!(format!("{0:x} {0:X}", 15), "f F");
t!(format!("{0:x} {0:X} {}", 15), "f F 15");
t!(format!("{:x}{0:X}{a:x}{:X}{1:x}{a:X}", 13, 14, a=15), "dDfEeF");
t!(format!("{a:x} {a:X}", a=15), "f F");
// And its edge cases
t!(format!("{a:.0$} {b:.0$} {0:.0$}\n{a:.c$} {b:.c$} {c:.c$}",
4, a="abcdefg", b="hijklmn", c=3),
"abcd hijk 4\nabc hij 3");
t!(format!("{a:.*} {0} {:.*}", 4, 3, "efgh", a="abcdef"), "abcd 4 efg");
t!(format!("{:.a$} {a} {a:#x}", "aaaaaa", a=2), "aa 2 0x2");
// Test that pointers don't get truncated.
{
let val = usize::MAX;
let exp = format!("{:#x}", val);
t!(format!("{:p}", val as *const isize), exp);
}
// Escaping
t!(format!("{{"), "{");
t!(format!("}}"), "}");
test_write();
test_print();
test_order();
test_once();
// make sure that format! doesn't move out of local variables
let a: Box<_> = box 3;
format!("{}", a);
format!("{}", a);
// make sure that format! doesn't cause spurious unused-unsafe warnings when
// it's inside of an outer unsafe block
unsafe {
let a: isize = ::std::mem::transmute(3_usize);
format!("{}", a);
}
test_format_args();
// test that trailing commas are acceptable
format!("{}", "test",);
format!("{foo}", foo="test",);
test_refcell();
}
// Basic test to make sure that we can invoke the `write!` macro with an
// fmt::Write instance.
fn test_write() {
let mut buf = String::new();
write!(&mut buf, "{}", 3);
{
let w = &mut buf;
write!(w, "{foo}", foo=4);
write!(w, "{}", "hello");
writeln!(w, "{}", "line");
writeln!(w, "{foo}", foo="bar");
w.write_char('☃');
w.write_str("str");
}
t!(buf, "34helloline\nbar\n☃str");
}
// Just make sure that the macros are defined, there's not really a lot that we
// can do with them just yet (to test the output)
fn test_print() {
print!("hi");
print!("{:?}", vec![0u8]);
println!("hello");
println!("this is a {}", "test");
println!("{foo}", foo="bar");
}
// Just make sure that the macros are defined, there's not really a lot that we
// can do with them just yet (to test the output)
fn test_format_args() {
let mut buf = String::new();
{
let w = &mut buf;
write!(w, "{}", format_args!("{}", 1));
write!(w, "{}", format_args!("test"));
write!(w, "{}", format_args!("{test}", test=3));
}
let s = buf;
t!(s, "1test3");
let s = fmt::format(format_args!("hello {}", "world"));
t!(s, "hello world");
let s = format!("{}: {}", "args were", format_args!("hello {}", "world"));
t!(s, "args were: hello world");
}
fn test_order() {
// Make sure format!() arguments are always evaluated in a left-to-right
// ordering
fn foo() -> isize {
static mut FOO: isize = 0;
unsafe {
FOO += 1;
FOO
}
}
assert_eq!(format!("{} {} {a} {b} {} {c}",
foo(), foo(), foo(), a=foo(), b=foo(), c=foo()),
"1 2 4 5 3 6".to_string());
}
fn test_once() {
// Make sure each argument are evaluated only once even though it may be
// formatted multiple times
fn foo() -> isize {
static mut FOO: isize = 0;
unsafe {
FOO += 1;
FOO
}
}
assert_eq!(format!("{0} {0} {0} {a} {a} {a}", foo(), a=foo()),
"1 1 1 2 2 2".to_string());
}
fn test_refcell() {
let refcell = RefCell::new(5);
assert_eq!(format!("{:?}", refcell), "RefCell { value: 5 }");
let borrow = refcell.borrow_mut();
assert_eq!(format!("{:?}", refcell), "RefCell { value: <borrowed> }");
drop(borrow);
assert_eq!(format!("{:?}", refcell), "RefCell { value: 5 }");
}

2
src/test/ui/issues/issue-37550.rs
View File

@ -1,6 +1,6 @@
const fn x() {
let t = true;
let x = || t; //~ ERROR function pointers in const fn are unstable
let x = || t; //~ ERROR function pointer
}
fn main() {}

6
src/test/ui/issues/issue-37550.stderr
View File

@ -1,12 +1,12 @@
error[E0723]: function pointers in const fn are unstable
error[E0658]: function pointers cannot appear in constant functions
--> $DIR/issue-37550.rs:3:9
|
LL | let x = || t;
| ^
|
= note: see issue #57563 <https://github.com/rust-lang/rust/issues/57563> for more information
= help: add `#![feature(const_fn)]` to the crate attributes to enable
= help: add `#![feature(const_fn_fn_ptr_basics)]` to the crate attributes to enable
error: aborting due to previous error
For more information about this error, try `rustc --explain E0723`.
For more information about this error, try `rustc --explain E0658`.

2
src/test/ui/issues/issue-46553.rs
View File

@ -1,5 +1,5 @@
// run-pass
#![feature(const_fn)]
#![feature(const_fn_fn_ptr_basics)]
#![deny(const_err)]
pub struct Data<T> {

6
src/test/ui/issues/issue-51154.rs Normal file
View File

@ -0,0 +1,6 @@
fn foo<F: FnMut()>() {
let _: Box<F> = Box::new(|| ());
//~^ ERROR mismatched types
}
fn main() {}

15
src/test/ui/issues/issue-51154.stderr Normal file
View File

@ -0,0 +1,15 @@
error[E0308]: mismatched types
--> $DIR/issue-51154.rs:2:30
|
LL | fn foo<F: FnMut()>() {
| - this type parameter
LL | let _: Box<F> = Box::new(|| ());
| ^^^^^ expected type parameter `F`, found closure
|
= note: expected type parameter `F`
found closure `[closure@$DIR/issue-51154.rs:2:30: 2:35]`
= help: every closure has a distinct type and so could not always match the caller-chosen type of parameter `F`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0308`.

103
src/test/ui/iterators/iter-zip.rs
View File

@ -1,103 +0,0 @@
// run-pass
// Test that .zip() specialization preserves side effects
// in sideeffectful iterator adaptors.
use std::cell::Cell;
#[derive(Debug)]
struct CountClone(Cell<i32>);
fn count_clone() -> CountClone { CountClone(Cell::new(0)) }
impl PartialEq<i32> for CountClone {
fn eq(&self, rhs: &i32) -> bool {
self.0.get() == *rhs
}
}
impl Clone for CountClone {
fn clone(&self) -> Self {
let ret = CountClone(self.0.clone());
let n = self.0.get();
self.0.set(n + 1);
ret
}
}
fn test_zip_cloned_sideffectful() {
let xs = [count_clone(), count_clone(), count_clone(), count_clone()];
let ys = [count_clone(), count_clone()];
for _ in xs.iter().cloned().zip(ys.iter().cloned()) { }
assert_eq!(&xs, &[1, 1, 1, 0][..]);
assert_eq!(&ys, &[1, 1][..]);
let xs = [count_clone(), count_clone()];
let ys = [count_clone(), count_clone(), count_clone(), count_clone()];
for _ in xs.iter().cloned().zip(ys.iter().cloned()) { }
assert_eq!(&xs, &[1, 1][..]);
assert_eq!(&ys, &[1, 1, 0, 0][..]);
}
fn test_zip_map_sideffectful() {
let mut xs = [0; 6];
let mut ys = [0; 4];
for _ in xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1)) { }
assert_eq!(&xs, &[1, 1, 1, 1, 1, 0]);
assert_eq!(&ys, &[1, 1, 1, 1]);
let mut xs = [0; 4];
let mut ys = [0; 6];
for _ in xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1)) { }
assert_eq!(&xs, &[1, 1, 1, 1]);
assert_eq!(&ys, &[1, 1, 1, 1, 0, 0]);
}
fn test_zip_map_rev_sideffectful() {
let mut xs = [0; 6];
let mut ys = [0; 4];
{
let mut it = xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1));
it.next_back();
}
assert_eq!(&xs, &[0, 0, 0, 1, 1, 1]);
assert_eq!(&ys, &[0, 0, 0, 1]);
let mut xs = [0; 6];
let mut ys = [0; 4];
{
let mut it = xs.iter_mut().map(|x| *x += 1).zip(ys.iter_mut().map(|y| *y += 1));
(&mut it).take(5).count();
it.next_back();
}
assert_eq!(&xs, &[1, 1, 1, 1, 1, 1]);
assert_eq!(&ys, &[1, 1, 1, 1]);
}
fn test_zip_nested_sideffectful() {
let mut xs = [0; 6];
let ys = [0; 4];
{
// test that it has the side effect nested inside enumerate
let it = xs.iter_mut().map(|x| *x = 1).enumerate().zip(&ys);
it.count();
}
assert_eq!(&xs, &[1, 1, 1, 1, 1, 0]);
}
fn main() {
test_zip_cloned_sideffectful();
test_zip_map_sideffectful();
test_zip_map_rev_sideffectful();
test_zip_nested_sideffectful();
}

32
src/test/ui/option-unwrap.rs
View File

@ -1,32 +0,0 @@
// run-pass
#![allow(non_camel_case_types)]
use std::cell::Cell;
struct dtor<'a> {
x: &'a Cell<isize>,
}
impl<'a> Drop for dtor<'a> {
fn drop(&mut self) {
self.x.set(self.x.get() - 1);
}
}
fn unwrap<T>(o: Option<T>) -> T {
match o {
Some(v) => v,
None => panic!()
}
}
pub fn main() {
let x = &Cell::new(1);
{
let b = Some(dtor { x:x });
let _c = unwrap(b);
}
assert_eq!(x.get(), 0);
}

19
src/test/ui/rfc-2091-track-caller/caller-location-fnptr-rt-ctfe-equiv.stderr
View File

@ -1,10 +1,27 @@
warning: skipping const checks
|
help: skipping check for `const_fn_fn_ptr_basics` feature
--> $DIR/caller-location-fnptr-rt-ctfe-equiv.rs:20:9
|
LL | let ptr: fn() -> L = attributed;
| ^^^
help: skipping check for `const_fn_fn_ptr_basics` feature
--> $DIR/caller-location-fnptr-rt-ctfe-equiv.rs:21:5
|
LL | ptr()
| ^^^
help: skipping check for `const_fn_fn_ptr_basics` feature
--> $DIR/caller-location-fnptr-rt-ctfe-equiv.rs:20:26
|
LL | let ptr: fn() -> L = attributed;
| ^^^^^^^^^^
help: skipping check that does not even have a feature gate
--> $DIR/caller-location-fnptr-rt-ctfe-equiv.rs:21:5
|
LL | ptr()
| ^^^^^
warning: 1 warning emitted
error: `-Zunleash-the-miri-inside-of-you` may not be used to circumvent feature gates, except when testing error paths in the CTFE engine
error: aborting due to previous error; 1 warning emitted

2
src/test/ui/type-alias-impl-trait/issue-53096.rs
View File

@ -1,5 +1,5 @@
// check-pass
#![feature(const_fn)]
#![feature(const_fn, const_fn_fn_ptr_basics)]
#![feature(type_alias_impl_trait)]
type Foo = impl Fn() -> usize;

4
src/tools/clippy/src/driver.rs
View File

@ -357,7 +357,7 @@ pub fn main() {
args.extend(vec!["--sysroot".into(), sys_root]);
};
return rustc_driver::run_compiler(&args, &mut DefaultCallbacks, None, None);
return rustc_driver::run_compiler(&args, &mut DefaultCallbacks, None, None, None);
}
if orig_args.iter().any(|a| a == "--version" || a == "-V") {
@ -420,6 +420,6 @@ pub fn main() {
let mut default = DefaultCallbacks;
let callbacks: &mut (dyn rustc_driver::Callbacks + Send) =
if clippy_enabled { &mut clippy } else { &mut default };
rustc_driver::run_compiler(&args, callbacks, None, None)
rustc_driver::run_compiler(&args, callbacks, None, None, None)
}))
}