use rustc::middle::lang_items;
use rustc::session::config::nightly_options;
use syntax::ast::LitKind;
-use syntax::feature_gate::{UnstableFeatures, feature_err, emit_feature_err, GateIssue};
+use syntax::feature_gate::{UnstableFeatures, emit_feature_err, GateIssue};
use syntax_pos::{Span, DUMMY_SP};
use std::fmt;
param_env: ty::ParamEnv<'tcx>,
local_qualif: IndexVec<Local, Option<Qualif>>,
qualif: Qualif,
- const_fn_arg_vars: BitSet<Local>,
temp_promotion_state: IndexVec<Local, TempState>,
promotion_candidates: Vec<Candidate>
}
param_env,
local_qualif,
qualif: Qualif::empty(),
- const_fn_arg_vars: BitSet::new_empty(mir.local_decls.len()),
temp_promotion_state: temps,
promotion_candidates: vec![]
}
}
}
- /// Error about extra statements in a constant.
- fn statement_like(&mut self) {
- self.add(Qualif::NOT_CONST);
- if self.mode != Mode::Fn {
- let mut err = feature_err(
- &self.tcx.sess.parse_sess,
- "const_let",
- self.span,
- GateIssue::Language,
- &format!("statements in {}s are unstable", self.mode),
- );
- if self.tcx.sess.teach(&err.get_code().unwrap()) {
- err.note("Blocks in constants may only contain items (such as constant, function \
- definition, etc...) and a tail expression.");
- err.help("To avoid it, you have to replace the non-item object.");
- }
- err.emit();
- }
- }
-
/// Add the given qualification to self.qualif.
fn add(&mut self, qualif: Qualif) {
self.qualif = self.qualif | qualif;
return;
}
- if self.tcx.features().const_let {
- let mut dest = dest;
- let index = loop {
- match dest {
- // with `const_let` active, we treat all locals equal
- Place::Local(index) => break *index,
- // projections are transparent for assignments
- // we qualify the entire destination at once, even if just a field would have
- // stricter qualification
- Place::Projection(proj) => {
- // Catch more errors in the destination. `visit_place` also checks various
- // projection rules like union field access and raw pointer deref
- self.visit_place(
- dest,
- PlaceContext::MutatingUse(MutatingUseContext::Store),
- location
- );
- dest = &proj.base;
- },
- Place::Promoted(..) => bug!("promoteds don't exist yet during promotion"),
- Place::Static(..) => {
- // Catch more errors in the destination. `visit_place` also checks that we
- // do not try to access statics from constants or try to mutate statics
- self.visit_place(
- dest,
- PlaceContext::MutatingUse(MutatingUseContext::Store),
- location
- );
- return;
- }
+ let mut dest = dest;
+ let index = loop {
+ match dest {
+ // We treat all locals equal in constants
+ Place::Local(index) => break *index,
+ // projections are transparent for assignments
+ // we qualify the entire destination at once, even if just a field would have
+ // stricter qualification
+ Place::Projection(proj) => {
+ // Catch more errors in the destination. `visit_place` also checks various
+ // projection rules like union field access and raw pointer deref
+ self.visit_place(
+ dest,
+ PlaceContext::MutatingUse(MutatingUseContext::Store),
+ location
+ );
+ dest = &proj.base;
+ },
+ Place::Promoted(..) => bug!("promoteds don't exist yet during promotion"),
+ Place::Static(..) => {
+ // Catch more errors in the destination. `visit_place` also checks that we
+ // do not try to access statics from constants or try to mutate statics
+ self.visit_place(
+ dest,
+ PlaceContext::MutatingUse(MutatingUseContext::Store),
+ location
+ );
+ return;
}
- };
- debug!("store to var {:?}", index);
- match &mut self.local_qualif[index] {
- // this is overly restrictive, because even full assignments do not clear the qualif
- // While we could special case full assignments, this would be inconsistent with
- // aggregates where we overwrite all fields via assignments, which would not get
- // that feature.
- Some(ref mut qualif) => *qualif = *qualif | self.qualif,
- // insert new qualification
- qualif @ None => *qualif = Some(self.qualif),
- }
- return;
- }
-
- match *dest {
- Place::Local(index) if self.mir.local_kind(index) == LocalKind::Temp ||
- self.mir.local_kind(index) == LocalKind::ReturnPointer => {
- debug!("store to {:?} (temp or return pointer)", index);
- store(&mut self.local_qualif[index])
- }
-
- Place::Projection(box Projection {
- base: Place::Local(index),
- elem: ProjectionElem::Deref
- }) if self.mir.local_kind(index) == LocalKind::Temp
- && self.mir.local_decls[index].ty.is_box()
- && self.local_qualif[index].map_or(false, |qualif| {
- qualif.contains(Qualif::NOT_CONST)
- }) => {
- // Part of `box expr`, we should've errored
- // already for the Box allocation Rvalue.
- }
-
- // This must be an explicit assignment.
- _ => {
- // Catch more errors in the destination.
- self.visit_place(
- dest,
- PlaceContext::MutatingUse(MutatingUseContext::Store),
- location
- );
- self.statement_like();
}
+ };
+ debug!("store to var {:?}", index);
+ match &mut self.local_qualif[index] {
+ // this is overly restrictive, because even full assignments do not clear the qualif
+ // While we could special case full assignments, this would be inconsistent with
+ // aggregates where we overwrite all fields via assignments, which would not get
+ // that feature.
+ Some(ref mut qualif) => *qualif = *qualif | self.qualif,
+ // insert new qualification
+ qualif @ None => *qualif = Some(self.qualif),
}
}
TerminatorKind::FalseUnwind { .. } => None,
TerminatorKind::Return => {
- if !self.tcx.features().const_let {
- // Check for unused values. This usually means
- // there are extra statements in the AST.
- for temp in mir.temps_iter() {
- if self.local_qualif[temp].is_none() {
- continue;
- }
-
- let state = self.temp_promotion_state[temp];
- if let TempState::Defined { location, uses: 0 } = state {
- let data = &mir[location.block];
- let stmt_idx = location.statement_index;
-
- // Get the span for the initialization.
- let source_info = if stmt_idx < data.statements.len() {
- data.statements[stmt_idx].source_info
- } else {
- data.terminator().source_info
- };
- self.span = source_info.span;
-
- // Treat this as a statement in the AST.
- self.statement_like();
- }
- }
-
- // Make sure there are no extra unassigned variables.
- self.qualif = Qualif::NOT_CONST;
- for index in mir.vars_iter() {
- if !self.const_fn_arg_vars.contains(index) {
- debug!("unassigned variable {:?}", index);
- self.assign(&Place::Local(index), Location {
- block: bb,
- statement_index: usize::MAX,
- });
- }
- }
- }
-
break;
}
};
LocalKind::ReturnPointer => {
self.not_const();
}
- LocalKind::Var if !self.tcx.features().const_let => {
- if self.mode != Mode::Fn {
- emit_feature_err(&self.tcx.sess.parse_sess, "const_let",
- self.span, GateIssue::Language,
- &format!("let bindings in {}s are unstable",self.mode));
- }
+ LocalKind::Arg |
+ LocalKind::Var if self.mode == Mode::Fn => {
self.add(Qualif::NOT_CONST);
}
LocalKind::Var |
debug!("visit_assign: dest={:?} rvalue={:?} location={:?}", dest, rvalue, location);
self.visit_rvalue(rvalue, location);
- // Check the allowed const fn argument forms.
- if let (Mode::ConstFn, &Place::Local(index)) = (self.mode, dest) {
- if self.mir.local_kind(index) == LocalKind::Var &&
- self.const_fn_arg_vars.insert(index) &&
- !self.tcx.features().const_let {
- // Direct use of an argument is permitted.
- match *rvalue {
- Rvalue::Use(Operand::Copy(Place::Local(local))) |
- Rvalue::Use(Operand::Move(Place::Local(local))) => {
- if self.mir.local_kind(local) == LocalKind::Arg {
- return;
- }
- }
- _ => {}
- }
- // Avoid a generic error for other uses of arguments.
- if self.qualif.contains(Qualif::FN_ARGUMENT) {
- let decl = &self.mir.local_decls[index];
- let mut err = feature_err(
- &self.tcx.sess.parse_sess,
- "const_let",
- decl.source_info.span,
- GateIssue::Language,
- "arguments of constant functions can only be immutable by-value bindings"
- );
- if self.tcx.sess.teach(&err.get_code().unwrap()) {
- err.note("Constant functions are not allowed to mutate anything. Thus, \
- binding to an argument with a mutable pattern is not allowed.");
- err.note("Remove any mutable bindings from the argument list to fix this \
- error. In case you need to mutate the argument, try lazily \
- initializing a global variable instead of using a const fn, or \
- refactoring the code to a functional style to avoid mutation if \
- possible.");
- }
- err.emit();
- return;
- }
- }
- }
-
self.assign(dest, location);
}
}
}
- for local in mir.vars_iter() {
- return Err((
- mir.local_decls[local].source_info.span,
- "local variables in const fn are unstable".into(),
- ));
- }
for local in &mir.local_decls {
check_ty(tcx, local.ty, local.source_info.span)?;
}
check_operand(tcx, mir, operand, span)
}
Rvalue::Len(place) | Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) => {
- check_place(tcx, mir, place, span, PlaceMode::Read)
+ check_place(tcx, mir, place, span)
}
Rvalue::Cast(CastKind::Misc, operand, cast_ty) => {
use rustc::ty::cast::CastTy;
}
}
-enum PlaceMode {
- Assign,
- Read,
-}
-
fn check_statement(
tcx: TyCtxt<'a, 'tcx, 'tcx>,
mir: &'a Mir<'tcx>,
let span = statement.source_info.span;
match &statement.kind {
StatementKind::Assign(place, rval) => {
- check_place(tcx, mir, place, span, PlaceMode::Assign)?;
+ check_place(tcx, mir, place, span)?;
check_rvalue(tcx, mir, rval, span)
}
- StatementKind::FakeRead(_, place) => check_place(tcx, mir, place, span, PlaceMode::Read),
+ StatementKind::FakeRead(_, place) => check_place(tcx, mir, place, span),
// just an assignment
StatementKind::SetDiscriminant { .. } => Ok(()),
) -> McfResult {
match operand {
Operand::Move(place) | Operand::Copy(place) => {
- check_place(tcx, mir, place, span, PlaceMode::Read)
+ check_place(tcx, mir, place, span)
}
Operand::Constant(_) => Ok(()),
}
mir: &'a Mir<'tcx>,
place: &Place<'tcx>,
span: Span,
- mode: PlaceMode,
) -> McfResult {
match place {
- Place::Local(l) => match mode {
- PlaceMode::Assign => match mir.local_kind(*l) {
- LocalKind::Temp | LocalKind::ReturnPointer => Ok(()),
- LocalKind::Arg | LocalKind::Var => {
- Err((span, "assignments in const fn are unstable".into()))
- }
- },
- PlaceMode::Read => Ok(()),
- },
+ Place::Local(_) => Ok(()),
// promoteds are always fine, they are essentially constants
Place::Promoted(_) => Ok(()),
Place::Static(_) => Err((span, "cannot access `static` items in const fn".into())),
Place::Projection(proj) => {
match proj.elem {
| ProjectionElem::Deref | ProjectionElem::Field(..) | ProjectionElem::Index(_) => {
- check_place(tcx, mir, &proj.base, span, mode)
+ check_place(tcx, mir, &proj.base, span)
}
// slice patterns are unstable
| ProjectionElem::ConstantIndex { .. } | ProjectionElem::Subslice { .. } => {
| TerminatorKind::Resume => Ok(()),
TerminatorKind::Drop { location, .. } => {
- check_place(tcx, mir, location, span, PlaceMode::Read)
+ check_place(tcx, mir, location, span)
}
TerminatorKind::DropAndReplace { location, value, .. } => {
- check_place(tcx, mir, location, span, PlaceMode::Read)?;
+ check_place(tcx, mir, location, span)?;
check_operand(tcx, mir, value, span)
},
// Allows the definition of `const` functions with some advanced features.
(active, const_fn, "1.2.0", Some(24111), None),
- // Allows let bindings and destructuring in `const` functions and constants.
- (active, const_let, "1.22.1", Some(48821), None),
-
// Allows accessing fields of unions inside `const` functions.
(active, const_fn_union, "1.27.0", Some(51909), None),
(accepted, min_const_unsafe_fn, "1.33.0", Some(55607), None),
// `#[cfg_attr(predicate, multiple, attributes, here)]`
(accepted, cfg_attr_multi, "1.33.0", Some(54881), None),
+ // Allows let bindings and destructuring in `const` functions and constants.
+ (accepted, const_let, "1.33.0", Some(48821), None),
);
// If you change this, please modify `src/doc/unstable-book` as well. You must
-#![feature(const_fn, const_let)]
+#![feature(const_fn)]
const X : usize = 2;
// run-pass
#![allow(dead_code)]
-#![feature(const_let)]
-
type Array = [u32; { let x = 2; 5 }];
pub fn main() {}
// run-pass
#![allow(dead_code)]
-#![feature(const_let)]
-
enum Foo {
Bar = { let x = 1; 3 }
}
#![allow(dead_code)]
#![allow(unused_variables)]
-#![feature(const_fn, const_let)]
+#![feature(const_fn)]
const fn x() {
let t = true;
// https://github.com/rust-lang/rust/issues/48821
-#![feature(const_fn, const_let)]
+#![feature(const_fn)]
const fn foo(i: usize) -> usize {
let x = i;
static STATIC11: Box<MyOwned> = box MyOwned;
//~^ ERROR allocations are not allowed in statics
+//~| ERROR static contains unimplemented expression type
static mut STATIC12: UnsafeStruct = UnsafeStruct;
static STATIC15: &'static [Box<MyOwned>] = &[
box MyOwned, //~ ERROR allocations are not allowed in statics
+ //~| ERROR contains unimplemented expression
box MyOwned, //~ ERROR allocations are not allowed in statics
+ //~| ERROR contains unimplemented expression
];
static STATIC16: (&'static Box<MyOwned>, &'static Box<MyOwned>) = (
&box MyOwned, //~ ERROR allocations are not allowed in statics
+ //~| ERROR contains unimplemented expression
&box MyOwned, //~ ERROR allocations are not allowed in statics
+ //~| ERROR contains unimplemented expression
);
static mut STATIC17: SafeEnum = SafeEnum::Variant1;
static STATIC19: Box<isize> =
box 3;
//~^ ERROR allocations are not allowed in statics
+ //~| ERROR contains unimplemented expression
pub fn main() {
let y = { static x: Box<isize> = box 3; x };
//~^ ERROR allocations are not allowed in statics
- //~^^ ERROR cannot move out of static item
+ //~| ERROR cannot move out of static item
+ //~| ERROR contains unimplemented expression
}
LL | static STATIC11: Box<MyOwned> = box MyOwned;
| ^^^^^^^^^^^ allocation not allowed in statics
+error[E0019]: static contains unimplemented expression type
+ --> $DIR/check-static-values-constraints.rs:79:37
+ |
+LL | static STATIC11: Box<MyOwned> = box MyOwned;
+ | ^^^^^^^
+
error[E0015]: calls in statics are limited to constant functions, tuple structs and tuple variants
- --> $DIR/check-static-values-constraints.rs:89:32
+ --> $DIR/check-static-values-constraints.rs:90:32
|
LL | field2: SafeEnum::Variant4("str".to_string())
| ^^^^^^^^^^^^^^^^^
error[E0010]: allocations are not allowed in statics
- --> $DIR/check-static-values-constraints.rs:94:5
+ --> $DIR/check-static-values-constraints.rs:95:5
|
LL | box MyOwned, //~ ERROR allocations are not allowed in statics
| ^^^^^^^^^^^ allocation not allowed in statics
+error[E0019]: static contains unimplemented expression type
+ --> $DIR/check-static-values-constraints.rs:95:9
+ |
+LL | box MyOwned, //~ ERROR allocations are not allowed in statics
+ | ^^^^^^^
+
error[E0010]: allocations are not allowed in statics
- --> $DIR/check-static-values-constraints.rs:95:5
+ --> $DIR/check-static-values-constraints.rs:97:5
|
LL | box MyOwned, //~ ERROR allocations are not allowed in statics
| ^^^^^^^^^^^ allocation not allowed in statics
+error[E0019]: static contains unimplemented expression type
+ --> $DIR/check-static-values-constraints.rs:97:9
+ |
+LL | box MyOwned, //~ ERROR allocations are not allowed in statics
+ | ^^^^^^^
+
error[E0010]: allocations are not allowed in statics
- --> $DIR/check-static-values-constraints.rs:99:6
+ --> $DIR/check-static-values-constraints.rs:102:6
|
LL | &box MyOwned, //~ ERROR allocations are not allowed in statics
| ^^^^^^^^^^^ allocation not allowed in statics
+error[E0019]: static contains unimplemented expression type
+ --> $DIR/check-static-values-constraints.rs:102:10
+ |
+LL | &box MyOwned, //~ ERROR allocations are not allowed in statics
+ | ^^^^^^^
+
error[E0010]: allocations are not allowed in statics
- --> $DIR/check-static-values-constraints.rs:100:6
+ --> $DIR/check-static-values-constraints.rs:104:6
|
LL | &box MyOwned, //~ ERROR allocations are not allowed in statics
| ^^^^^^^^^^^ allocation not allowed in statics
+error[E0019]: static contains unimplemented expression type
+ --> $DIR/check-static-values-constraints.rs:104:10
+ |
+LL | &box MyOwned, //~ ERROR allocations are not allowed in statics
+ | ^^^^^^^
+
error[E0010]: allocations are not allowed in statics
- --> $DIR/check-static-values-constraints.rs:106:5
+ --> $DIR/check-static-values-constraints.rs:111:5
|
LL | box 3;
| ^^^^^ allocation not allowed in statics
+error[E0019]: static contains unimplemented expression type
+ --> $DIR/check-static-values-constraints.rs:111:9
+ |
+LL | box 3;
+ | ^
+
error[E0507]: cannot move out of static item
- --> $DIR/check-static-values-constraints.rs:110:45
+ --> $DIR/check-static-values-constraints.rs:116:45
|
LL | let y = { static x: Box<isize> = box 3; x };
| ^ cannot move out of static item
error[E0010]: allocations are not allowed in statics
- --> $DIR/check-static-values-constraints.rs:110:38
+ --> $DIR/check-static-values-constraints.rs:116:38
|
LL | let y = { static x: Box<isize> = box 3; x };
| ^^^^^ allocation not allowed in statics
-error: aborting due to 10 previous errors
+error[E0019]: static contains unimplemented expression type
+ --> $DIR/check-static-values-constraints.rs:116:42
+ |
+LL | let y = { static x: Box<isize> = box 3; x };
+ | ^
+
+error: aborting due to 17 previous errors
-Some errors occurred: E0010, E0015, E0493, E0507.
+Some errors occurred: E0010, E0015, E0019, E0493, E0507.
For more information about an error, try `rustc --explain E0010`.
+++ /dev/null
-const A: usize = { 1; 2 };
-//~^ ERROR statements in constants are unstable
-
-const B: usize = { { } 2 };
-//~^ ERROR statements in constants are unstable
-
-macro_rules! foo {
- () => (()) //~ ERROR statements in constants are unstable
-}
-const C: usize = { foo!(); 2 };
-
-const D: usize = { let x = 4; 2 };
-//~^ ERROR let bindings in constants are unstable
-//~| ERROR statements in constants are unstable
-//~| ERROR let bindings in constants are unstable
-//~| ERROR statements in constants are unstable
-
-pub fn main() {}
+++ /dev/null
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/const-block-non-item-statement-2.rs:1:20
- |
-LL | const A: usize = { 1; 2 };
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/const-block-non-item-statement-2.rs:4:20
- |
-LL | const B: usize = { { } 2 };
- | ^^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/const-block-non-item-statement-2.rs:8:12
- |
-LL | () => (()) //~ ERROR statements in constants are unstable
- | ^^
-LL | }
-LL | const C: usize = { foo!(); 2 };
- | ------- in this macro invocation
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: let bindings in constants are unstable (see issue #48821)
- --> $DIR/const-block-non-item-statement-2.rs:12:28
- |
-LL | const D: usize = { let x = 4; 2 };
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/const-block-non-item-statement-2.rs:12:28
- |
-LL | const D: usize = { let x = 4; 2 };
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: let bindings in constants are unstable (see issue #48821)
- --> $DIR/const-block-non-item-statement-2.rs:12:1
- |
-LL | const D: usize = { let x = 4; 2 };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/const-block-non-item-statement-2.rs:12:1
- |
-LL | const D: usize = { let x = 4; 2 };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error: aborting due to 7 previous errors
-
-For more information about this error, try `rustc --explain E0658`.
+++ /dev/null
-type Array = [u32; { let x = 2; 5 }];
-//~^ ERROR let bindings in constants are unstable
-//~| ERROR statements in constants are unstable
-//~| ERROR let bindings in constants are unstable
-//~| ERROR statements in constants are unstable
-
-pub fn main() {}
+++ /dev/null
-error[E0658]: let bindings in constants are unstable (see issue #48821)
- --> $DIR/const-block-non-item-statement-3.rs:1:31
- |
-LL | type Array = [u32; { let x = 2; 5 }];
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/const-block-non-item-statement-3.rs:1:31
- |
-LL | type Array = [u32; { let x = 2; 5 }];
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: let bindings in constants are unstable (see issue #48821)
- --> $DIR/const-block-non-item-statement-3.rs:1:20
- |
-LL | type Array = [u32; { let x = 2; 5 }];
- | ^^^^^^^^^^^^^^^^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/const-block-non-item-statement-3.rs:1:20
- |
-LL | type Array = [u32; { let x = 2; 5 }];
- | ^^^^^^^^^^^^^^^^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error: aborting due to 4 previous errors
-
-For more information about this error, try `rustc --explain E0658`.
+// compile-pass
+
enum Foo {
Bar = { let x = 1; 3 }
- //~^ ERROR let bindings in constants are unstable
- //~| ERROR statements in constants are unstable
- //~| ERROR let bindings in constants are unstable
- //~| ERROR statements in constants are unstable
}
+
+const A: usize = { 1; 2 };
+
+const B: usize = { { } 2 };
+
+macro_rules! foo {
+ () => (())
+}
+
+const C: usize = { foo!(); 2 };
+
+const D: usize = { let x = 4; 2 };
+
+type Array = [u32; { let x = 2; 5 }];
+type Array2 = [u32; { let mut x = 2; x = 3; x}];
+
pub fn main() {}
+++ /dev/null
-error[E0658]: let bindings in constants are unstable (see issue #48821)
- --> $DIR/const-block-non-item-statement.rs:2:21
- |
-LL | Bar = { let x = 1; 3 }
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/const-block-non-item-statement.rs:2:21
- |
-LL | Bar = { let x = 1; 3 }
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: let bindings in constants are unstable (see issue #48821)
- --> $DIR/const-block-non-item-statement.rs:2:11
- |
-LL | Bar = { let x = 1; 3 }
- | ^^^^^^^^^^^^^^^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/const-block-non-item-statement.rs:2:11
- |
-LL | Bar = { let x = 1; 3 }
- | ^^^^^^^^^^^^^^^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error: aborting due to 4 previous errors
-
-For more information about this error, try `rustc --explain E0658`.
// The test should never compile successfully
#![feature(const_raw_ptr_deref)]
-#![feature(const_let)]
use std::cell::UnsafeCell;
error[E0019]: static contains unimplemented expression type
- --> $DIR/assign-to-static-within-other-static-2.rs:17:5
+ --> $DIR/assign-to-static-within-other-static-2.rs:16:5
|
LL | *FOO.0.get() = 5; //~ ERROR contains unimplemented expression type
| ^^^^^^^^^^^^^^^^
// The test should never compile successfully
#![feature(const_raw_ptr_deref)]
-#![feature(const_let)]
use std::cell::UnsafeCell;
error: cannot mutate statics in the initializer of another static
- --> $DIR/assign-to-static-within-other-static.rs:11:5
+ --> $DIR/assign-to-static-within-other-static.rs:10:5
|
LL | FOO = 5; //~ ERROR cannot mutate statics in the initializer of another static
| ^^^^^^^
-#![feature(const_let)]
-
fn main() {}
struct FakeNeedsDrop;
error[E0019]: constant contains unimplemented expression type
- --> $DIR/const_let.rs:15:55
+ --> $DIR/const_let.rs:13:55
|
LL | const Y: FakeNeedsDrop = { let mut x = FakeNeedsDrop; x = FakeNeedsDrop; x };
| ^
error[E0019]: constant contains unimplemented expression type
- --> $DIR/const_let.rs:19:35
+ --> $DIR/const_let.rs:17:35
|
LL | const Z: () = { let mut x = None; x = Some(FakeNeedsDrop); };
| ^
-#![feature(const_let)]
-
fn main() {
// Tests the Collatz conjecture with an incorrect base case (0 instead of 1).
// The value of `n` will loop indefinitely (4 - 2 - 1 - 4).
error[E0019]: constant contains unimplemented expression type
- --> $DIR/infinite_loop.rs:9:9
+ --> $DIR/infinite_loop.rs:7:9
|
LL | / while n != 0 { //~ ERROR constant contains unimplemented expression type
LL | | n = if n % 2 == 0 { n/2 } else { 3*n + 1 };
| |_________^
warning: Constant evaluating a complex constant, this might take some time
- --> $DIR/infinite_loop.rs:6:18
+ --> $DIR/infinite_loop.rs:4:18
|
LL | let _ = [(); {
| __________________^
| |_____^
error[E0080]: evaluation of constant value failed
- --> $DIR/infinite_loop.rs:10:20
+ --> $DIR/infinite_loop.rs:8:20
|
LL | n = if n % 2 == 0 { n/2 } else { 3*n + 1 };
| ^^^^^^^^^^ duplicate interpreter state observed here, const evaluation will never terminate
-#![feature(const_let)]
-
fn main() {
let _ = [(); {
//~^ WARNING Constant evaluating a complex constant, this might take some time
error[E0019]: constant contains unimplemented expression type
- --> $DIR/issue-52475.rs:8:9
+ --> $DIR/issue-52475.rs:6:9
|
LL | / while n < 5 { //~ ERROR constant contains unimplemented expression type
LL | | n = (n + 1) % 5; //~ ERROR evaluation of constant value failed
| |_________^
warning: Constant evaluating a complex constant, this might take some time
- --> $DIR/issue-52475.rs:4:18
+ --> $DIR/issue-52475.rs:2:18
|
LL | let _ = [(); {
| __________________^
| |_____^
error[E0080]: evaluation of constant value failed
- --> $DIR/issue-52475.rs:9:17
+ --> $DIR/issue-52475.rs:7:17
|
LL | n = (n + 1) % 5; //~ ERROR evaluation of constant value failed
| ^^^^^^^^^^^ duplicate interpreter state observed here, const evaluation will never terminate
// The test should never compile successfully
#![feature(const_raw_ptr_deref)]
-#![feature(const_let)]
use std::cell::UnsafeCell;
error[E0019]: static contains unimplemented expression type
- --> $DIR/mod-static-with-const-fn.rs:19:5
+ --> $DIR/mod-static-with-const-fn.rs:18:5
|
LL | *FOO.0.get() = 5;
| ^^^^^^^^^^^^^^^^
error[E0015]: calls in statics are limited to constant functions, tuple structs and tuple variants
- --> $DIR/mod-static-with-const-fn.rs:22:5
+ --> $DIR/mod-static-with-const-fn.rs:21:5
|
LL | foo();
| ^^^^^
-#![feature(const_transmute,const_let)]
+#![feature(const_transmute)]
#![allow(const_err)] // make sure we cannot allow away the errors tested here
use std::mem;
-// test that certain things are disallowed in constant functions
+// compile-pass
-#![feature(const_fn)]
-
-// no destructuring
-const fn i((
- a,
- //~^ ERROR arguments of constant functions can only be immutable by-value bindings
- b
- //~^ ERROR arguments of constant functions can only be immutable by-value bindings
- ): (u32, u32)) -> u32 {
+const fn i((a, b): (u32, u32)) -> u32 {
a + b
- //~^ ERROR let bindings in constant functions are unstable
- //~| ERROR let bindings in constant functions are unstable
}
fn main() {}
+++ /dev/null
-error[E0658]: arguments of constant functions can only be immutable by-value bindings (see issue #48821)
- --> $DIR/const-fn-destructuring-arg.rs:7:13
- |
-LL | a,
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: arguments of constant functions can only be immutable by-value bindings (see issue #48821)
- --> $DIR/const-fn-destructuring-arg.rs:9:13
- |
-LL | b
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: let bindings in constant functions are unstable (see issue #48821)
- --> $DIR/const-fn-destructuring-arg.rs:12:5
- |
-LL | a + b
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: let bindings in constant functions are unstable (see issue #48821)
- --> $DIR/const-fn-destructuring-arg.rs:12:9
- |
-LL | a + b
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error: aborting due to 4 previous errors
-
-For more information about this error, try `rustc --explain E0658`.
}
const fn get() -> u32 {
- let x = 22; //~ ERROR let bindings in constant functions are unstable
-//~^ ERROR statements in constant functions
- let y = 44; //~ ERROR let bindings in constant functions are unstable
-//~^ ERROR statements in constant functions
+ let x = 22;
+ let y = 44;
x + y
-//~^ ERROR let bindings in constant functions are unstable
-//~| ERROR let bindings in constant functions are unstable
}
fn main() {}
LL | &Y
| ^^
-error[E0658]: let bindings in constant functions are unstable (see issue #48821)
- --> $DIR/const-fn-not-safe-for-const.rs:30:13
- |
-LL | let x = 22; //~ ERROR let bindings in constant functions are unstable
- | ^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in constant functions are unstable (see issue #48821)
- --> $DIR/const-fn-not-safe-for-const.rs:30:13
- |
-LL | let x = 22; //~ ERROR let bindings in constant functions are unstable
- | ^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: let bindings in constant functions are unstable (see issue #48821)
- --> $DIR/const-fn-not-safe-for-const.rs:32:13
- |
-LL | let y = 44; //~ ERROR let bindings in constant functions are unstable
- | ^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in constant functions are unstable (see issue #48821)
- --> $DIR/const-fn-not-safe-for-const.rs:32:13
- |
-LL | let y = 44; //~ ERROR let bindings in constant functions are unstable
- | ^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: let bindings in constant functions are unstable (see issue #48821)
- --> $DIR/const-fn-not-safe-for-const.rs:34:5
- |
-LL | x + y
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: let bindings in constant functions are unstable (see issue #48821)
- --> $DIR/const-fn-not-safe-for-const.rs:34:9
- |
-LL | x + y
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error: aborting due to 9 previous errors
+error: aborting due to 3 previous errors
-Some errors occurred: E0013, E0015, E0658.
+Some errors occurred: E0013, E0015.
For more information about an error, try `rustc --explain E0013`.
// compile-pass
-#![feature(const_let)]
-
struct S(i32);
const A: () = {
// compile-pass
-#![feature(const_let)]
#![feature(const_fn)]
pub struct AA {
-#![feature(const_let)]
#![feature(const_fn)]
struct S {
s
};
+type Array = [u32; { let mut x = 2; let y = &mut x; *y = 42; *y}];
+//~^ ERROR references in constants may only refer to immutable values
+//~| ERROR constant contains unimplemented expression type
+
fn main() {
assert_eq!(FOO.state, 3);
}
error[E0019]: constant function contains unimplemented expression type
- --> $DIR/const_let_assign3.rs:10:9
+ --> $DIR/const_let_assign3.rs:9:9
|
LL | self.state = x;
| ^^^^^^^^^^^^^^
error[E0017]: references in constants may only refer to immutable values
- --> $DIR/const_let_assign3.rs:17:5
+ --> $DIR/const_let_assign3.rs:16:5
|
LL | s.foo(3); //~ ERROR references in constants may only refer to immutable values
| ^ constants require immutable values
-error: aborting due to 2 previous errors
+error[E0017]: references in constants may only refer to immutable values
+ --> $DIR/const_let_assign3.rs:20:45
+ |
+LL | type Array = [u32; { let mut x = 2; let y = &mut x; *y = 42; *y}];
+ | ^^^^^^ constants require immutable values
+
+error[E0019]: constant contains unimplemented expression type
+ --> $DIR/const_let_assign3.rs:20:53
+ |
+LL | type Array = [u32; { let mut x = 2; let y = &mut x; *y = 42; *y}];
+ | ^^^^^^^
+
+error: aborting due to 4 previous errors
Some errors occurred: E0017, E0019.
For more information about an error, try `rustc --explain E0017`.
-#![feature(const_let, const_fn)]
+#![feature(const_fn)]
// run-pass
// compile-pass
-#![feature(const_let, const_fn)]
+#![feature(const_fn)]
struct Foo<T>(T);
struct Bar<T> { x: T }
-#![feature(underscore_const_names, const_let)]
+#![feature(underscore_const_names)]
const _: bool = false && false;
const _: bool = true && false;
// https://github.com/rust-lang/rust/issues/55223
-#![feature(const_let)]
-
union Foo<'a> {
y: &'a (),
long_live_the_unit: &'static (),
error: any use of this value will cause an error
- --> $DIR/dangling-alloc-id-ice.rs:10:1
+ --> $DIR/dangling-alloc-id-ice.rs:8:1
|
LL | / const FOO: &() = { //~ ERROR any use of this value will cause an error
LL | | let y = ();
-#![feature(const_let)]
-
const FOO: *const u32 = { //~ ERROR any use of this value will cause an error
let x = 42;
&x
error: any use of this value will cause an error
- --> $DIR/dangling_raw_ptr.rs:3:1
+ --> $DIR/dangling_raw_ptr.rs:1:1
|
LL | / const FOO: *const u32 = { //~ ERROR any use of this value will cause an error
LL | | let x = 42;
const fn foo30_4(b: bool) -> usize { if b { 1 } else { 42 } }
//~^ ERROR `if`, `match`, `&&` and `||` are not stable in const fn
const fn foo30_5(b: bool) { while b { } } //~ ERROR not stable in const fn
-const fn foo30_6() -> bool { let x = true; x } //~ ERROR local variables in const fn
+const fn foo30_6() -> bool { let x = true; x }
const fn foo36(a: bool, b: bool) -> bool { a && b }
//~^ ERROR `if`, `match`, `&&` and `||` are not stable in const fn
const fn foo37(a: bool, b: bool) -> bool { a || b }
LL | const fn foo30_5(b: bool) { while b { } } //~ ERROR not stable in const fn
| ^^^^^^^^^^^
-error: local variables in const fn are unstable
- --> $DIR/min_const_fn.rs:99:34
- |
-LL | const fn foo30_6() -> bool { let x = true; x } //~ ERROR local variables in const fn
- | ^
-
error: `if`, `match`, `&&` and `||` are not stable in const fn
--> $DIR/min_const_fn.rs:100:44
|
LL | const fn no_fn_ptrs2() -> fn() { fn foo() {} foo }
| ^^^^
-error: aborting due to 35 previous errors
+error: aborting due to 34 previous errors
For more information about this error, try `rustc --explain E0493`.
const fn mutable_ref_in_const() -> u8 {
- let mut a = 0; //~ ERROR local variables in const fn
- let b = &mut a;
+ let mut a = 0;
+ let b = &mut a; //~ ERROR mutable references in const fn
*b
}
impl X {
const fn inherent_mutable_ref_in_const() -> u8 {
- let mut a = 0; //~ ERROR local variables in const fn
- let b = &mut a;
+ let mut a = 0;
+ let b = &mut a; //~ ERROR mutable references in const fn
*b
}
}
-error: local variables in const fn are unstable
- --> $DIR/mutable_borrow.rs:2:9
+error: mutable references in const fn are unstable
+ --> $DIR/mutable_borrow.rs:3:9
|
-LL | let mut a = 0; //~ ERROR local variables in const fn
- | ^^^^^
+LL | let b = &mut a; //~ ERROR mutable references in const fn
+ | ^
-error: local variables in const fn are unstable
- --> $DIR/mutable_borrow.rs:11:13
+error: mutable references in const fn are unstable
+ --> $DIR/mutable_borrow.rs:12:13
|
-LL | let mut a = 0; //~ ERROR local variables in const fn
- | ^^^^^
+LL | let b = &mut a; //~ ERROR mutable references in const fn
+ | ^
error: aborting due to 2 previous errors
-#![feature(const_let)]
-
use std::cell::Cell;
const FOO: &(Cell<usize>, bool) = {
error[E0492]: cannot borrow a constant which may contain interior mutability, create a static instead
- --> $DIR/partial_qualif.rs:8:5
+ --> $DIR/partial_qualif.rs:6:5
|
LL | &{a} //~ ERROR cannot borrow a constant which may contain interior mutability
| ^^^^
-#![feature(const_let)]
-
use std::cell::Cell;
const FOO: &u32 = {
error[E0017]: references in constants may only refer to immutable values
- --> $DIR/projection_qualif.rs:8:27
+ --> $DIR/projection_qualif.rs:6:27
|
LL | let b: *mut u32 = &mut a; //~ ERROR may only refer to immutable values
| ^^^^^^ constants require immutable values
error[E0019]: constant contains unimplemented expression type
- --> $DIR/projection_qualif.rs:9:18
+ --> $DIR/projection_qualif.rs:7:18
|
LL | unsafe { *b = 5; } //~ ERROR dereferencing raw pointers in constants
| ^^^^^^
error[E0658]: dereferencing raw pointers in constants is unstable (see issue #51911)
- --> $DIR/projection_qualif.rs:9:18
+ --> $DIR/projection_qualif.rs:7:18
|
LL | unsafe { *b = 5; } //~ ERROR dereferencing raw pointers in constants
| ^^^^^^
-#![feature(const_let)]
-
fn main() {
let x: &'static u32 = {
let y = 42;
&y //~ ERROR does not live long enough
};
+ let x: &'static u32 = &{ //~ ERROR does not live long enough
+ let y = 42;
+ y
+ };
}
error[E0597]: `y` does not live long enough
- --> $DIR/promote_const_let.rs:6:10
+ --> $DIR/promote_const_let.rs:4:10
|
LL | &y //~ ERROR does not live long enough
| ^ borrowed value does not live long enough
|
= note: borrowed value must be valid for the static lifetime...
-error: aborting due to previous error
+error[E0597]: borrowed value does not live long enough
+ --> $DIR/promote_const_let.rs:6:28
+ |
+LL | let x: &'static u32 = &{ //~ ERROR does not live long enough
+ | ____________________________^
+LL | | let y = 42;
+LL | | y
+LL | | };
+ | |_____^ temporary value does not live long enough
+LL | }
+ | - temporary value only lives until here
+ |
+ = note: borrowed value must be valid for the static lifetime...
+
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0597`.
-#![feature(const_let)]
-
use std::cell::Cell;
// this is overly conservative. The reset to `None` should clear `a` of all qualifications
error[E0492]: cannot borrow a constant which may contain interior mutability, create a static instead
- --> $DIR/qualif_overwrite.rs:12:5
+ --> $DIR/qualif_overwrite.rs:10:5
|
LL | &{a} //~ ERROR cannot borrow a constant which may contain interior mutability
| ^^^^
-#![feature(const_let)]
-
use std::cell::Cell;
// const qualification is not smart enough to know about fields and always assumes that there might
error[E0492]: cannot borrow a constant which may contain interior mutability, create a static instead
- --> $DIR/qualif_overwrite_2.rs:10:5
+ --> $DIR/qualif_overwrite_2.rs:8:5
|
LL | &{a.0} //~ ERROR cannot borrow a constant which may contain interior mutability
| ^^^^^^
-#![feature(const_let)]
-
static mut STDERR_BUFFER_SPACE: u8 = 0;
pub static mut STDERR_BUFFER: () = unsafe { *(&mut STDERR_BUFFER_SPACE) = 42; };
error[E0017]: references in statics may only refer to immutable values
- --> $DIR/static_mut_containing_mut_ref2.rs:5:46
+ --> $DIR/static_mut_containing_mut_ref2.rs:3:46
|
LL | pub static mut STDERR_BUFFER: () = unsafe { *(&mut STDERR_BUFFER_SPACE) = 42; };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ statics require immutable values
error[E0019]: static contains unimplemented expression type
- --> $DIR/static_mut_containing_mut_ref2.rs:5:45
+ --> $DIR/static_mut_containing_mut_ref2.rs:3:45
|
LL | pub static mut STDERR_BUFFER: () = unsafe { *(&mut STDERR_BUFFER_SPACE) = 42; };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-#![feature(const_let)]
-
static mut FOO: (u8, u8) = (42, 43);
static mut BAR: () = unsafe { FOO.0 = 99; };
error[E0080]: could not evaluate static initializer
- --> $DIR/static_mut_containing_mut_ref3.rs:5:31
+ --> $DIR/static_mut_containing_mut_ref3.rs:3:31
|
LL | static mut BAR: () = unsafe { FOO.0 = 99; };
| ^^^^^^^^^^ tried to modify a static's initial value from another static's initializer
#![allow(warnings)]
const CON : Box<i32> = box 0; //~ ERROR E0010
+//~^ ERROR constant contains unimplemented expression type
fn main() {}
|
= note: The value of statics and constants must be known at compile time, and they live for the entire lifetime of a program. Creating a boxed value allocates memory on the heap at runtime, and therefore cannot be done at compile time.
-error: aborting due to previous error
+error[E0019]: constant contains unimplemented expression type
+ --> $DIR/E0010-teach.rs:6:28
+ |
+LL | const CON : Box<i32> = box 0; //~ ERROR E0010
+ | ^
+ |
+ = note: A function call isn't allowed in the const's initialization expression because the expression's value must be known at compile-time.
+ = note: Remember: you can't use a function call inside a const's initialization expression! However, you can use it anywhere else.
+
+error: aborting due to 2 previous errors
-For more information about this error, try `rustc --explain E0010`.
+Some errors occurred: E0010, E0019.
+For more information about an error, try `rustc --explain E0010`.
#![allow(warnings)]
const CON : Box<i32> = box 0; //~ ERROR E0010
+//~^ ERROR constant contains unimplemented expression type
fn main() {}
LL | const CON : Box<i32> = box 0; //~ ERROR E0010
| ^^^^^ allocation not allowed in constants
-error: aborting due to previous error
+error[E0019]: constant contains unimplemented expression type
+ --> $DIR/E0010.rs:4:28
+ |
+LL | const CON : Box<i32> = box 0; //~ ERROR E0010
+ | ^
+
+error: aborting due to 2 previous errors
-For more information about this error, try `rustc --explain E0010`.
+Some errors occurred: E0010, E0019.
+For more information about an error, try `rustc --explain E0010`.
+++ /dev/null
-// Test use of const let without feature gate.
-
-const FOO: usize = {
- //~^ ERROR statements in constants are unstable
- //~| ERROR: let bindings in constants are unstable
- let x = 42;
- //~^ ERROR statements in constants are unstable
- //~| ERROR: let bindings in constants are unstable
- 42
-};
-
-static BAR: usize = {
- //~^ ERROR statements in statics are unstable
- //~| ERROR: let bindings in statics are unstable
- let x = 42;
- //~^ ERROR statements in statics are unstable
- //~| ERROR: let bindings in statics are unstable
- 42
-};
-
-fn main() {}
+++ /dev/null
-error[E0658]: let bindings in constants are unstable (see issue #48821)
- --> $DIR/feature-gate-const_let.rs:6:13
- |
-LL | let x = 42;
- | ^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/feature-gate-const_let.rs:6:13
- |
-LL | let x = 42;
- | ^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: let bindings in constants are unstable (see issue #48821)
- --> $DIR/feature-gate-const_let.rs:3:1
- |
-LL | / const FOO: usize = {
-LL | | //~^ ERROR statements in constants are unstable
-LL | | //~| ERROR: let bindings in constants are unstable
-LL | | let x = 42;
-... |
-LL | | 42
-LL | | };
- | |__^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/feature-gate-const_let.rs:3:1
- |
-LL | / const FOO: usize = {
-LL | | //~^ ERROR statements in constants are unstable
-LL | | //~| ERROR: let bindings in constants are unstable
-LL | | let x = 42;
-... |
-LL | | 42
-LL | | };
- | |__^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: let bindings in statics are unstable (see issue #48821)
- --> $DIR/feature-gate-const_let.rs:15:13
- |
-LL | let x = 42;
- | ^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in statics are unstable (see issue #48821)
- --> $DIR/feature-gate-const_let.rs:15:13
- |
-LL | let x = 42;
- | ^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: let bindings in statics are unstable (see issue #48821)
- --> $DIR/feature-gate-const_let.rs:12:1
- |
-LL | / static BAR: usize = {
-LL | | //~^ ERROR statements in statics are unstable
-LL | | //~| ERROR: let bindings in statics are unstable
-LL | | let x = 42;
-... |
-LL | | 42
-LL | | };
- | |__^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in statics are unstable (see issue #48821)
- --> $DIR/feature-gate-const_let.rs:12:1
- |
-LL | / static BAR: usize = {
-LL | | //~^ ERROR statements in statics are unstable
-LL | | //~| ERROR: let bindings in statics are unstable
-LL | | let x = 42;
-... |
-LL | | 42
-LL | | };
- | |__^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error: aborting due to 8 previous errors
-
-For more information about this error, try `rustc --explain E0658`.
-#![feature(const_let)]
-
trait Trt {}
struct Str {}
error[E0658]: naming constants with `_` is unstable (see issue #54912)
- --> $DIR/feature-gate-underscore_const_names.rs:8:1
+ --> $DIR/feature-gate-underscore_const_names.rs:6:1
|
LL | / const _ : () = {
LL | | //~^ ERROR is unstable
pub fn main() {
const z: &'static isize = {
- //~^ ERROR let bindings in constants are unstable
- //~| ERROR statements in constants are unstable
let p = 3;
- //~^ ERROR let bindings in constants are unstable
- //~| ERROR statements in constants are unstable
&p //~ ERROR `p` does not live long enough
- //~^ ERROR let bindings in constants are unstable
};
}
-error[E0658]: let bindings in constants are unstable (see issue #48821)
- --> $DIR/issue-18118.rs:5:17
- |
-LL | let p = 3;
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/issue-18118.rs:5:17
- |
-LL | let p = 3;
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: let bindings in constants are unstable (see issue #48821)
- --> $DIR/issue-18118.rs:8:9
- |
-LL | &p //~ ERROR `p` does not live long enough
- | ^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: let bindings in constants are unstable (see issue #48821)
- --> $DIR/issue-18118.rs:2:5
- |
-LL | / const z: &'static isize = {
-LL | | //~^ ERROR let bindings in constants are unstable
-LL | | //~| ERROR statements in constants are unstable
-LL | | let p = 3;
-... |
-LL | | //~^ ERROR let bindings in constants are unstable
-LL | | };
- | |______^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/issue-18118.rs:2:5
- |
-LL | / const z: &'static isize = {
-LL | | //~^ ERROR let bindings in constants are unstable
-LL | | //~| ERROR statements in constants are unstable
-LL | | let p = 3;
-... |
-LL | | //~^ ERROR let bindings in constants are unstable
-LL | | };
- | |______^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
error[E0597]: `p` does not live long enough
- --> $DIR/issue-18118.rs:8:10
+ --> $DIR/issue-18118.rs:4:10
|
LL | &p //~ ERROR `p` does not live long enough
| ^ borrowed value does not live long enough
-LL | //~^ ERROR let bindings in constants are unstable
LL | };
| - borrowed value only lives until here
|
= note: borrowed value must be valid for the static lifetime...
-error: aborting due to 6 previous errors
+error: aborting due to previous error
-Some errors occurred: E0597, E0658.
-For more information about an error, try `rustc --explain E0597`.
+For more information about this error, try `rustc --explain E0597`.
const bad : u32 = {
{
5;
- //~^ ERROR statements in constants are unstable
0
}
};
const bad_two : u32 = {
{
invalid();
- //~^ ERROR statements in constants are unstable
- //~^^ ERROR: calls in constants are limited to constant functions, tuple structs and tuple variants
+ //~^ ERROR: calls in constants are limited to constant functions, tuple structs and tuple variants
0
}
};
const bad_three : u32 = {
{
valid();
- //~^ ERROR statements in constants are unstable
0
}
};
static bad_four : u32 = {
{
5;
- //~^ ERROR statements in statics are unstable
0
}
};
{
invalid();
//~^ ERROR: calls in statics are limited to constant functions, tuple structs and tuple variants
- //~| ERROR statements in statics are unstable
0
}
};
static bad_six : u32 = {
{
valid();
- //~^ ERROR statements in statics are unstable
0
}
};
static mut bad_seven : u32 = {
{
5;
- //~^ ERROR statements in statics are unstable
0
}
};
static mut bad_eight : u32 = {
{
invalid();
- //~^ ERROR statements in statics are unstable
- //~| ERROR: calls in statics are limited to constant functions, tuple structs and tuple variants
+ //~^ ERROR: calls in statics are limited to constant functions, tuple structs and tuple variants
0
}
};
static mut bad_nine : u32 = {
{
valid();
- //~^ ERROR statements in statics are unstable
0
}
};
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/issue-32829-2.rs:7:9
- |
-LL | 5;
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
error[E0015]: calls in constants are limited to constant functions, tuple structs and tuple variants
- --> $DIR/issue-32829-2.rs:15:9
+ --> $DIR/issue-32829-2.rs:14:9
|
LL | invalid();
| ^^^^^^^^^
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/issue-32829-2.rs:15:9
- |
-LL | invalid();
- | ^^^^^^^^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in constants are unstable (see issue #48821)
- --> $DIR/issue-32829-2.rs:24:9
- |
-LL | valid();
- | ^^^^^^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in statics are unstable (see issue #48821)
- --> $DIR/issue-32829-2.rs:32:9
- |
-LL | 5;
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
error[E0015]: calls in statics are limited to constant functions, tuple structs and tuple variants
- --> $DIR/issue-32829-2.rs:40:9
+ --> $DIR/issue-32829-2.rs:36:9
|
LL | invalid();
| ^^^^^^^^^
-error[E0658]: statements in statics are unstable (see issue #48821)
- --> $DIR/issue-32829-2.rs:40:9
- |
-LL | invalid();
- | ^^^^^^^^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in statics are unstable (see issue #48821)
- --> $DIR/issue-32829-2.rs:49:9
- |
-LL | valid();
- | ^^^^^^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in statics are unstable (see issue #48821)
- --> $DIR/issue-32829-2.rs:57:9
- |
-LL | 5;
- | ^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
error[E0015]: calls in statics are limited to constant functions, tuple structs and tuple variants
- --> $DIR/issue-32829-2.rs:65:9
+ --> $DIR/issue-32829-2.rs:58:9
|
LL | invalid();
| ^^^^^^^^^
-error[E0658]: statements in statics are unstable (see issue #48821)
- --> $DIR/issue-32829-2.rs:65:9
- |
-LL | invalid();
- | ^^^^^^^^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error[E0658]: statements in statics are unstable (see issue #48821)
- --> $DIR/issue-32829-2.rs:74:9
- |
-LL | valid();
- | ^^^^^^^
- |
- = help: add #![feature(const_let)] to the crate attributes to enable
-
-error: aborting due to 12 previous errors
+error: aborting due to 3 previous errors
-Some errors occurred: E0015, E0658.
-For more information about an error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0015`.
const fn x() {
- let t = true; //~ ERROR local variables in const fn
- let x = || t;
+ let t = true;
+ let x = || t; //~ ERROR function pointers in const fn are unstable
}
fn main() {}
-error: local variables in const fn are unstable
- --> $DIR/issue-37550.rs:2:9
+error: function pointers in const fn are unstable
+ --> $DIR/issue-37550.rs:3:9
|
-LL | let t = true; //~ ERROR local variables in const fn
+LL | let x = || t; //~ ERROR function pointers in const fn are unstable
| ^
error: aborting due to previous error
static boxed: Box<RefCell<isize>> = box RefCell::new(0);
//~^ ERROR allocations are not allowed in statics
//~| ERROR `std::cell::RefCell<isize>` cannot be shared between threads safely [E0277]
+//~| ERROR static contains unimplemented expression type
fn main() { }
LL | static boxed: Box<RefCell<isize>> = box RefCell::new(0);
| ^^^^^^^^^^^^^^^^^^^ allocation not allowed in statics
+error[E0019]: static contains unimplemented expression type
+ --> $DIR/issue-7364.rs:6:41
+ |
+LL | static boxed: Box<RefCell<isize>> = box RefCell::new(0);
+ | ^^^^^^^^^^^^^^^
+
error[E0277]: `std::cell::RefCell<isize>` cannot be shared between threads safely
--> $DIR/issue-7364.rs:6:1
|
= note: required because it appears within the type `std::boxed::Box<std::cell::RefCell<isize>>`
= note: shared static variables must have a type that implements `Sync`
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
-Some errors occurred: E0010, E0277.
+Some errors occurred: E0010, E0019, E0277.
For more information about an error, try `rustc --explain E0010`.
static mut a: Box<isize> = box 3;
//~^ ERROR allocations are not allowed in statics
+//~| ERROR static contains unimplemented expression type
fn main() {}
LL | static mut a: Box<isize> = box 3;
| ^^^^^ allocation not allowed in statics
-error: aborting due to previous error
+error[E0019]: static contains unimplemented expression type
+ --> $DIR/static-mut-not-constant.rs:3:32
+ |
+LL | static mut a: Box<isize> = box 3;
+ | ^
+
+error: aborting due to 2 previous errors
-For more information about this error, try `rustc --explain E0010`.
+Some errors occurred: E0010, E0019.
+For more information about an error, try `rustc --explain E0010`.
// compile-pass
-#![feature(const_let)]
#![feature(underscore_const_names)]
trait Trt {}
-#![feature(rustc_attrs, const_let, const_fn)]
+#![feature(rustc_attrs, const_fn)]
#[rustc_layout_scalar_valid_range_start(1)]
#[repr(transparent)]
-#![feature(rustc_attrs, const_let, const_fn)]
+#![feature(rustc_attrs, const_fn)]
use std::cell::Cell;
-#![feature(rustc_attrs, const_let, const_fn)]
+#![feature(rustc_attrs, const_fn)]
#[rustc_layout_scalar_valid_range_start(1)]
#[repr(transparent)]
-#![feature(const_let)]
-
pub static mut A: u32 = 0;
pub static mut B: () = unsafe { A = 1; };
//~^ ERROR could not evaluate static initializer
error[E0080]: could not evaluate static initializer
- --> $DIR/write-to-static-mut-in-static.rs:4:33
+ --> $DIR/write-to-static-mut-in-static.rs:2:33
|
LL | pub static mut B: () = unsafe { A = 1; };
| ^^^^^ tried to modify a static's initial value from another static's initializer
error[E0391]: cycle detected when const-evaluating `C`
- --> $DIR/write-to-static-mut-in-static.rs:7:34
+ --> $DIR/write-to-static-mut-in-static.rs:5:34
|
LL | pub static mut C: u32 = unsafe { C = 1; 0 };
| ^^^^^
|
note: ...which requires const-evaluating `C`...
- --> $DIR/write-to-static-mut-in-static.rs:7:1
+ --> $DIR/write-to-static-mut-in-static.rs:5:1
|
LL | pub static mut C: u32 = unsafe { C = 1; 0 };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: ...which again requires const-evaluating `C`, completing the cycle
note: cycle used when const-evaluating + checking `C`
- --> $DIR/write-to-static-mut-in-static.rs:7:1
+ --> $DIR/write-to-static-mut-in-static.rs:5:1
|
LL | pub static mut C: u32 = unsafe { C = 1; 0 };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
projects / rust.git / commitdiff