---

yaml
---
r: 42351
b: refs/heads/master
c: 82d7396
h: refs/heads/master
i:
  42349: d06f1db
  42347: 9f32cb4
  42343: 1ea9dec
  42335: 8173a8e
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 17a14fe0e9402cf0883f5957879646a9ef359769
+refs/heads/master: 82d73963334f01b818cda767b44cd0c8f3baf4cc
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650

trunk/mk/docs.mk

@@ -45,7 +45,7 @@ doc/rust.html: rust.md doc/version_info.html doc/rust.css doc/manual.css
          --from=markdown --to=html \
          --css=rust.css \
          --css=manual.css \
-	 --include-before-body=doc/version_info.html \
+	     --include-before-body=doc/version_info.html \
          --output=$@
   endif
 
@@ -66,6 +66,7 @@ doc/rust.tex: rust.md doc/version.md
 	"$(CFG_PANDOC)" \
          --standalone --toc \
          --number-sections \
+	     --include-before-body=doc/version.md \
          --from=markdown --to=latex \
          --output=$@
 
@@ -199,16 +200,17 @@ ifdef CFG_DISABLE_DOCS
 endif
 
 
-doc/version.md: $(MKFILE_DEPS) rust.md
+doc/version.md: $(MKFILE_DEPS) $(wildcard $(S)doc/*.*)
 	@$(call E, version-stamp: $@)
 	$(Q)echo "$(CFG_VERSION)" >$@
 
-doc/version_info.html: version_info.html.template
+doc/version_info.html: version_info.html.template $(MKFILE_DEPS) \
+                       $(wildcard $(S)doc/*.*)
 	@$(call E, version-info: $@)
 	sed -e "s/VERSION/$(CFG_RELEASE)/; s/SHORT_HASH/$(shell echo \
                     $(CFG_VER_HASH) | head -c 8)/;\
 	            s/STAMP/$(CFG_VER_HASH)/;" $< >$@
 
-GENERATED += doc/version.md
+GENERATED += doc/version.md doc/version_info.html
 
 docs: $(DOCS)

trunk/src/librustc/middle/trans/base.rs

@@ -813,27 +813,6 @@ pub fn get_discrim_val(cx: @crate_ctxt, span: span, enum_did: ast::def_id,
     }
 }
 
-pub fn lookup_discriminant(ccx: @crate_ctxt, vid: ast::def_id) -> ValueRef {
-    unsafe {
-        let _icx = ccx.insn_ctxt("lookup_discriminant");
-        match ccx.discrims.find(&vid) {
-            None => {
-                // It's an external discriminant that we haven't seen yet.
-                assert (vid.crate != ast::local_crate);
-                let sym = csearch::get_symbol(ccx.sess.cstore, vid);
-                let gvar = str::as_c_str(sym, |buf| {
-                    llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type, buf)
-                });
-                lib::llvm::SetLinkage(gvar, lib::llvm::ExternalLinkage);
-                llvm::LLVMSetGlobalConstant(gvar, True);
-                ccx.discrims.insert(vid, gvar);
-                return gvar;
-            }
-            Some(llval) => return llval,
-        }
-    }
-}
-
 pub fn invoke(bcx: block, llfn: ValueRef, +llargs: ~[ValueRef]) -> block {
     let _icx = bcx.insn_ctxt("invoke_");
     if bcx.unreachable { return bcx; }

trunk/src/librustc/middle/trans/expr.rs

@@ -696,15 +696,15 @@ fn trans_def_dps_unadjusted(bcx: block, ref_expr: @ast::expr,
             return fn_data_to_datum(bcx, impl_did, fn_data, lldest);
         }
         ast::def_variant(tid, vid) => {
-            if ty::enum_variant_with_id(ccx.tcx, tid, vid).args.len() > 0u {
+            let variant_info = ty::enum_variant_with_id(ccx.tcx, tid, vid);
+            if variant_info.args.len() > 0u {
                 // N-ary variant.
                 let fn_data = callee::trans_fn_ref(bcx, vid, ref_expr.id);
                 return fn_data_to_datum(bcx, vid, fn_data, lldest);
             } else {
                 // Nullary variant.
                 let lldiscrimptr = GEPi(bcx, lldest, [0u, 0u]);
-                let lldiscrim_gv = base::lookup_discriminant(ccx, vid);
-                let lldiscrim = Load(bcx, lldiscrim_gv);
+                let lldiscrim = C_int(bcx.ccx(), variant_info.disr_val);
                 Store(bcx, lldiscrim, lldiscrimptr);
                 return bcx;
             }

trunk/src/libstd/cmp.rs

@@ -15,36 +15,36 @@ use core::f32;
 use core::f64;
 use core::float;
 
-pub const FUZZY_EPSILON: float = 1.0e-6;
+const fuzzy_epsilon: float = 1.0e-6;
 
-pub trait FuzzyEq<Eps> {
+pub trait FuzzyEq {
     pure fn fuzzy_eq(&self, other: &Self) -> bool;
-    pure fn fuzzy_eq_eps(&self, other: &Self, epsilon: &Eps) -> bool;
+    pure fn fuzzy_eq_eps(&self, other: &Self, epsilon: &Self) -> bool;
 }
 
-impl float: FuzzyEq<float> {
+impl float: FuzzyEq {
     pure fn fuzzy_eq(&self, other: &float) -> bool {
-        self.fuzzy_eq_eps(other, &FUZZY_EPSILON)
+        self.fuzzy_eq_eps(other, &fuzzy_epsilon)
     }
 
     pure fn fuzzy_eq_eps(&self, other: &float, epsilon: &float) -> bool {
         float::abs(*self - *other) < *epsilon
     }
 }
 
-impl f32: FuzzyEq<f32> {
+impl f32: FuzzyEq {
     pure fn fuzzy_eq(&self, other: &f32) -> bool {
-        self.fuzzy_eq_eps(other, &(FUZZY_EPSILON as f32))
+        self.fuzzy_eq_eps(other, &(fuzzy_epsilon as f32))
     }
 
     pure fn fuzzy_eq_eps(&self, other: &f32, epsilon: &f32) -> bool {
         f32::abs(*self - *other) < *epsilon
     }
 }
 
-impl f64: FuzzyEq<f64> {
+impl f64: FuzzyEq {
     pure fn fuzzy_eq(&self, other: &f64) -> bool {
-        self.fuzzy_eq_eps(other, &(FUZZY_EPSILON as f64))
+        self.fuzzy_eq_eps(other, &(fuzzy_epsilon as f64))
     }
 
     pure fn fuzzy_eq_eps(&self, other: &f64, epsilon: &f64) -> bool {
@@ -64,40 +64,3 @@ fn test_fuzzy_eq_eps() {
     assert (&1.2f).fuzzy_eq_eps(&0.9, &0.5);
     assert !(&1.5f).fuzzy_eq_eps(&0.9, &0.5);
 }
-
-#[test]
-mod test_complex{
-    use cmp::*;
-
-    struct Complex { r: float, i: float }
-
-    impl Complex: FuzzyEq<float> {
-        pure fn fuzzy_eq(&self, other: &Complex) -> bool {
-            self.fuzzy_eq_eps(other, &FUZZY_EPSILON)
-        }
-
-        pure fn fuzzy_eq_eps(&self, other: &Complex,
-                             epsilon: &float) -> bool {
-            self.r.fuzzy_eq_eps(&other.r, epsilon) &&
-            self.i.fuzzy_eq_eps(&other.i, epsilon)
-        }
-    }
-
-    #[test]
-    fn test_fuzzy_equals() {
-        let a = Complex {r: 0.9, i: 0.9};
-        let b = Complex {r: 0.9, i: 0.9};
-
-        assert (a.fuzzy_eq(&b));
-    }
-
-    #[test]
-    fn test_fuzzy_eq_eps() {
-        let other = Complex {r: 0.9, i: 0.9};
-
-        assert (&Complex {r: 0.9, i: 1.2}).fuzzy_eq_eps(&other, &0.5);
-        assert (&Complex {r: 1.2, i: 0.9}).fuzzy_eq_eps(&other, &0.5);
-        assert !(&Complex {r: 0.9, i: 1.5}).fuzzy_eq_eps(&other, &0.5);
-        assert !(&Complex {r: 1.5, i: 0.9}).fuzzy_eq_eps(&other, &0.5);
-    }
-}