---

yaml
---
r: 54228
b: refs/heads/dist-snap
c: 91cb668
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: 772293a25120367bed984243fffd59fcb4b8cd80
+refs/heads/dist-snap: 91cb6687a8869fa14aef8d978fb13e330c711cd3
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcore/cmp.rs

@@ -45,62 +45,31 @@ pub trait TotalOrd {
     fn cmp(&self, other: &Self) -> Ordering;
 }
 
-#[inline(always)]
-fn icmp<T: Ord>(a: &T, b: &T) -> Ordering {
-    if *a < *b { Less }
-    else if *a > *b { Greater }
-    else { Equal }
-}
-
-impl TotalOrd for u8 {
-    #[inline(always)]
-    fn cmp(&self, other: &u8) -> Ordering { icmp(self, other) }
-}
-
-impl TotalOrd for u16 {
-    #[inline(always)]
-    fn cmp(&self, other: &u16) -> Ordering { icmp(self, other) }
-}
-
-impl TotalOrd for u32 {
-    #[inline(always)]
-    fn cmp(&self, other: &u32) -> Ordering { icmp(self, other) }
-}
-
-impl TotalOrd for u64 {
-    #[inline(always)]
-    fn cmp(&self, other: &u64) -> Ordering { icmp(self, other) }
-}
-
-impl TotalOrd for i8 {
-    #[inline(always)]
-    fn cmp(&self, other: &i8) -> Ordering { icmp(self, other) }
-}
-
-impl TotalOrd for i16 {
-    #[inline(always)]
-    fn cmp(&self, other: &i16) -> Ordering { icmp(self, other) }
-}
-
-impl TotalOrd for i32 {
-    #[inline(always)]
-    fn cmp(&self, other: &i32) -> Ordering { icmp(self, other) }
-}
+macro_rules! totalord_impl(
+    ($t:ty) => {
+        impl TotalOrd for $t {
+            #[inline(always)]
+            fn cmp(&self, other: &$t) -> Ordering {
+                if *self < *other { Less }
+                else if *self > *other { Greater }
+                else { Equal }
+            }
+        }
+    }
+)
 
-impl TotalOrd for i64 {
-    #[inline(always)]
-    fn cmp(&self, other: &i64) -> Ordering { icmp(self, other) }
-}
+totalord_impl!(u8)
+totalord_impl!(u16)
+totalord_impl!(u32)
+totalord_impl!(u64)
 
-impl TotalOrd for int {
-    #[inline(always)]
-    fn cmp(&self, other: &int) -> Ordering { icmp(self, other) }
-}
+totalord_impl!(i8)
+totalord_impl!(i16)
+totalord_impl!(i32)
+totalord_impl!(i64)
 
