---

yaml
---
r: 48813
b: refs/heads/snap-stage3
c: a14ec73
h: refs/heads/master
i:
  48811: 3a0a14a
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 3bbcac322669cff3abde5be937cc4ec3860f3985
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: e82167198900a8d592535f40307f7c3a71b8b72b
+refs/heads/snap-stage3: a14ec73cd2d15a2454113011835557ccf447f14d
 refs/heads/try: 2a8fb58d79e685d5ca07b039badcf2ae3ef077ea
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/librustc/driver/driver.rs

@@ -132,15 +132,15 @@ pub fn build_configuration(sess: Session, +argv0: ~str, input: input) ->
 }
 
 // Convert strings provided as --cfg [cfgspec] into a crate_cfg
-pub fn parse_cfgspecs(cfgspecs: ~[~str]) -> ast::crate_cfg {
-    // FIXME (#2399): It would be nice to use the parser to parse all
-    // varieties of meta_item here. At the moment we just support the
-    // meta_word variant.
-    let mut words = ~[];
+fn parse_cfgspecs(cfgspecs: ~[~str],
+                  demitter: diagnostic::Emitter) -> ast::crate_cfg {
+    let mut meta = ~[];
     for cfgspecs.each |s| {
-        words.push(attr::mk_word_item(@/*bad*/copy *s));
+        let sess = parse::new_parse_sess(Some(demitter));
+        let m = parse::parse_meta_from_source_str(~"cfgspec", @/*bad*/ copy *s, ~[], sess);
+        meta.push(m)
     }
-    return words;
+    return meta;
 }
 
 pub enum input {
@@ -639,7 +639,7 @@ pub fn build_session_options(+binary: ~str,
     let addl_lib_search_paths =
         getopts::opt_strs(matches, ~"L")
         .map(|s| Path(*s));
-    let cfg = parse_cfgspecs(getopts::opt_strs(matches, ~"cfg"));
+    let cfg = parse_cfgspecs(getopts::opt_strs(matches, ~"cfg"), demitter);
     let test = opt_present(matches, ~"test");
     let android_cross_path = getopts::opt_maybe_str(
         matches, ~"android-cross-path");

branches/snap-stage3/src/librustc/middle/lint.rs

@@ -498,7 +498,12 @@ fn check_item(i: @ast::item, cx: ty::ctxt) {
 // not traverse into subitems, since that is handled by the outer
 // lint visitor.
 fn item_stopping_visitor<E>(v: visit::vt<E>) -> visit::vt<E> {
-    visit::mk_vt(@visit::Visitor {visit_item: |_i, _e, _v| { },.. **v})
+    visit::mk_vt(@visit::Visitor {visit_item: |_i, _e, _v| { },
+        .. **(ty_stopping_visitor(v))})
+}
+
+fn ty_stopping_visitor<E>(v: visit::vt<E>) -> visit::vt<E> {
+    visit::mk_vt(@visit::Visitor {visit_ty: |_t, _e, _v| { },.. **v})
 }
 
 fn check_item_while_true(cx: ty::ctxt, it: @ast::item) {

branches/snap-stage3/src/librustc/middle/trans/adt.rs

@@ -23,10 +23,6 @@
  * Having everything in one place will enable improvements to data
  * structure representation; possibilities include:
  *
- * - Aligning enum bodies correctly, which in turn makes possible SIMD
- *   vector types (which are strict-alignment even on x86) and ports
- *   to strict-alignment architectures (PowerPC, SPARC, etc.).
- *
  * - User-specified alignment (e.g., cacheline-aligning parts of
  *   concurrently accessed data structures); LLVM can't represent this
  *   directly, so we'd have to insert padding fields in any structure
@@ -82,10 +78,8 @@ pub enum Repr {
      */
     Univariant(Struct, bool),
     /**
-     * General-case enums: discriminant as int, followed by fields.
-     * The fields start immediately after the discriminant, meaning
-     * that they may not be correctly aligned for the platform's ABI;
-     * see above.
+     * General-case enums: for each case there is a struct, and they
+     * all start with a field for the discriminant.
      */
     General(~[Struct])
 }
@@ -156,7 +150,8 @@ pub fn represent_type(cx: @CrateContext, t: ty::t) -> @Repr {
                                       discriminants",
                                      ty::item_path_str(cx.tcx, def_id)))
                 }
-                General(cases.map(|c| mk_struct(cx, c.tys)))
+                let discr = ~[ty::mk_int(cx.tcx)];
+                General(cases.map(|c| mk_struct(cx, discr + c.tys)))
             }
         }
         _ => cx.sess.bug(~"adt::represent_type called on non-ADT type")
@@ -191,20 +186,44 @@ fn generic_fields_of(cx: @CrateContext, r: &Repr, sizing: bool)
     -> ~[TypeRef] {
     match *r {
         CEnum(*) => ~[T_enum_discrim(cx)],
-        Univariant(ref st, _dtor) => {
-            if sizing {
-                st.fields.map(|&ty| type_of::sizing_type_of(cx, ty))
-            } else {
-                st.fields.map(|&ty| type_of::type_of(cx, ty))
-            }
-        }
+        Univariant(ref st, _dtor) => struct_llfields(cx, st, sizing),
         General(ref sts) => {
-            ~[T_enum_discrim(cx),
-              T_array(T_i8(), sts.map(|st| st.size).max() /*bad*/as uint)]
+            // To get "the" type of a general enum, we pick the case
+            // with the largest alignment (so it will always align
+            // correctly in containing structures) and pad it out.
+            fail_unless!(sts.len() >= 1);
+            let mut most_aligned = None;
+            let mut largest_align = 0;
+            let mut largest_size = 0;
+            for sts.each |st| {
+                if largest_size < st.size {
+                    largest_size = st.size;
+                }
+                if largest_align < st.align {
+                    // Clang breaks ties by size; it is unclear if
+                    // that accomplishes anything important.
+                    largest_align = st.align;
+                    most_aligned = Some(st);
+                }
+            }
+            let most_aligned = most_aligned.get();
+            let padding = largest_size - most_aligned.size;
+
+            struct_llfields(cx, most_aligned, sizing)
+                + [T_array(T_i8(), padding /*bad*/as uint)]
         }
     }
 }
 
+fn struct_llfields(cx: @CrateContext, st: &Struct, sizing: bool)
+    -> ~[TypeRef] {
+    if sizing {
+        st.fields.map(|&ty| type_of::sizing_type_of(cx, ty))
+    } else {
+        st.fields.map(|&ty| type_of::type_of(cx, ty))
+    }
+}
+
 /**
  * Obtain a representation of the discriminant sufficient to translate
  * destructuring; this may or may not involve the actual discriminant.
@@ -309,7 +328,7 @@ pub fn num_args(r: &Repr, discr: int) -> uint {
             fail_unless!(discr == 0);
             st.fields.len() - (if dtor { 1 } else { 0 })
         }
-        General(ref cases) => cases[discr as uint].fields.len()
+        General(ref cases) => cases[discr as uint].fields.len() - 1
     }
 }
 
@@ -328,8 +347,7 @@ pub fn trans_field_ptr(bcx: block, r: &Repr, val: ValueRef, discr: int,
             struct_field_ptr(bcx, st, val, ix, false)
         }
         General(ref cases) => {
-            struct_field_ptr(bcx, &cases[discr as uint],
-                                 GEPi(bcx, val, [0, 1]), ix, true)
+            struct_field_ptr(bcx, &cases[discr as uint], val, ix + 1, true)
         }
     }
 }
@@ -371,13 +389,12 @@ pub fn trans_drop_flag_ptr(bcx: block, r: &Repr, val: ValueRef) -> ValueRef {
  * depending on which case of an enum it is.
  *
  * To understand the alignment situation, consider `enum E { V64(u64),
- * V32(u32, u32) }` on win32.  The type should have 8-byte alignment
- * to accommodate the u64 (currently it doesn't; this is a known bug),
- * but `V32(x, y)` would have LLVM type `{i32, i32, i32}`, which is
- * 4-byte aligned.
+ * V32(u32, u32) }` on win32.  The type has 8-byte alignment to
+ * accommodate the u64, but `V32(x, y)` would have LLVM type `{i32,
+ * i32, i32}`, which is 4-byte aligned.
  *
  * Currently the returned value has the same size as the type, but
- * this may be changed in the future to avoid allocating unnecessary
+ * this could be changed in the future to avoid allocating unnecessary
  * space after values of shorter-than-maximum cases.
  */
 pub fn trans_const(ccx: @CrateContext, r: &Repr, discr: int,
@@ -395,14 +412,9 @@ pub fn trans_const(ccx: @CrateContext, r: &Repr, discr: int,
         General(ref cases) => {
             let case = &cases[discr as uint];
             let max_sz = cases.map(|s| s.size).max();
-            let body = build_const_struct(ccx, case, vals);
-
-            // The unary packed struct has alignment 1 regardless of
-            // its contents, so it will always be located at the
-            // expected offset at runtime.
-            C_struct([C_int(ccx, discr),
-                      C_packed_struct([C_struct(body)]),
-                      padding(max_sz - case.size)])
+            let contents = build_const_struct(ccx, case,
+                                              ~[C_int(ccx, discr)] + vals);
+            C_struct(contents + [padding(max_sz - case.size)])
         }
     }
 }
@@ -472,11 +484,9 @@ pub fn const_get_discrim(ccx: @CrateContext, r: &Repr, val: ValueRef)
 pub fn const_get_field(ccx: @CrateContext, r: &Repr, val: ValueRef,
                        _discr: int, ix: uint) -> ValueRef {
     match *r {
-        CEnum(*) => ccx.sess.bug(~"element access in C-like enum \
-                                             const"),
+        CEnum(*) => ccx.sess.bug(~"element access in C-like enum const"),
         Univariant(*) => const_struct_field(ccx, val, ix),
-        General(*) => const_struct_field(ccx, const_get_elt(ccx, val,
-                                                            [1, 0]), ix)
+        General(*) => const_struct_field(ccx, val, ix + 1)
     }
 }
 

branches/snap-stage3/src/librustc/middle/trans/callee.rs

@@ -491,14 +491,12 @@ pub fn trans_call_inner(
             }
         };
 
