---

yaml
---
r: 95166
b: refs/heads/dist-snap
c: 012f909
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 28e88b4c6f752203c4ceff7d87094de63e8fdb8d
+refs/heads/dist-snap: 012f909f3546dc7515b43ba389cfc0a1ead0d21f
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/Makefile.in

@@ -88,7 +88,7 @@ ifneq ($(wildcard $(NON_BUILD_TARGET_TRIPLES)),)
 CFG_INFO := $(info cfg: non-build target triples $(NON_BUILD_TARGET_TRIPLES))
 endif
 
-CFG_RUSTC_FLAGS := $(RUSTFLAGS)
+CFG_RUSTC_FLAGS := $(RUSTFLAGS) --cfg nofmt
 CFG_GCCISH_CFLAGS :=
 CFG_GCCISH_LINK_FLAGS :=
 
@@ -141,11 +141,11 @@ endif
 
 # version-string calculation
 CFG_GIT_DIR := $(CFG_SRC_DIR).git
-CFG_RELEASE = 0.8
+CFG_RELEASE = 0.9-pre
 CFG_VERSION = $(CFG_RELEASE)
 # windows exe's need numeric versions - don't use anything but
 # numbers and dots here
-CFG_VERSION_WIN = 0.8
+CFG_VERSION_WIN = 0.9
 
 ifneq ($(wildcard $(CFG_GIT)),)
 ifneq ($(wildcard $(CFG_GIT_DIR)),)
@@ -608,6 +608,10 @@ config.stamp: $(S)configure $(S)Makefile.in $(S)src/snapshots.txt
 # Primary-target makefiles
 ######################################################################
 
+# Issue #9531: If you change the order of any of the following (or add
+# new definitions), make sure definitions always precede their uses,
+# especially for the dependency lists of recipes.
+
 include $(CFG_SRC_DIR)mk/target.mk
 include $(CFG_SRC_DIR)mk/host.mk
 include $(CFG_SRC_DIR)mk/stage0.mk

branches/dist-snap/doc/rust.md

@@ -363,19 +363,17 @@ A _floating-point literal_ has one of two forms:
   second decimal literal.
 * A single _decimal literal_ followed by an _exponent_.
 
-By default, a floating-point literal is of type `float`. A
-floating-point literal may be followed (immediately, without any
-spaces) by a _floating-point suffix_, which changes the type of the
-literal. There are three floating-point suffixes: `f` (for the base
-`float` type), `f32`, and `f64` (the 32-bit and 64-bit floating point
-types).
+By default, a floating-point literal has a generic type, but will fall back to
+`f64`. A floating-point literal may be followed (immediately, without any
+spaces) by a _floating-point suffix_, which changes the type of the literal.
+There are two floating-point suffixes: `f32`, and `f64` (the 32-bit and 64-bit
+floating point types).
 
 Examples of floating-point literals of various forms:
 
 ~~~~
-123.0;                             // type float
-0.1;                               // type float
-3f;                                // type float
+123.0;                             // type f64
+0.1;                               // type f64
 0.1f32;                            // type f32
 12E+99_f64;                        // type f64
 ~~~~
@@ -683,15 +681,15 @@ mod math {
     type complex = (f64, f64);
     fn sin(f: f64) -> f64 {
         ...
-# fail!();
+# fail2!();
     }
     fn cos(f: f64) -> f64 {
         ...
-# fail!();
+# fail2!();
     }
     fn tan(f: f64) -> f64 {
         ...
-# fail!();
+# fail2!();
     }
 }
 ~~~~~~~~
@@ -817,12 +815,14 @@ An example of `use` declarations:
 use std::num::sin;
 use std::option::{Some, None};
 
+# fn foo<T>(_: T){}
+
 fn main() {
-    // Equivalent to 'info!(std::num::sin(1.0));'
-    info!(sin(1.0));
+    // Equivalent to 'std::num::sin(1.0);'
+    sin(1.0);
 
-    // Equivalent to 'info!(~[std::option::Some(1.0), std::option::None]);'
-    info!(~[Some(1.0), None]);
+    // Equivalent to 'foo(~[std::option::Some(1.0), std::option::None]);'
+    foo(~[Some(1.0), None]);
 }
 ~~~~
 
