---

yaml
---
r: 151039
b: refs/heads/try2
c: aa4bc89
h: refs/heads/master
i:
  151037: 07f44f2
  151035: bc420c0
  151031: 3d9dada
  151023: e1957bc
  151007: 450ef55
  150975: 2f18332
  150911: cda1696
  150783: 8303ec4
  150527: 8531317
v: v3

Author: exscape

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 30fe55066a29a14fffd2a5f41e0ab21e7056fb34
+refs/heads/try2: aa4bc89b17f2dd2f8c5ecad0a63cec39f24449bc
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/guide-tasks.md

@@ -306,7 +306,7 @@ be distributed on the available cores.
 fn partial_sum(start: uint) -> f64 {
     let mut local_sum = 0f64;
     for num in range(start*100000, (start+1)*100000) {
-        local_sum += (num as f64 + 1.0).powf(-2.0);
+        local_sum += (num as f64 + 1.0).powf(&-2.0);
     }
     local_sum
 }
@@ -343,7 +343,7 @@ extern crate sync;
 use sync::Arc;
 
 fn pnorm(nums: &[f64], p: uint) -> f64 {
-    nums.iter().fold(0.0, |a, b| a + b.powf(p as f64)).powf(1.0 / (p as f64))
+    nums.iter().fold(0.0, |a,b| a+(*b).powf(&(p as f64)) ).powf(&(1.0 / (p as f64)))
 }
 
 fn main() {

branches/try2/src/doc/tutorial.md

@@ -33,7 +33,7 @@ pleasant high-level features include:
 This is an introductory tutorial for the Rust programming language. It
 covers the fundamentals of the language, including the syntax, the
 type system and memory model, generics, and modules. [Additional
-tutorials](#what-next?) cover specific language features in greater
+tutorials](#what-next) cover specific language features in greater
 depth.
 
 This tutorial assumes that the reader is already familiar with one or
@@ -2253,7 +2253,7 @@ defining one.
 
 The type parameters bound by a trait are in scope in each of the
 method declarations. So, re-declaring the type parameter
-`T` as an explicit type parameter for `length`, in either the trait or
+`T` as an explicit type parameter for `len`, in either the trait or
 the impl, would be a compile-time error.
 
 Within a trait definition, `Self` is a special type that you can think

branches/try2/src/libhexfloat/lib.rs

@@ -105,7 +105,6 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) ->
         Some(Ident{ident, span}) => match token::get_ident(ident).get() {
             "f32" => Some(ast::TyF32),
             "f64" => Some(ast::TyF64),
-            "f128" => Some(ast::TyF128),
             _ => {
                 cx.span_err(span, "invalid floating point type in hexfloat!");
                 None

branches/try2/src/libnum/complex.rs

@@ -82,15 +82,15 @@ impl<T: Clone + Float> Cmplx<T> {
     /// Calculate |self|
     #[inline]
     pub fn norm(&self) -> T {
-        self.re.hypot(self.im)
+        self.re.hypot(&self.im)
     }
 }
 
 impl<T: Clone + Float> Cmplx<T> {
     /// Calculate the principal Arg of self.
     #[inline]
     pub fn arg(&self) -> T {
-        self.im.atan2(self.re)
+        self.im.atan2(&self.re)
     }
     /// Convert to polar form (r, theta), such that `self = r * exp(i
     /// * theta)`

branches/try2/src/libnum/rational.rs

@@ -15,7 +15,7 @@ use Integer;
 use std::cmp;
 use std::fmt;
 use std::from_str::FromStr;
-use std::num::{Zero, One, ToStrRadix, FromStrRadix};
+use std::num::{Zero,One,ToStrRadix,FromStrRadix,Round};
 use bigint::{BigInt, BigUint, Sign, Plus, Minus};
 
 /// Represents the ratio between 2 numbers.
@@ -113,40 +113,6 @@ impl<T: Clone + Integer + Ord>
     pub fn recip(&self) -> Ratio<T> {
         Ratio::new_raw(self.denom.clone(), self.numer.clone())
     }
-
-    pub fn floor(&self) -> Ratio<T> {
-        if *self < Zero::zero() {
-            Ratio::from_integer((self.numer - self.denom + One::one()) / self.denom)
-        } else {
-            Ratio::from_integer(self.numer / self.denom)
-        }
-    }
-
-    pub fn ceil(&self) -> Ratio<T> {
-        if *self < Zero::zero() {
-            Ratio::from_integer(self.numer / self.denom)
-        } else {
-            Ratio::from_integer((self.numer + self.denom - One::one()) / self.denom)
-        }
-    }
-
-    #[inline]
-    pub fn round(&self) -> Ratio<T> {
-        if *self < Zero::zero() {
-            Ratio::from_integer((self.numer - self.denom + One::one()) / self.denom)
-        } else {
-            Ratio::from_integer((self.numer + self.denom - One::one()) / self.denom)
-        }
-    }
-
-    #[inline]
-    pub fn trunc(&self) -> Ratio<T> {
-        Ratio::from_integer(self.numer / self.denom)
-    }
-
-    pub fn fract(&self) -> Ratio<T> {
-        Ratio::new_raw(self.numer % self.denom, self.denom.clone())
-    }
 }
 
 impl Ratio<BigInt> {
@@ -272,6 +238,45 @@ impl<T: Clone + Integer + Ord>
 impl<T: Clone + Integer + Ord>
     Num for Ratio<T> {}
 
+/* Utils */
+impl<T: Clone + Integer + Ord>
+    Round for Ratio<T> {
+
+    fn floor(&self) -> Ratio<T> {
+        if *self < Zero::zero() {
+            Ratio::from_integer((self.numer - self.denom + One::one()) / self.denom)
+        } else {
+            Ratio::from_integer(self.numer / self.denom)
+        }
+    }
+
+    fn ceil(&self) -> Ratio<T> {
+        if *self < Zero::zero() {
+            Ratio::from_integer(self.numer / self.denom)
+        } else {
+            Ratio::from_integer((self.numer + self.denom - One::one()) / self.denom)
+        }
+    }
+
+    #[inline]
+    fn round(&self) -> Ratio<T> {
+        if *self < Zero::zero() {
+            Ratio::from_integer((self.numer - self.denom + One::one()) / self.denom)
+        } else {
+            Ratio::from_integer((self.numer + self.denom - One::one()) / self.denom)
+        }
+    }
+
+    #[inline]
+    fn trunc(&self) -> Ratio<T> {
+        Ratio::from_integer(self.numer / self.denom)
+    }
+
+    fn fract(&self) -> Ratio<T> {
+        Ratio::new_raw(self.numer % self.denom, self.denom.clone())
+    }
+}
+
 /* String conversions */
 impl<T: fmt::Show> fmt::Show for Ratio<T> {
     /// Renders as `numer/denom`.
@@ -631,19 +636,19 @@ mod test {
 
         // f32
         test(3.14159265359f32, ("13176795", "4194304"));
-        test(2f32.powf(100.), ("1267650600228229401496703205376", "1"));
-        test(-2f32.powf(100.), ("-1267650600228229401496703205376", "1"));
-        test(1.0 / 2f32.powf(100.), ("1", "1267650600228229401496703205376"));
+        test(2f32.powf(&100.), ("1267650600228229401496703205376", "1"));
+        test(-2f32.powf(&100.), ("-1267650600228229401496703205376", "1"));
+        test(1.0 / 2f32.powf(&100.), ("1", "1267650600228229401496703205376"));
         test(684729.48391f32, ("1369459", "2"));
         test(-8573.5918555f32, ("-4389679", "512"));
 
         // f64
         test(3.14159265359f64, ("3537118876014453", "1125899906842624"));
-        test(2f64.powf(100.), ("1267650600228229401496703205376", "1"));
-        test(-2f64.powf(100.), ("-1267650600228229401496703205376", "1"));
+        test(2f64.powf(&100.), ("1267650600228229401496703205376", "1"));
+        test(-2f64.powf(&100.), ("-1267650600228229401496703205376", "1"));
         test(684729.48391f64, ("367611342500051", "536870912"));
         test(-8573.5918555, ("-4713381968463931", "549755813888"));
-        test(1.0 / 2f64.powf(100.), ("1", "1267650600228229401496703205376"));
+        test(1.0 / 2f64.powf(&100.), ("1", "1267650600228229401496703205376"));
     }
 
     #[test]

branches/try2/src/librand/distributions/gamma.rs

@@ -147,7 +147,7 @@ impl IndependentSample<f64> for GammaSmallShape {
     fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64 {
         let Open01(u) = rng.gen::<Open01<f64>>();
 
-        self.large_shape.ind_sample(rng) * u.powf(self.inv_shape)
+        self.large_shape.ind_sample(rng) * u.powf(&self.inv_shape)
     }
 }
 impl IndependentSample<f64> for GammaLargeShape {

branches/try2/src/librustc/driver/driver.rs

@@ -299,7 +299,7 @@ pub fn phase_3_run_analysis_passes(sess: Session,
         last_private_map: last_private_map
     } =
         time(time_passes, "resolution", (), |_|
-             middle::resolve::resolve_crate(&sess, &lang_items, krate));
+             middle::resolve::resolve_crate(&sess, lang_items, krate));
 
     // Discard MTWT tables that aren't required past resolution.
     syntax::ext::mtwt::clear_tables();
@@ -316,7 +316,7 @@ pub fn phase_3_run_analysis_passes(sess: Session,
                 sess.diagnostic(), krate)));
 
     let freevars = time(time_passes, "freevar finding", (), |_|
-                        freevars::annotate_freevars(&def_map, krate));
+                        freevars::annotate_freevars(def_map, krate));
 
     let region_map = time(time_passes, "region resolution", (), |_|
                           middle::region::resolve_crate(&sess, krate));
@@ -328,7 +328,7 @@ pub fn phase_3_run_analysis_passes(sess: Session,
                             freevars, region_map, lang_items);
 
     // passes are timed inside typeck
-    typeck::check_crate(&ty_cx, trait_map, krate);
+    let (method_map, vtable_map) = typeck::check_crate(&ty_cx, trait_map, krate);
 
     time(time_passes, "check static items", (), |_|
          middle::check_static::check_crate(&ty_cx, krate));
@@ -338,52 +338,56 @@ pub fn phase_3_run_analysis_passes(sess: Session,
          middle::const_eval::process_crate(krate, &ty_cx));
 
     time(time_passes, "const checking", (), |_|
-         middle::check_const::check_crate(krate, &ty_cx));
+         middle::check_const::check_crate(krate, def_map, method_map, &ty_cx));
 
     let maps = (external_exports, last_private_map);
     let (exported_items, public_items) =
             time(time_passes, "privacy checking", maps, |(a, b)|
-                 middle::privacy::check_crate(&ty_cx, &exp_map2, a, b, krate));
+                 middle::privacy::check_crate(&ty_cx, &method_map, &exp_map2,
+                                              a, b, krate));
 
     time(time_passes, "effect checking", (), |_|
-         middle::effect::check_crate(&ty_cx, krate));
+         middle::effect::check_crate(&ty_cx, method_map, krate));
 
     let middle::moves::MoveMaps {moves_map, moved_variables_set,
                                  capture_map} =
         time(time_passes, "compute moves", (), |_|
-             middle::moves::compute_moves(&ty_cx, krate));
+             middle::moves::compute_moves(&ty_cx, method_map, krate));
 
     time(time_passes, "match checking", (), |_|
-         middle::check_match::check_crate(&ty_cx, &moves_map, krate));
+         middle::check_match::check_crate(&ty_cx, method_map,
+                                          &moves_map, krate));
 
     time(time_passes, "liveness checking", (), |_|
-         middle::liveness::check_crate(&ty_cx, &capture_map, krate));
+         middle::liveness::check_crate(&ty_cx, method_map,
+                                       &capture_map, krate));
 
     let root_map =
         time(time_passes, "borrow checking", (), |_|
-             middle::borrowck::check_crate(&ty_cx, &moves_map,
-                                           &moved_variables_set,
+             middle::borrowck::check_crate(&ty_cx, method_map,
+                                           &moves_map, &moved_variables_set,
                                            &capture_map, krate));
 
     drop(moves_map);
     drop(moved_variables_set);
 
     time(time_passes, "kind checking", (), |_|
-         kind::check_crate(&ty_cx, krate));
+         kind::check_crate(&ty_cx, method_map, krate));
 
     let reachable_map =
         time(time_passes, "reachability checking", (), |_|
-             reachable::find_reachable(&ty_cx, &exported_items));
+             reachable::find_reachable(&ty_cx, method_map, &exported_items));
 
     time(time_passes, "death checking", (), |_| {
         middle::dead::check_crate(&ty_cx,
+                                  method_map,
                                   &exported_items,
                                   &reachable_map,
                                   krate)
     });
 
     time(time_passes, "lint checking", (), |_|
-         lint::check_crate(&ty_cx, &exported_items, krate));
+         lint::check_crate(&ty_cx, method_map, &exported_items, krate));
 
     CrateAnalysis {
         exp_map2: exp_map2,
@@ -392,6 +396,8 @@ pub fn phase_3_run_analysis_passes(sess: Session,
         public_items: public_items,
         maps: astencode::Maps {
             root_map: root_map,
+            method_map: method_map,
+            vtable_map: vtable_map,
             capture_map: RefCell::new(capture_map)
         },
         reachable: reachable_map

branches/try2/src/librustc/front/config.rs

@@ -103,12 +103,12 @@ fn fold_item_underscore(cx: &mut Context, item: &ast::Item_) -> ast::Item_ {
                 .map(|x| *x).collect();
             ast::ItemImpl((*a).clone(), (*b).clone(), c, methods)
         }
-        ast::ItemTrait(ref a, b, ref c, ref methods) => {
+        ast::ItemTrait(ref a, ref b, ref methods) => {
             let methods = methods.iter()
                                  .filter(|m| trait_method_in_cfg(cx, *m) )
                                  .map(|x| (*x).clone())
                                  .collect();
-            ast::ItemTrait((*a).clone(), b, (*c).clone(), methods)
+            ast::ItemTrait((*a).clone(), (*b).clone(), methods)
         }
         ast::ItemStruct(def, ref generics) => {
             ast::ItemStruct(fold_struct(cx, def), generics.clone())

branches/try2/src/librustc/front/feature_gate.rs

@@ -57,8 +57,6 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("linkage", Active),
     ("struct_inherit", Active),
 
-    ("quad_precision_float", Active),
-
     // These are used to test this portion of the compiler, they don't actually
     // mean anything
     ("test_accepted_feature", Accepted),
@@ -79,15 +77,13 @@ enum Status {
 
 /// A set of features to be used by later passes.
 pub struct Features {
-    pub default_type_params: Cell<bool>,
-    pub quad_precision_float: Cell<bool>
+    pub default_type_params: Cell<bool>
 }
 
 impl Features {
     pub fn new() -> Features {
         Features {
-            default_type_params: Cell::new(false),
-            quad_precision_float: Cell::new(false)
+            default_type_params: Cell::new(false)
         }
     }
 }
@@ -368,5 +364,4 @@ pub fn check_crate(sess: &Session, krate: &ast::Crate) {
     sess.abort_if_errors();
 
     sess.features.default_type_params.set(cx.has_feature("default_type_params"));
-    sess.features.quad_precision_float.set(cx.has_feature("quad_precision_float"));
 }