---

yaml
---
r: 128627
b: refs/heads/try
c: c186b4b
h: refs/heads/master
i:
  128625: 3937005
  128623: efb754a
v: v3

Author: adrienbrault

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: 4879ca79240387d18723a324d92c603c5057d342
+refs/heads/try: c186b4be6b773243b6f066df450be77508fe31a6
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/tutorial.md

@@ -76,7 +76,7 @@ OS X, the install page provides links to native installers.
 > the precise details of which are not discussed here.
 
 For Linux and OS X, the install page provides links to binary tarballs.
-To install the Rust compiler from the from a binary tarball, download
+To install the Rust compiler from a binary tarball, download
 the binary package, extract it, and execute the `install.sh` script in
 the root directory of the package.
 

branches/try/src/librustc/lint/context.rs

@@ -576,7 +576,7 @@ impl<'a> Visitor<()> for Context<'a> {
         run_lints!(self, check_lifetime_ref, lt);
     }
 
-    fn visit_lifetime_decl(&mut self, lt: &ast::LifetimeDef, _: ()) {
+    fn visit_lifetime_decl(&mut self, lt: &ast::Lifetime, _: ()) {
         run_lints!(self, check_lifetime_decl, lt);
     }
 

branches/try/src/librustc/lint/mod.rs

@@ -150,7 +150,7 @@ pub trait LintPass {
     fn check_variant(&mut self, _: &Context, _: &ast::Variant, _: &ast::Generics) { }
     fn check_opt_lifetime_ref(&mut self, _: &Context, _: Span, _: &Option<ast::Lifetime>) { }
     fn check_lifetime_ref(&mut self, _: &Context, _: &ast::Lifetime) { }
-    fn check_lifetime_decl(&mut self, _: &Context, _: &ast::LifetimeDef) { }
+    fn check_lifetime_decl(&mut self, _: &Context, _: &ast::Lifetime) { }
     fn check_explicit_self(&mut self, _: &Context, _: &ast::ExplicitSelf) { }
     fn check_mac(&mut self, _: &Context, _: &ast::Mac) { }
     fn check_path(&mut self, _: &Context, _: &ast::Path, _: ast::NodeId) { }

branches/try/src/librustc/metadata/encoder.rs

@@ -1755,8 +1755,7 @@ fn encode_reachable_extern_fns(ecx: &EncodeContext, rbml_w: &mut Encoder) {
         match ecx.tcx.map.find(*id) {
             Some(ast_map::NodeItem(i)) => {
                 match i.node {
-                    ast::ItemFn(_, _, abi, ref generics, _)
-                                if abi != abi::Rust && !generics.is_type_parameterized() => {
+                    ast::ItemFn(_, _, abi, _, _) if abi != abi::Rust => {
                         rbml_w.wr_tagged_u32(tag_reachable_extern_fn_id, *id);
                     }
                     _ => {}

branches/try/src/librustc/middle/resolve_lifetime.rs

@@ -59,10 +59,10 @@ struct LifetimeContext<'a> {
 enum ScopeChain<'a> {
     /// EarlyScope(i, ['a, 'b, ...], s) extends s with early-bound
     /// lifetimes, assigning indexes 'a => i, 'b => i+1, ... etc.
-    EarlyScope(subst::ParamSpace, &'a Vec<ast::LifetimeDef>, Scope<'a>),
+    EarlyScope(subst::ParamSpace, &'a Vec<ast::Lifetime>, Scope<'a>),
     /// LateScope(binder_id, ['a, 'b, ...], s) extends s with late-bound
     /// lifetimes introduced by the declaration binder_id.
-    LateScope(ast::NodeId, &'a Vec<ast::LifetimeDef>, Scope<'a>),
+    LateScope(ast::NodeId, &'a Vec<ast::Lifetime>, Scope<'a>),
     /// lifetimes introduced by items within a code block are scoped
     /// to that block.
     BlockScope(ast::NodeId, Scope<'a>),
@@ -136,7 +136,7 @@ impl<'a, 'b> Visitor<Scope<'a>> for LifetimeContext<'b> {
         fn push_fn_scope(this: &mut LifetimeContext,
                          ty: &ast::Ty,
                          scope: Scope,
-                         lifetimes: &Vec<ast::LifetimeDef>) {
+                         lifetimes: &Vec<ast::Lifetime>) {
             let scope1 = LateScope(ty.id, lifetimes, scope);
             this.check_lifetime_names(lifetimes);
             debug!("pushing fn scope id={} due to type", ty.id);
@@ -216,7 +216,7 @@ impl<'a> LifetimeContext<'a> {
             walk(self, &scope1)
         } else {
             let (early, late) = generics.lifetimes.clone().partition(
-                |l| referenced_idents.iter().any(|&i| i == l.lifetime.name));
+                |l| referenced_idents.iter().any(|&i| i == l.name));
 
             let scope1 = EarlyScope(subst::FnSpace, &early, scope);
             let scope2 = LateScope(n, &late, &scope1);
@@ -334,39 +334,29 @@ impl<'a> LifetimeContext<'a> {
                     token::get_name(lifetime_ref.name)).as_slice());
     }
 
-    fn check_lifetime_names(&self, lifetimes: &Vec<ast::LifetimeDef>) {
+    fn check_lifetime_names(&self, lifetimes: &Vec<ast::Lifetime>) {
         for i in range(0, lifetimes.len()) {
             let lifetime_i = lifetimes.get(i);
 
             let special_idents = [special_idents::static_lifetime];
             for lifetime in lifetimes.iter() {
-                if special_idents.iter().any(|&i| i.name == lifetime.lifetime.name) {
+                if special_idents.iter().any(|&i| i.name == lifetime.name) {
                     self.sess.span_err(
-                        lifetime.lifetime.span,
+                        lifetime.span,
                         format!("illegal lifetime parameter name: `{}`",
-                                token::get_name(lifetime.lifetime.name))
-                            .as_slice());
+                                token::get_name(lifetime.name)).as_slice());
                 }
             }
 
             for j in range(i + 1, lifetimes.len()) {
                 let lifetime_j = lifetimes.get(j);
 
-                if lifetime_i.lifetime.name == lifetime_j.lifetime.name {
+                if lifetime_i.name == lifetime_j.name {
                     self.sess.span_err(
-                        lifetime_j.lifetime.span,
+                        lifetime_j.span,
                         format!("lifetime name `{}` declared twice in \
                                 the same scope",
-                                token::get_name(lifetime_j.lifetime.name))
-                            .as_slice());
-                }
-            }
-
-            for bound in lifetime_i.bounds.iter() {
-                if !self.sess.features.issue_5723_bootstrap.get() {
-                    self.sess.span_err(
-                        bound.span,
-                        "region bounds require `issue_5723_bootstrap`");
+                                token::get_name(lifetime_j.name)).as_slice());
                 }
             }
         }
@@ -389,28 +379,28 @@ impl<'a> LifetimeContext<'a> {
     }
 }
 
-fn search_lifetimes(lifetimes: &Vec<ast::LifetimeDef>,
+fn search_lifetimes(lifetimes: &Vec<ast::Lifetime>,
                     lifetime_ref: &ast::Lifetime)
                     -> Option<(uint, ast::NodeId)> {
     for (i, lifetime_decl) in lifetimes.iter().enumerate() {
-        if lifetime_decl.lifetime.name == lifetime_ref.name {
-            return Some((i, lifetime_decl.lifetime.id));
+        if lifetime_decl.name == lifetime_ref.name {
+            return Some((i, lifetime_decl.id));
         }
     }
     return None;
 }
 
 ///////////////////////////////////////////////////////////////////////////
 
-pub fn early_bound_lifetimes<'a>(generics: &'a ast::Generics) -> Vec<ast::LifetimeDef> {
+pub fn early_bound_lifetimes<'a>(generics: &'a ast::Generics) -> Vec<ast::Lifetime> {
     let referenced_idents = free_lifetimes(&generics.ty_params);
     if referenced_idents.is_empty() {
         return Vec::new();
     }
 
     generics.lifetimes.iter()
-        .filter(|l| referenced_idents.iter().any(|&i| i == l.lifetime.name))
-        .map(|l| (*l).clone())
+        .filter(|l| referenced_idents.iter().any(|&i| i == l.name))
+        .map(|l| *l)
         .collect()
 }
 

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

@@ -171,7 +171,7 @@ impl<'a> Drop for StatRecorder<'a> {
 }
 
 // only use this for foreign function ABIs and glue, use `decl_rust_fn` for Rust functions
-pub fn decl_fn(ccx: &CrateContext, name: &str, cc: llvm::CallConv,
+fn decl_fn(ccx: &CrateContext, name: &str, cc: llvm::CallConv,
            ty: Type, output: ty::t) -> ValueRef {
 
     let llfn: ValueRef = name.with_c_str(|buf| {
@@ -1922,27 +1922,20 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) {
     let _icx = push_ctxt("trans_item");
     match item.node {
       ast::ItemFn(ref decl, _fn_style, abi, ref generics, ref body) => {
-        if !generics.is_type_parameterized() {
+        if abi != Rust {
+            let llfndecl = get_item_val(ccx, item.id);
+            foreign::trans_rust_fn_with_foreign_abi(
+                ccx, &**decl, &**body, item.attrs.as_slice(), llfndecl, item.id);
+        } else if !generics.is_type_parameterized() {
             let llfn = get_item_val(ccx, item.id);
-            if abi != Rust {
-                foreign::trans_rust_fn_with_foreign_abi(ccx,
-                                                        &**decl,
-                                                        &**body,
-                                                        item.attrs.as_slice(),
-                                                        llfn,
-                                                        &param_substs::empty(),
-                                                        item.id,
-                                                        None);
-            } else {
-                trans_fn(ccx,
-                         &**decl,
-                         &**body,
-                         llfn,
-                         &param_substs::empty(),
-                         item.id,
-                         item.attrs.as_slice(),
-                         TranslateItems);
-            }
+            trans_fn(ccx,
+                     &**decl,
+                     &**body,
+                     llfn,
+                     &param_substs::empty(),
+                     item.id,
+                     item.attrs.as_slice(),
+                     TranslateItems);
         } else {
             // Be sure to travel more than just one layer deep to catch nested
             // items in blocks and such.

branches/try/src/librustc/middle/trans/foreign.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -24,7 +24,6 @@ use middle::trans::type_of::*;
 use middle::trans::type_of;
 use middle::ty::FnSig;
 use middle::ty;
-use middle::subst::Subst;
 use std::cmp;
 use libc::c_uint;
 use syntax::abi::{Cdecl, Aapcs, C, Win64, Abi};
@@ -526,26 +525,6 @@ pub fn trans_foreign_mod(ccx: &CrateContext, foreign_mod: &ast::ForeignMod) {
 // inline the one into the other. Of course we could just generate the
 // correct code in the first place, but this is much simpler.
 
-pub fn decl_rust_fn_with_foreign_abi(ccx: &CrateContext,
-                                     t: ty::t,
-                                     name: &str)
-                                     -> ValueRef {
-    let tys = foreign_types_for_fn_ty(ccx, t);
-    let llfn_ty = lltype_for_fn_from_foreign_types(ccx, &tys);
-    let cconv = match ty::get(t).sty {
-        ty::ty_bare_fn(ref fn_ty) => {
-            let c = llvm_calling_convention(ccx, fn_ty.abi);
-            c.unwrap_or(llvm::CCallConv)
-        }
-        _ => fail!("expected bare fn in decl_rust_fn_with_foreign_abi")
-    };
-    let llfn = base::decl_fn(ccx, name, cconv, llfn_ty, ty::mk_nil());
-    add_argument_attributes(&tys, llfn);
-    debug!("decl_rust_fn_with_foreign_abi(llfn_ty={}, llfn={})",
-           ccx.tn.type_to_string(llfn_ty), ccx.tn.val_to_string(llfn));
-    llfn
-}
-
 pub fn register_rust_fn_with_foreign_abi(ccx: &CrateContext,
                                          sp: Span,
                                          sym: String,
@@ -575,39 +554,31 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
                                       body: &ast::Block,
                                       attrs: &[ast::Attribute],
                                       llwrapfn: ValueRef,
-                                      param_substs: &param_substs,
-                                      id: ast::NodeId,
-                                      hash: Option<&str>) {
+                                      id: ast::NodeId) {
     let _icx = push_ctxt("foreign::build_foreign_fn");
-
-    let fnty = ty::node_id_to_type(ccx.tcx(), id);
-    let mty = fnty.subst(ccx.tcx(), &param_substs.substs);
-    let tys = foreign_types_for_fn_ty(ccx, mty);
+    let tys = foreign_types_for_id(ccx, id);
 
     unsafe { // unsafe because we call LLVM operations
         // Build up the Rust function (`foo0` above).
-        let llrustfn = build_rust_fn(ccx, decl, body, param_substs, attrs, id, hash);
+        let llrustfn = build_rust_fn(ccx, decl, body, attrs, id);
 
         // Build up the foreign wrapper (`foo` above).
-        return build_wrap_fn(ccx, llrustfn, llwrapfn, &tys, mty);
+        return build_wrap_fn(ccx, llrustfn, llwrapfn, &tys, id);
     }
 
     fn build_rust_fn(ccx: &CrateContext,
                      decl: &ast::FnDecl,
                      body: &ast::Block,
-                     param_substs: &param_substs,
                      attrs: &[ast::Attribute],
-                     id: ast::NodeId,
-                     hash: Option<&str>)
+                     id: ast::NodeId)
                      -> ValueRef {
         let _icx = push_ctxt("foreign::foreign::build_rust_fn");
         let tcx = ccx.tcx();
-        let t = ty::node_id_to_type(tcx, id).subst(
-            ccx.tcx(), &param_substs.substs);
+        let t = ty::node_id_to_type(tcx, id);
 
         let ps = ccx.tcx.map.with_path(id, |path| {
             let abi = Some(ast_map::PathName(special_idents::clownshoe_abi.name));
-            link::mangle(path.chain(abi.move_iter()), hash)
+            link::mangle(path.chain(abi.move_iter()), None)
         });
 
         // Compute the type that the function would have if it were just a
@@ -630,19 +601,22 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
 
         let llfn = base::decl_internal_rust_fn(ccx, t, ps.as_slice());
         base::set_llvm_fn_attrs(attrs, llfn);
-        base::trans_fn(ccx, decl, body, llfn, param_substs, id, [], TranslateItems);
+        base::trans_fn(ccx, decl, body, llfn, &param_substs::empty(), id, [],
+                       TranslateItems);
         llfn
     }
 
     unsafe fn build_wrap_fn(ccx: &CrateContext,
                             llrustfn: ValueRef,
                             llwrapfn: ValueRef,
                             tys: &ForeignTypes,
-                            t: ty::t) {
+                            id: ast::NodeId) {
         let _icx = push_ctxt(
             "foreign::trans_rust_fn_with_foreign_abi::build_wrap_fn");
         let tcx = ccx.tcx();
 
+        let t = ty::node_id_to_type(tcx, id);
+
         debug!("build_wrap_fn(llrustfn={}, llwrapfn={}, t={})",
                ccx.tn.val_to_string(llrustfn),
                ccx.tn.val_to_string(llwrapfn),