@@ -1040,8 +1040,8 @@ output slot type would normally be. For example:
 
 ~~~~
 fn my_err(s: &str) -> ! {
-    info!(s);
-    fail!();
+    info2!("{}", s);
+    fail2!();
 }
 ~~~~
 
@@ -1059,7 +1059,7 @@ were declared without the `!` annotation, the following code would not
 typecheck:
 
 ~~~~
-# fn my_err(s: &str) -> ! { fail!() }
+# fn my_err(s: &str) -> ! { fail2!() }
 
 fn f(i: int) -> int {
    if i == 42 {
@@ -1177,8 +1177,8 @@ a = Cat;
 Enumeration constructors can have either named or unnamed fields:
 ~~~~
 enum Animal {
-    Dog (~str, float),
-    Cat { name: ~str, weight: float }
+    Dog (~str, f64),
+    Cat { name: ~str, weight: f64 }
 }
 
 let mut a: Animal = Dog(~"Cocoa", 37.2);
@@ -1342,17 +1342,17 @@ For example:
 trait Num {
     fn from_int(n: int) -> Self;
 }
-impl Num for float {
-    fn from_int(n: int) -> float { n as float }
+impl Num for f64 {
+    fn from_int(n: int) -> f64 { n as f64 }
 }
-let x: float = Num::from_int(42);
+let x: f64 = Num::from_int(42);
 ~~~~
 
 Traits may inherit from other traits. For example, in
 
 ~~~~
-trait Shape { fn area() -> float; }
-trait Circle : Shape { fn radius() -> float; }
+trait Shape { fn area() -> f64; }
+trait Circle : Shape { fn radius() -> f64; }
 ~~~~
 
 the syntax `Circle : Shape` means that types that implement `Circle` must also have an implementation for `Shape`.
@@ -1365,9 +1365,9 @@ methods of the supertrait may be called on values of subtrait-bound type paramet
 Referring to the previous example of `trait Circle : Shape`:
 
 ~~~
-# trait Shape { fn area(&self) -> float; }
-# trait Circle : Shape { fn radius(&self) -> float; }
-fn radius_times_area<T: Circle>(c: T) -> float {
+# trait Shape { fn area(&self) -> f64; }
+# trait Circle : Shape { fn radius(&self) -> f64; }
+fn radius_times_area<T: Circle>(c: T) -> f64 {
     // `c` is both a Circle and a Shape
     c.radius() * c.area()
 }
@@ -1376,10 +1376,10 @@ fn radius_times_area<T: Circle>(c: T) -> float {
 Likewise, supertrait methods may also be called on trait objects.
 
 ~~~ {.xfail-test}
-# trait Shape { fn area(&self) -> float; }
-# trait Circle : Shape { fn radius(&self) -> float; }
-# impl Shape for int { fn area(&self) -> float { 0.0 } }
-# impl Circle for int { fn radius(&self) -> float { 0.0 } }
+# trait Shape { fn area(&self) -> f64; }
+# trait Circle : Shape { fn radius(&self) -> f64; }
+# impl Shape for int { fn area(&self) -> f64 { 0.0 } }
+# impl Circle for int { fn radius(&self) -> f64 { 0.0 } }
 # let mycircle = 0;
 
 let mycircle: Circle = @mycircle as @Circle;
@@ -1393,14 +1393,14 @@ An _implementation_ is an item that implements a [trait](#traits) for a specific
 Implementations are defined with the keyword `impl`.
 
 ~~~~
-# struct Point {x: float, y: float};
+# struct Point {x: f64, y: f64};
 # type Surface = int;
-# struct BoundingBox {x: float, y: float, width: float, height: float};
+# struct BoundingBox {x: f64, y: f64, width: f64, height: f64};
 # trait Shape { fn draw(&self, Surface); fn bounding_box(&self) -> BoundingBox; }
 # fn do_draw_circle(s: Surface, c: Circle) { }
 
 struct Circle {
-    radius: float,
+    radius: f64,
     center: Point,
 }
 
@@ -1968,7 +1968,7 @@ values.
 
 ~~~~~~~~ {.tuple}
 (0,);
-(0f, 4.5f);
+(0.0, 4.5);
 ("a", 4u, true);
 ~~~~~~~~
 
@@ -2000,12 +2000,12 @@ A _unit-like structure expression_ consists only of the [path](#paths) of a [str
 The following are examples of structure expressions:
 
 ~~~~
-# struct Point { x: float, y: float }
-# struct TuplePoint(float, float);
+# struct Point { x: f64, y: f64 }
+# struct TuplePoint(f64, f64);
 # mod game { pub struct User<'self> { name: &'self str, age: uint, score: uint } }
 # struct Cookie; fn some_fn<T>(t: T) {}
-Point {x: 10f, y: 20f};
-TuplePoint(10f, 20f);
+Point {x: 10.0, y: 20.0};
+TuplePoint(10.0, 20.0);
 let u = game::User {name: "Joe", age: 35, score: 100_000};
 some_fn::<Cookie>(Cookie);
 ~~~~
@@ -2246,12 +2246,12 @@ Any other cast is unsupported and will fail to compile.
 An example of an `as` expression:
 
 ~~~~
-# fn sum(v: &[float]) -> float { 0.0 }
-# fn len(v: &[float]) -> int { 0 }
+# fn sum(v: &[f64]) -> f64 { 0.0 }
+# fn len(v: &[f64]) -> int { 0 }
 
-fn avg(v: &[float]) -> float {
-  let sum: float = sum(v);
-  let sz: float = len(v) as float;
+fn avg(v: &[f64]) -> f64 {
+  let sum: f64 = sum(v);
+  let sz: f64 = len(v) as f64;
   return sum / sz;
 }
 ~~~~
@@ -2382,7 +2382,7 @@ fn ten_times(f: &fn(int)) {
     }
 }
 
-ten_times(|j| println(fmt!("hello, %d", j)));
+ten_times(|j| println!("hello, {}", j));
 
 ~~~~
 
@@ -2594,9 +2594,9 @@ enum List<X> { Nil, Cons(X, @List<X>) }
 let x: List<int> = Cons(10, @Cons(11, @Nil));
 
 match x {
-    Cons(_, @Nil) => fail!("singleton list"),
+    Cons(_, @Nil) => fail2!("singleton list"),
     Cons(*)       => return,
-    Nil           => fail!("empty list")
+    Nil           => fail2!("empty list")
 }
 ~~~~
 
@@ -2633,7 +2633,7 @@ match x {
         return;
     }
     _ => {
-        fail!();
+        fail2!();
     }
 }
 ~~~~
@@ -2687,7 +2687,7 @@ guard may refer to the variables bound within the pattern they follow.
 let message = match maybe_digit {
   Some(x) if x < 10 => process_digit(x),
   Some(x) => process_other(x),
-  None => fail!()
+  None => fail2!()
 };
 ~~~~
 
@@ -2765,19 +2765,6 @@ size, in bits, is equal to the size of the rust type `uint` on the same target
 machine.
 
 
-#### Machine-dependent floating point type
-
-The Rust type `float` is a machine-specific type equal to one of the supported
-Rust floating-point machine types (`f32` or `f64`). It is the largest
-floating-point type that is directly supported by hardware on the target
-machine, or if the target machine has no floating-point hardware support, the
-largest floating-point type supported by the software floating-point library
-used to support the other floating-point machine types.
-
-Note that due to the preference for hardware-supported floating-point, the
-type `float` may not be equal to the largest *supported* floating-point type.
-
-
 ### Textual types
 
 The types `char` and `str` hold textual data.
@@ -3472,20 +3459,20 @@ that demonstrates all four of them:
 
 ```rust
 fn main() {
-    error!("This is an error log")
-    warn!("This is a warn log")
-    info!("this is an info log")
-    debug!("This is a debug log")
+    error2!("This is an error log")
+    warn2!("This is a warn log")
+    info2!("this is an info log")
+    debug2!("This is a debug log")
 }
 ```
 
 These four log levels correspond to levels 1-4, as controlled by `RUST_LOG`:
 
 ```bash
 $ RUST_LOG=rust=3 ./rust
-rust: ~"\"This is an error log\""
-rust: ~"\"This is a warn log\""
-rust: ~"\"this is an info log\""
+This is an error log
+This is a warn log
+this is an info log
 ```
 
 # Appendix: Rationales and design tradeoffs