[MSYS2][msys2] can be used to easily build Rust on Windows:
-msys2: https://msys2.github.io/
+[msys2]: https://msys2.github.io/
1. Grab the latest [MSYS2 installer][msys2] and go through the installer.
######################################################################
# The version number
-CFG_RELEASE_NUM=1.11.0
+CFG_RELEASE_NUM=1.12.0
# An optional number to put after the label, e.g. '.2' -> '-beta.2'
# NB Make sure it starts with a dot to conform to semver pre-release
parser.add_argument('--clean', action='store_true')
parser.add_argument('-v', '--verbose', action='store_true')
- args = [a for a in sys.argv if a != '-h']
+ args = [a for a in sys.argv if a != '-h' and a != '--help']
args, _ = parser.parse_known_args(args)
# Configure initial bootstrap
where F: Fn(&'a 32) -> i32 {
```
-However this presents a problem with in our case. When you specify the explict
+However this presents a problem with in our case. When you specify the explicit
lifetime on a function it binds that lifetime to the *entire* scope of the function
instead of just the invocation scope of our closure. This means that the borrow checker
will see a mutable reference in the same lifetime as our immutable reference and fail
```
This lets the Rust compiler find the minimum lifetime to invoke our closure and
-satisfy the borrow checker's rules. Our function then compiles and excutes as we
+satisfy the borrow checker's rules. Our function then compiles and executes as we
expect.
```rust
//! The `foo` module contains a lot of useful functionality blah blah blah
```
+### Crate documentation
+
+Crates can be documented by placing an inner doc comment (`//!`) at the
+beginning of the crate root, aka `lib.rs`:
+
+```rust
+//! This is documentation for the `foo` crate.
+//!
+//! The foo crate is meant to be used for bar.
+```
+
### Documentation comment style
Check out [RFC 505][rfc505] for full conventions around the style and format of
[Cargo’s documentation][cargodoc] contains more details.
[semver]: http://semver.org
-[cargodoc]: http://doc.crates.io/crates-io.html
+[cargodoc]: http://doc.crates.io/specifying-dependencies.html
Now, without changing any of our code, let’s build our project:
#### On ranges:
```rust
-for (i,j) in (5..10).enumerate() {
+for (i, j) in (5..10).enumerate() {
println!("i = {} and j = {}", i, j);
}
```
# Interior vs. Exterior Mutability
However, when we say something is ‘immutable’ in Rust, that doesn’t mean that
-it’s not able to be changed: we mean something has ‘exterior mutability’. Consider,
-for example, [`Arc<T>`][arc]:
+it’s not able to be changed: we are referring to its ‘exterior mutability’ that
+in this case is immutable. Consider, for example, [`Arc<T>`][arc]:
```rust
use std::sync::Arc;
let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);
```
-Here, `black` and `origin` are not equal, even though they contain the same
-values.
-It is almost always better to use a `struct` than a tuple struct. We
-would write `Color` and `Point` like this instead:
+Here, `black` and `origin` are not the same type, even though they contain the
+same values.
+
+The members of a tuple struct may be accessed by dot notation or destructuring
+`let`, just like regular tuples:
+
+```rust
+# struct Color(i32, i32, i32);
+# struct Point(i32, i32, i32);
+# let black = Color(0, 0, 0);
+# let origin = Point(0, 0, 0);
+let black_r = black.0;
+let Point(_, origin_y, origin_z) = origin;
+```
+
+Patterns like `Point(_, origin_y, origin_z)` are also used in
+[match expressions][match].
+
+One case when a tuple struct is very useful is when it has only one element.
+We call this the ‘newtype’ pattern, because it allows you to create a new type
+that is distinct from its contained value and also expresses its own semantic
+meaning:
+
+```rust
+struct Inches(i32);
+
+let length = Inches(10);
+
+let Inches(integer_length) = length;
+println!("length is {} inches", integer_length);
+```
+
+As above, you can extract the inner integer type through a destructuring `let`.
+In this case, the `let Inches(integer_length)` assigns `10` to `integer_length`.
+We could have used dot notation to do the same thing:
+
+```rust
+# struct Inches(i32);
+# let length = Inches(10);
+let integer_length = length.0;
+```
+
+It's always possible to use a `struct` instead of a tuple struct, and can be
+clearer. We could write `Color` and `Point` like this instead:
```rust
struct Color {
referenced with dot notation as well, a `struct` gives us actual names,
rather than positions.
-There _is_ one case when a tuple struct is very useful, though, and that is when
-it has only one element. We call this the ‘newtype’ pattern, because
-it allows you to create a new type that is distinct from its contained value
-and also expresses its own semantic meaning:
-
-```rust
-struct Inches(i32);
-
-let length = Inches(10);
-
-let Inches(integer_length) = length;
-println!("length is {} inches", integer_length);
-```
-
-As you can see here, you can extract the inner integer type through a
-destructuring `let`, as with regular tuples. In this case, the
-`let Inches(integer_length)` assigns `10` to `integer_length`.
+[match]: match.html
# Unit-like structs
You can define a `struct` with no members at all:
```rust
-struct Electron;
+struct Electron {} // use empty braces...
+struct Proton; // ...or just a semicolon
-let x = Electron;
+// whether you declared the struct with braces or not, do the same when creating one
+let x = Electron {};
+let y = Proton;
```
Such a `struct` is called ‘unit-like’ because it resembles the empty
Cargo will ignore files in subdirectories of the `tests/` directory.
Therefore shared modules in integrations tests are possible.
-For example `tests/common/mod.rs` is not seperatly compiled by cargo but can
+For example `tests/common/mod.rs` is not separately compiled by cargo but can
be imported in every test with `mod common;`
That's all there is to the `tests` directory. The `tests` module isn't needed
#[stable(feature = "rust1", since = "1.0.0")]
pub fn transmute<T, U>(e: T) -> U;
- /// Gives the address for the return value of the enclosing function.
- ///
- /// Using this intrinsic in a function that does not use an out pointer
- /// will trigger a compiler error.
- pub fn return_address() -> *const u8;
-
/// Returns `true` if the actual type given as `T` requires drop
/// glue; returns `false` if the actual type provided for `T`
/// implements `Copy`.
impl<I: Iterator> Peekable<I> {
/// Returns a reference to the next() value without advancing the iterator.
///
- /// The `peek()` method will return the value that a call to [`next()`] would
- /// return, but does not advance the iterator. Like [`next()`], if there is
- /// a value, it's wrapped in a `Some(T)`, but if the iterator is over, it
- /// will return `None`.
+ /// Like [`next()`], if there is a value, it is wrapped in a `Some(T)`.
+ /// But if the iteration is over, `None` is returned.
///
/// [`next()`]: trait.Iterator.html#tymethod.next
///
- /// Because `peek()` returns reference, and many iterators iterate over
- /// references, this leads to a possibly confusing situation where the
+ /// Because `peek()` returns a reference, and many iterators iterate over
+ /// references, there can be a possibly confusing situation where the
/// return value is a double reference. You can see this effect in the
- /// examples below, with `&&i32`.
+ /// examples below.
///
/// # Examples
///
///
/// assert_eq!(iter.next(), Some(&2));
///
- /// // we can peek() multiple times, the iterator won't advance
+ /// // The iterator does not advance even if we `peek` multiple times
/// assert_eq!(iter.peek(), Some(&&3));
/// assert_eq!(iter.peek(), Some(&&3));
///
/// assert_eq!(iter.next(), Some(&3));
///
- /// // after the iterator is finished, so is peek()
+ /// // After the iterator is finished, so is `peek()`
/// assert_eq!(iter.peek(), None);
/// assert_eq!(iter.next(), None);
/// ```
///
/// let mut iter = xs.iter().peekable();
///
- /// // there are still elements to iterate over
+ /// // There are still elements to iterate over
/// assert_eq!(iter.is_empty(), false);
///
- /// // let's consume the iterator
+ /// // Let's consume the iterator
/// iter.next();
/// iter.next();
/// iter.next();
use num::Float;
use num::FpCategory as Fp;
+/// The radix or base of the internal representation of `f32`.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const RADIX: u32 = 2;
+/// Number of significant digits in base 2.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const MANTISSA_DIGITS: u32 = 24;
+/// Approximate number of significant digits in base 10.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const DIGITS: u32 = 6;
+/// Difference between `1.0` and the next largest representable number.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const EPSILON: f32 = 1.19209290e-07_f32;
-/// Smallest finite f32 value
+/// Smallest finite `f32` value.
#[stable(feature = "rust1", since = "1.0.0")]
pub const MIN: f32 = -3.40282347e+38_f32;
-/// Smallest positive, normalized f32 value
+/// Smallest positive normal `f32` value.
#[stable(feature = "rust1", since = "1.0.0")]
pub const MIN_POSITIVE: f32 = 1.17549435e-38_f32;
-/// Largest finite f32 value
+/// Largest finite `f32` value.
#[stable(feature = "rust1", since = "1.0.0")]
pub const MAX: f32 = 3.40282347e+38_f32;
+/// One greater than the minimum possible normal power of 2 exponent.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const MIN_EXP: i32 = -125;
+/// Maximum possible power of 2 exponent.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const MAX_EXP: i32 = 128;
+/// Minimum possible normal power of 10 exponent.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const MIN_10_EXP: i32 = -37;
+/// Maximum possible power of 10 exponent.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const MAX_10_EXP: i32 = 38;
+/// Not a Number (NaN).
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const NAN: f32 = 0.0_f32/0.0_f32;
+/// Infinity (∞).
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const INFINITY: f32 = 1.0_f32/0.0_f32;
+/// Negative infinity (-∞).
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const NEG_INFINITY: f32 = -1.0_f32/0.0_f32;
/// Basic mathematical constants.
pub mod consts {
// FIXME: replace with mathematical constants from cmath.
- /// Archimedes' constant
+ /// Archimedes' constant (π)
#[stable(feature = "rust1", since = "1.0.0")]
pub const PI: f32 = 3.14159265358979323846264338327950288_f32;
- /// pi/2.0
+ /// π/2
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_2: f32 = 1.57079632679489661923132169163975144_f32;
- /// pi/3.0
+ /// π/3
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_3: f32 = 1.04719755119659774615421446109316763_f32;
- /// pi/4.0
+ /// π/4
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_4: f32 = 0.785398163397448309615660845819875721_f32;
- /// pi/6.0
+ /// π/6
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_6: f32 = 0.52359877559829887307710723054658381_f32;
- /// pi/8.0
+ /// π/8
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_8: f32 = 0.39269908169872415480783042290993786_f32;
- /// 1.0/pi
+ /// 1/π
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_1_PI: f32 = 0.318309886183790671537767526745028724_f32;
- /// 2.0/pi
+ /// 2/π
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_2_PI: f32 = 0.636619772367581343075535053490057448_f32;
- /// 2.0/sqrt(pi)
+ /// 2/sqrt(π)
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_2_SQRT_PI: f32 = 1.12837916709551257389615890312154517_f32;
- /// sqrt(2.0)
+ /// sqrt(2)
#[stable(feature = "rust1", since = "1.0.0")]
pub const SQRT_2: f32 = 1.41421356237309504880168872420969808_f32;
- /// 1.0/sqrt(2.0)
+ /// 1/sqrt(2)
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_1_SQRT_2: f32 = 0.707106781186547524400844362104849039_f32;
- /// Euler's number
+ /// Euler's number (e)
#[stable(feature = "rust1", since = "1.0.0")]
pub const E: f32 = 2.71828182845904523536028747135266250_f32;
- /// log2(e)
+ /// log<sub>2</sub>(e)
#[stable(feature = "rust1", since = "1.0.0")]
pub const LOG2_E: f32 = 1.44269504088896340735992468100189214_f32;
- /// log10(e)
+ /// log<sub>10</sub>(e)
#[stable(feature = "rust1", since = "1.0.0")]
pub const LOG10_E: f32 = 0.434294481903251827651128918916605082_f32;
- /// ln(2.0)
+ /// ln(2)
#[stable(feature = "rust1", since = "1.0.0")]
pub const LN_2: f32 = 0.693147180559945309417232121458176568_f32;
- /// ln(10.0)
+ /// ln(10)
#[stable(feature = "rust1", since = "1.0.0")]
pub const LN_10: f32 = 2.30258509299404568401799145468436421_f32;
}
use num::FpCategory as Fp;
use num::Float;
+/// The radix or base of the internal representation of `f64`.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const RADIX: u32 = 2;
+/// Number of significant digits in base 2.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const MANTISSA_DIGITS: u32 = 53;
+/// Approximate number of significant digits in base 10.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const DIGITS: u32 = 15;
+/// Difference between `1.0` and the next largest representable number.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const EPSILON: f64 = 2.2204460492503131e-16_f64;
-/// Smallest finite f64 value
+/// Smallest finite `f64` value.
#[stable(feature = "rust1", since = "1.0.0")]
pub const MIN: f64 = -1.7976931348623157e+308_f64;
-/// Smallest positive, normalized f64 value
+/// Smallest positive normal `f64` value.
#[stable(feature = "rust1", since = "1.0.0")]
pub const MIN_POSITIVE: f64 = 2.2250738585072014e-308_f64;
-/// Largest finite f64 value
+/// Largest finite `f64` value.
#[stable(feature = "rust1", since = "1.0.0")]
pub const MAX: f64 = 1.7976931348623157e+308_f64;
+/// One greater than the minimum possible normal power of 2 exponent.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const MIN_EXP: i32 = -1021;
+/// Maximum possible power of 2 exponent.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const MAX_EXP: i32 = 1024;
+/// Minimum possible normal power of 10 exponent.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const MIN_10_EXP: i32 = -307;
+/// Maximum possible power of 10 exponent.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const MAX_10_EXP: i32 = 308;
+/// Not a Number (NaN).
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const NAN: f64 = 0.0_f64/0.0_f64;
+/// Infinity (∞).
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const INFINITY: f64 = 1.0_f64/0.0_f64;
+/// Negative infinity (-∞).
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const NEG_INFINITY: f64 = -1.0_f64/0.0_f64;
/// Basic mathematical constants.
pub mod consts {
// FIXME: replace with mathematical constants from cmath.
- /// Archimedes' constant
+ /// Archimedes' constant (π)
#[stable(feature = "rust1", since = "1.0.0")]
pub const PI: f64 = 3.14159265358979323846264338327950288_f64;
- /// pi/2.0
+ /// π/2
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_2: f64 = 1.57079632679489661923132169163975144_f64;
- /// pi/3.0
+ /// π/3
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_3: f64 = 1.04719755119659774615421446109316763_f64;
- /// pi/4.0
+ /// π/4
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_4: f64 = 0.785398163397448309615660845819875721_f64;
- /// pi/6.0
+ /// π/6
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_6: f64 = 0.52359877559829887307710723054658381_f64;
- /// pi/8.0
+ /// π/8
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_PI_8: f64 = 0.39269908169872415480783042290993786_f64;
- /// 1.0/pi
+ /// 1/π
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_1_PI: f64 = 0.318309886183790671537767526745028724_f64;
- /// 2.0/pi
+ /// 2/π
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_2_PI: f64 = 0.636619772367581343075535053490057448_f64;
- /// 2.0/sqrt(pi)
+ /// 2/sqrt(π)
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_2_SQRT_PI: f64 = 1.12837916709551257389615890312154517_f64;
- /// sqrt(2.0)
+ /// sqrt(2)
#[stable(feature = "rust1", since = "1.0.0")]
pub const SQRT_2: f64 = 1.41421356237309504880168872420969808_f64;
- /// 1.0/sqrt(2.0)
+ /// 1/sqrt(2)
#[stable(feature = "rust1", since = "1.0.0")]
pub const FRAC_1_SQRT_2: f64 = 0.707106781186547524400844362104849039_f64;
- /// Euler's number
+ /// Euler's number (e)
#[stable(feature = "rust1", since = "1.0.0")]
pub const E: f64 = 2.71828182845904523536028747135266250_f64;
- /// log2(e)
+ /// log<sub>2</sub>(e)
#[stable(feature = "rust1", since = "1.0.0")]
pub const LOG2_E: f64 = 1.44269504088896340735992468100189214_f64;
- /// log10(e)
+ /// log<sub>10</sub>(e)
#[stable(feature = "rust1", since = "1.0.0")]
pub const LOG10_E: f64 = 0.434294481903251827651128918916605082_f64;
- /// ln(2.0)
+ /// ln(2)
#[stable(feature = "rust1", since = "1.0.0")]
pub const LN_2: f64 = 0.693147180559945309417232121458176568_f64;
- /// ln(10.0)
+ /// ln(10)
#[stable(feature = "rust1", since = "1.0.0")]
pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64;
}
macro_rules! int_module { ($T:ident, $bits:expr) => (
+/// The smallest value that can be represented by this integer type.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const MIN: $T = $T::min_value();
+/// The largest value that can be represented by this integer type.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const MAX: $T = $T::max_value();
) }
//! Numeric traits and functions for the built-in numeric types.
#![stable(feature = "rust1", since = "1.0.0")]
-#![allow(missing_docs)]
use char::CharExt;
use cmp::PartialOrd;
macro_rules! uint_module { ($T:ident, $bits:expr) => (
+/// The smallest value that can be represented by this integer type.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const MIN: $T = $T::min_value();
+/// The largest value that can be represented by this integer type.
#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(missing_docs)]
pub const MAX: $T = $T::max_value();
) }
ExprVec(HirVec<P<Expr>>),
/// A function call
///
- /// The first field resolves to the function itself,
+ /// The first field resolves to the function itself (usually an `ExprPath`),
/// and the second field is the list of arguments
ExprCall(P<Expr>, HirVec<P<Expr>>),
/// A method call (`x.foo::<Bar, Baz>(a, b, c, d)`)
/// The vector of `Ty`s are the ascripted type parameters for the method
/// (within the angle brackets).
///
- /// The first element of the vector of `Expr`s is the expression that evaluates
- /// to the object on which the method is being called on (the receiver),
- /// and the remaining elements are the rest of the arguments.
+ /// The first element of the vector of `Expr`s is the expression that
+ /// evaluates to the object on which the method is being called on (the
+ /// receiver), and the remaining elements are the rest of the arguments.
///
/// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as
/// `ExprMethodCall(foo, [Bar, Baz], [x, a, b, c, d])`.
/// Inline assembly (from `asm!`), with its outputs and inputs.
ExprInlineAsm(InlineAsm, Vec<P<Expr>>, Vec<P<Expr>>),
- /// A struct literal expression.
+ /// A struct or struct-like variant literal expression.
///
/// For example, `Foo {x: 1, y: 2}`, or
/// `Foo {x: 1, .. base}`, where `base` is the `Option<Expr>`.
ExprStruct(Path, HirVec<Field>, Option<P<Expr>>),
- /// A vector literal constructed from one repeated element.
+ /// An array literal constructed from one repeated element.
///
/// For example, `[1; 5]`. The first expression is the element
/// to be repeated; the second is the number of times to repeat it.
pub position: usize,
}
+/// Hints at the original code for a `match _ { .. }`
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)]
pub enum MatchSource {
+ /// A `match _ { .. }`
Normal,
+ /// An `if let _ = _ { .. }` (optionally with `else { .. }`)
IfLetDesugar {
contains_else_clause: bool,
},
+ /// A `while let _ = _ { .. }` (which was desugared to a
+ /// `loop { match _ { .. } }`)
WhileLetDesugar,
+ /// A desugared `for _ in _ { .. }` loop
ForLoopDesugar,
+ /// A desugared `?` operator
TryDesugar,
}
pub mutbl: Mutability,
}
-/// Represents a method's signature in a trait declaration,
-/// or in an implementation.
+/// Represents a method's signature in a trait declaration or implementation.
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct MethodSig {
pub unsafety: Unsafety,
pub span: Span,
}
+/// Represents a trait method or associated constant or type
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum TraitItem_ {
+ /// An associated constant with an optional value (otherwise `impl`s
+ /// must contain a value)
ConstTraitItem(P<Ty>, Option<P<Expr>>),
+ /// A method with an optional body
MethodTraitItem(MethodSig, Option<P<Block>>),
+ /// An associated type with (possibly empty) bounds and optional concrete
+ /// type
TypeTraitItem(TyParamBounds, Option<P<Ty>>),
}
+/// Represents anything within an `impl` block
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub struct ImplItem {
pub id: NodeId,
pub span: Span,
}
+/// Represents different contents within `impl`s
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum ImplItemKind {
+ /// An associated constant of the given type, set to the constant result
+ /// of the expression
Const(P<Ty>, P<Expr>),
+ /// A method implementation with the given signature and body
Method(MethodSig, P<Block>),
+ /// An associated type
Type(P<Ty>),
}
if !msg.is_empty() {
msg = format!(". Did you mean {}?", msg);
} else {
- // we check if this a module and if so, we display a help
- // message
+ // we display a help message if this is a module
let name_path = path.segments.iter()
.map(|seg| seg.identifier.name)
.collect::<Vec<_>>();
use rustc::hir::def::Def;
use rustc::hir::def_id::DefId;
+use rustc::hir::map::Node;
use rustc::session::Session;
use rustc::ty::{self, TyCtxt, ImplOrTraitItem, ImplOrTraitItemContainer};
ast::ExprKind::TupField(ref sub_ex, idx) => {
self.visit_expr(&sub_ex);
- let hir_node = self.save_ctxt.tcx.map.expect_expr(sub_ex.id);
+ let hir_node = match self.save_ctxt.tcx.map.find(sub_ex.id) {
+ Some(Node::NodeExpr(expr)) => expr,
+ _ => {
+ debug!("Missing or weird node for sub-expression {} in {:?}",
+ sub_ex.id, ex);
+ return;
+ }
+ };
let ty = &self.tcx.expr_ty_adjusted(&hir_node).sty;
match *ty {
ty::TyStruct(def, _) => {
register_long_diagnostics! {
-E0510: r##"
-`return_address` was used in an invalid context. Erroneous code example:
-
-```ignore
-#![feature(intrinsics)]
-
-extern "rust-intrinsic" {
- fn return_address() -> *const u8;
-}
-
-unsafe fn by_value() -> i32 {
- let _ = return_address();
- // error: invalid use of `return_address` intrinsic: function does
- // not use out pointer
- 0
-}
-```
-
-Return values may be stored in a return register(s) or written into a so-called
-out pointer. In case the returned value is too big (this is
-target-ABI-dependent and generally not portable or future proof) to fit into
-the return register(s), the compiler will return the value by writing it into
-space allocated in the caller's stack frame. Example:
-
-```
-#![feature(intrinsics)]
-
-extern "rust-intrinsic" {
- fn return_address() -> *const u8;
-}
-
-unsafe fn by_pointer() -> String {
- let _ = return_address();
- String::new() // ok!
-}
-```
-"##,
-
E0511: r##"
Invalid monomorphization of an intrinsic function was used. Erroneous code
example:
},
-
- (_, "return_address") => {
- if !fcx.fn_ty.ret.is_indirect() {
- span_err!(tcx.sess, span, E0510,
- "invalid use of `return_address` intrinsic: function \
- does not use out pointer");
- C_null(Type::i8p(ccx))
- } else {
- PointerCast(bcx, llvm::get_param(fcx.llfn, 0), Type::i8p(ccx))
- }
- }
-
(_, "discriminant_value") => {
let val_ty = substs.types.get(FnSpace, 0);
match val_ty.sty {
"fadd_fast" | "fsub_fast" | "fmul_fast" | "fdiv_fast" | "frem_fast" =>
(1, vec![param(ccx, 0), param(ccx, 0)], param(ccx, 0)),
- "return_address" => (0, vec![], tcx.mk_imm_ptr(tcx.types.u8)),
-
"assume" => (0, vec![tcx.types.bool], tcx.mk_nil()),
"discriminant_value" => (1, vec![
///
/// 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
-/// the implemention.
+/// the implementation.
pub trait Writer {
/// Called when we start processing a span of text that should be highlighted.
/// The `Class` argument specifies how it should be highlighted.
let parentlen = cx.current.len() - if it.is_mod() {1} else {0};
// the sidebar is designed to display sibling functions, modules and
- // other miscellaneous informations. since there are lots of sibling
+ // other miscellaneous information. since there are lots of sibling
// items (and that causes quadratic growth in large modules),
// we refactor common parts into a shared JavaScript file per module.
// still, we don't move everything into JS because we want to preserve
text[..offset].iter().rposition(|elt| *elt == x)
}
- // test fallback implementations on all plattforms
+ // test fallback implementations on all platforms
#[test]
fn matches_one() {
assert_eq!(Some(0), memchr(b'a', b"a"));
};
fld.cx.bt_pop();
- modified.into_iter().flat_map(|it| expand_annotatable(it, fld)).collect()
+ let configured = modified.into_iter().flat_map(|it| {
+ it.fold_with(&mut fld.strip_unconfigured())
+ }).collect::<SmallVector<_>>();
+
+ configured.into_iter().flat_map(|it| expand_annotatable(it, fld)).collect()
}
}
}
+++ /dev/null
-// Copyright 2014 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(warnings)]
-#![feature(intrinsics)]
-
-extern "rust-intrinsic" {
- fn return_address() -> *const u8;
-}
-
-unsafe fn f() { let _ = return_address(); }
-//~^ ERROR invalid use of `return_address` intrinsic: function does not use out pointer
-
-unsafe fn g() -> isize { let _ = return_address(); 0 }
-//~^ ERROR invalid use of `return_address` intrinsic: function does not use out pointer
-
-fn main() {}
..(*quote_item!(cx, enum Foo2 { Bar2, Baz2 }).unwrap()).clone()
})),
Annotatable::Item(quote_item!(cx, enum Foo3 { Bar }).unwrap()),
+ Annotatable::Item(quote_item!(cx, #[cfg(any())] fn foo2() {}).unwrap()),
],
Annotatable::ImplItem(it) => vec![
quote_item!(cx, impl X { fn foo(&self) -> i32 { 42 } }).unwrap().and_then(|i| {
#[derive(PartialEq, Clone, Debug)]
fn foo() -> AnotherFakeTypeThatHadBetterGoAway {}
+// Check that the `#[into_multi_foo]`-generated `foo2` is configured away
+fn foo2() {}
+
trait Qux {
#[into_multi_foo]
fn bar();
+++ /dev/null
-// Copyright 2012-2014 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(intrinsics)]
-
-use std::ptr;
-
-struct Point {
- x: f32,
- y: f32,
- z: f32,
-}
-
-extern "rust-intrinsic" {
- fn return_address() -> *const u8;
-}
-
-fn f(result: &mut usize) -> Point {
- unsafe {
- *result = return_address() as usize;
- Point {
- x: 1.0,
- y: 2.0,
- z: 3.0,
- }
- }
-
-}
-
-fn main() {
- let mut intrinsic_reported_address = 0;
- let pt = f(&mut intrinsic_reported_address);
- let actual_address = &pt as *const Point as usize;
- assert_eq!(intrinsic_reported_address, actual_address);
-}