-impl TotalOrd for uint {
-    #[inline(always)]
-    fn cmp(&self, other: &uint) -> Ordering { icmp(self, other) }
-}
+totalord_impl!(int)
+totalord_impl!(uint)
 
 /**
 * Trait for values that can be compared for a sort-order.

branches/dist-snap/src/librustc/metadata/tydecode.rs

@@ -24,7 +24,6 @@ use core::vec;
 use syntax::ast;
 use syntax::ast::*;
 use syntax::codemap::{respan, dummy_sp};
-use syntax::opt_vec;
 
 // Compact string representation for ty::t values. API ty_str &
 // parse_from_str. Extra parameters are for converting to/from def_ids in the
@@ -480,9 +479,7 @@ fn parse_sig(st: @mut PState, conv: conv_did) -> ty::FnSig {
     }
     st.pos += 1u; // eat the ']'
     let ret_ty = parse_ty(st, conv);
-    ty::FnSig {bound_lifetime_names: opt_vec::Empty, // FIXME(#4846)
-               inputs: inputs,
-               output: ret_ty}
+    ty::FnSig {inputs: inputs, output: ret_ty}
 }
 
 // Rust metadata parsing

branches/dist-snap/src/librustc/middle/trans/foreign.rs

@@ -40,7 +40,6 @@ use util::ppaux::ty_to_str;
 use syntax::codemap::span;
 use syntax::{ast, ast_util};
 use syntax::{attr, ast_map};
-use syntax::opt_vec;
 use syntax::parse::token::special_idents;
 
 fn abi_info(arch: session::arch) -> @cabi::ABIInfo {
@@ -616,8 +615,7 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                 sigil: ast::BorrowedSigil,
                 onceness: ast::Many,
                 region: ty::re_bound(ty::br_anon(0)),
-                sig: FnSig {bound_lifetime_names: opt_vec::Empty,
-                            inputs: ~[arg {mode: ast::expl(ast::by_copy),
+                sig: FnSig {inputs: ~[arg {mode: ast::expl(ast::by_copy),
                                            ty: star_u8}],
                             output: ty::mk_nil(bcx.tcx())}
             });

branches/dist-snap/src/librustc/middle/trans/monomorphize.rs

@@ -37,7 +37,6 @@ use syntax::ast;
 use syntax::ast_map;
 use syntax::ast_map::{path, path_mod, path_name};
 use syntax::ast_util::local_def;
-use syntax::opt_vec;
 use syntax::parse::token::special_idents;
 
 pub fn monomorphic_fn(ccx: @CrateContext,
@@ -283,8 +282,7 @@ pub fn normalize_for_monomorphization(tcx: ty::ctxt,
                 ty::BareFnTy {
                     purity: ast::impure_fn,
                     abi: ast::RustAbi,
-                    sig: FnSig {bound_lifetime_names: opt_vec::Empty,
-                                inputs: ~[],
+                    sig: FnSig {inputs: ~[],
                                 output: ty::mk_nil(tcx)}}))
         }
         ty::ty_closure(ref fty) => {
@@ -318,8 +316,7 @@ pub fn normalize_for_monomorphization(tcx: ty::ctxt,
                 sigil: sigil,
                 onceness: ast::Many,
                 region: ty::re_static,
-                sig: ty::FnSig {bound_lifetime_names: opt_vec::Empty,
-                                inputs: ~[],
+                sig: ty::FnSig {inputs: ~[],
                                 output: ty::mk_nil(tcx)}})
     }
 }

branches/dist-snap/src/librustc/middle/ty.rs

@@ -45,8 +45,6 @@ use syntax::codemap::span;
 use syntax::codemap;
 use syntax::print::pprust;
 use syntax::{ast, ast_map};
-use syntax::opt_vec::OptVec;
-use syntax::opt_vec;
 use syntax;
 
 // Data types
@@ -378,12 +376,10 @@ pub struct ClosureTy {
  * Signature of a function type, which I have arbitrarily
  * decided to use to refer to the input/output types.
  *
- * - `lifetimes` is the list of region names bound in this fn.
  * - `inputs` is the list of arguments and their modes.
  * - `output` is the return type. */
 #[deriving(Eq)]
 pub struct FnSig {
-    bound_lifetime_names: OptVec<ast::ident>,
     inputs: ~[arg],
     output: t
 }
@@ -1066,8 +1062,7 @@ pub fn mk_ctor_fn(cx: ctxt, input_tys: &[ty::t], output: ty::t) -> t {
                BareFnTy {
                    purity: ast::pure_fn,
                    abi: ast::RustAbi,
-                   sig: FnSig {bound_lifetime_names: opt_vec::Empty,
-                               inputs: input_args,
+                   sig: FnSig {inputs: input_args,
                                output: output}})
 }
 
@@ -1208,7 +1203,6 @@ pub fn fold_sig(sig: &FnSig, fldop: &fn(t) -> t) -> FnSig {
     };
 
     FnSig {
-        bound_lifetime_names: copy sig.bound_lifetime_names,
         inputs: args,
         output: fldop(sig.output)
     }

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

