---

yaml
---
r: 83101
b: refs/heads/auto
c: 818ebf2
h: refs/heads/master
i:
  83099: 8b62582
v: v3

Author: brson

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: a7e8957c591651b6568d1b495d29ee85d11c0975
+refs/heads/auto: 818ebf2ed6c6f61d0a2ec86cb104c4467b28d75e
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/doc/tutorial-ffi.md

@@ -415,18 +415,21 @@ fn main() {
 
 Most foreign code exposes a C ABI, and Rust uses the platform's C calling convention by default when
 calling foreign functions. Some foreign functions, most notably the Windows API, use other calling
-conventions. Rust provides a way to tell the compiler which convention to use:
+conventions. Rust provides the `abi` attribute as a way to hint to the compiler which calling
+convention to use:
 
 ~~~~
 #[cfg(target_os = "win32")]
+#[abi = "stdcall"]
 #[link_name = "kernel32"]
-extern "stdcall" {
+extern {
     fn SetEnvironmentVariableA(n: *u8, v: *u8) -> int;
 }
 ~~~~
 
-This applies to the entire `extern` block, and must be either `"cdecl"` or
-`"stdcall"`. The compiler may eventually support other calling conventions.
+The `abi` attribute applies to a foreign module (it cannot be applied to a single function within a
+module), and must be either `"cdecl"` or `"stdcall"`. The compiler may eventually support other
+calling conventions.
 
 # Interoperability with foreign code
 

branches/auto/doc/tutorial.md

@@ -2811,7 +2811,7 @@ For every crate you can define a number of metadata items, such as link name, ve
 You can also toggle settings that have crate-global consequences. Both mechanism
 work by providing attributes in the crate root.
 
-For example, Rust uniquely identifies crates by their link metadata, which includes
+For example, Rust uniquely identifies crates by their link metadate, which includes
 the link name and the version. It also hashes the filename and the symbols in a binary
 based on the link metadata, allowing you to use two different versions of the same library in a crate
 without conflict.
@@ -2916,7 +2916,7 @@ As well as this line into every module body:
 use std::prelude::*;
 ~~~
 
-The role of the `prelude` module is to re-export common definitions from `std`.
+The role of the `prelude` module is to re-exports common definitions from `std`.
 
 This allows you to use common types and functions like `Option<T>` or `println`
 without needing to import them. And if you need something from `std` that's not in the prelude,

branches/auto/src/libextra/test.rs

@@ -57,23 +57,6 @@ impl ToStr for TestName {
     }
 }
 
-#[deriving(Clone)]
-enum NamePadding { PadNone, PadOnLeft, PadOnRight }
-
-impl TestDesc {
-    fn padded_name(&self, column_count: uint, align: NamePadding) -> ~str {
-        use std::num::Saturating;
-        let name = self.name.to_str();
-        let fill = column_count.saturating_sub(name.len());
-        let pad = " ".repeat(fill);
-        match align {
-            PadNone => name,
-            PadOnLeft => pad.append(name),
-            PadOnRight => name.append(pad),
-        }
-    }
-}
-
 // A function that runs a test. If the function returns successfully,
 // the test succeeds; if the function fails then the test fails. We
 // may need to come up with a more clever definition of test in order
@@ -87,19 +70,6 @@ pub enum TestFn {
     DynBenchFn(~fn(&mut BenchHarness))
 }
 
-impl TestFn {
-    fn padding(&self) -> NamePadding {
-        match self {
-            &StaticTestFn(*)   => PadNone,
-            &StaticBenchFn(*)  => PadOnRight,
-            &StaticMetricFn(*) => PadOnRight,
-            &DynTestFn(*)      => PadNone,
-            &DynMetricFn(*)    => PadOnRight,
-            &DynBenchFn(*)     => PadOnRight,
-        }
-    }
-}
-
 // Structure passed to BenchFns
 pub struct BenchHarness {
     iterations: u64,
@@ -346,8 +316,7 @@ struct ConsoleTestState {
     ignored: uint,
     measured: uint,
     metrics: MetricMap,
-    failures: ~[TestDesc],
-    max_name_len: uint, // number of columns to fill when aligning names
+    failures: ~[TestDesc]
 }
 
 impl ConsoleTestState {
@@ -379,8 +348,7 @@ impl ConsoleTestState {
             ignored: 0u,
             measured: 0u,
             metrics: MetricMap::new(),
-            failures: ~[],
-            max_name_len: 0u,
+            failures: ~[]
         }
     }
 
@@ -443,9 +411,8 @@ impl ConsoleTestState {
         self.out.write_line(format!("\nrunning {} {}", len, noun));
     }
 
-    pub fn write_test_start(&self, test: &TestDesc, align: NamePadding) {
-        let name = test.padded_name(self.max_name_len, align);
-        self.out.write_str(format!("test {} ... ", name));
+    pub fn write_test_start(&self, test: &TestDesc) {
+        self.out.write_str(format!("test {} ... ", test.name.to_str()));
     }
 
     pub fn write_result(&self, result: &TestResult) {
@@ -592,12 +559,12 @@ pub fn fmt_metrics(mm: &MetricMap) -> ~str {
 
 pub fn fmt_bench_samples(bs: &BenchSamples) -> ~str {
     if bs.mb_s != 0 {
-        format!("{:>9} ns/iter (+/- {}) = {} MB/s",
+        format!("{} ns/iter (+/- {}) = {} MB/s",
              bs.ns_iter_summ.median as uint,
              (bs.ns_iter_summ.max - bs.ns_iter_summ.min) as uint,
              bs.mb_s)
     } else {
-        format!("{:>9} ns/iter (+/- {})",
+        format!("{} ns/iter (+/- {})",
              bs.ns_iter_summ.median as uint,
              (bs.ns_iter_summ.max - bs.ns_iter_summ.min) as uint)
     }
@@ -610,7 +577,7 @@ pub fn run_tests_console(opts: &TestOpts,
         debug2!("callback(event={:?})", event);
         match (*event).clone() {
             TeFiltered(ref filtered_tests) => st.write_run_start(filtered_tests.len()),
-            TeWait(ref test, padding) => st.write_test_start(test, padding),
+            TeWait(ref test) => st.write_test_start(test),
             TeResult(test, result) => {
                 st.write_log(&test, &result);
                 st.write_result(&result);
@@ -640,20 +607,6 @@ pub fn run_tests_console(opts: &TestOpts,
         }
     }
     let st = @mut ConsoleTestState::new(opts);
-    fn len_if_padded(t: &TestDescAndFn) -> uint {
-        match t.testfn.padding() {
-            PadNone => 0u,
-            PadOnLeft | PadOnRight => t.desc.name.to_str().len(),
-        }
-    }
-    match tests.iter().max_by(|t|len_if_padded(*t)) {
-        Some(t) => {
-            let n = t.desc.name.to_str();
-            debug2!("Setting max_name_len from: {}", n);
-            st.max_name_len = n.len();
-        },
-        None => {}
-    }
     run_tests(opts, tests, |x| callback(&x, st));
     match opts.save_metrics {
         None => (),
@@ -693,8 +646,7 @@ fn should_sort_failures_before_printing_them() {
             ignored: 0u,
             measured: 0u,
             metrics: MetricMap::new(),
-            failures: ~[test_b, test_a],
-            max_name_len: 0u,
+            failures: ~[test_b, test_a]
         };
 
         st.write_failures();
@@ -710,7 +662,7 @@ fn use_color() -> bool { return get_concurrency() == 1; }
 #[deriving(Clone)]
 enum TestEvent {
     TeFiltered(~[TestDesc]),
-    TeWait(TestDesc, NamePadding),
+    TeWait(TestDesc),
     TeResult(TestDesc, TestResult),
 }
 
@@ -752,15 +704,15 @@ fn run_tests(opts: &TestOpts,
                 // We are doing one test at a time so we can print the name
                 // of the test before we run it. Useful for debugging tests
                 // that hang forever.
-                callback(TeWait(test.desc.clone(), test.testfn.padding()));
+                callback(TeWait(test.desc.clone()));
             }
             run_test(!opts.run_tests, test, ch.clone());
             pending += 1;
         }
 
         let (desc, result) = p.recv();
         if concurrency != 1 {
-            callback(TeWait(desc.clone(), PadNone));
+            callback(TeWait(desc.clone()));
         }
         callback(TeResult(desc, result));
         pending -= 1;
@@ -769,7 +721,7 @@ fn run_tests(opts: &TestOpts,
     // All benchmarks run at the end, in serial.
     // (this includes metric fns)
     for b in filtered_benchs_and_metrics.move_iter() {
-        callback(TeWait(b.desc.clone(), b.testfn.padding()));
+        callback(TeWait(b.desc.clone()));
         run_test(!opts.run_benchmarks, b, ch.clone());
         let (test, result) = p.recv();
         callback(TeResult(test, result));

branches/auto/src/libextra/time.rs

@@ -19,6 +19,7 @@ static NSEC_PER_SEC: i32 = 1_000_000_000_i32;
 pub mod rustrt {
     use super::Tm;
 
+    #[abi = "cdecl"]
     extern {
         pub fn get_time(sec: &mut i64, nsec: &mut i32);
         pub fn precise_time_ns(ns: &mut u64);

branches/auto/src/libextra/unicode.rs

@@ -162,6 +162,7 @@ pub mod icu {
 
         // #[link_name = "icuuc"]
         #[link_args = "-licuuc"]
+        #[abi = "cdecl"]
         extern {
             pub fn u_hasBinaryProperty(c: UChar32, which: UProperty) -> UBool;
             pub fn u_isdigit(c: UChar32) -> UBool;

branches/auto/src/librustc/lib/llvm.rs

@@ -300,6 +300,7 @@ pub mod llvm {
 
     #[link_args = "-Lrustllvm -lrustllvm"]
     #[link_name = "rustllvm"]
+    #[abi = "cdecl"]
     extern {
         /* Create and destroy contexts. */
         pub fn LLVMContextCreate() -> ContextRef;

branches/auto/src/librustc/middle/trans/adt.rs

@@ -505,27 +505,26 @@ pub fn trans_const(ccx: &mut CrateContext, r: &Repr, discr: Disr,
         }
         Univariant(ref st, _dro) => {
             assert_eq!(discr, 0);
-            let contents = build_const_struct(ccx, st, vals);
-            C_struct(contents, st.packed)
+            C_struct(build_const_struct(ccx, st, vals))
         }
         General(ref cases) => {
             let case = &cases[discr];
             let max_sz = cases.iter().map(|x| x.size).max().unwrap();
             let discr_ty = C_disr(ccx, discr);
             let contents = build_const_struct(ccx, case,
                                               ~[discr_ty] + vals);
-            C_struct(contents + &[padding(max_sz - case.size)], false)
+            C_struct(contents + &[padding(max_sz - case.size)])
         }
         NullablePointer{ nonnull: ref nonnull, nndiscr, ptrfield, _ } => {
             if discr == nndiscr {
-                C_struct(build_const_struct(ccx, nonnull, vals), false)
+                C_struct(build_const_struct(ccx, nonnull, vals))
             } else {
                 assert_eq!(vals.len(), 0);
                 let vals = do nonnull.fields.iter().enumerate().map |(i, &ty)| {
                     let llty = type_of::sizing_type_of(ccx, ty);
                     if i == ptrfield { C_null(llty) } else { C_undef(llty) }
                 }.collect::<~[ValueRef]>();
-                C_struct(build_const_struct(ccx, nonnull, vals), false)
+                C_struct(build_const_struct(ccx, nonnull, vals))
             }
         }
     }
@@ -560,7 +559,7 @@ fn build_const_struct(ccx: &mut CrateContext, st: &Struct, vals: &[ValueRef])
             offset = target_offset;
         }
         let val = if is_undef(vals[i]) {
-            let wrapped = C_struct([vals[i]], false);
+            let wrapped = C_struct([vals[i]]);
             assert!(!is_undef(wrapped));
             wrapped
         } else {

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

@@ -2936,7 +2936,7 @@ pub fn create_module_map(ccx: &mut CrateContext) -> (ValueRef, uint, uint) {
             let elt = C_struct([
                 C_estr_slice(ccx, *key),
                 v_ptr
-            ], false);
+            ]);
             elts.push(elt);
     }
     unsafe {
@@ -3012,13 +3012,13 @@ pub fn fill_crate_map(ccx: &mut CrateContext, map: ValueRef) {
                 p2i(ccx, mod_map),
                 // byte size of the module map array, an entry consists of two integers
                 C_int(ccx, ((mod_count * mod_struct_size) as int))
-             ], false),
+             ]),
              C_struct([
                 p2i(ccx, vec_elements),
                 // byte size of the subcrates array, an entry consists of an integer
                 C_int(ccx, (subcrates.len() * llsize_of_alloc(ccx, ccx.int_type)) as int)
-             ], false)
-        ], false));
+             ])
+        ]));
     }
 }
 
@@ -3052,7 +3052,7 @@ pub fn write_metadata(cx: &CrateContext, crate: &ast::Crate) {
 
     let encode_parms = crate_ctxt_to_encode_parms(cx, encode_inlined_item);
     let llmeta = C_bytes(encoder::encode_metadata(encode_parms, crate));
-    let llconst = C_struct([llmeta], false);
+    let llconst = C_struct([llmeta]);
     let mut llglobal = do "rust_metadata".with_c_str |buf| {
         unsafe {
             llvm::LLVMAddGlobal(cx.llmod, val_ty(llconst).to_ref(), buf)

branches/auto/src/librustc/middle/trans/common.rs

@@ -848,7 +848,7 @@ pub fn C_floating(s: &str, t: Type) -> ValueRef {
 }
 
 pub fn C_nil() -> ValueRef {
-    C_struct([], false)
+    return C_struct([]);
 }
 
 pub fn C_bool(val: bool) -> ValueRef {
@@ -913,7 +913,7 @@ pub fn C_estr_slice(cx: &mut CrateContext, s: @str) -> ValueRef {
     unsafe {
         let len = s.len();
         let cs = llvm::LLVMConstPointerCast(C_cstr(cx, s), Type::i8p().to_ref());
-        C_struct([cs, C_uint(cx, len)], false)
+        C_struct([cs, C_uint(cx, len)])
     }
 }
 
@@ -927,10 +927,18 @@ pub fn C_zero_byte_arr(size: uint) -> ValueRef {
     }
 }
 
-pub fn C_struct(elts: &[ValueRef], packed: bool) -> ValueRef {
+pub fn C_struct(elts: &[ValueRef]) -> ValueRef {
     unsafe {
         do elts.as_imm_buf |ptr, len| {
-            llvm::LLVMConstStructInContext(base::task_llcx(), ptr, len as c_uint, packed as Bool)
+            llvm::LLVMConstStructInContext(base::task_llcx(), ptr, len as c_uint, False)
+        }
+    }
+}
+
+pub fn C_packed_struct(elts: &[ValueRef]) -> ValueRef {
+    unsafe {
+        do elts.as_imm_buf |ptr, len| {
+            llvm::LLVMConstStructInContext(base::task_llcx(), ptr, len as c_uint, True)
         }
     }
 }