---

yaml
---
r: 80635
b: refs/heads/auto
c: 77bbf23
h: refs/heads/master
i:
  80633: d188f2a
  80631: b295d8d
v: v3

Author: steveklabnik

[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: a5275ffd5c3fe22228b23f602ae4e7169df55d82
+refs/heads/auto: 77bbf23b4a6782b3e460c7eea339b858d98ae676
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/doc/tutorial-tasks.md

@@ -47,14 +47,16 @@ concurrency at this writing:
 
 * [`std::task`] - All code relating to tasks and task scheduling,
 * [`std::comm`] - The message passing interface,
-* [`extra::comm`] - Additional messaging types based on `std::comm`,
+* [`std::pipes`] - The underlying messaging infrastructure,
+* [`extra::comm`] - Additional messaging types based on `std::pipes`,
 * [`extra::sync`] - More exotic synchronization tools, including locks,
 * [`extra::arc`] - The Arc (atomically reference counted) type,
   for safely sharing immutable data,
 * [`extra::future`] - A type representing values that may be computed concurrently and retrieved at a later time.
 
 [`std::task`]: std/task.html
 [`std::comm`]: std/comm.html
+[`std::pipes`]: std/pipes.html
 [`extra::comm`]: extra/comm.html
 [`extra::sync`]: extra/sync.html
 [`extra::arc`]: extra/arc.html
@@ -123,7 +125,7 @@ receiving messages. Pipes are low-level communication building-blocks and so
 come in a variety of forms, each one appropriate for a different use case. In
 what follows, we cover the most commonly used varieties.
 
-The simplest way to create a pipe is to use the `comm::stream`
+The simplest way to create a pipe is to use the `pipes::stream`
 function to create a `(Port, Chan)` pair. In Rust parlance, a *channel*
 is a sending endpoint of a pipe, and a *port* is the receiving
 endpoint. Consider the following example of calculating two results

branches/auto/src/libextra/json.rs

@@ -135,21 +135,18 @@ impl serialize::Encoder for Encoder {
                          _id: uint,
                          cnt: uint,
                          f: &fn(&mut Encoder)) {
-        // enums are encoded as strings or objects
+        // enums are encoded as strings or vectors:
         // Bunny => "Bunny"
-        // Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]}
+        // Kangaroo(34,"William") => ["Kangaroo",[34,"William"]]
+
         if cnt == 0 {
             self.wr.write_str(escape_str(name));
         } else {
-            self.wr.write_char('{');
-            self.wr.write_str("\"variant\"");
-            self.wr.write_char(':');
+            self.wr.write_char('[');
             self.wr.write_str(escape_str(name));
             self.wr.write_char(',');
-            self.wr.write_str("\"fields\"");
-            self.wr.write_str(":[");
             f(self);
-            self.wr.write_str("]}");
+            self.wr.write_char(']');
         }
     }
 
@@ -950,20 +947,14 @@ impl serialize::Decoder for Decoder {
         debug!("read_enum_variant(names=%?)", names);
         let name = match self.stack.pop() {
             String(s) => s,
-            Object(o) => {
-                let n = match o.find(&~"variant").expect("invalidly encoded json") {
-                    &String(ref s) => s.clone(),
-                    _ => fail!("invalidly encoded json"),
-                };
-                match o.find(&~"fields").expect("invalidly encoded json") {
-                    &List(ref l) => {
-                        for field in l.rev_iter() {
-                            self.stack.push(field.clone());
-                        }
-                    },
-                    _ => fail!("invalidly encoded json")
+            List(list) => {
+                for v in list.move_rev_iter() {
+                    self.stack.push(v);
+                }
+                match self.stack.pop() {
+                    String(s) => s,
+                    value => fail!("invalid variant name: %?", value),
                 }
-                n
             }
             ref json => fail!("invalid variant: %?", *json),
         };
@@ -1526,7 +1517,7 @@ mod tests {
                 let mut encoder = Encoder(wr);
                 animal.encode(&mut encoder);
             },
-            ~"{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
+            ~"[\"Frog\",\"Henry\",349]"
         );
         assert_eq!(
             do io::with_str_writer |wr| {
@@ -1930,14 +1921,14 @@ mod tests {
         assert_eq!(value, Dog);
 
         let mut decoder =
-            Decoder(from_str("{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}").unwrap());
+            Decoder(from_str("[\"Frog\",\"Henry\",349]").unwrap());
         let value: Animal = Decodable::decode(&mut decoder);
         assert_eq!(value, Frog(~"Henry", 349));
     }
 
     #[test]
     fn test_decode_map() {
-        let s = ~"{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\"fields\":[\"Henry\", 349]}}";
+        let s = ~"{\"a\": \"Dog\", \"b\": [\"Frog\", \"Henry\", 349]}";
         let mut decoder = Decoder(from_str(s).unwrap());
         let mut map: TreeMap<~str, Animal> = Decodable::decode(&mut decoder);
 

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

@@ -174,7 +174,6 @@ impl<'self> Drop for StatRecorder<'self> {
     }
 }
 
-// only use this for foreign function ABIs and glue, use `decl_rust_fn` for Rust functions
 pub fn decl_fn(llmod: ModuleRef, name: &str, cc: lib::llvm::CallConv, ty: Type) -> ValueRef {
     let llfn: ValueRef = do name.with_c_str |buf| {
         unsafe {
@@ -186,12 +185,18 @@ pub fn decl_fn(llmod: ModuleRef, name: &str, cc: lib::llvm::CallConv, ty: Type)
     return llfn;
 }
 
-// only use this for foreign function ABIs and glue, use `decl_rust_fn` for Rust functions
 pub fn decl_cdecl_fn(llmod: ModuleRef, name: &str, ty: Type) -> ValueRef {
     return decl_fn(llmod, name, lib::llvm::CCallConv, ty);
 }
 
-// only use this for foreign function ABIs and glue, use `get_extern_rust_fn` for Rust functions
+// Only use this if you are going to actually define the function. It's
+// not valid to simply declare a function as internal.
+pub fn decl_internal_cdecl_fn(llmod: ModuleRef, name: &str, ty: Type) -> ValueRef {
+    let llfn = decl_cdecl_fn(llmod, name, ty);
+    lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage);
+    return llfn;
+}
+
 pub fn get_extern_fn(externs: &mut ExternMap, llmod: ModuleRef, name: &str,
                      cc: lib::llvm::CallConv, ty: Type) -> ValueRef {
     match externs.find_equiv(&name) {
@@ -200,73 +205,7 @@ pub fn get_extern_fn(externs: &mut ExternMap, llmod: ModuleRef, name: &str,
     }
     let f = decl_fn(llmod, name, cc, ty);
     externs.insert(name.to_owned(), f);
-    f
-}
-
-pub fn get_extern_rust_fn(ccx: &mut CrateContext, inputs: &[ty::t], output: ty::t,
-                          name: &str) -> ValueRef {
-    match ccx.externs.find_equiv(&name) {
-        Some(n) => return *n,
-        None => ()
-    }
-    let f = decl_rust_fn(ccx, inputs, output, name);
-    ccx.externs.insert(name.to_owned(), f);
-    f
-}
-
-pub fn decl_rust_fn(ccx: &mut CrateContext, inputs: &[ty::t], output: ty::t,
-                    name: &str) -> ValueRef {
-    let llfty = type_of_rust_fn(ccx, inputs, output);
-    let llfn = decl_cdecl_fn(ccx.llmod, name, llfty);
-
-    match ty::get(output).sty {
-        // `~` pointer return values never alias because ownership is transferred
-        ty::ty_uniq(*) |
-        ty::ty_evec(_, ty::vstore_uniq) => {
-            unsafe {
-                llvm::LLVMAddReturnAttribute(llfn, lib::llvm::NoAliasAttribute as c_uint);
-            }
-        }
-        _ => ()
-    }
-
-    let uses_outptr = type_of::return_uses_outptr(ccx.tcx, output);
-    let offset = if uses_outptr { 2 } else { 1 };
-
-    for (i, &arg_ty) in inputs.iter().enumerate() {
-        let llarg = unsafe { llvm::LLVMGetParam(llfn, (offset + i) as c_uint) };
-        match ty::get(arg_ty).sty {
-            // `~` pointer parameters never alias because ownership is transferred
-            ty::ty_uniq(*) |
-            ty::ty_evec(_, ty::vstore_uniq) |
-            ty::ty_closure(ty::ClosureTy {sigil: ast::OwnedSigil, _}) => {
-                unsafe {
-                    llvm::LLVMAddAttribute(llarg, lib::llvm::NoAliasAttribute as c_uint);
-                }
-            }
-            _ => ()
-        }
-    }
-
-    // The out pointer will never alias with any other pointers, as the object only exists at a
-    // language level after the call. It can also be tagged with SRet to indicate that it is
-    // guaranteed to point to a usable block of memory for the type.
-    if uses_outptr {
-        unsafe {
-            let outptr = llvm::LLVMGetParam(llfn, 0);
-            llvm::LLVMAddAttribute(outptr, lib::llvm::StructRetAttribute as c_uint);
-            llvm::LLVMAddAttribute(outptr, lib::llvm::NoAliasAttribute as c_uint);
-        }
-    }
-
-    llfn
-}
-
-pub fn decl_internal_rust_fn(ccx: &mut CrateContext, inputs: &[ty::t], output: ty::t,
-                             name: &str) -> ValueRef {
-    let llfn = decl_rust_fn(ccx, inputs, output, name);
-    lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage);
-    llfn
+    return f;
 }
 
 pub fn get_extern_const(externs: &mut ExternMap, llmod: ModuleRef,
@@ -870,30 +809,33 @@ pub fn null_env_ptr(ccx: &CrateContext) -> ValueRef {
     C_null(Type::opaque_box(ccx).ptr_to())
 }
 
-pub fn trans_external_path(ccx: &mut CrateContext, did: ast::DefId, t: ty::t) -> ValueRef {
+pub fn trans_external_path(ccx: &mut CrateContext, did: ast::DefId, t: ty::t)
+    -> ValueRef {
     let name = csearch::get_symbol(ccx.sess.cstore, did);
     match ty::get(t).sty {
         ty::ty_bare_fn(ref fn_ty) => {
-            match fn_ty.abis.for_arch(ccx.sess.targ_cfg.arch) {
-                Some(Rust) | Some(RustIntrinsic) => {
-                    get_extern_rust_fn(ccx, fn_ty.sig.inputs, fn_ty.sig.output, name)
-                }
+            // Currently llvm_calling_convention triggers unimpl/bug on
+            // Rust/RustIntrinsic, so those two are handled specially here.
+            let cconv = match fn_ty.abis.for_arch(ccx.sess.targ_cfg.arch) {
+                Some(Rust) | Some(RustIntrinsic) => lib::llvm::CCallConv,
                 Some(*) | None => {
                     let c = foreign::llvm_calling_convention(ccx, fn_ty.abis);
-                    let cconv = c.unwrap_or(lib::llvm::CCallConv);
-                    let llty = type_of_fn_from_ty(ccx, t);
-                    get_extern_fn(&mut ccx.externs, ccx.llmod, name, cconv, llty)
+                    c.unwrap_or(lib::llvm::CCallConv)
                 }
-            }
+            };
+            let llty = type_of_fn_from_ty(ccx, t);
+            return get_extern_fn(&mut ccx.externs, ccx.llmod, name, cconv, llty);
         }
-        ty::ty_closure(ref f) => {
-            get_extern_rust_fn(ccx, f.sig.inputs, f.sig.output, name)
+        ty::ty_closure(_) => {
+            let llty = type_of_fn_from_ty(ccx, t);
+            return get_extern_fn(&mut ccx.externs, ccx.llmod, name,
+            lib::llvm::CCallConv, llty);
         }
         _ => {
             let llty = type_of(ccx, t);
-            get_extern_const(&mut ccx.externs, ccx.llmod, name, llty)
+            return get_extern_const(&mut ccx.externs, ccx.llmod, name, llty);
         }
-    }
+    };
 }
 
 pub fn invoke(bcx: @mut Block, llfn: ValueRef, llargs: ~[ValueRef],
@@ -926,8 +868,7 @@ pub fn invoke(bcx: @mut Block, llfn: ValueRef, llargs: ~[ValueRef],
                               llfn,
                               llargs,
                               normal_bcx.llbb,
-                              get_landing_pad(bcx),
-                              attributes);
+                              get_landing_pad(bcx));
         return (llresult, normal_bcx);
     } else {
         unsafe {
@@ -1766,7 +1707,8 @@ pub fn new_fn_ctxt(ccx: @mut CrateContext,
 // field of the fn_ctxt with
 pub fn create_llargs_for_fn_args(cx: @mut FunctionContext,
                                  self_arg: self_arg,
-                                 args: &[ast::arg])
+                                 args: &[ast::arg],
+                                 arg_tys: &[ty::t])
                               -> ~[ValueRef] {
     let _icx = push_ctxt("create_llargs_for_fn_args");
 
@@ -1784,7 +1726,23 @@ pub fn create_llargs_for_fn_args(cx: @mut FunctionContext,
     // Return an array containing the ValueRefs that we get from
     // llvm::LLVMGetParam for each argument.
     do vec::from_fn(args.len()) |i| {
-        unsafe { llvm::LLVMGetParam(cx.llfn, cx.arg_pos(i) as c_uint) }
+        let arg_n = cx.arg_pos(i);
+        let arg_ty = arg_tys[i];
+        let llarg = unsafe {llvm::LLVMGetParam(cx.llfn, arg_n as c_uint) };
+
+        match ty::get(arg_ty).sty {
+            // `~` pointer parameters never alias because ownership is transferred
+            ty::ty_uniq(*) |
+            ty::ty_evec(_, ty::vstore_uniq) |
+            ty::ty_closure(ty::ClosureTy {sigil: ast::OwnedSigil, _}) => {
+                unsafe {
+                    llvm::LLVMAddAttribute(llarg, lib::llvm::NoAliasAttribute as c_uint);
+                }
+            }
+            _ => ()
+        }
+
+        llarg
     }
 }
 
@@ -1938,7 +1896,8 @@ pub fn trans_closure(ccx: @mut CrateContext,
 
     // Set up arguments to the function.
     let arg_tys = ty::ty_fn_args(node_id_type(bcx, id));
-    let raw_llargs = create_llargs_for_fn_args(fcx, self_arg, decl.inputs);
+    let raw_llargs = create_llargs_for_fn_args(fcx, self_arg,
+                                               decl.inputs, arg_tys);
 
     // Set the fixed stack segment flag if necessary.
     if attr::contains_name(attributes, "fixed_stack_segment") {
@@ -2002,6 +1961,18 @@ pub fn trans_fn(ccx: @mut CrateContext,
            param_substs.repr(ccx.tcx));
     let _icx = push_ctxt("trans_fn");
     let output_type = ty::ty_fn_ret(ty::node_id_to_type(ccx.tcx, id));
+
+    match ty::get(output_type).sty {
+        // `~` pointer return values never alias because ownership is transferred
+        ty::ty_uniq(*) |
+        ty::ty_evec(_, ty::vstore_uniq) => {
+            unsafe {
+                llvm::LLVMAddReturnAttribute(llfndecl, lib::llvm::NoAliasAttribute as c_uint);
+            }
+        }
+        _ => ()
+    }
+
     trans_closure(ccx,
                   path.clone(),
                   decl,
@@ -2149,7 +2120,7 @@ pub fn trans_enum_variant_or_tuple_like_struct<A:IdAndTy>(
 
     let arg_tys = ty::ty_fn_args(ctor_ty);
 
-    let raw_llargs = create_llargs_for_fn_args(fcx, no_self, fn_args);
+    let raw_llargs = create_llargs_for_fn_args(fcx, no_self, fn_args, arg_tys);
 
     let bcx = fcx.entry_bcx.unwrap();
 
@@ -2327,28 +2298,10 @@ pub fn register_fn(ccx: @mut CrateContext,
                    node_id: ast::NodeId,
                    node_type: ty::t)
                    -> ValueRef {
-    let f = match ty::get(node_type).sty {
-        ty::ty_bare_fn(ref f) => {
-            assert!(f.abis.is_rust() || f.abis.is_intrinsic());
-            f
-        }
-        _ => fail!("expected bare rust fn or an intrinsic")
-    };
-
-    let llfn = decl_rust_fn(ccx, f.sig.inputs, f.sig.output, sym);
-    ccx.item_symbols.insert(node_id, sym);
-
-    // FIXME #4404 android JNI hacks
-    let is_entry = is_entry_fn(&ccx.sess, node_id) && (!*ccx.sess.building_library ||
-                      (*ccx.sess.building_library &&
-                       ccx.sess.targ_cfg.os == session::OsAndroid));
-    if is_entry {
-        create_entry_wrapper(ccx, sp, llfn);
-    }
-    llfn
+    let llfty = type_of_fn_from_ty(ccx, node_type);
+    register_fn_llvmty(ccx, sp, sym, node_id, lib::llvm::CCallConv, llfty)
 }
 
-// only use this for foreign function ABIs and glue, use `register_fn` for Rust functions
 pub fn register_fn_llvmty(ccx: @mut CrateContext,
                           sp: Span,
                           sym: ~str,