Kind::Bench => describe!(check::Crate, check::CrateLibrustc),
Kind::Doc => describe!(doc::UnstableBook, doc::UnstableBookGen, doc::TheBook,
doc::Standalone, doc::Std, doc::Test, doc::Rustc, doc::ErrorIndex, doc::Nomicon,
- doc::Reference, doc::Rustdoc),
+ doc::Reference, doc::Rustdoc, doc::CargoBook),
Kind::Dist => describe!(dist::Docs, dist::Mingw, dist::Rustc, dist::DebuggerScripts,
dist::Std, dist::Analysis, dist::Src, dist::PlainSourceTarball, dist::Cargo,
dist::Rls, dist::Extended, dist::HashSign),
}
}
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct CargoBook {
+ target: Interned<String>,
+}
+
+impl Step for CargoBook {
+ type Output = ();
+ const DEFAULT: bool = true;
+
+ fn should_run(run: ShouldRun) -> ShouldRun {
+ let builder = run.builder;
+ run.path("src/doc/cargo").default_condition(builder.build.config.docs)
+ }
+
+ fn make_run(run: RunConfig) {
+ run.builder.ensure(CargoBook {
+ target: run.target,
+ });
+ }
+
+ /// Create a placeholder for the cargo documentation so that doc.rust-lang.org/cargo will
+ /// redirect to doc.crates.io. We want to publish doc.rust-lang.org/cargo in the paper
+ /// version of the book, but we don't want to rush the process of switching cargo's docs
+ /// over to mdbook and deploying them. When the cargo book is ready, this implementation
+ /// should build the mdbook instead of this redirect page.
+ fn run(self, builder: &Builder) {
+ let build = builder.build;
+ let out = build.doc_out(self.target);
+
+ let cargo_dir = out.join("cargo");
+ t!(fs::create_dir_all(&cargo_dir));
+
+ let index = cargo_dir.join("index.html");
+ let redirect_html = r#"
+ <html>
+ <head>
+ <meta http-equiv="refresh" content="0; URL='http://doc.crates.io'" />
+ </head>
+ </html>"#;
+
+ println!("Creating cargo book redirect page");
+ t!(t!(File::create(&index)).write_all(redirect_html.as_bytes()));
+ }
+}
+
fn invoke_rustdoc(builder: &Builder, compiler: Compiler, target: Interned<String>, markdown: &str) {
let build = builder.build;
let out = build.doc_out(target);
}
/// 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
/// 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),
/// (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
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.
///
/// // now let's write a test
/// #[test]
/// fn test_writes_bytes() {
-/// // setting up a real File is much more slow than an in-memory buffer,
+/// // setting up a real File is much slower than an in-memory buffer,
/// // let's use a cursor instead
/// use std::io::Cursor;
/// let mut buff = Cursor::new(vec![0; 15]);
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);
/// }
/// }
//! 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:
//!
--- /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
projects / rust.git / commitdiff