-        let llretslot = trans_ret_slot(bcx, fn_expr_ty, dest);
-
-        let mut llargs = ~[];
-        llargs.push(llretslot);
-        llargs.push(llenv);
-        bcx = trans_args(bcx, args, fn_expr_ty,
-                         ret_flag, autoref_arg, &mut llargs);
+        let args_res = trans_args(bcx, llenv, args, fn_expr_ty,
+                                  dest, ret_flag, autoref_arg);
+        bcx = args_res.bcx;
+        let mut llargs = /*bad*/copy args_res.args;
 
+        let llretslot = args_res.retslot;
 
         // Now that the arguments have finished evaluating, we need to revoke
         // the cleanup for the self argument, if it exists
@@ -556,12 +554,30 @@ pub enum CallArgs {
     ArgVals(&'self [ValueRef])
 }
 
-pub fn trans_ret_slot(+bcx: block,
-                      +fn_ty: ty::t,
-                      +dest: expr::Dest) -> ValueRef
-{
+pub struct Args {
+    bcx: block,
+    args: ~[ValueRef],
+    retslot: ValueRef
+}
+
+pub fn trans_args(cx: block,
+                  llenv: ValueRef,
+                  +args: CallArgs,
+                  fn_ty: ty::t,
+                  dest: expr::Dest,
+                  ret_flag: Option<ValueRef>,
+                  +autoref_arg: AutorefArg) -> Args {
+    let _icx = cx.insn_ctxt("trans_args");
+    let mut temp_cleanups = ~[];
+    let arg_tys = ty::ty_fn_args(fn_ty);
+    let mut llargs: ~[ValueRef] = ~[];
+
+    let mut bcx = cx;
+
     let retty = ty::ty_fn_ret(fn_ty);
-    match dest {
+
+    // Arg 0: Output pointer.
+    let llretslot = match dest {
         expr::SaveIn(dst) => dst,
         expr::Ignore => {
             if ty::type_is_nil(retty) {
@@ -572,21 +588,13 @@ pub fn trans_ret_slot(+bcx: block,
                 alloc_ty(bcx, retty)
             }
         }
-    }
-}
+    };
+    llargs.push(llretslot);
 
-pub fn trans_args(+cx: block,
-                  +args: CallArgs,
-                  +fn_ty: ty::t,
-                  +ret_flag: Option<ValueRef>,
-                  +autoref_arg: AutorefArg,
-                  +llargs: &mut ~[ValueRef]) -> block
-{
-    let _icx = cx.insn_ctxt("trans_args");
-    let mut temp_cleanups = ~[];
-    let arg_tys = ty::ty_fn_args(fn_ty);
+    // Arg 1: Env (closure-bindings / self value)
+    llargs.push(llenv);
 
-    let mut bcx = cx;
+    // ... then explicit args.
 
     // First we figure out the caller's view of the types of the arguments.
     // This will be needed if this is a generic call, because the callee has
@@ -615,7 +623,7 @@ pub fn trans_args(+cx: block,
         revoke_clean(bcx, *c)
     }
 
-    return bcx;
+    Args { bcx: bcx, args: llargs, retslot: llretslot }
 }
 
 pub enum AutorefArg {

branches/snap-stage3/src/librustc/middle/typeck/astconv.rs

@@ -54,6 +54,7 @@
 
 use core::prelude::*;
 
+use middle::const_eval;
 use middle::ty::{arg, field, substs};
 use middle::ty::{ty_param_substs_and_ty};
 use middle::ty;
@@ -412,9 +413,29 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + Durable>(
           }
         }
       }
-      ast::ty_fixed_length_vec(a_mt, u) => {
-        ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, a_mt),
-                    ty::vstore_fixed(u))
+      ast::ty_fixed_length_vec(a_mt, e) => {
+        match const_eval::eval_const_expr_partial(tcx, e) {
+          Ok(ref r) => {
+            match *r {
+              const_eval::const_int(i) =>
+                ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, a_mt),
+                            ty::vstore_fixed(i as uint)),
+              const_eval::const_uint(i) =>
+                ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, a_mt),
+                            ty::vstore_fixed(i as uint)),
+              _ => {
+                tcx.sess.span_fatal(
+                    ast_ty.span, ~"expected constant expr for vector length");
+              }
+            }
+          }
+          Err(ref r) => {
+            tcx.sess.span_fatal(
+                ast_ty.span,
+                fmt!("expected constant expr for vector length: %s",
+                     *r));
+          }
+        }
       }
       ast::ty_infer => {
         // ty_infer should only appear as the type of arguments or return

branches/snap-stage3/src/librustc/middle/typeck/check/mod.rs

@@ -2169,7 +2169,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
           }
           ast::expr_repeat(element, count_expr, mutbl) => {
             let count = ty::eval_repeat_count(tcx, count_expr);
-            fcx.write_ty(count_expr.id, ty::mk_uint(tcx));
+            check_expr_with_hint(fcx, count_expr, ty::mk_uint(tcx));
             let tt = ast_expr_vstore_to_vstore(fcx, ev, count, vst);
             let t: ty::t = fcx.infcx().next_ty_var();
             bot |= check_expr_has_type(fcx, element, t);
@@ -2537,7 +2537,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
       }
       ast::expr_repeat(element, count_expr, mutbl) => {
         let count = ty::eval_repeat_count(tcx, count_expr);
-        fcx.write_ty(count_expr.id, ty::mk_uint(tcx));
+        check_expr_with_hint(fcx, count_expr, ty::mk_uint(tcx));
         let t: ty::t = fcx.infcx().next_ty_var();
         bot |= check_expr_has_type(fcx, element, t);
         let t = ty::mk_evec(tcx, ty::mt {ty: t, mutbl: mutbl},

branches/snap-stage3/src/libsyntax/ast.rs

@@ -386,7 +386,6 @@ pub enum vstore {
 #[auto_decode]
 #[deriving_eq]
 pub enum expr_vstore {
-    // FIXME (#3469): Change uint to @expr (actually only constant exprs)
     expr_vstore_fixed(Option<uint>),   // [1,2,3,4]
     expr_vstore_uniq,                  // ~[1,2,3,4]
     expr_vstore_box,                   // @[1,2,3,4]
@@ -916,7 +915,7 @@ pub enum ty_ {
     ty_box(mt),
     ty_uniq(mt),
     ty_vec(mt),
-    ty_fixed_length_vec(mt, uint),
+    ty_fixed_length_vec(mt, @expr),
     ty_ptr(mt),
     ty_rptr(Option<@Lifetime>, mt),
     ty_closure(@TyClosure),

branches/snap-stage3/src/libsyntax/fold.rs

@@ -622,10 +622,10 @@ pub fn noop_fold_ty(t: &ty_, fld: @ast_fold) -> ty_ {
         }
         ty_tup(ref tys) => ty_tup(tys.map(|ty| fld.fold_ty(*ty))),
         ty_path(path, id) => ty_path(fld.fold_path(path), fld.new_id(id)),
-        ty_fixed_length_vec(ref mt, vs) => {
+        ty_fixed_length_vec(ref mt, e) => {
             ty_fixed_length_vec(
                 fold_mt(mt, fld),
-                vs
+                fld.fold_expr(e)
             )
         }
         ty_mac(ref mac) => ty_mac(fold_mac(*mac))