}
/// Returns the root output directory for all Cargo output in a given stage,
- /// running a particular compiler, wehther or not we're building the
+ /// running a particular compiler, whether or not we're building the
/// standard library, and targeting the specified architecture.
fn cargo_out(&self,
compiler: Compiler,
//! Compilation of native dependencies like LLVM.
//!
//! Native projects like LLVM unfortunately aren't suited just yet for
-//! compilation in build scripts that Cargo has. This is because thie
+//! compilation in build scripts that Cargo has. This is because the
//! compilation takes a *very* long time but also because we don't want to
//! compile LLVM 3 times as part of a normal bootstrap (we want it cached).
//!
-Subproject commit 6f1a03dae6bcea44976918186f2d554186b3499c
+Subproject commit d09c9e8144ed32170b7596abb145ade8b097acaf
-Subproject commit f570bcb681771d691aa4fdb8dfcfad1939844bf5
+Subproject commit a4322ccb289a43cc238d4536982f184a3eec9ba7
-Subproject commit 1abfbaa70313fdf527cf799ffd9b9a096a62105c
+Subproject commit 266d429a48468371d2d90669f6a30dd659bb4bdb
+++ /dev/null
-# `rvalue_static_promotion`
-
-The tracking issue for this feature is: [#38865]
-
-[#38865]: https://github.com/rust-lang/rust/issues/38865
-
-------------------------
-
-The `rvalue_static_promotion` feature allows directly creating `'static` references to
-constant `rvalue`s, which in particular allowing for more concise code in the common case
-in which a `'static` reference is all that's needed.
-
-
-## Examples
-
-```rust
-#![feature(rvalue_static_promotion)]
-
-fn main() {
- let DEFAULT_VALUE: &'static u32 = &42;
- assert_eq!(*DEFAULT_VALUE, 42);
-}
-```
/// Creates a layout describing the record for `self` followed by
/// `next` with no additional padding between the two. Since no
/// padding is inserted, the alignment of `next` is irrelevant,
- /// and is not incoporated *at all* into the resulting layout.
+ /// and is not incorporated *at all* into the resulting layout.
///
/// Returns `(k, offset)`, where `k` is layout of the concatenated
/// record and `offset` is the relative location, in bytes, of the
/// to allocate that block of memory.
unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout);
- /// Allocator-specific method for signalling an out-of-memory
+ /// Allocator-specific method for signaling an out-of-memory
/// condition.
///
/// `oom` aborts the thread or process, optionally performing
/// unsatisfied allocation request (signaled by an error such as
/// `AllocErr::Exhausted`), and wish to abandon computation rather
/// than attempt to recover locally. Such clients should pass the
- /// signalling error value back into `oom`, where the allocator
+ /// signaling error value back into `oom`, where the allocator
/// may incorporate that error value into its diagnostic report
/// before aborting.
///
}
impl<Node, Type> Handle<Node, Type> {
- /// Retrieves the node that contains the edge of key/value pair this handle pointes to.
+ /// Retrieves the node that contains the edge of key/value pair this handle points to.
pub fn into_node(self) -> Node {
self.node
}
/// Attempts to ensure that the buffer contains at least enough space to hold
/// `used_cap + needed_extra_cap` elements. If it doesn't already have
/// enough capacity, will reallocate in place enough space plus comfortable slack
- /// space to get amortized `O(1)` behaviour. Will limit this behaviour
+ /// space to get amortized `O(1)` behavior. Will limit this behaviour
/// if it would needlessly cause itself to panic.
///
/// If `used_cap` exceeds `self.cap()`, this may fail to actually allocate
/// the requested space. This is not really unsafe, but the unsafe
- /// code *you* write that relies on the behaviour of this function may break.
+ /// code *you* write that relies on the behavior of this function may break.
///
/// Returns true if the reallocation attempt has succeeded, or false otherwise.
///
/// [`write_u8`]: #method.write_u8
#[stable(feature = "rust1", since = "1.0.0")]
pub trait Hasher {
- /// Completes a round of hashing, producing the output hash generated.
+ /// Returns the hash value for the values written so far.
+ ///
+ /// Despite its name, the method does not reset the hasher’s internal
+ /// state. Additional [`write`]s will continue from the current value.
+ /// If you need to start a fresh hash value, you will have to create
+ /// a new hasher.
///
/// # Examples
///
///
/// println!("Hash is {:x}!", hasher.finish());
/// ```
+ ///
+ /// ['write']: #tymethod.write
#[stable(feature = "rust1", since = "1.0.0")]
fn finish(&self) -> u64;
/// The number of bits in the exponent.
const EXP_BITS: u8;
- /// The number of bits in the singificand, *including* the hidden bit.
+ /// The number of bits in the significand, *including* the hidden bit.
const SIG_BITS: u8;
- /// The number of bits in the singificand, *excluding* the hidden bit.
+ /// The number of bits in the significand, *excluding* the hidden bit.
const EXPLICIT_SIG_BITS: u8;
/// The maximum legal exponent in fractional representation.
/// `MIN_EXP` for integral representation, i.e., with the shift applied.
const MIN_EXP_INT: i16;
- /// The maximum normalized singificand in integral representation.
+ /// The maximum normalized significand in integral representation.
const MAX_SIG: u64;
/// The minimal normalized significand in integral representation.
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-/// A trait for customizing the behaviour of the `?` operator.
+/// A trait for customizing the behavior of the `?` operator.
///
/// A type implementing `Try` is one that has a canonical way to view it
/// in terms of a success/failure dichotomy. This trait allows both
///
/// pub fn lock(&self) {
/// while !self.flag.compare_and_swap(false, true, Ordering::Relaxed) {}
-/// // This fence syncronizes-with store in `unlock`.
+/// // This fence synchronizes-with store in `unlock`.
/// fence(Ordering::Acquire);
/// }
///
//! Generate files suitable for use with [Graphviz](http://www.graphviz.org/)
//!
//! The `render` function generates output (e.g. an `output.dot` file) for
-//! use with [Graphviz](http://www.graphviz.org/) by walking a labelled
+//! use with [Graphviz](http://www.graphviz.org/) by walking a labeled
//! graph. (Graphviz can then automatically lay out the nodes and edges
//! of the graph, and also optionally render the graph as an image or
//! other [output formats](
//!
//! The output from this example renders four nodes that make up the
//! Hasse-diagram for the subsets of the set `{x, y}`. Each edge is
-//! labelled with the ⊆ character (specified using the HTML character
+//! labeled with the ⊆ character (specified using the HTML character
//! entity `&sube`).
//!
//! ```rust
}
struct LabelledGraph {
- /// The name for this graph. Used for labelling generated `digraph`.
+ /// The name for this graph. Used for labeling generated `digraph`.
name: &'static str,
/// Each node is an index into `node_labels`; these labels are
/// The Fisher F distribution `F(m, n)`.
///
-/// This distribution is equivalent to the ratio of two normalised
+/// This distribution is equivalent to the ratio of two normalized
/// chi-squared distributions, that is, `F(m,n) = (χ²(m)/m) /
/// (χ²(n)/n)`.
pub struct FisherF {
rng
}
- /// Initialises `self`. If `use_rsl` is true, then use the current value
+ /// Initializes `self`. If `use_rsl` is true, then use the current value
/// of `rsl` as a seed, otherwise construct one algorithmically (not
/// randomly).
fn init(&mut self, use_rsl: bool) {
rng
}
- /// Initialises `self`. If `use_rsl` is true, then use the current value
+ /// Initializes `self`. If `use_rsl` is true, then use the current value
/// of `rsl` as a seed, otherwise construct one algorithmically (not
/// randomly).
fn init(&mut self, use_rsl: bool) {
/// This method does *not* have a requirement to bear any fixed
/// relationship to the other methods, for example, it does *not*
/// have to result in the same output as progressively filling
- /// `dest` with `self.gen::<u8>()`, and any such behaviour should
+ /// `dest` with `self.gen::<u8>()`, and any such behavior should
/// not be relied upon.
///
/// This method should guarantee that `dest` is entirely filled
rng: R,
generation_threshold: usize,
bytes_generated: usize,
- /// Controls the behaviour when reseeding the RNG.
+ /// Controls the behavior when reseeding the RNG.
pub reseeder: Rsdr,
}
struct Foo { x: &bool } // error
struct Foo<'a> { x: &'a bool } // correct
+struct Bar { x: Foo }
+ ^^^ expected lifetime parameter
+struct Bar<'a> { x: Foo<'a> } // correct
+
enum Bar { A(u8), B(&bool), } // error
enum Bar<'a> { A(u8), B(&'a bool), } // correct
/// Returns the nearest enclosing scope. A scope is an item or block.
/// FIXME it is not clear to me that all items qualify as scopes - statics
- /// and associated types probably shouldn't, for example. Behaviour in this
+ /// and associated types probably shouldn't, for example. Behavior in this
/// regard should be expected to be highly unstable.
pub fn get_enclosing_scope(&self, id: NodeId) -> Option<NodeId> {
match self.walk_parent_nodes(id, |node| match *node {
//! a span, but also more information so that we can generate a meaningful
//! error message.
//!
-//! Having a catalogue of all the different reasons an error can arise is
+//! Having a catalog of all the different reasons an error can arise is
//! also useful for other reasons, like cross-referencing FAQs etc, though
//! we are not really taking advantage of this yet.
//!
}
/// The opportunistic type and region resolver is similar to the
-/// opportunistic type resolver, but also opportunistly resolves
+/// opportunistic type resolver, but also opportunistically resolves
/// regions. It is useful for canonicalization.
pub struct OpportunisticTypeAndRegionResolver<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
pub reference: &'static str // e.g., a URL for an issue/PR/RFC or error code
}
-/// The targed of the `by_name` map, which accounts for renaming/deprecation.
+/// The target of the `by_name` map, which accounts for renaming/deprecation.
enum TargetLint {
/// A direct lint target
Id(LintId),
let promotable = self.tcx.rvalue_promotable_to_static.borrow().get(&id).cloned()
.unwrap_or(false);
- // When the corresponding feature isn't toggled, only promote `[T; 0]`.
+ // Always promote `[T; 0]` (even when e.g. borrowed mutably).
let promotable = match expr_ty.sty {
ty::TyArray(_, 0) => true,
- _ => promotable && self.tcx.sess.features.borrow().rvalue_static_promotion,
+ _ => promotable,
};
// Compute maximum lifetime of this rvalue. This is 'static if
/// (M1.): Misc extent of the whole `let a = ...;` statement.
/// (M2.): Misc extent of the `f()` expression.
/// (M3.): Misc extent of the `f().g(..)` expression.
-/// (M4.): Misc extent of the block labelled `'b:`.
+/// (M4.): Misc extent of the block labeled `'b:`.
/// (M5.): Misc extent of the `let x = d();` statement
/// (D6.): DestructionScope for temporaries created during M5.
/// (R7.): Remainder extent for block `'b:`, stmt 0 (let x = ...).
///
/// Reverse postorder is the reverse order of a postorder traversal.
/// This is different to a preorder traversal and represents a natural
-/// linearisation of control-flow.
+/// linearization of control-flow.
///
/// ```text
///
/// consists of a list of obligations that must be (eventually)
/// satisfied. The job is to track which are satisfied, which yielded
/// errors, and which are still pending. At any point, users can call
-/// `select_where_possible`, and the fulfilment context will try to do
+/// `select_where_possible`, and the fulfillment context will try to do
/// selection, retaining only those obligations that remain
/// ambiguous. This may be helpful in pushing type inference
/// along. Once all type inference constraints have been generated, the
/// A vector of every trait accessible in the whole crate
/// (i.e. including those from subcrates). This is used only for
- /// error reporting, and so is lazily initialised and generally
+ /// error reporting, and so is lazily initialized and generally
/// shouldn't taint the common path (hence the RefCell).
pub all_traits: RefCell<Option<Vec<DefId>>>,
}
/// The minimal set of DefIds required to represent the whole set.
/// If A and B are DefIds in the DefIdForest, and A is a descendant
/// of B, then only B will be in root_ids.
- /// We use a SmallVec here because (for its use for cacheing inhabitedness)
+ /// We use a SmallVec here because (for its use for caching inhabitedness)
/// its rare that this will contain even two ids.
root_ids: SmallVec<[DefId; 1]>,
}
///
/// The process of doing that is called "skolemization". The bound regions
/// are replaced by skolemized markers, which don't satisfy any relation
-/// not explicity provided.
+/// not explicitly provided.
///
/// There are 2 kinds of skolemized regions in rustc: `ReFree` and
/// `ReSkolemized`. When checking an item's body, `ReFree` is supposed
//! Space for up to N elements is provided on the stack. If more elements are collected, Vec is
//! used to store the values on the heap.
//!
-//! The N above is determined by Array's implementor, by way of an associatated constant.
+//! The N above is determined by Array's implementor, by way of an associated constant.
use std::ops::{Deref, DerefMut};
use std::iter::{self, IntoIterator, FromIterator};
/// A write-once variable. When constructed, it is empty, and
/// can only be set once.
///
-/// Ivars ensure that data that can only be initialised once. A full
+/// Ivars ensure that data that can only be initialized once. A full
/// implementation is used for concurrency and blocks on a read of an
/// unfulfilled value. This implementation is more minimal and panics
/// if you attempt to read the value before it has been set. It is also
//! used to store the values on the heap. SmallVec is similar to AccumulateVec, but adds
//! the ability to push elements.
//!
-//! The N above is determined by Array's implementor, by way of an associatated constant.
+//! The N above is determined by Array's implementor, by way of an associated constant.
use std::ops::{Deref, DerefMut};
use std::iter::{IntoIterator, FromIterator};
}
}
-/// CompileController is used to customise compilation, it allows compilation to
+/// CompileController is used to customize compilation, it allows compilation to
/// be stopped and/or to call arbitrary code at various points in compilation.
/// It also allows for various flags to be set to influence what information gets
/// collected during compilation.
}
// Note: Also used by librustdoc, see PR #43348. Consider moving this struct elsewhere.
+//
+// FIXME: Currently the `everybody_loops` transformation is not applied to:
+// * `const fn`, due to issue #43636 that `loop` is not supported for const evaluation. We are
+// waiting for miri to fix that.
+// * `impl Trait`, due to issue #43869 that functions returning impl Trait cannot be diverging.
+// Solving this may require `!` to implement every trait, which relies on the an even more
+// ambitious form of the closed RFC #1637. See also [#34511].
+//
+// [#34511]: https://github.com/rust-lang/rust/issues/34511#issuecomment-322340401
pub struct ReplaceBodyWithLoop {
within_static_or_const: bool,
}
self.within_static_or_const = old_const;
ret
}
+
+ fn should_ignore_fn(ret_ty: &ast::FnDecl) -> bool {
+ if let ast::FunctionRetTy::Ty(ref ty) = ret_ty.output {
+ fn involves_impl_trait(ty: &ast::Ty) -> bool {
+ match ty.node {
+ ast::TyKind::ImplTrait(_) => true,
+ ast::TyKind::Slice(ref subty) |
+ ast::TyKind::Array(ref subty, _) |
+ ast::TyKind::Ptr(ast::MutTy { ty: ref subty, .. }) |
+ ast::TyKind::Rptr(_, ast::MutTy { ty: ref subty, .. }) |
+ ast::TyKind::Paren(ref subty) => involves_impl_trait(subty),
+ ast::TyKind::Tup(ref tys) => tys.iter().any(|subty| involves_impl_trait(subty)),
+ _ => false,
+ }
+ }
+ involves_impl_trait(ty)
+ } else {
+ false
+ }
+ }
}
impl fold::Folder for ReplaceBodyWithLoop {
fn fold_item_kind(&mut self, i: ast::ItemKind) -> ast::ItemKind {
let is_const = match i {
ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => true,
- ast::ItemKind::Fn(_, _, ref constness, _, _, _) =>
- constness.node == ast::Constness::Const,
+ ast::ItemKind::Fn(ref decl, _, ref constness, _, _, _) =>
+ constness.node == ast::Constness::Const || Self::should_ignore_fn(decl),
_ => false,
};
self.run(is_const, |s| fold::noop_fold_item_kind(i, s))
fn fold_trait_item(&mut self, i: ast::TraitItem) -> SmallVector<ast::TraitItem> {
let is_const = match i.node {
ast::TraitItemKind::Const(..) => true,
- ast::TraitItemKind::Method(ast::MethodSig { ref constness, .. }, _) =>
- constness.node == ast::Constness::Const,
+ ast::TraitItemKind::Method(ast::MethodSig { ref decl, ref constness, .. }, _) =>
+ constness.node == ast::Constness::Const || Self::should_ignore_fn(decl),
_ => false,
};
self.run(is_const, |s| fold::noop_fold_trait_item(i, s))
fn fold_impl_item(&mut self, i: ast::ImplItem) -> SmallVector<ast::ImplItem> {
let is_const = match i.node {
ast::ImplItemKind::Const(..) => true,
- ast::ImplItemKind::Method(ast::MethodSig { ref constness, .. }, _) =>
- constness.node == ast::Constness::Const,
+ ast::ImplItemKind::Method(ast::MethodSig { ref decl, ref constness, .. }, _) =>
+ constness.node == ast::Constness::Const || Self::should_ignore_fn(decl),
_ => false,
};
self.run(is_const, |s| fold::noop_fold_impl_item(i, s))
}
/// Cancel the diagnostic (a structured diagnostic must either be emitted or
- /// cancelled or it will panic when dropped).
+ /// canceled or it will panic when dropped).
/// BEWARE: if this DiagnosticBuilder is an error, then creating it will
- /// bump the error count on the Handler and cancelling it won't undo that.
+ /// bump the error count on the Handler and canceling it won't undo that.
/// If you want to decrement the error count you should use `Handler::cancel`.
pub fn cancel(&mut self) {
self.level = Level::Cancelled;
}
}
-/// Destructor bomb - a `DiagnosticBuilder` must be either emitted or cancelled
+/// Destructor bomb - a `DiagnosticBuilder` must be either emitted or canceled
/// or we emit a bug.
impl<'a> Drop for DiagnosticBuilder<'a> {
fn drop(&mut self) {
.map(|_| " ")
.collect::<String>();
- /// Return wether `style`, or the override if present and the style is `NoStyle`.
+ /// Return whether `style`, or the override if present and the style is `NoStyle`.
fn style_or_override(style: Style, override_style: Option<Style>) -> Style {
if let Some(o) = override_style {
if style == Style::NoStyle {
}
impl Annotation {
- /// Wether this annotation is a vertical line placeholder.
+ /// Whether this annotation is a vertical line placeholder.
pub fn is_line(&self) -> bool {
if let AnnotationType::MultilineLine(_) = self.annotation_type {
true
//! representation of the DAG):
//!
//! - SCCs, in the form of a union-find repr that can convert each node to
-//! its *cycle head* (an arbitrarly chosen representative from the cycle)
+//! its *cycle head* (an arbitrarily chosen representative from the cycle)
//! - a vector of *leaf nodes*, just a convenience
//! - a vector of *parents* for each node (in some cases, nodes have no parents,
//! or their parent is another member of same cycle; in that case, the vector
pass.run_pass(tcx, source, mir);
+ for (index, promoted_mir) in mir.promoted.iter_enumerated_mut() {
+ let promoted_source = MirSource::Promoted(source.item_id(), index);
+ pass.run_pass(tcx, promoted_source, promoted_mir);
+
+ // Let's make sure we don't miss any nested instances
+ assert!(promoted_mir.promoted.is_empty());
+ }
+
for hook in tcx.mir_passes.hooks() {
hook.on_mir_pass(tcx, suite, pass_num, &pass.name(), source, &mir, true);
}
Attribute::NoUnwind.toggle_llfn(Function, val, !can_unwind);
}
-/// Tell LLVM whether it should optimise function for size.
+/// Tell LLVM whether it should optimize function for size.
#[inline]
#[allow(dead_code)] // possibly useful function
pub fn set_optimize_for_size(val: ValueRef, optimize: bool) {
}
}
-/// Create the `main` function which will initialise the rust runtime and call
+/// Create the `main` function which will initialize the rust runtime and call
/// users main function.
fn maybe_create_entry_wrapper(ccx: &CrateContext) {
let (main_def_id, span) = match *ccx.sess().entry_fn.borrow() {
//! encounters a recursive reference, it will hit the cache and does not try to
//! describe the type anew.
//!
-//! This behaviour is encapsulated in the 'RecursiveTypeDescription' enum,
+//! This behavior is encapsulated in the 'RecursiveTypeDescription' enum,
//! which represents a kind of continuation, storing all state needed to
//! continue traversal at the type members after the type has been registered
//! with the cache. (This implementation approach might be a tad over-
//! (2) Structs, enums and traits have a multipart identifier
//!
//! (1) The first part is the SVH (strict version hash) of the crate they
-//! wereoriginally defined in
+//! were originally defined in
//!
//! (2) The second part is the ast::NodeId of the definition in their
-//! originalcrate
+//! original crate
//!
//! (3) The final part is a concatenation of the type IDs of their concrete
-//! typearguments if they are generic types.
+//! type arguments if they are generic types.
//!
//! (3) Tuple-, pointer and function types are structurally identified, which
//! means that they are equivalent if their component types are equivalent
if !static_sources.is_empty() {
err.note("found the following associated functions; to be used as methods, \
functions must have a `self` parameter");
+ err.help(&format!("try with `{}::{}`", self.ty_to_string(actual), item_name));
report_candidates(&mut err, static_sources);
}
type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
"attempted to take value of method `{}` on type `{}`",
field.node, expr_t)
- .help("maybe a `()` to call it is missing? \
- If not, try an anonymous function")
+ .help("maybe a `()` to call it is missing?")
.emit();
self.tcx().types.err
} else {
}
/// Trait that controls writing the output of syntax highlighting. Users should
-/// implement this trait to customise writing output.
+/// implement this trait to customize writing output.
///
/// The classifier will call into the `Writer` implementation as it finds spans
/// of text to highlight. Exactly how that text should be highlighted is up to
/// self.top_level, D is in C.children, and C, E, F, G are in
/// self.chain.
///
- /// When we attempt to push H, we realise that first G is not the
+ /// When we attempt to push H, we realize that first G is not the
/// parent (level is too high) so it is popped from chain and put
/// into F.children, then F isn't the parent (level is equal, aka
/// sibling), so it's also popped and put into E.children.
})
}
-/// Prints an uniformised error message on the standard error output
+/// Prints an uniformized error message on the standard error output
fn print_error<T>(error_message: T) where T: Display {
writeln!(
&mut io::stderr(),
///
/// It is your responsibility to make sure that the underlying memory is not
/// freed too early. For example, the following code will cause undefined
- /// behaviour when `ptr` is used inside the `unsafe` block:
+ /// behavior when `ptr` is used inside the `unsafe` block:
///
/// ```no_run
/// use std::ffi::{CString};
/// Creates a new `OsString` with the given capacity.
///
- /// The string will be able to hold exactly `capacity` lenth units of other
+ /// The string will be able to hold exactly `capacity` length units of other
/// OS strings without reallocating. If `capacity` is 0, the string will not
/// allocate.
///
impl OnceState {
/// Returns whether the associated [`Once`] has been poisoned.
///
- /// Once an initalization routine for a [`Once`] has panicked it will forever
+ /// Once an initialization routine for a [`Once`] has panicked it will forever
/// indicate to future forced initialization routines that it is poisoned.
///
/// [`Once`]: struct.Once.html
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-//! Global initialization and retreival of command line arguments.
+//! Global initialization and retrieval of command line arguments.
//!
//! On some platforms these are stored during runtime startup,
//! and on some they are retrieved from the system on demand.
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-//! Global initialization and retreival of command line arguments.
+//! Global initialization and retrieval of command line arguments.
//!
//! On some platforms these are stored during runtime startup,
//! and on some they are retrieved from the system on demand.
/// implementing low-level shared resources or synchronization primitives.
///
/// However programmers will usually prefer to use, [`channel`]s, [`Condvar`]s,
-/// [`Mutex`]es or [`join`] for their synchronisation routines, as they avoid
+/// [`Mutex`]es or [`join`] for their synchronization routines, as they avoid
/// thinking about thread scheduling.
///
/// Note that [`channel`]s for example are implemented using this primitive.
/// println!("{}", elapsed.as_secs());
/// }
/// Err(e) => {
-/// // an error occured!
+/// // an error occurred!
/// println!("Error: {:?}", e);
/// }
/// }
// Allows `repr(align(u16))` struct attribute (RFC 1358)
(active, repr_align, "1.17.0", Some(33626)),
- // See rust-lang/rfcs#1414. Allows code like `let x: &'static u32 = &42` to work.
- (active, rvalue_static_promotion, "1.15.1", Some(38865)),
-
// Used to preserve symbols (see llvm.used)
(active, used, "1.18.0", Some(40289)),
(accepted, associated_consts, "1.20.0", Some(29646)),
// Usage of the `compile_error!` macro
(accepted, compile_error, "1.20.0", Some(40872)),
+ // See rust-lang/rfcs#1414. Allows code like `let x: &'static u32 = &42` to work.
+ (accepted, rvalue_static_promotion, "1.21.0", Some(38865)),
);
// If you change this, please modify src/doc/unstable-book as well. You must
//! A JSON emitter for errors.
//!
//! This works by converting errors to a simplified structural format (see the
-//! structs at the start of the file) and then serialising them. These should
+//! structs at the start of the file) and then serializing them. These should
//! contain as much information about the error as possible.
//!
//! The format of the JSON output should be considered *unstable*. For now the
//! and lifetimes for methods.)
//! - Additional bounds on the type parameters (`TraitDef.additional_bounds`)
//!
-//! The most important thing for implementers is the `Substructure` and
+//! The most important thing for implementors is the `Substructure` and
//! `SubstructureFields` objects. The latter groups 5 possibilities of the
//! arguments:
//!
// Test lifetimes are linked properly when we take reference
// to interior.
+fn id<T>(x: T) -> T { x }
+
struct Foo(isize);
fn foo<'a>() -> &'a isize {
- let &Foo(ref x) = &Foo(3); //~ ERROR borrowed value does not live long enough
+ let &Foo(ref x) = &id(Foo(3)); //~ ERROR borrowed value does not live long enough
x
}
+++ /dev/null
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[allow(unused_variables)]
-fn main() {
- let x: &'static u32 = &42; //~ error: does not live long enough
- let y: &'static Option<u32> = &None; //~ error: does not live long enough
-}
// This file must never have a trailing newline
+fn id<T>(x: T) -> T { x }
+
fn main() {
let x = Some(3);
- let y = x.as_ref().unwrap_or(&5); //~ ERROR: borrowed value does not live long enough
+ let y = x.as_ref().unwrap_or(&id(5)); //~ ERROR: borrowed value does not live long enough
}
#![feature(fn_traits)]
+fn id<T>(x: T) -> T { x }
+
pub fn foo<'a, F: Fn(&'a ())>(bar: F) {
bar.call((
- &(), //~ ERROR borrowed value does not live long enough
+ &id(()), //~ ERROR borrowed value does not live long enough
));
}
fn main() {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+fn id<T>(x: T) -> T { x }
+
const FOO: usize = 3;
-fn foo() -> &'static usize { &FOO }
+fn foo() -> &'static usize { &id(FOO) }
//~^ ERROR: borrowed value does not live long enough
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// Regression test for issue #27591.
+// Regression test for issue #27592.
fn write<'a, F: ::std::ops::FnOnce()->::std::fmt::Arguments<'a> + 'a>(fcn: F) {
use std::fmt::Write;
}
fn main() {
- write(|| format_args!("{}", "Hello world"));
+ write(|| format_args!("{}", String::from("Hello world")));
//~^ ERROR borrowed value does not live long enough
//~| ERROR borrowed value does not live long enough
}
// are treated as rvalues and their lifetime is not bounded to
// the static scope.
+fn id<T>(x: T) -> T { x }
+
struct Test;
enum MyEnum {
}
fn structLifetime<'a>() -> &'a Test {
- let testValue = &Test; //~ ERROR borrowed value does not live long enough
+ let testValue = &id(Test);
+ //~^ ERROR borrowed value does not live long enough
testValue
}
fn variantLifetime<'a>() -> &'a MyEnum {
- let testValue = &MyEnum::Variant1; //~ ERROR borrowed value does not live long enough
+ let testValue = &id(MyEnum::Variant1);
+ //~^ ERROR borrowed value does not live long enough
testValue
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+fn id<T>(x: T) -> T { x }
+
fn f(_x: &isize) -> &isize {
- return &3; //~ ERROR borrowed value does not live long enough
+ return &id(3); //~ ERROR borrowed value does not live long enough
}
fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+fn id<T>(x: T) -> T { x }
+
fn foo(cond: bool) {
// Here we will infer a type that uses the
// region of the if stmt then block:
let mut x;
if cond {
- x = &3; //~ ERROR borrowed value does not live long enough
+ x = &id(3); //~ ERROR borrowed value does not live long enough
assert_eq!(*x, 3);
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+fn id<T>(x: T) -> T { x }
+
struct StateMachineIter<'a> {
statefn: &'a StateMachineFunc<'a>
}
}
fn state1(self_: &mut StateMachineIter) -> Option<&'static str> {
- self_.statefn = &(state2 as StateMachineFunc);
+ self_.statefn = &id(state2 as StateMachineFunc);
//~^ ERROR borrowed value does not live long enough
return Some("state1");
}
fn state2(self_: &mut StateMachineIter) -> Option<(&'static str)> {
- self_.statefn = &(state3 as StateMachineFunc);
+ self_.statefn = &id(state3 as StateMachineFunc);
//~^ ERROR borrowed value does not live long enough
return Some("state2");
}
fn state3(self_: &mut StateMachineIter) -> Option<(&'static str)> {
- self_.statefn = &(finished as StateMachineFunc);
+ self_.statefn = &id(finished as StateMachineFunc);
//~^ ERROR borrowed value does not live long enough
return Some("state3");
}
fn state_iter() -> StateMachineIter<'static> {
StateMachineIter {
- statefn: &(state1 as StateMachineFunc) //~ ERROR borrowed value does not live long enough
+ statefn: &id(state1 as StateMachineFunc)
+ //~^ ERROR borrowed value does not live long enough
}
}
#![feature(box_syntax)]
+fn id<T>(x: T) -> T { x }
+
fn f<T:'static>(_: T) {}
fn main() {
let x: Box<_> = box 3;
f(x);
- let x = &3; //~ ERROR borrowed value does not live long enough
+ let x = &id(3); //~ ERROR borrowed value does not live long enough
f(x);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-#![feature(rvalue_static_promotion)]
-
#[allow(unused_variables)]
fn main() {
let x: &'static u32 = &42;
--- /dev/null
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(conservative_impl_trait)]
+
+pub fn g() -> impl Iterator<Item=u8> {
+ Some(1u8).into_iter()
+}
+
+pub fn h() -> (impl Iterator<Item=u8>) {
+ Some(1u8).into_iter()
+}
+
+pub fn i() -> impl Iterator<Item=u8> + 'static {
+ Some(1u8).into_iter()
+}
+
+pub fn j() -> impl Iterator<Item=u8> + Clone {
+ Some(1u8).into_iter()
+}
+
+// @has issue_43869/fn.g.html
+// @has issue_43869/fn.h.html
+// @has issue_43869/fn.i.html
+// @has issue_43869/fn.j.html
| ^
|
= note: found the following associated functions; to be used as methods, functions must have a `self` parameter
+ = help: try with `{integer}::f`
note: candidate #1 is defined in the trait `issue_41652_b::Tr`
--> $DIR/auxiliary/issue_41652_b.rs:14:5
|
// except according to those terms.
fn f() {
- let x = [1].iter();
+ let x = vec![1].iter();
}
fn main() {
error[E0597]: borrowed value does not live long enough
- --> $DIR/borrowck-let-suggestion.rs:12:23
+ --> $DIR/borrowck-let-suggestion.rs:12:27
|
-12 | let x = [1].iter();
- | --- ^ temporary value dropped here while still borrowed
+12 | let x = vec![1].iter();
+ | ------- ^ temporary value dropped here while still borrowed
| |
| temporary value created here
13 | }
| - temporary value needs to live until here
|
= note: consider using a `let` binding to increase its lifetime
+ = note: this error originates in a macro outside of the current crate
error: aborting due to previous error
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+fn id<T>(x: T) -> T { x }
+
fn f() {
let old = ['o']; // statement 0
let mut v1 = Vec::new(); // statement 1
let mut v3 = Vec::new(); // statement 5
- v3.push(&'x'); // statement 6
+ v3.push(&id('x')); // statement 6
//~^ ERROR borrowed value does not live long enough
//~| NOTE temporary value created here
//~| NOTE temporary value only lives until here
let mut v4 = Vec::new(); // (sub) statement 0
- v4.push(&'y');
+ v4.push(&id('y'));
//~^ ERROR borrowed value does not live long enough
//~| NOTE temporary value created here
//~| NOTE temporary value only lives until here
let mut v5 = Vec::new(); // statement 8
- v5.push(&'z');
+ v5.push(&id('z'));
//~^ ERROR borrowed value does not live long enough
//~| NOTE temporary value created here
//~| NOTE temporary value only lives until here
error[E0597]: `young[..]` does not live long enough
- --> $DIR/borrowck-let-suggestion-suffixes.rs:52:1
+ --> $DIR/borrowck-let-suggestion-suffixes.rs:54:1
|
-19 | v2.push(&young[0]); // statement 4
+21 | v2.push(&young[0]); // statement 4
| -------- borrow occurs here
...
-52 | }
+54 | }
| ^ `young[..]` dropped here while still borrowed
|
= note: values in a scope are dropped in the opposite order they are created
error[E0597]: borrowed value does not live long enough
- --> $DIR/borrowck-let-suggestion-suffixes.rs:24:18
+ --> $DIR/borrowck-let-suggestion-suffixes.rs:26:22
|
-24 | v3.push(&'x'); // statement 6
- | --- ^ temporary value dropped here while still borrowed
+26 | v3.push(&id('x')); // statement 6
+ | ------- ^ temporary value dropped here while still borrowed
| |
| temporary value created here
...
-52 | }
+54 | }
| - temporary value needs to live until here
|
= note: consider using a `let` binding to increase its lifetime
error[E0597]: borrowed value does not live long enough
- --> $DIR/borrowck-let-suggestion-suffixes.rs:34:22
+ --> $DIR/borrowck-let-suggestion-suffixes.rs:36:26
|
-34 | v4.push(&'y');
- | --- ^ temporary value dropped here while still borrowed
+36 | v4.push(&id('y'));
+ | ------- ^ temporary value dropped here while still borrowed
| |
| temporary value created here
...
-40 | } // (statement 7)
+42 | } // (statement 7)
| - temporary value needs to live until here
|
= note: consider using a `let` binding to increase its lifetime
error[E0597]: borrowed value does not live long enough
- --> $DIR/borrowck-let-suggestion-suffixes.rs:45:18
+ --> $DIR/borrowck-let-suggestion-suffixes.rs:47:22
|
-45 | v5.push(&'z');
- | --- ^ temporary value dropped here while still borrowed
+47 | v5.push(&id('z'));
+ | ------- ^ temporary value dropped here while still borrowed
| |
| temporary value created here
...
-52 | }
+54 | }
| - temporary value needs to live until here
|
= note: consider using a `let` binding to increase its lifetime
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+fn id<T>(x: T) -> T { x }
+
fn main() {
let v = vec![
- &3
+ &id(3)
];
for &&x in &v {
error[E0597]: borrowed value does not live long enough
- --> $DIR/issue-15480.rs:14:6
+ --> $DIR/issue-15480.rs:16:6
|
-13 | &3
- | - temporary value created here
-14 | ];
+15 | &id(3)
+ | ----- temporary value created here
+16 | ];
| ^ temporary value dropped here while still borrowed
...
-19 | }
+21 | }
| - temporary value needs to live until here
|
= note: consider using a `let` binding to increase its lifetime
| ^^
|
= note: found the following associated functions; to be used as methods, functions must have a `self` parameter
+ = help: try with `usize::f9`
note: candidate #1 is defined in the trait `CtxtFn`
--> $DIR/issue-7575.rs:16:5
|
| ^^^
|
= note: found the following associated functions; to be used as methods, functions must have a `self` parameter
+ = help: try with `Myisize::fff`
note: candidate #1 is defined in an impl for the type `Myisize`
--> $DIR/issue-7575.rs:51:5
|
| ^^^^^^
|
= note: found the following associated functions; to be used as methods, functions must have a `self` parameter
+ = help: try with `T::is_str`
note: candidate #1 is defined in the trait `ManyImplTrait`
--> $DIR/issue-7575.rs:57:5
|
#![feature(box_syntax)]
+fn id<T>(x: T) -> T { x }
+
trait Foo { }
impl<'a> Foo for &'a isize { }
fn main() {
let blah;
{
- let ss: &isize = &1;
+ let ss: &isize = &id(1);
blah = box ss as Box<Foo>;
}
}
error[E0597]: borrowed value does not live long enough
- --> $DIR/regions-close-over-borrowed-ref-in-obj.rs:22:5
+ --> $DIR/regions-close-over-borrowed-ref-in-obj.rs:24:5
|
-20 | let ss: &isize = &1;
- | - temporary value created here
-21 | blah = box ss as Box<Foo>;
-22 | }
+22 | let ss: &isize = &id(1);
+ | ----- temporary value created here
+23 | blah = box ss as Box<Foo>;
+24 | }
| ^ temporary value dropped here while still borrowed
-23 | }
+25 | }
| - temporary value needs to live until here
error: aborting due to previous error
fn main() {
let y;
{
- let x: &[isize] = &[1, 2, 3, 4, 5];
+ let x: &[isize] = &vec![1, 2, 3, 4, 5];
y = &x[1..];
}
}
error[E0597]: borrowed value does not live long enough
--> $DIR/slice-borrow.rs:18:5
|
-16 | let x: &[isize] = &[1, 2, 3, 4, 5];
- | --------------- temporary value created here
+16 | let x: &[isize] = &vec![1, 2, 3, 4, 5];
+ | ------------------- temporary value created here
17 | y = &x[1..];
18 | }
| ^ temporary value dropped here while still borrowed
19 | }
| - temporary value needs to live until here
+ |
+ = note: this error originates in a macro outside of the current crate
error: aborting due to previous error
projects / rust.git / commitdiff