---

yaml
---
r: 3181
b: refs/heads/master
c: b84fffa
h: refs/heads/master
i:
  3179: 679a5d1
v: v3

Author: graydon

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: eb9969f54699924e4373f6c447aaeb4dd041b0dd
+refs/heads/master: b84fffaa4e0e672b4653a7832d75a2dc120040aa

trunk/src/comp/back/abi.rs

@@ -90,9 +90,10 @@ const int obj_body_elt_fields = 2;
 
 const int obj_body_elt_with_obj = 3;
 
- /* The base object to which an anonymous
-  * object is attached */
- const int fn_field_code = 0;
+
+/* The base object to which an anonymous
+ * object is attached */
+const int fn_field_code = 0;
 
 const int fn_field_box = 1;
 

trunk/src/comp/back/link.rs

@@ -175,6 +175,7 @@ mod write {
             } else {
                 // If we aren't saving temps then just output the file
                 // type corresponding to the '-c' or '-S' flag used
+
                 auto triple = x86::get_target_triple();
                 llvm::LLVMRustWriteOutputFile(pm.llpm, llmod,
                                               str::buf(triple),

trunk/src/comp/back/x86.rs

@@ -16,11 +16,9 @@ fn get_meta_sect_name() -> str {
 
 fn get_data_layout() -> str {
     if (str::eq(target_os(), "macos")) {
-        ret "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16"
-            + "-i32:32:32-i64:32:64"
-            + "-f32:32:32-f64:32:64-v64:64:64"
-            + "-v128:128:128-a0:0:64-f80:128:128"
-            + "-n8:16:32";
+        ret "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16" + "-i32:32:32-i64:32:64" +
+                "-f32:32:32-f64:32:64-v64:64:64" +
+                "-v128:128:128-a0:0:64-f80:128:128" + "-n8:16:32";
     }
     if (str::eq(target_os(), "win32")) {
         ret "e-p:32:32-f64:64:64-i64:64:64-f80:32:32-n8:16:32";

trunk/src/comp/driver/rustc.rs

@@ -239,7 +239,7 @@ fn build_session_options(str binary, getopts::match match) ->
                 case ("3") { 3u }
                 case (_) {
                     log_err "error: optimization level needs " +
-                        "to be between 0-3";
+                                "to be between 0-3";
                     fail
                 }
             }
@@ -399,13 +399,11 @@ fn main(vec[str] args) {
         let str prog = "gcc";
         // The invocations of gcc share some flags across platforms
 
-        let vec[str] common_args = [stage, "-Lrt", "-lrustrt",
-         "-fno-strict-aliasing", "-fPIC", "-Wall",
-         "-fno-rtti", "-fno-exceptions", "-g", glu, "-o",
-         saved_out_filename, saved_out_filename + ".o"];
-
-       auto shared_cmd;
-
+        let vec[str] common_args =
+            [stage, "-Lrt", "-lrustrt", "-fno-strict-aliasing", "-fPIC",
+             "-Wall", "-fno-rtti", "-fno-exceptions", "-g", glu, "-o",
+             saved_out_filename, saved_out_filename + ".o"];
+        auto shared_cmd;
         alt (sess.get_targ_cfg().os) {
             case (session::os_win32) {
                 shared_cmd = "-shared";
@@ -421,12 +419,12 @@ fn main(vec[str] args) {
             }
         }
         if (sopts.shared) {
-           gcc_args += [shared_cmd];
+            gcc_args += [shared_cmd];
         } else {
-           gcc_args += ["-Lrustllvm", "-lrustllvm", "-lstd", "-lm", main];
+            gcc_args += ["-Lrustllvm", "-lrustllvm", "-lstd", "-lm", main];
         }
-
         // We run 'gcc' here
+
         run::run_program(prog, gcc_args);
         // Clean up on Darwin
 

trunk/src/comp/front/ast.rs

@@ -245,13 +245,16 @@ tag expr_ {
     expr_alt(@expr, vec[arm], ann);
     expr_fn(_fn, ann);
     expr_block(block, ann);
-    expr_move(@expr /* TODO: @expr|is_lval */, @expr, ann);
-    expr_assign(@expr /* TODO: @expr|is_lval */, @expr, ann);
-    expr_swap(@expr /* TODO: @expr|is_lval */,
-              @expr /* TODO: @expr|is_lval */, ann);
-    expr_assign_op(binop, @expr /* TODO: @expr|is_lval */, @expr, ann);
-    expr_send(@expr /* TODO: @expr|is_lval */, @expr, ann);
-    expr_recv(@expr /* TODO: @expr|is_lval */, @expr, ann);
+    /*
+     * FIXME: many of these @exprs should be constrained with
+     * is_lval once we have constrained types working.
+     */
+    expr_move(@expr, @expr, ann);
+    expr_assign(@expr,@expr, ann);
+    expr_swap(@expr, @expr, ann);
+    expr_assign_op(binop, @expr, @expr, ann);
+    expr_send(@expr, @expr, ann);
+    expr_recv(@expr, @expr, ann);
     expr_field(@expr, ident, ann);
     expr_index(@expr, @expr, ann);
     expr_path(path, ann);
@@ -366,16 +369,14 @@ type constr_arg = constr_arg_general[uint];
 
 type constr_arg_general[T] = spanned[constr_arg_general_[T]];
 
-type constr_ = rec(path path,
-                   vec[@constr_arg_general[uint]] args,
-                   ann ann);
+type constr_ = rec(path path, vec[@constr_arg_general[uint]] args, ann ann);
 
 type constr = spanned[constr_];
 
+
 /* The parser generates ast::constrs; resolve generates
  a mapping from each function to a list of ty::constr_defs,
  corresponding to these. */
-
 type arg = rec(mode mode, @ty ty, ident ident, def_id id);
 
 type fn_decl =
@@ -464,12 +465,14 @@ tag attr_style { attr_outer; attr_inner; }
 
 type attribute_ = rec(attr_style style, meta_item value);
 
-type item = rec(ident ident,
-                vec[attribute] attrs,
-                def_id id, // For objs, this is the type def_id
-                ann ann,
-                item_ node,
-                span span);
+type item =
+    rec(ident ident,
+        vec[attribute] attrs,
+        def_id id, // For objs, this is the type def_id
+
+        ann ann,
+        item_ node,
+        span span);
 
 tag item_ {
     item_const(@ty, @expr);
@@ -478,7 +481,9 @@ tag item_ {
     item_native_mod(native_mod);
     item_ty(@ty, vec[ty_param]);
     item_tag(vec[variant], vec[ty_param]);
-    item_obj(_obj, vec[ty_param], def_id /* constructor id */);
+    item_obj(_obj, vec[ty_param], def_id);
+    /* constructor id */
+
 }
 
 type native_item = spanned[native_item_];
@@ -521,9 +526,9 @@ fn is_exported(ident i, _mod m) -> bool {
             case (_) {/* fall through */ }
         }
     }
-
     // If there are no declared exports then 
     // everything not imported is exported
+
     ret count == 0u && !nonlocal;
 }
 

trunk/src/comp/front/creader.rs

@@ -478,8 +478,7 @@ fn tag_variant_ids(&ebml::doc item, int this_cnum) -> vec[ast::def_id] {
 
 fn get_metadata_section(str filename) -> option::t[vec[u8]] {
     auto b = str::buf(filename);
-    auto mb =
-        llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(b);
+    auto mb = llvm::LLVMRustCreateMemoryBufferWithContentsOfFile(b);
     if (mb as int == 0) { ret option::none[vec[u8]]; }
     auto of = mk_object_file(mb);
     auto si = mk_section_iter(of.llof);

trunk/src/comp/front/eval.rs

@@ -294,17 +294,19 @@ fn eval_crate_directive(ctx cx, env e, @ast::crate_directive cdir, str prefix,
             cx.p.set_def(next_id._1);
             cx.chpos = p0.get_chpos();
             cx.next_ann = p0.next_ann_num();
-            auto i = front::parser::mk_item(cx.p, cdir.span.lo, cdir.span.hi,
-                                            id, ast::item_mod(m0), []);
+            auto i =
+                front::parser::mk_item(cx.p, cdir.span.lo, cdir.span.hi, id,
+                                       ast::item_mod(m0), []);
             vec::push[@ast::item](items, i);
         }
         case (ast::cdir_dir_mod(?id, ?dir_opt, ?cdirs)) {
             auto path = id;
             alt (dir_opt) { case (some(?d)) { path = d; } case (none) { } }
             auto full_path = prefix + std::fs::path_sep() + path;
             auto m0 = eval_crate_directives_to_mod(cx, e, cdirs, full_path);
-            auto i = front::parser::mk_item
-                (cx.p, cdir.span.lo, cdir.span.hi, id, ast::item_mod(m0), []);
+            auto i =
+                front::parser::mk_item(cx.p, cdir.span.lo, cdir.span.hi, id,
+                                       ast::item_mod(m0), []);
             vec::push[@ast::item](items, i);
         }
         case (ast::cdir_view_item(?vi)) {

trunk/src/comp/front/lexer.rs

@@ -281,7 +281,7 @@ fn scan_number(char c, &reader rdr) -> token::token {
                 rdr.bump();
                 ret token::LIT_MACH_FLOAT(util::common::ty_f64,
                                           intern(*rdr.get_interner(),
-                                                           float_str));
+                                                 float_str));
                 /* FIXME: if this is out of range for either a 32-bit or
                    64-bit float, it won't be noticed till the back-end */
 

trunk/src/comp/middle/alias.rs

@@ -34,12 +34,12 @@ type scope = vec[restrict];
 tag local_info { arg(ast::mode); objfield(ast::mutability); }
 
 type ctx =
-    rec(@ty::ctxt tcx,
-        std::map::hashmap[def_num, local_info] local_map);
+    rec(@ty::ctxt tcx, std::map::hashmap[def_num, local_info] local_map);
 
 fn check_crate(@ty::ctxt tcx, &@ast::crate crate) {
     auto cx =
         @rec(tcx=tcx,
+
              // Stores information about object fields and function
              // arguments that's otherwise not easily available.
              local_map=util::common::new_int_hash());
@@ -93,8 +93,8 @@ fn visit_expr(@ctx cx, &@ast::expr ex, &scope sc, &vt[scope] v) {
                     auto root = expr_root(*cx, ex, false);
                     if (mut_field(root.ds)) {
                         cx.tcx.sess.span_err(ex.span,
-                                             "result of put must be"
-                                             + " immutably rooted");
+                                             "result of put must be" +
+                                                 " immutably rooted");
                     }
                     visit_expr(cx, ex, sc, v);
                 }
@@ -129,7 +129,6 @@ fn check_call(&ctx cx, &@ast::expr f, &vec[@ast::expr] args, &scope sc) ->
    rec(vec[def_num] root_vars, vec[ty::t] unsafe_ts) {
     auto fty = ty::expr_ty(*cx.tcx, f);
     auto arg_ts = fty_args(cx, fty);
-
     let vec[def_num] roots = [];
     let vec[tup(uint, def_num)] mut_roots = [];
     let vec[ty::t] unsafe_ts = [];
@@ -146,7 +145,8 @@ fn check_call(&ctx cx, &@ast::expr f, &vec[@ast::expr] args, &scope sc) ->
                     }
                     case (_) {
                         if (!mut_field(root.ds)) {
-                            auto m = "passing a temporary value or \
+                            auto m =
+                                "passing a temporary value or \
                                  immutable field by mutable alias";
                             cx.tcx.sess.span_err(arg.span, m);
                         }
@@ -171,10 +171,10 @@ fn check_call(&ctx cx, &@ast::expr f, &vec[@ast::expr] args, &scope sc) ->
         alt (f.node) {
             case (ast::expr_path(_, ?ann)) {
                 if (def_is_local(cx.tcx.def_map.get(ann.id), true)) {
-                    cx.tcx.sess.span_err
-                        (f.span, #fmt("function may alias with argument \
-                         %u, which is not immutably rooted",
-                         unsafe_t_offsets.(0)));
+                    cx.tcx.sess.span_err(f.span,
+                                         #fmt("function may alias with \
+                         argument %u, which is not immutably rooted",
+                                              unsafe_t_offsets.(0)));
                 }
             }
             case (_) { }
@@ -218,9 +218,10 @@ fn check_call(&ctx cx, &@ast::expr f, &vec[@ast::expr] args, &scope sc) ->
 
 fn check_tail_call(&ctx cx, &@ast::expr call) {
     auto args;
-    auto f = alt (call.node) {
-        case (ast::expr_call(?f, ?args_, _)) { args = args_; f }
-    };
+    auto f =
+        alt (call.node) {
+            case (ast::expr_call(?f, ?args_, _)) { args = args_; f }
+        };
     auto i = 0u;
     for (ty::arg arg_t in fty_args(cx, ty::expr_ty(*cx.tcx, f))) {
         if (arg_t.mode != ty::mo_val) {
@@ -233,30 +234,28 @@ fn check_tail_call(&ctx cx, &@ast::expr call) {
                     alt (cx.local_map.find(dnum)) {
                         case (some(arg(ast::alias(?mut)))) {
                             if (mut_a && !mut) {
-                                cx.tcx.sess.span_warn
-                                    (args.(i).span, "passing an immutable \
+                                cx.tcx.sess.span_warn(args.(i).span,
+                                                      "passing an immutable \
                                      alias by mutable alias");
                             }
                         }
-                        case (_) {
-                            ok = !def_is_local(def, false);
-                        }
+                        case (_) { ok = !def_is_local(def, false); }
                     }
                 }
                 case (_) { ok = false; }
             }
             if (!ok) {
-                cx.tcx.sess.span_warn
-                    (args.(i).span, "can not pass a local value by alias to \
-                                     a tail call");
+                cx.tcx.sess.span_warn(args.(i).span,
+                                      "can not pass a local value by \
+                                     alias to a tail call");
             }
         }
         i += 1u;
     }
 }
 
-fn check_alt(&ctx cx, &@ast::expr input, &vec[ast::arm] arms,
-             &scope sc, &vt[scope] v) {
+fn check_alt(&ctx cx, &@ast::expr input, &vec[ast::arm] arms, &scope sc,
+             &vt[scope] v) {
     visit::visit_expr(input, sc, v);
     auto root = expr_root(cx, input, true);
     auto roots =
@@ -630,21 +629,20 @@ fn ty_can_unsafely_include(&ctx cx, ty::t needle, ty::t haystack, bool mut) ->
 
 fn def_is_local(&ast::def d, bool objfields_count) -> bool {
     ret alt (d) {
-        case (ast::def_local(_)) { true }
-        case (ast::def_arg(_)) { true }
-        case (ast::def_obj_field(_)) { objfields_count }
-        case (ast::def_binding(_)) { true }
-        case (_) { false }
-    };
+            case (ast::def_local(_)) { true }
+            case (ast::def_arg(_)) { true }
+            case (ast::def_obj_field(_)) { objfields_count }
+            case (ast::def_binding(_)) { true }
+            case (_) { false }
+        };
 }
 
 fn fty_args(&ctx cx, ty::t fty) -> vec[ty::arg] {
     ret alt (ty::struct(*cx.tcx, fty)) {
-        case (ty::ty_fn(_, ?args, _, _, _)) { args }
-        case (ty::ty_native_fn(_, ?args, _)) { args }
-    };
+            case (ty::ty_fn(_, ?args, _, _, _)) { args }
+            case (ty::ty_native_fn(_, ?args, _)) { args }
+        };
 }
-
 // Local Variables:
 // mode: rust
 // fill-column: 78;

trunk/src/comp/middle/metadata.rs

@@ -557,8 +557,8 @@ fn encode_info_for_item(@trans::crate_ctxt cx, &ebml::writer ebml_w,
                 encode_variant_id(ebml_w, v.node.id);
             }
             ebml::end_tag(ebml_w);
-            encode_tag_variant_info(cx, ebml_w, item.id, variants,
-                                    index, tps);
+            encode_tag_variant_info(cx, ebml_w, item.id, variants, index,
+                                    tps);
         }
         case (ast::item_obj(_, ?tps, ?ctor_id)) {
             ebml::start_tag(ebml_w, tag_items_data_item);