---

yaml
---
r: 54271
b: refs/heads/dist-snap
c: 5a97c48
h: refs/heads/master
i:
  54269: fc83152
  54267: e3372be
  54263: fc1fdcf
  54255: e4979bd
  54239: 010d0c8
  54207: 534e187
  54143: 9aa2c6b
  54015: 9d3c806
  53759: 2473e58
  53247: e75f266
v: v3

Author: bors

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: eac2f3b93e1458488e0aefcdfa02a4e524e8736d
+refs/heads/dist-snap: 5a97c484b1b5af479e34b7d5c454c7c97d9b31fb
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/configure

@@ -533,7 +533,7 @@ then
     LLVM_VERSION=$($LLVM_CONFIG --version)
 
     case $LLVM_VERSION in
-	(3.1svn|3.1|3.0svn|3.0)
+	(3.2svn|3.2|3.1svn|3.1|3.0svn|3.0)
 	    msg "found ok version of LLVM: $LLVM_VERSION"
 	    ;;
 	(*)

branches/dist-snap/src/libcore/stackwalk.rs

@@ -80,7 +80,7 @@ fn breakpoint() {
     }
 }
 
-fn frame_address(f: &fn(++x: *u8)) {
+fn frame_address(f: &fn(x: *u8)) {
     unsafe {
         rusti::frame_address(f)
     }
@@ -95,7 +95,7 @@ pub mod rustrt {
 pub mod rusti {
     #[abi = "rust-intrinsic"]
     pub extern {
-        pub fn frame_address(f: &once fn(++x: *u8));
+        pub fn frame_address(f: &once fn(x: *u8));
     }
 }
 

branches/dist-snap/src/libcore/unstable/extfmt.rs

@@ -470,9 +470,6 @@ pub mod ct {
 // decisions made a runtime. If it proves worthwhile then some of these
 // conditions can be evaluated at compile-time. For now though it's cleaner to
 // implement it this way, I think.
-#[cfg(stage1)]
-#[cfg(stage2)]
-#[cfg(stage3)]
 #[doc(hidden)]
 pub mod rt {
     use float;
@@ -676,192 +673,6 @@ pub mod rt {
     }
 }
 
-// XXX: remove after a snapshot of the above changes have gone in
-#[cfg(stage0)]
-#[doc(hidden)]
-pub mod rt {
-    use float;
-    use str;
-    use sys;
-    use uint;
-    use vec;
-
-    pub static flag_none : u32 = 0u32;
-    pub static flag_left_justify   : u32 = 0b00000000000001u32;
-    pub static flag_left_zero_pad  : u32 = 0b00000000000010u32;
-    pub static flag_space_for_sign : u32 = 0b00000000000100u32;
-    pub static flag_sign_always    : u32 = 0b00000000001000u32;
-    pub static flag_alternate      : u32 = 0b00000000010000u32;
-
-    pub enum Count { CountIs(uint), CountImplied, }
-
-    pub enum Ty { TyDefault, TyBits, TyHexUpper, TyHexLower, TyOctal, }
-
-    pub struct Conv {
-        flags: u32,
-        width: Count,
-        precision: Count,
-        ty: Ty,
-    }
-
-    pub fn conv_int(cv: Conv, i: int) -> ~str {
-        let radix = 10;
-        let prec = get_int_precision(cv);
-        let mut s : ~str = int_to_str_prec(i, radix, prec);
-        if 0 <= i {
-            if have_flag(cv.flags, flag_sign_always) {
-                unsafe { str::unshift_char(&mut s, '+') };
-            } else if have_flag(cv.flags, flag_space_for_sign) {
-                unsafe { str::unshift_char(&mut s, ' ') };
-            }
-        }
-        return unsafe { pad(cv, s, PadSigned) };
-    }
-    pub fn conv_uint(cv: Conv, u: uint) -> ~str {
-        let prec = get_int_precision(cv);
-        let mut rs =
-            match cv.ty {
-              TyDefault => uint_to_str_prec(u, 10, prec),
-              TyHexLower => uint_to_str_prec(u, 16, prec),
-              TyHexUpper => str::to_upper(uint_to_str_prec(u, 16, prec)),
-              TyBits => uint_to_str_prec(u, 2, prec),
-              TyOctal => uint_to_str_prec(u, 8, prec)
-            };
-        return unsafe { pad(cv, rs, PadUnsigned) };
-    }
-    pub fn conv_bool(cv: Conv, b: bool) -> ~str {
-        let s = if b { ~"true" } else { ~"false" };
-        // run the boolean conversion through the string conversion logic,
-        // giving it the same rules for precision, etc.
-        return conv_str(cv, s);
-    }
-    pub fn conv_char(cv: Conv, c: char) -> ~str {
-        let mut s = str::from_char(c);
-        return unsafe { pad(cv, s, PadNozero) };
-    }
-    pub fn conv_str(cv: Conv, s: &str) -> ~str {
-        // For strings, precision is the maximum characters
-        // displayed
-        let mut unpadded = match cv.precision {
-          CountImplied => s.to_owned(),
-          CountIs(max) => if (max as uint) < str::char_len(s) {
-            str::substr(s, 0, max as uint).to_owned()
-          } else {
-            s.to_owned()
-          }
-        };
-        return unsafe { pad(cv, unpadded, PadNozero) };
-    }
-    pub fn conv_float(cv: Conv, f: float) -> ~str {
-        let (to_str, digits) = match cv.precision {
-              CountIs(c) => (float::to_str_exact, c as uint),
-              CountImplied => (float::to_str_digits, 6u)
-        };
-        let mut s = unsafe { to_str(f, digits) };
-        if 0.0 <= f {
-            if have_flag(cv.flags, flag_sign_always) {
-                s = ~"+" + s;
-            } else if have_flag(cv.flags, flag_space_for_sign) {
-                s = ~" " + s;
-            }
-        }
-        return unsafe { pad(cv, s, PadFloat) };
-    }
-    pub fn conv_poly<T>(cv: Conv, v: &T) -> ~str {
-        let s = sys::log_str(v);
-        return conv_str(cv, s);
-    }
-
-    // Convert an int to string with minimum number of digits. If precision is
-    // 0 and num is 0 then the result is the empty string.
-    pub fn int_to_str_prec(num: int, radix: uint, prec: uint) -> ~str {
-        return if num < 0 {
-                ~"-" + uint_to_str_prec(-num as uint, radix, prec)
-            } else { uint_to_str_prec(num as uint, radix, prec) };
-    }
-
-    // Convert a uint to string with a minimum number of digits.  If precision
-    // is 0 and num is 0 then the result is the empty string. Could move this
-    // to uint: but it doesn't seem all that useful.
-    pub fn uint_to_str_prec(num: uint, radix: uint,
-                                 prec: uint) -> ~str {
-        return if prec == 0u && num == 0u {
-                ~""
-            } else {
-                let s = uint::to_str_radix(num, radix);
-                let len = str::char_len(s);
-                if len < prec {
-                    let diff = prec - len;
-                    let pad = str::from_chars(vec::from_elem(diff, '0'));
-                    pad + s
-                } else { s }
-            };
-    }
-    pub fn get_int_precision(cv: Conv) -> uint {
-        return match cv.precision {
-              CountIs(c) => c as uint,
-              CountImplied => 1u
-            };
-    }
-
-    #[deriving(Eq)]
-    pub enum PadMode { PadSigned, PadUnsigned, PadNozero, PadFloat }
-
-    pub fn pad(cv: Conv, s: ~str, mode: PadMode) -> ~str {
-        let mut s = s; // sadtimes
-        let uwidth : uint = match cv.width {
-          CountImplied => return (s),
-          CountIs(width) => { width as uint }
-        };
-        let strlen = str::char_len(s);
-        if uwidth <= strlen { return (s); }
-        let mut padchar = ' ';
-        let diff = uwidth - strlen;
-        if have_flag(cv.flags, flag_left_justify) {
-            let padstr = str::from_chars(vec::from_elem(diff, padchar));
-            return s + padstr;
-        }
-        let (might_zero_pad, signed) = match mode {
-          PadNozero   => (false, true),
-          PadSigned   => (true, true),
-          PadFloat    => (true, true),
-          PadUnsigned => (true, false)
-        };
-        fn have_precision(cv: Conv) -> bool {
-            return match cv.precision { CountImplied => false, _ => true };
-        }
-        let zero_padding = {
-            if might_zero_pad && have_flag(cv.flags, flag_left_zero_pad) &&
-                (!have_precision(cv) || mode == PadFloat) {
-                padchar = '0';
-                true
-            } else {
-                false
-            }
-        };
-        let padstr = str::from_chars(vec::from_elem(diff, padchar));
-        // This is completely heinous. If we have a signed value then
-        // potentially rip apart the intermediate result and insert some
-        // zeros. It may make sense to convert zero padding to a precision
-        // instead.
-
-        if signed && zero_padding && s.len() > 0 {
-            let head = str::shift_char(&mut s);
-            if head == '+' || head == '-' || head == ' ' {
-                let headstr = str::from_chars(vec::from_elem(1u, head));
-                return headstr + padstr + s;
-            }
-            else {
-                str::unshift_char(&mut s, head);
-            }
-        }
-        return padstr + s;
-    }
-    pub fn have_flag(flags: u32, f: u32) -> bool {
-        flags & f != 0
-    }
-}
-
 // Bulk of the tests are in src/test/run-pass/syntax-extension-fmt.rs
 #[cfg(test)]
 mod test {

branches/dist-snap/src/librustc/metadata/encoder.rs

@@ -286,8 +286,7 @@ fn encode_enum_variant_info(ecx: @EncodeContext, ebml_w: writer::Encoder,
                     if args.len() > 0 && generics.ty_params.len() == 0 => {
                 encode_symbol(ecx, ebml_w, variant.node.id);
             }
-            ast::tuple_variant_kind(_) | ast::struct_variant_kind(_) |
-            ast::enum_variant_kind(_) => {}
+            ast::tuple_variant_kind(_) | ast::struct_variant_kind(_) => {}
         }
         encode_discriminant(ecx, ebml_w, variant.node.id);
         if vi[i].disr_val != disr_val {

branches/dist-snap/src/librustc/middle/resolve.rs

@@ -37,7 +37,7 @@ use syntax::ast::{expr_binary, expr_break, expr_cast, expr_field};
 use syntax::ast::{expr_fn_block, expr_index, expr_method_call, expr_path};
 use syntax::ast::{def_prim_ty, def_region, def_self, def_ty, def_ty_param};
 use syntax::ast::{def_upvar, def_use, def_variant, div, eq};
-use syntax::ast::{enum_variant_kind, expr, expr_again, expr_assign_op};
+use syntax::ast::{expr, expr_again, expr_assign_op};
 use syntax::ast::{expr_index, expr_loop};
 use syntax::ast::{expr_path, expr_struct, expr_unary, fn_decl};
 use syntax::ast::{foreign_item, foreign_item_const, foreign_item_fn, ge};
@@ -1383,16 +1383,6 @@ pub impl Resolver {
                                   variant.span);
                 self.structs.insert(local_def(variant.node.id));
             }
-            enum_variant_kind(ref enum_definition) => {
-                child.define_type(privacy,
-                                  def_ty(local_def(variant.node.id)),
-                                  variant.span);
-                for (*enum_definition).variants.each |variant| {
-                    self.build_reduced_graph_for_variant(*variant, item_id,
-                                                         parent_privacy,
-                                                         parent, visitor);
-                }
-            }
         }
     }
 

branches/dist-snap/src/librustc/middle/trans/base.rs

@@ -2051,14 +2051,6 @@ pub fn trans_enum_def(ccx: @CrateContext, enum_definition: ast::enum_def,
                 trans_struct_def(ccx, struct_def, path,
                                  variant.node.id);
             }
-            ast::enum_variant_kind(ref enum_definition) => {
-                trans_enum_def(ccx,
-                               *enum_definition,
-                               id,
-                               path,
-                               vi,
-                               &mut *i);
-            }
         }
     }
 }
