---

yaml
---
r: 44374
b: refs/heads/master
c: f2a8a71
h: refs/heads/master
v: v3

Author: cyndis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: f9c7ba009b51f39629d74ac67781c034643e74e8
+refs/heads/master: f2a8a712669911eb36166c35199fe18ce19ed7e9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

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

@@ -407,6 +407,10 @@ pub fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
                     // variant or we wouldn't have gotten here -- the constant
                     // checker forbids paths that don't map to C-like enum
                     // variants.
+                    if ty::enum_is_univariant(cx.tcx, enum_did) {
+                        // Univariants have no discriminant field.
+                        C_struct(~[])
+                    } else {
                     let lldiscrim = base::get_discrim_val(cx, e.span,
                                                           enum_did,
                                                           variant_did);
@@ -418,6 +422,7 @@ pub fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
                     let padding = C_null(T_array(T_i8(), size));
                     C_struct(~[lldiscrim, padding])
                 }
+                }
                 Some(ast::def_struct(_)) => {
                     let ety = ty::expr_ty(cx.tcx, e);
                     let llty = type_of::type_of(cx, ety);
@@ -442,14 +447,14 @@ pub fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
                 }
             Some(ast::def_variant(tid, vid)) => {
                 let ety = ty::expr_ty(cx.tcx, e);
-                let degen = ty::enum_is_univariant(cx.tcx, tid);
+                let univar = ty::enum_is_univariant(cx.tcx, tid);
                 let size = machine::static_size_of_enum(cx, ety);
 
                 let discrim = base::get_discrim_val(cx, e.span, tid, vid);
                 let c_args = C_struct(args.map(|a| const_expr(cx, *a)));
 
                 // FIXME (#1645): enum body alignment is generaly wrong.
-                if !degen {
+                if !univar {
                     // Pad out the data to the size of its type_of;
                     // this is necessary if the enum is contained
                     // within an aggregate (tuple, struct, vector) so
@@ -464,8 +469,6 @@ pub fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
                     // without affecting its internal alignment or
                     // changing the alignment of the enum.
                     C_struct(~[discrim, C_packed_struct(~[c_args]), padding])
-                } else if size == 0 {
-                    C_struct(~[discrim])
                 } else {
                     C_struct(~[c_args])
                 }

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

@@ -674,12 +674,15 @@ fn trans_def_dps_unadjusted(bcx: block, ref_expr: @ast::expr,
                 // 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 {
+            } else if !ty::enum_is_univariant(ccx.tcx, tid) {
                 // Nullary variant.
                 let lldiscrimptr = GEPi(bcx, lldest, [0u, 0u]);
                 let lldiscrim = C_int(bcx.ccx(), variant_info.disr_val);
                 Store(bcx, lldiscrim, lldiscrimptr);
                 return bcx;
+            } else {
+                // Nullary univariant.
+                return bcx;
             }
         }
         ast::def_struct(*) => {
@@ -1591,10 +1594,22 @@ fn trans_imm_cast(bcx: block, expr: @ast::expr,
             {in: cast_enum, out: cast_integral} |
             {in: cast_enum, out: cast_float} => {
                 let bcx = bcx;
-                let llenumty = T_opaque_enum_ptr(ccx);
-                let av_enum = PointerCast(bcx, llexpr, llenumty);
-                let lldiscrim_a_ptr = GEPi(bcx, av_enum, [0u, 0u]);
-                let lldiscrim_a = Load(bcx, lldiscrim_a_ptr);
+                let in_tid = match ty::get(t_in).sty {
+                    ty::ty_enum(did, _) => did,
+                    _ => ccx.sess.bug(~"enum cast source is not enum")
+                };
+                let variants = ty::enum_variants(ccx.tcx, in_tid);
+                let lldiscrim_a = if variants.len() == 1 {
+                    // Univariants don't have a discriminant field,
+                    // because there's only one value it could have:
+                    C_integral(T_enum_discrim(ccx),
+                               variants[0].disr_val as u64, True)
+                } else {
+                    let llenumty = T_opaque_enum_ptr(ccx);
+                    let av_enum = PointerCast(bcx, llexpr, llenumty);
+                    let lldiscrim_a_ptr = GEPi(bcx, av_enum, [0u, 0u]);
+                    Load(bcx, lldiscrim_a_ptr)
+                };
                 match k_out {
                     cast_integral => int_cast(bcx, ll_t_out,
                                               val_ty(lldiscrim_a),

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

@@ -242,14 +242,11 @@ pub fn fill_type_of_enum(cx: @crate_ctxt, did: ast::def_id, t: ty::t,
     debug!("type_of_enum %?: %?", t, ty::get(t));
 
     let lltys = {
-        let degen = ty::enum_is_univariant(cx.tcx, did);
+        let univar = ty::enum_is_univariant(cx.tcx, did);
         let size = machine::static_size_of_enum(cx, t);
-        if !degen {
+        if !univar {
             ~[T_enum_discrim(cx), T_array(T_i8(), size)]
         }
-        else if size == 0u {
-            ~[T_enum_discrim(cx)]
-        }
         else {
             ~[T_array(T_i8(), size)]
         }

trunk/src/libstd/treemap.rs

@@ -576,62 +576,63 @@ pure fn each_reverse<K: Ord, V>(node: &r/Option<~TreeNode<K, V>>,
 }
 
 // Remove left horizontal link by rotating right
-fn skew<K: Ord, V>(node: &mut ~TreeNode<K, V>) {
+fn skew<K: Ord, V>(mut node: ~TreeNode<K, V>) -> ~TreeNode<K, V> {
     if node.left.map_default(false, |x| x.level == node.level) {
         let mut save = node.left.swap_unwrap();
         node.left <-> save.right; // save.right now None
-        *node <-> save;
-        node.right = Some(save);
+        save.right = Some(node);
+        save
+    } else {
+        node // nothing to do
     }
 }
 
 // Remove dual horizontal link by rotating left and increasing level of
 // the parent
-fn split<K: Ord, V>(node: &mut ~TreeNode<K, V>) {
+fn split<K: Ord, V>(mut node: ~TreeNode<K, V>) -> ~TreeNode<K, V> {
     if node.right.map_default(false,
       |x| x.right.map_default(false, |y| y.level == node.level)) {
         let mut save = node.right.swap_unwrap();
         node.right <-> save.left; // save.left now None
+        save.left = Some(node);
         save.level += 1;
-        *node <-> save;
-        node.left = Some(save);
+        save
+    } else {
+        node // nothing to do
     }
 }
 
 fn insert<K: Ord, V>(node: &mut Option<~TreeNode<K, V>>, key: K,
                      value: V) -> bool {
-    match *node {
-      Some(ref mut save) => {
+    if node.is_none() {
+        *node = Some(~TreeNode::new(key, value));
+        true
+    } else {
+        let mut save = node.swap_unwrap();
         if key < save.key {
             let inserted = insert(&mut save.left, key, value);
-            skew(save);
-            split(save);
+            *node = Some(split(skew(save))); // re-balance, if necessary
             inserted
         } else if save.key < key {
             let inserted = insert(&mut save.right, key, value);
-            skew(save);
-            split(save);
+            *node = Some(split(skew(save))); // re-balance, if necessary
             inserted
         } else {
             save.key = key;
             save.value = value;
+            *node = Some(save);
             false
         }
-      }
-      None => {
-       *node = Some(~TreeNode::new(key, value));
-        true
-      }
     }
 }
 
 fn remove<K: Ord, V>(node: &mut Option<~TreeNode<K, V>>, key: &K) -> bool {
-    fn heir_swap<K: Ord, V>(node: &mut ~TreeNode<K, V>,
+    fn heir_swap<K: Ord, V>(node: &mut TreeNode<K, V>,
                             child: &mut Option<~TreeNode<K, V>>) {
         // *could* be done without recursion, but it won't borrow check
         do child.mutate |mut child| {
             if child.right.is_some() {
-                heir_swap(node, &mut child.right);
+                heir_swap(&mut *node, &mut child.right);
             } else {
                 node.key <-> child.key;
                 node.value <-> child.value;
@@ -640,15 +641,15 @@ fn remove<K: Ord, V>(node: &mut Option<~TreeNode<K, V>>, key: &K) -> bool {
         }
     }
 
-    match *node {
-      None => {
+    if node.is_none() {
         return false // bottom of tree
-      }
-      Some(ref mut save) => {
-        let (removed, this) = if save.key < *key {
-            (remove(&mut save.right, key), false)
+    } else {
+        let mut save = node.swap_unwrap();
+
+        let removed = if save.key < *key {
+            remove(&mut save.right, key)
         } else if *key < save.key {
-            (remove(&mut save.left, key), false)
+            remove(&mut save.left, key)
         } else {
             if save.left.is_some() {
                 if save.right.is_some() {
@@ -662,22 +663,16 @@ fn remove<K: Ord, V>(node: &mut Option<~TreeNode<K, V>>, key: &K) -> bool {
                     save.left = Some(left);
                     remove(&mut save.left, key);
                 } else {
-                    *save = save.left.swap_unwrap();
+                    save = save.left.swap_unwrap();
                 }
-                (true, false)
             } else if save.right.is_some() {
-                *save = save.right.swap_unwrap();
-                (true, false)
+                save = save.right.swap_unwrap();
             } else {
-                (true, true)
+                return true // leaf
             }
+            true
         };
 
-        if this {
-            *node = None;
-            return true;
-        }
-
         let left_level = save.left.map_default(0, |x| x.level);
         let right_level = save.right.map_default(0, |x| x.level);
 
@@ -689,28 +684,19 @@ fn remove<K: Ord, V>(node: &mut Option<~TreeNode<K, V>>, key: &K) -> bool {
                 do save.right.mutate |mut x| { x.level = save.level; x }
             }
 
-            skew(save);
-
-            match save.right {
-              Some(ref mut right) => {
-                skew(right);
-                match right.right {
-                  Some(ref mut x) => { skew(x) },
-                  None => ()
-                }
-              }
-              None => ()
-            }
+            save = skew(save);
 
-            split(save);
-            match save.right {
-              Some(ref mut x) => { split(x) },
-              None => ()
+            do save.right.mutate |mut right| {
+                right = skew(right);
+                right.right.mutate(skew);
+                right
             }
+            save = split(save);
+            save.right.mutate(split);
         }
 
+        *node = Some(save);
         removed
-      }
     }
 }
 

trunk/src/libsyntax/ext/source_util.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use codemap;
-use codemap::{FileMap, Loc, Pos, span};
+use codemap::{FileMap, Loc, Pos, ExpandedFrom, span};
 use ext::base::*;
 use ext::base;
 use ext::build::{mk_base_vec_e, mk_uint, mk_u8, mk_base_str};
@@ -21,20 +21,39 @@ use core::result;
 use core::str;
 use core::vec;
 
+fn topmost_expn_info(expn_info: @codemap::ExpnInfo) -> @codemap::ExpnInfo {
+    let ExpandedFrom({call_site, _}) = *expn_info;
+    match call_site.expn_info {
+        Some(next_expn_info) => {
+            let ExpandedFrom({callie: {name, _}, _}) = *next_expn_info;
+            // Don't recurse into file using "include!"
+            if name == ~"include" { return expn_info; }
+
+            topmost_expn_info(next_expn_info)
+        },
+        None => expn_info
+    }
+}
+
 /* line!(): expands to the current line number */
 pub fn expand_line(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     -> base::MacResult {
     base::check_zero_tts(cx, sp, tts, "line!");
-    let loc = cx.codemap().lookup_char_pos(sp.lo);
-    base::MRExpr(mk_uint(cx, sp, loc.line))
+
+    let topmost = topmost_expn_info(cx.backtrace().get());
+    let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
+
+    base::MRExpr(mk_uint(cx, topmost.call_site, loc.line))
 }
 
 /* col!(): expands to the current column number */
 pub fn expand_col(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     -> base::MacResult {
     base::check_zero_tts(cx, sp, tts, "col!");
-    let loc = cx.codemap().lookup_char_pos(sp.lo);
-    base::MRExpr(mk_uint(cx, sp, loc.col.to_uint()))
+
+    let topmost = topmost_expn_info(cx.backtrace().get());
+    let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
+    base::MRExpr(mk_uint(cx, topmost.call_site, loc.col.to_uint()))
 }
 
 /* file!(): expands to the current filename */
@@ -43,9 +62,11 @@ pub fn expand_col(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
 pub fn expand_file(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     -> base::MacResult {
     base::check_zero_tts(cx, sp, tts, "file!");
+
+    let topmost = topmost_expn_info(cx.backtrace().get());
     let Loc { file: @FileMap { name: filename, _ }, _ } =
-        cx.codemap().lookup_char_pos(sp.lo);
-    base::MRExpr(mk_base_str(cx, sp, filename))
+        cx.codemap().lookup_char_pos(topmost.call_site.lo);
+    base::MRExpr(mk_base_str(cx, topmost.call_site, filename))
 }
 
 pub fn expand_stringify(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])