---

yaml
---
r: 36255
b: refs/heads/try2
c: 1ead8aa
h: refs/heads/master
i:
  36253: 138f986
  36251: e35b525
  36247: 7bbe71d
  36239: 94f3be7
  36223: a3f1ef5
v: v3

Author: brson

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 37ed7fcaae1477cd85985886b5f8a4514bf98d0e
+refs/heads/try2: 1ead8aa0b583b43ac0c8cafe9ab6d9f9d2537f88
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
 refs/heads/dist-snap: 22efa39382d41b084fde1719df7ae8ce5697d8c9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try2/src/libcore/option.rs

@@ -87,7 +87,7 @@ pub pure fn get_ref<T>(opt: &r/Option<T>) -> &r/T {
 
 pub pure fn expect<T>(opt: Option<T>, reason: ~str) -> T {
     /*!
-     * Gets the value out of an option without copying, printing a 
+     * Gets the value out of an option without copying, printing a
      * specified message on failure.
      *
      * # Failure

branches/try2/src/librustc/metadata/csearch.rs

@@ -63,7 +63,10 @@ fn get_type_param_count(cstore: cstore::CStore, def: ast::def_id) -> uint {
 fn each_path(cstore: cstore::CStore, cnum: ast::crate_num,
              f: fn(decoder::path_entry) -> bool) {
     let crate_data = cstore::get_crate_data(cstore, cnum);
-    decoder::each_path(cstore.intr, crate_data, f);
+    let get_crate_data: decoder::GetCrateDataCb = |cnum| {
+        cstore::get_crate_data(cstore, cnum)
+    };
+    decoder::each_path(cstore.intr, crate_data, get_crate_data, f);
 }
 
 fn get_item_path(tcx: ty::ctxt, def: ast::def_id) -> ast_map::path {

branches/try2/src/librustc/metadata/cstore.rs

@@ -98,7 +98,11 @@ fn get_crate_vers(cstore: CStore, cnum: ast::crate_num) -> ~str {
 fn set_crate_data(cstore: CStore, cnum: ast::crate_num,
                   data: crate_metadata) {
     p(cstore).metas.insert(cnum, data);
-    for vec::each(decoder::get_crate_module_paths(cstore.intr, data)) |dp| {
+    let get_crate_data: decoder::GetCrateDataCb = |cnum| {
+        cstore::get_crate_data(cstore, cnum)
+    };
+    for vec::each(decoder::get_crate_module_paths(cstore.intr, data,
+                                                  get_crate_data)) |dp| {
         let (did, path) = *dp;
         let d = {crate: cnum, node: did.node};
         p(cstore).mod_path_map.insert(d, @path);

branches/try2/src/librustc/metadata/decoder.rs

@@ -60,6 +60,7 @@ export item_type; // sketchy
 export maybe_get_item_ast;
 export decode_inlined_item;
 export method_info, _impl;
+export GetCrateDataCb;
 
 // Used internally by astencode:
 export translate_def_id;
@@ -88,6 +89,8 @@ fn lookup_hash(d: ebml::Doc, eq_fn: fn(x:&[u8]) -> bool, hash: uint) ->
     None
 }
 
+pub type GetCrateDataCb = &fn(ast::crate_num) -> cmd;
+
 fn maybe_find_item(item_id: int, items: ebml::Doc) -> Option<ebml::Doc> {
     fn eq_item(bytes: &[u8], item_id: int) -> bool {
         return io::u64_from_be_bytes(vec::view(bytes, 0u, 4u), 0u, 4u) as int
@@ -477,7 +480,9 @@ fn path_entry(path_string: ~str, def_like: def_like) -> path_entry {
 }
 
 /// Iterates over all the paths in the given crate.
-fn each_path(intr: @ident_interner, cdata: cmd, f: fn(path_entry) -> bool) {
+fn each_path(intr: @ident_interner, cdata: cmd,
+             get_crate_data: GetCrateDataCb,
+             f: fn(path_entry) -> bool) {
     let root = ebml::Doc(cdata.data);
     let items = ebml::get_doc(root, tag_items);
     let items_data = ebml::get_doc(items, tag_items_data);
@@ -526,8 +531,17 @@ fn each_path(intr: @ident_interner, cdata: cmd, f: fn(path_entry) -> bool) {
                         reexport_path = path + ~"::" + reexport_name;
                     }
 
+                    // This reexport may be in yet another crate
+                    let other_crates_items = if def_id.crate == cdata.cnum {
+                        items
+                    } else {
+                        let crate_data = get_crate_data(def_id.crate);
+                        let root = ebml::Doc(crate_data.data);
+                        ebml::get_doc(root, tag_items)
+                    };
+
                     // Get the item.
-                    match maybe_find_item(def_id.node, items) {
+                    match maybe_find_item(def_id.node, other_crates_items) {
                         None => {}
                         Some(item_doc) => {
                             // Construct the def for this item.
@@ -1079,9 +1093,10 @@ fn get_crate_vers(data: @~[u8]) -> ~str {
     };
 }
 
-fn iter_crate_items(intr: @ident_interner,
-                    cdata: cmd, proc: fn(~str, ast::def_id)) {
-    for each_path(intr, cdata) |path_entry| {
+fn iter_crate_items(intr: @ident_interner, cdata: cmd,
+                    get_crate_data: GetCrateDataCb,
+                    proc: fn(~str, ast::def_id)) {
+    for each_path(intr, cdata, get_crate_data) |path_entry| {
         match path_entry.def_like {
             dl_impl(*) | dl_field => {}
             dl_def(def) => {
@@ -1091,7 +1106,8 @@ fn iter_crate_items(intr: @ident_interner,
     }
 }
 
-fn get_crate_module_paths(intr: @ident_interner, cdata: cmd)
+fn get_crate_module_paths(intr: @ident_interner, cdata: cmd,
+                          get_crate_data: GetCrateDataCb)
                                     -> ~[(ast::def_id, ~str)] {
     fn mod_of_path(p: ~str) -> ~str {
         str::connect(vec::init(str::split_str(p, ~"::")), ~"::")
@@ -1101,7 +1117,7 @@ fn get_crate_module_paths(intr: @ident_interner, cdata: cmd)
     // fowarded path due to renamed import or reexport
     let mut res = ~[];
     let mods = map::HashMap();
-    do iter_crate_items(intr, cdata) |path, did| {
+    do iter_crate_items(intr, cdata, get_crate_data) |path, did| {
         let m = mod_of_path(path);
         if str::is_not_empty(m) {
             // if m has a sub-item, it must be a module

branches/try2/src/librustc/metadata/tyencode.rs

@@ -286,6 +286,11 @@ fn enc_sty(w: io::Writer, cx: @ctxt, st: ty::sty) {
         w.write_char('I');
         w.write_uint(id.to_uint());
       }
+      ty::ty_infer(ty::FloatVar(id)) => {
+        w.write_char('X');
+        w.write_char('F');
+        w.write_uint(id.to_uint());
+      }
       ty::ty_param({idx: id, def_id: did}) => {
         w.write_char('p');
         w.write_str(cx.ds(did));

branches/try2/src/librustc/middle/const_eval.rs

@@ -389,6 +389,8 @@ fn lit_to_const(lit: @lit) -> const_val {
       lit_uint(n, _) => const_uint(n),
       lit_int_unsuffixed(n) => const_int(n),
       lit_float(n, _) => const_float(float::from_str(*n).get() as f64),
+      lit_float_unsuffixed(n) =>
+        const_float(float::from_str(*n).get() as f64),
       lit_nil => const_int(0i64),
       lit_bool(b) => const_bool(b)
     }

branches/try2/src/librustc/middle/trans/base.rs

@@ -2436,7 +2436,10 @@ fn gather_local_rtcalls(ccx: @crate_ctxt, crate: @ast::crate) {
 
 fn gather_external_rtcalls(ccx: @crate_ctxt) {
     do cstore::iter_crate_data(ccx.sess.cstore) |_cnum, cmeta| {
-        do decoder::each_path(ccx.sess.intr(), cmeta) |path| {
+        let get_crate_data: decoder::GetCrateDataCb = |cnum| {
+            cstore::get_crate_data(ccx.sess.cstore, cnum)
+        };
+        do decoder::each_path(ccx.sess.intr(), cmeta, get_crate_data) |path| {
             let pathname = path.path_string;
             match path.def_like {
               decoder::dl_def(d) => {

branches/try2/src/librustc/middle/trans/consts.rs

@@ -22,6 +22,19 @@ fn const_lit(cx: @crate_ctxt, e: @ast::expr, lit: ast::lit)
         }
       }
       ast::lit_float(fs, t) => C_floating(*fs, T_float_ty(cx, t)),
+      ast::lit_float_unsuffixed(fs) => {
+        let lit_float_ty = ty::node_id_to_type(cx.tcx, e.id);
+        match ty::get(lit_float_ty).sty {
+          ty::ty_float(t) => {
+            C_floating(*fs, T_float_ty(cx, t))
+          }
+          _ => {
+            cx.sess.span_bug(lit.span,
+                             ~"floating point literal doesn't have the right \
+                               type");
+          }
+        }
+      }
       ast::lit_bool(b) => C_bool(b),
       ast::lit_nil => C_nil(),
       ast::lit_str(s) => C_estr_slice(cx, *s)

branches/try2/src/librustc/middle/ty.rs

@@ -21,7 +21,7 @@ use util::ppaux::{ty_to_str, proto_ty_to_str, tys_to_str};
 
 export ProvidedMethodSource;
 export InstantiatedTraitRef;
-export TyVid, IntVid, FnVid, RegionVid, vid;
+export TyVid, IntVid, FloatVid, FnVid, RegionVid, vid;
 export br_hashmap;
 export is_instantiable;
 export node_id_to_type;
@@ -86,6 +86,7 @@ export ty_fn, FnTy, FnTyBase, FnMeta, FnSig, mk_fn;
 export ty_fn_proto, ty_fn_purity, ty_fn_ret, ty_fn_ret_style, tys_in_fn_ty;
 export ty_int, mk_int, mk_mach_int, mk_char;
 export mk_i8, mk_u8, mk_i16, mk_u16, mk_i32, mk_u32, mk_i64, mk_u64;
+export mk_f32, mk_f64;
 export ty_estr, mk_estr, type_is_str;
 export ty_evec, mk_evec, type_is_vec;
 export ty_unboxed_vec, mk_unboxed_vec, mk_mut_unboxed_vec;
@@ -102,8 +103,8 @@ export ty_tup, mk_tup;
 export ty_type, mk_type;
 export ty_uint, mk_uint, mk_mach_uint;
 export ty_uniq, mk_uniq, mk_imm_uniq, type_is_unique_box;
-export ty_infer, mk_infer, type_is_ty_var, mk_var, mk_int_var;
-export InferTy, TyVar, IntVar;
+export ty_infer, mk_infer, type_is_ty_var, mk_var, mk_int_var, mk_float_var;
+export InferTy, TyVar, IntVar, FloatVar;
 export ty_self, mk_self, type_has_self;
 export ty_class;
 export Region, bound_region, encl_region;
@@ -172,7 +173,8 @@ export ty_sort_str;
 export normalize_ty;
 export to_str;
 export bound_const;
-export terr_no_integral_type, terr_ty_param_size, terr_self_substs;
+export terr_no_integral_type, terr_no_floating_point_type;
+export terr_ty_param_size, terr_self_substs;
 export terr_in_field, terr_record_fields, terr_vstores_differ, terr_arg_count;
 export terr_sorts, terr_vec, terr_str, terr_record_size, terr_tuple_size;
 export terr_regions_does_not_outlive, terr_mutability, terr_purity_mismatch;
@@ -666,6 +668,7 @@ enum type_err {
     terr_sorts(expected_found<t>),
     terr_self_substs,
     terr_no_integral_type,
+    terr_no_floating_point_type,
 }
 
 enum param_bound {
@@ -678,21 +681,24 @@ enum param_bound {
 
 enum TyVid = uint;
 enum IntVid = uint;
+enum FloatVid = uint;
 enum FnVid = uint;
 #[auto_serialize]
 #[auto_deserialize]
 enum RegionVid = uint;
 
 enum InferTy {
     TyVar(TyVid),
-    IntVar(IntVid)
+    IntVar(IntVid),
+    FloatVar(FloatVid)
 }
 
 impl InferTy : to_bytes::IterBytes {
     pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         match self {
           TyVar(ref tv) => to_bytes::iter_bytes_2(&0u8, tv, lsb0, f),
-          IntVar(ref iv) => to_bytes::iter_bytes_2(&1u8, iv, lsb0, f)
+          IntVar(ref iv) => to_bytes::iter_bytes_2(&1u8, iv, lsb0, f),
+          FloatVar(ref fv) => to_bytes::iter_bytes_2(&2u8, fv, lsb0, f)
         }
     }
 }
@@ -758,6 +764,11 @@ impl IntVid: vid {
     pure fn to_str() -> ~str { fmt!("<VI%u>", self.to_uint()) }
 }
 
+impl FloatVid: vid {
+    pure fn to_uint() -> uint { *self }
+    pure fn to_str() -> ~str { fmt!("<VF%u>", self.to_uint()) }
+}
+
 impl FnVid: vid {
     pure fn to_uint() -> uint { *self }
     pure fn to_str() -> ~str { fmt!("<F%u>", self.to_uint()) }
@@ -773,13 +784,15 @@ impl InferTy {
         match self {
             TyVar(v) => v.to_uint() << 1,
             IntVar(v) => (v.to_uint() << 1) + 1,
+            FloatVar(v) => (v.to_uint() << 1) + 2
         }
     }
 
     pure fn to_str() -> ~str {
         match self {
             TyVar(v) => v.to_str(),
             IntVar(v) => v.to_str(),
+            FloatVar(v) => v.to_str()
         }
     }
 }
@@ -812,6 +825,12 @@ impl IntVid : to_bytes::IterBytes {
     }
 }
 
+impl FloatVid : to_bytes::IterBytes {
+    pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
+        (*self).iter_bytes(lsb0, f)
+    }
+}
+
 impl FnVid : to_bytes::IterBytes {
     pure fn iter_bytes(+lsb0: bool, f: to_bytes::Cb) {
         (*self).iter_bytes(lsb0, f)
@@ -1030,6 +1049,10 @@ fn mk_u32(cx: ctxt) -> t { mk_t(cx, ty_uint(ast::ty_u32)) }
 
 fn mk_u64(cx: ctxt) -> t { mk_t(cx, ty_uint(ast::ty_u64)) }
 
+fn mk_f32(cx: ctxt) -> t { mk_t(cx, ty_float(ast::ty_f32)) }
+
+fn mk_f64(cx: ctxt) -> t { mk_t(cx, ty_float(ast::ty_f64)) }
+
 fn mk_mach_int(cx: ctxt, tm: ast::int_ty) -> t { mk_t(cx, ty_int(tm)) }
 
 fn mk_mach_uint(cx: ctxt, tm: ast::uint_ty) -> t { mk_t(cx, ty_uint(tm)) }
@@ -1110,9 +1133,9 @@ fn mk_class(cx: ctxt, class_id: ast::def_id, +substs: substs) -> t {
 
 fn mk_var(cx: ctxt, v: TyVid) -> t { mk_infer(cx, TyVar(v)) }
 
-fn mk_int_var(cx: ctxt, v: IntVid) -> t {
-    mk_infer(cx, IntVar(v))
-}
+fn mk_int_var(cx: ctxt, v: IntVid) -> t { mk_infer(cx, IntVar(v)) }
+
+fn mk_float_var(cx: ctxt, v: FloatVid) -> t { mk_infer(cx, FloatVar(v)) }
 
 fn mk_infer(cx: ctxt, it: InferTy) -> t { mk_t(cx, ty_infer(it)) }
 
@@ -1661,7 +1684,8 @@ pure fn type_is_unique(ty: t) -> bool {
 pure fn type_is_scalar(ty: t) -> bool {
     match get(ty).sty {
       ty_nil | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) |
-      ty_infer(IntVar(_)) | ty_type | ty_ptr(_) => true,
+      ty_infer(IntVar(_)) | ty_infer(FloatVar(_)) | ty_type |
+      ty_ptr(_) => true,
       _ => false
     }
 }
@@ -2428,7 +2452,7 @@ fn type_is_integral(ty: t) -> bool {
 
 fn type_is_fp(ty: t) -> bool {
     match get(ty).sty {
-      ty_float(_) => true,
+      ty_infer(FloatVar(_)) | ty_float(_) => true,
       _ => false
     }
 }
@@ -3260,6 +3284,7 @@ fn ty_sort_str(cx: ctxt, t: t) -> ~str {
       ty_tup(_) => ~"tuple",
       ty_infer(TyVar(_)) => ~"inferred type",
       ty_infer(IntVar(_)) => ~"integral variable",
+      ty_infer(FloatVar(_)) => ~"floating-point variable",
       ty_param(_) => ~"type parameter",
       ty_self => ~"self"
     }
@@ -3387,6 +3412,10 @@ fn type_err_to_str(cx: ctxt, err: &type_err) -> ~str {
             ~"couldn't determine an appropriate integral type for integer \
               literal"
         }
+        terr_no_floating_point_type => {
+            ~"couldn't determine an appropriate floating point type for \
+              floating point literal"
+        }
     }
 }
 
@@ -4000,7 +4029,7 @@ fn is_binopable(_cx: ctxt, ty: t, op: ast::binop) -> bool {
         match get(ty).sty {
           ty_bool => tycat_bool,
           ty_int(_) | ty_uint(_) | ty_infer(IntVar(_)) => tycat_int,
-          ty_float(_) => tycat_float,
+          ty_float(_) | ty_infer(FloatVar(_)) => tycat_float,
           ty_rec(_) | ty_tup(_) | ty_enum(_, _) => tycat_struct,
           ty_bot => tycat_bot,
           _ => tycat_other
@@ -4230,6 +4259,11 @@ impl IntVid : cmp::Eq {
     pure fn ne(other: &IntVid) -> bool { *self != *(*other) }
 }
 
+impl FloatVid : cmp::Eq {
+    pure fn eq(other: &FloatVid) -> bool { *self == *(*other) }
+    pure fn ne(other: &FloatVid) -> bool { *self != *(*other) }
+}
+
 impl FnVid : cmp::Eq {
     pure fn eq(other: &FnVid) -> bool { *self == *(*other) }
     pure fn ne(other: &FnVid) -> bool { *self != *(*other) }

branches/try2/src/librustc/middle/typeck/check.rs

@@ -850,6 +850,11 @@ fn check_lit(fcx: @fn_ctxt, lit: @ast::lit) -> ty::t {
         ty::mk_int_var(tcx, fcx.infcx().next_int_var_id())
       }
       ast::lit_float(_, t) => ty::mk_mach_float(tcx, t),
+      ast::lit_float_unsuffixed(_) => {
+        // An unsuffixed floating point literal could have any floating point
+        // type, so we create a floating point type variable for it.
+        ty::mk_float_var(tcx, fcx.infcx().next_float_var_id())
+      }
       ast::lit_nil => ty::mk_nil(tcx),
       ast::lit_bool(_) => ty::mk_bool(tcx)
     }

branches/try2/src/librustc/middle/typeck/check/method.rs

@@ -664,6 +664,7 @@ impl LookupContext {
         match ty::get(self_ty).sty {
             ty_box(*) | ty_uniq(*) | ty_rptr(*) |
             ty_infer(IntVar(_)) | // FIXME(#3211)---should be resolved
+            ty_infer(FloatVar(_)) | // FIXME(#3211)---should be resolved
             ty_self | ty_param(*) | ty_nil | ty_bot | ty_bool |
             ty_int(*) | ty_uint(*) |
             ty_float(*) | ty_enum(*) | ty_ptr(*) | ty_rec(*) |