@@ -2513,9 +2505,6 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::node_id) -> ValueRef {
                 ast::struct_variant_kind(_) => {
                     fail!(~"struct variant kind unexpected in get_item_val")
                 }
-                ast::enum_variant_kind(_) => {
-                    fail!(~"enum variant kind unexpected in get_item_val")
-                }
             }
             set_inline_hint(llfn);
             llfn
@@ -2540,8 +2529,9 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::node_id) -> ValueRef {
             }
           }
 
-          _ => {
-            ccx.sess.bug(~"get_item_val(): unexpected variant")
+          ref variant => {
+            ccx.sess.bug(fmt!("get_item_val(): unexpected variant: %?",
+                              variant))
           }
         };
         if !(exprt || ccx.reachable.contains(&id)) {
@@ -3085,6 +3075,7 @@ pub fn trans_crate(sess: session::Session,
               const_cstr_cache: @mut LinearMap::new(),
               const_globals: @mut LinearMap::new(),
               const_values: @mut LinearMap::new(),
+              extern_const_values: @mut LinearMap::new(),
               module_data: @mut LinearMap::new(),
               lltypes: @mut LinearMap::new(),
               llsizingtypes: @mut LinearMap::new(),

branches/dist-snap/src/librustc/middle/trans/common.rs

@@ -201,6 +201,10 @@ pub struct CrateContext {
 
      // Cache of emitted const values
      const_values: @mut LinearMap<ast::node_id, ValueRef>,
+
+     // Cache of external const values
+     extern_const_values: @mut LinearMap<ast::def_id, ValueRef>,
+
      module_data: @mut LinearMap<~str, ValueRef>,
      lltypes: @mut LinearMap<ty::t, TypeRef>,
      llsizingtypes: @mut LinearMap<ty::t, TypeRef>,

branches/dist-snap/src/librustc/middle/trans/expr.rs

@@ -124,6 +124,7 @@ use core::prelude::*;
 use back::abi;
 use lib;
 use lib::llvm::{ValueRef, TypeRef, llvm, True};
+use metadata::csearch;
 use middle::borrowck::root_map_key;
 use middle::trans::_match;
 use middle::trans::adt;
@@ -150,6 +151,7 @@ use middle::ty::{AutoPtr, AutoBorrowVec, AutoBorrowVecRef, AutoBorrowFn,
 use util::common::indenter;
 use util::ppaux::ty_to_str;
 
+use core::cast::transmute;
 use core::hashmap::linear::LinearMap;
 use syntax::print::pprust::{expr_to_str};
 use syntax::ast;
@@ -1079,11 +1081,35 @@ fn trans_lvalue_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock {
 
                 fn get_val(bcx: block, did: ast::def_id, const_ty: ty::t)
                     -> ValueRef {
-                    // The LLVM global has the type of its initializer,
-                    // which may not be equal to the enum's type for
-                    // non-C-like enums.
-                    PointerCast(bcx, base::get_item_val(bcx.ccx(), did.node),
-                                T_ptr(type_of(bcx.ccx(), const_ty)))
+                    if did.crate == ast::local_crate {
+                        // The LLVM global has the type of its initializer,
+                        // which may not be equal to the enum's type for
+                        // non-C-like enums.
+                        PointerCast(bcx,
+                                    base::get_item_val(bcx.ccx(), did.node),
+                                    T_ptr(type_of(bcx.ccx(), const_ty)))
+                    } else {
+                        // For external constants, we don't inline.
+                        match bcx.ccx().extern_const_values.find(&did) {
+                            None => {
+                                unsafe {
+                                    let llty = type_of(bcx.ccx(), const_ty);
+                                    let symbol = csearch::get_symbol(
+                                        bcx.ccx().sess.cstore,
+                                        did);
+                                    let llval = llvm::LLVMAddGlobal(
+                                        bcx.ccx().llmod,
+                                        llty,
+                                        transmute::<&u8,*i8>(&symbol[0]));
+                                    bcx.ccx().extern_const_values.insert(
+                                        did,
+                                        llval);
+                                    llval
+                                }
+                            }
+                            Some(llval) => *llval
+                        }
+                    }
                 }
 
                 let did = get_did(ccx, did);

branches/dist-snap/src/librustc/middle/trans/monomorphize.rs

@@ -204,8 +204,6 @@ pub fn monomorphic_fn(ccx: @CrateContext,
             }
             ast::struct_variant_kind(_) =>
                 ccx.tcx.sess.bug(~"can't monomorphize struct variants"),
-            ast::enum_variant_kind(_) =>
-                ccx.tcx.sess.bug(~"can't monomorphize enum variants")
         }
         d
       }