@@ -58,7 +58,7 @@ use middle::const_eval;
 use middle::ty::{arg, field, substs};
 use middle::ty::{ty_param_substs_and_ty};
 use middle::ty;
-use middle::typeck::rscope::{in_binding_rscope};
+use middle::typeck::rscope::{in_binding_rscope, in_binding_rscope_ext};
 use middle::typeck::rscope::{region_scope, type_rscope, RegionError};
 use middle::typeck::rscope::{RegionParamNames};
 
@@ -67,7 +67,6 @@ use core::vec;
 use syntax::{ast, ast_util};
 use syntax::codemap::span;
 use syntax::opt_vec::OptVec;
-use syntax::opt_vec;
 use syntax::print::pprust::{lifetime_to_str, path_to_str};
 use syntax::parse::token::special_idents;
 use util::common::indenter;
@@ -348,7 +347,7 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + Durable>(
       }
       ast::ty_bare_fn(ref bf) => {
           ty::mk_bare_fn(tcx, ty_of_bare_fn(self, rscope, bf.purity,
-                                            bf.abi, &bf.lifetimes, &bf.decl))
+                                            bf.abi, &bf.decl))
       }
       ast::ty_closure(ref f) => {
           let fn_decl = ty_of_closure(self,
@@ -509,50 +508,18 @@ pub fn ty_of_arg<AC:AstConv,RS:region_scope + Copy + Durable>(
     arg {mode: mode, ty: ty}
 }
 
-pub fn bound_lifetimes<AC:AstConv>(
-    self: &AC,
-    ast_lifetimes: &OptVec<ast::Lifetime>) -> OptVec<ast::ident>
-{
-    /*!
-     *
-     * Converts a list of lifetimes into a list of bound identifier
-     * names.  Does not permit special names like 'static or 'self to
-     * be bound.  Note that this function is for use in closures,
-     * methods, and fn definitions.  It is legal to bind 'self in a
-     * type.  Eventually this distinction should go away and the same
-     * rules should apply everywhere ('self would not be a special name
-     * at that point).
-     */
-
-    let special_idents = [special_idents::static, special_idents::self_];
-    let mut bound_lifetime_names = opt_vec::Empty;
-    ast_lifetimes.map_to_vec(|ast_lifetime| {
-        if special_idents.any(|&i| i == ast_lifetime.ident) {
-            self.tcx().sess.span_err(
-                ast_lifetime.span,
-                fmt!("illegal lifetime parameter name: `%s`",
-                     lifetime_to_str(ast_lifetime, self.tcx().sess.intr())));
-        } else {
-            bound_lifetime_names.push(ast_lifetime.ident);
-        }
-    });
-    bound_lifetime_names
-}
-
 pub fn ty_of_bare_fn<AC:AstConv,RS:region_scope + Copy + Durable>(
-    self: &AC,
-    rscope: &RS,
-    purity: ast::purity,
-    abi: ast::Abi,
-    lifetimes: &OptVec<ast::Lifetime>,
-    decl: &ast::fn_decl) -> ty::BareFnTy
-{
+        self: &AC,
+        rscope: &RS,
+        purity: ast::purity,
+        abi: ast::Abi,
+        decl: &ast::fn_decl)
+     -> ty::BareFnTy {
     debug!("ty_of_bare_fn");
 
     // new region names that appear inside of the fn decl are bound to
     // that function type
-    let bound_lifetime_names = bound_lifetimes(self, lifetimes);
-    let rb = in_binding_rscope(rscope, RegionParamNames(copy bound_lifetime_names));
+    let rb = in_binding_rscope(rscope);
 
     let input_tys = decl.inputs.map(|a| ty_of_arg(self, &rb, *a, None));
     let output_ty = match decl.output.node {
@@ -563,9 +530,34 @@ pub fn ty_of_bare_fn<AC:AstConv,RS:region_scope + Copy + Durable>(
     ty::BareFnTy {
         purity: purity,
         abi: abi,
-        sig: ty::FnSig {bound_lifetime_names: bound_lifetime_names,
-                        inputs: input_tys,
-                        output: output_ty}
+        sig: ty::FnSig {inputs: input_tys, output: output_ty}
+    }
+}
+
+pub fn ty_of_bare_fn_ext<AC:AstConv,RS:region_scope + Copy + Durable>(
+        self: &AC,
+        rscope: &RS,
+        purity: ast::purity,
+        abi: ast::Abi,
+        decl: &ast::fn_decl,
+        +region_param_names: RegionParamNames)
+     -> ty::BareFnTy {
+    debug!("ty_of_bare_fn_ext");
+
+    // new region names that appear inside of the fn decl are bound to
+    // that function type
+    let rb = in_binding_rscope_ext(rscope, region_param_names);
+
+    let input_tys = decl.inputs.map(|a| ty_of_arg(self, &rb, *a, None));
+    let output_ty = match decl.output.node {
+        ast::ty_infer => self.ty_infer(decl.output.span),
+        _ => ast_ty_to_ty(self, &rb, decl.output)
+    };
+
+    ty::BareFnTy {
+        purity: purity,
+        abi: abi,
+        sig: ty::FnSig {inputs: input_tys, output: output_ty}
     }
 }
 
@@ -577,16 +569,10 @@ pub fn ty_of_closure<AC:AstConv,RS:region_scope + Copy + Durable>(
         onceness: ast::Onceness,
         opt_lifetime: Option<@ast::Lifetime>,
         decl: &ast::fn_decl,
-        expected_sig: Option<ty::FnSig>,
+        expected_tys: Option<ty::FnSig>,
         lifetimes: &OptVec<ast::Lifetime>,
         span: span)
-     -> ty::ClosureTy
-{
-    // The caller should not both provide explicit bound lifetime
-    // names and expected types.  Either we infer the bound lifetime
-    // names or they are provided, but not both.
-    fail_unless!(lifetimes.is_empty() || expected_sig.is_none());
-
+     -> ty::ClosureTy {
     debug!("ty_of_fn_decl");
     let _i = indenter();
 
@@ -613,19 +599,19 @@ pub fn ty_of_closure<AC:AstConv,RS:region_scope + Copy + Durable>(
 
     // new region names that appear inside of the fn decl are bound to
     // that function type
-    let bound_lifetime_names = bound_lifetimes(self, lifetimes);
-    let rb = in_binding_rscope(rscope, RegionParamNames(copy bound_lifetime_names));
+    let region_param_names = RegionParamNames::from_lifetimes(lifetimes);
+    let rb = in_binding_rscope_ext(rscope, region_param_names);
 
     let input_tys = do decl.inputs.mapi |i, a| {
-        let expected_arg_ty = do expected_sig.chain_ref |e| {
+        let expected_arg_ty = do expected_tys.chain_ref |e| {
             // no guarantee that the correct number of expected args
             // were supplied
             if i < e.inputs.len() {Some(e.inputs[i])} else {None}
         };
         ty_of_arg(self, &rb, *a, expected_arg_ty)
     };
 
-    let expected_ret_ty = expected_sig.map(|e| e.output);
+    let expected_ret_ty = expected_tys.map(|e| e.output);
     let output_ty = match decl.output.node {
         ast::ty_infer if expected_ret_ty.is_some() => expected_ret_ty.get(),
         ast::ty_infer => self.ty_infer(decl.output.span),
@@ -637,8 +623,7 @@ pub fn ty_of_closure<AC:AstConv,RS:region_scope + Copy + Durable>(
         sigil: sigil,
         onceness: onceness,
         region: bound_region,
-        sig: ty::FnSig {bound_lifetime_names: bound_lifetime_names,
-                        inputs: input_tys,
+        sig: ty::FnSig {inputs: input_tys,
                         output: output_ty}
     }
 }