---

yaml
---
r: 158638
b: refs/heads/try
c: 7d2da3a
h: refs/heads/master
v: v3

Author: eddyb

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: a0a7ab461283322215f0343cd2b5e66fc19a7bd5
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 1b2ad7831f1745bf4a4709a1fa1772afb47c933c
-refs/heads/try: fba86567a95ca5e8711f3cfd92e347a37281a92c
+refs/heads/try: 7d2da3a8dbe8284678607e0b07f4d94ab22a37c8
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

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

@@ -39,7 +39,7 @@ use middle::astencode;
 use middle::lang_items::{LangItem, ExchangeMallocFnLangItem, StartFnLangItem};
 use middle::subst;
 use middle::weak_lang_items;
-use middle::subst::Subst;
+use middle::subst::{Subst, Substs};
 use middle::trans::_match;
 use middle::trans::adt;
 use middle::trans::build::*;
@@ -51,8 +51,8 @@ use middle::trans::cleanup;
 use middle::trans::common::{Block, C_bool, C_bytes_in_context, C_i32, C_integral, C_nil};
 use middle::trans::common::{C_null, C_struct_in_context, C_u64, C_u8, C_uint, C_undef};
 use middle::trans::common::{CrateContext, ExternMap, FunctionContext};
-use middle::trans::common::{NodeInfo, Result, SubstP};
-use middle::trans::common::{node_id_type, param_substs, return_type_is_void};
+use middle::trans::common::{NodeInfo, Result};
+use middle::trans::common::{node_id_type, return_type_is_void};
 use middle::trans::common::{tydesc_info, type_is_immediate};
 use middle::trans::common::{type_is_zero_size, val_ty};
 use middle::trans::common;
@@ -1431,11 +1431,11 @@ pub fn new_fn_ctxt<'a, 'tcx>(ccx: &'a CrateContext<'a, 'tcx>,
                              id: ast::NodeId,
                              has_env: bool,
                              output_type: ty::FnOutput<'tcx>,
-                             param_substs: &'a param_substs<'tcx>,
+                             param_substs: &'a Substs<'tcx>,
                              sp: Option<Span>,
                              block_arena: &'a TypedArena<common::BlockS<'a, 'tcx>>)
                              -> FunctionContext<'a, 'tcx> {
-    param_substs.validate();
+    common::validate_substs(param_substs);
 
     debug!("new_fn_ctxt(path={}, id={}, param_substs={})",
            if id == -1 {
@@ -1447,7 +1447,7 @@ pub fn new_fn_ctxt<'a, 'tcx>(ccx: &'a CrateContext<'a, 'tcx>,
 
     let uses_outptr = match output_type {
         ty::FnConverging(output_type) => {
-            let substd_output_type = output_type.substp(ccx.tcx(), param_substs);
+            let substd_output_type = output_type.subst(ccx.tcx(), param_substs);
             type_of::return_uses_outptr(ccx, substd_output_type)
         }
         ty::FnDiverging => false
@@ -1500,7 +1500,7 @@ pub fn init_function<'a, 'tcx>(fcx: &'a FunctionContext<'a, 'tcx>,
     if let ty::FnConverging(output_type) = output {
         // This shouldn't need to recompute the return type,
         // as new_fn_ctxt did it already.
-        let substd_output_type = output_type.substp(fcx.ccx.tcx(), fcx.param_substs);
+        let substd_output_type = output_type.subst(fcx.ccx.tcx(), fcx.param_substs);
         if !return_type_is_void(fcx.ccx, substd_output_type) {
             // If the function returns nil/bot, there is no real return
             // value, so do not set `llretslotptr`.
@@ -1729,7 +1729,7 @@ pub fn finish_fn<'blk, 'tcx>(fcx: &'blk FunctionContext<'blk, 'tcx>,
 
     // This shouldn't need to recompute the return type,
     // as new_fn_ctxt did it already.
-    let substd_retty = retty.substp(fcx.ccx.tcx(), fcx.param_substs);
+    let substd_retty = retty.subst(fcx.ccx.tcx(), fcx.param_substs);
     build_return_block(fcx, ret_cx, substd_retty);
 
     debuginfo::clear_source_location(fcx);
@@ -1805,7 +1805,7 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                    decl: &ast::FnDecl,
                                    body: &ast::Block,
                                    llfndecl: ValueRef,
-                                   param_substs: &param_substs<'tcx>,
+                                   param_substs: &Substs<'tcx>,
                                    fn_ast_id: ast::NodeId,
                                    _attributes: &[ast::Attribute],
                                    output_type: ty::FnOutput<'tcx>,
@@ -1950,7 +1950,7 @@ pub fn trans_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                           decl: &ast::FnDecl,
                           body: &ast::Block,
                           llfndecl: ValueRef,
-                          param_substs: &param_substs<'tcx>,
+                          param_substs: &Substs<'tcx>,
                           id: ast::NodeId,
                           attrs: &[ast::Attribute]) {
     let _s = StatRecorder::new(ccx, ccx.tcx().map.path_to_string(id).to_string());
@@ -1976,7 +1976,7 @@ pub fn trans_enum_variant<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                     variant: &ast::Variant,
                                     _args: &[ast::VariantArg],
                                     disr: ty::Disr,
-                                    param_substs: &param_substs<'tcx>,
+                                    param_substs: &Substs<'tcx>,
                                     llfndecl: ValueRef) {
     let _icx = push_ctxt("trans_enum_variant");
 
@@ -2051,7 +2051,7 @@ pub fn trans_named_tuple_constructor<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
 pub fn trans_tuple_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                     _fields: &[ast::StructField],
                                     ctor_id: ast::NodeId,
-                                    param_substs: &param_substs<'tcx>,
+                                    param_substs: &Substs<'tcx>,
                                     llfndecl: ValueRef) {
     let _icx = push_ctxt("trans_tuple_struct");
 
@@ -2066,10 +2066,10 @@ pub fn trans_tuple_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
 fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                                      ctor_id: ast::NodeId,
                                                      disr: ty::Disr,
-                                                     param_substs: &param_substs<'tcx>,
+                                                     param_substs: &Substs<'tcx>,
                                                      llfndecl: ValueRef) {
     let ctor_ty = ty::node_id_to_type(ccx.tcx(), ctor_id);
-    let ctor_ty = ctor_ty.substp(ccx.tcx(), param_substs);
+    let ctor_ty = ctor_ty.subst(ccx.tcx(), param_substs);
 
     let result_ty = match ty::get(ctor_ty).sty {
         ty::ty_bare_fn(ref bft) => bft.sig.output,
@@ -2242,15 +2242,15 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) {
                                                             &**body,
                                                             item.attrs.as_slice(),
                                                             llfn,
-                                                            &param_substs::empty(),
+                                                            &Substs::trans_empty(),
                                                             item.id,
                                                             None);
                 } else {
                     trans_fn(ccx,
                              &**decl,
                              &**body,
                              llfn,
-                             &param_substs::empty(),
+                             &Substs::trans_empty(),
                              item.id,
                              item.attrs.as_slice());
                 }

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

@@ -25,7 +25,7 @@ use llvm;
 use metadata::csearch;
 use middle::def;
 use middle::subst;
-use middle::subst::{Subst};
+use middle::subst::{Subst, Substs};
 use middle::trans::adt;
 use middle::trans::base;
 use middle::trans::base::*;
@@ -316,7 +316,7 @@ pub fn trans_unboxing_shim<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                                      function_name.as_slice());
 
     let block_arena = TypedArena::new();
-    let empty_param_substs = param_substs::empty();
+    let empty_param_substs = Substs::trans_empty();
     let return_type = ty::ty_fn_ret(boxed_function_type);
     let fcx = new_fn_ctxt(ccx,
                           llfn,

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

@@ -15,6 +15,7 @@ use driver::config::FullDebugInfo;
 use llvm::ValueRef;
 use middle::def;
 use middle::mem_categorization::Typer;
+use middle::subst::Substs;
 use middle::trans::adt;
 use middle::trans::base::*;
 use middle::trans::build::*;
@@ -627,7 +628,7 @@ pub fn get_wrapper_for_bare_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
     let _icx = push_ctxt("closure::get_wrapper_for_bare_fn");
 
     let arena = TypedArena::new();
-    let empty_param_substs = param_substs::empty();
+    let empty_param_substs = Substs::trans_empty();
     let fcx = new_fn_ctxt(ccx, llfn, ast::DUMMY_NODE_ID, true, f.sig.output,
                           &empty_param_substs, None, &arena);
     let bcx = init_function(&fcx, true, f.sig.output);

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

@@ -20,7 +20,7 @@ use middle::def;
 use middle::lang_items::LangItem;
 use middle::mem_categorization as mc;
 use middle::subst;
-use middle::subst::Subst;
+use middle::subst::{Subst, Substs};
 use middle::trans::base;
 use middle::trans::build;
 use middle::trans::cleanup;
@@ -188,39 +188,8 @@ pub fn BuilderRef_res(b: BuilderRef) -> BuilderRef_res {
 
 pub type ExternMap = HashMap<String, ValueRef>;
 
-// Here `self_ty` is the real type of the self parameter to this method. It
-// will only be set in the case of default methods.
-pub struct param_substs<'tcx> {
-    pub substs: subst::Substs<'tcx>,
-}
-
-impl<'tcx> param_substs<'tcx> {
-    pub fn empty() -> param_substs<'tcx> {
-        param_substs {
-            substs: subst::Substs::trans_empty(),
-        }
-    }
-
-    pub fn validate(&self) {
-        assert!(self.substs.types.all(|t| !ty::type_needs_infer(*t)));
-    }
-}
-
-impl<'tcx> Repr<'tcx> for param_substs<'tcx> {
-    fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String {
-        self.substs.repr(tcx)
-    }
-}
-
-pub trait SubstP<'tcx> {
-    fn substp(&self, tcx: &ty::ctxt<'tcx>, param_substs: &param_substs<'tcx>)
-              -> Self;
-}
-
-impl<'tcx, T: Subst<'tcx> + Clone> SubstP<'tcx> for T {
-    fn substp(&self, tcx: &ty::ctxt<'tcx>, substs: &param_substs<'tcx>) -> T {
-        self.subst(tcx, &substs.substs)
-    }
+pub fn validate_substs(substs: &Substs) {
+    assert!(substs.types.all(|t| !ty::type_needs_infer(*t)));
 }
 
 // work around bizarre resolve errors
@@ -280,7 +249,7 @@ pub struct FunctionContext<'a, 'tcx: 'a> {
 
     // If this function is being monomorphized, this contains the type
     // substitutions used.
-    pub param_substs: &'a param_substs<'tcx>,
+    pub param_substs: &'a Substs<'tcx>,
 
     // The source span and nesting context where this function comes from, for
     // error reporting and symbol generation.
@@ -780,7 +749,7 @@ pub fn is_null(val: ValueRef) -> bool {
 }
 
 pub fn monomorphize_type<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, t: Ty<'tcx>) -> Ty<'tcx> {
-    t.subst(bcx.tcx(), &bcx.fcx.param_substs.substs)
+    t.subst(bcx.tcx(), bcx.fcx.param_substs)
 }
 
 pub fn node_id_type<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, id: ast::NodeId) -> Ty<'tcx> {
@@ -936,7 +905,7 @@ pub fn node_id_substs<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     }
 
     let substs = substs.erase_regions();
-    substs.substp(tcx, bcx.fcx.param_substs)
+    substs.subst(tcx, bcx.fcx.param_substs)
 }
 
 pub fn langcall(bcx: Block,

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

@@ -190,7 +190,7 @@ use llvm;
 use llvm::{ModuleRef, ContextRef, ValueRef};
 use llvm::debuginfo::*;
 use metadata::csearch;
-use middle::subst::{mod, Subst};
+use middle::subst::{mod, Subst, Substs};
 use middle::trans::adt;
 use middle::trans::common::*;
 use middle::trans::machine;
@@ -1163,7 +1163,7 @@ pub fn start_emitting_source_locations(fcx: &FunctionContext) {
 /// for the function.
 pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                                fn_ast_id: ast::NodeId,
-                                               param_substs: &param_substs<'tcx>,
+                                               param_substs: &Substs<'tcx>,
                                                llfn: ValueRef) -> FunctionDebugContext {
     if cx.sess().opts.debuginfo == NoDebugInfo {
         return FunctionDebugContext { repr: DebugInfoDisabled };
@@ -1365,7 +1365,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
     fn get_function_signature<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                         fn_ast_id: ast::NodeId,
                                         fn_decl: &ast::FnDecl,
-                                        param_substs: &param_substs<'tcx>,
+                                        param_substs: &Substs<'tcx>,
                                         error_reporting_span: Span) -> DIArray {
         if cx.sess().opts.debuginfo == LimitedDebugInfo {
             return create_DIArray(DIB(cx), []);
@@ -1382,7 +1382,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                 assert_type_for_node_id(cx, fn_ast_id, error_reporting_span);
 
                 let return_type = ty::node_id_to_type(cx.tcx(), fn_ast_id);
-                let return_type = return_type.substp(cx.tcx(), param_substs);
+                let return_type = return_type.subst(cx.tcx(), param_substs);
                 signature.push(type_metadata(cx, return_type, codemap::DUMMY_SP));
             }
         }
@@ -1391,7 +1391,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         for arg in fn_decl.inputs.iter() {
             assert_type_for_node_id(cx, arg.pat.id, arg.pat.span);
             let arg_type = ty::node_id_to_type(cx.tcx(), arg.pat.id);
-            let arg_type = arg_type.substp(cx.tcx(), param_substs);
+            let arg_type = arg_type.subst(cx.tcx(), param_substs);
             signature.push(type_metadata(cx, arg_type, codemap::DUMMY_SP));
         }
 
@@ -1400,11 +1400,11 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
     fn get_template_parameters<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                          generics: &ast::Generics,
-                                         param_substs: &param_substs<'tcx>,
+                                         param_substs: &Substs<'tcx>,
                                          file_metadata: DIFile,
                                          name_to_append_suffix_to: &mut String)
                                          -> DIArray {
-        let self_type = param_substs.substs.self_ty();
+        let self_type = param_substs.self_ty();
 
         // Only true for static default methods:
         let has_self_type = self_type.is_some();
@@ -1461,7 +1461,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         }
 
         // Handle other generic parameters
-        let actual_types = param_substs.substs.types.get_slice(subst::FnSpace);
+        let actual_types = param_substs.types.get_slice(subst::FnSpace);
         for (index, &ast::TyParam{ ident, .. }) in generics.ty_params.iter().enumerate() {
             let actual_type = actual_types[index];
             // Add actual type name to <...> clause of function name

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

@@ -329,8 +329,7 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 let trait_ref =
                     Rc::new(ty::TraitRef { def_id: def_id,
                                            substs: substs });
-                let trait_ref =
-                    trait_ref.subst(bcx.tcx(), &bcx.fcx.param_substs.substs);
+                let trait_ref = trait_ref.subst(bcx.tcx(), bcx.fcx.param_substs);
                 let box_ty = mk_ty(unsized_ty);
                 PointerCast(bcx,
                             meth::get_vtable(bcx, box_ty, trait_ref),
@@ -1117,8 +1116,7 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                                              .find(&expr.id)
                                              .map(|t| (*t).clone())
                                              .unwrap();
-                let trait_ref =
-                    trait_ref.subst(bcx.tcx(), &bcx.fcx.param_substs.substs);
+                let trait_ref = trait_ref.subst(bcx.tcx(), bcx.fcx.param_substs);
                 let datum = unpack_datum!(bcx, trans(bcx, &**val));
                 meth::trans_trait_cast(bcx, datum, expr.id,
                                        trait_ref, dest)

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

@@ -24,7 +24,7 @@ use middle::trans::type_of::*;
 use middle::trans::type_of;
 use middle::ty::FnSig;
 use middle::ty::{mod, Ty};
-use middle::subst::Subst;
+use middle::subst::{Subst, Substs};
 use std::cmp;
 use libc::c_uint;
 use syntax::abi::{Cdecl, Aapcs, C, Win64, Abi};
@@ -556,13 +556,13 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                                 body: &ast::Block,
                                                 attrs: &[ast::Attribute],
                                                 llwrapfn: ValueRef,
-                                                param_substs: &param_substs<'tcx>,
+                                                param_substs: &Substs<'tcx>,
                                                 id: ast::NodeId,
                                                 hash: Option<&str>) {
     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 mty = fnty.subst(ccx.tcx(), param_substs);
     let tys = foreign_types_for_fn_ty(ccx, mty);
 
     unsafe { // unsafe because we call LLVM operations
@@ -576,15 +576,14 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
     fn build_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                decl: &ast::FnDecl,
                                body: &ast::Block,
-                               param_substs: &param_substs<'tcx>,
+                               param_substs: &Substs<'tcx>,
                                attrs: &[ast::Attribute],
                                id: ast::NodeId,
                                hash: Option<&str>)
                                -> 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).subst(ccx.tcx(), param_substs);
 
         let ps = ccx.tcx().map.with_path(id, |path| {
             let abi = Some(ast_map::PathName(special_idents::clownshoe_abi.name));

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

@@ -19,7 +19,7 @@ use llvm::{ValueRef, True, get_param};
 use llvm;
 use middle::lang_items::ExchangeFreeFnLangItem;
 use middle::subst;
-use middle::subst::Subst;
+use middle::subst::{Subst, Substs};
 use middle::trans::adt;
 use middle::trans::base::*;
 use middle::trans::build::*;
@@ -540,7 +540,7 @@ fn make_generic_glue<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
     let _s = StatRecorder::new(ccx, glue_name);
 
     let arena = TypedArena::new();
-    let empty_param_substs = param_substs::empty();
+    let empty_param_substs = Substs::trans_empty();
     let fcx = new_fn_ctxt(ccx, llfn, ast::DUMMY_NODE_ID, false, ty::FnConverging(ty::mk_nil()),
                           &empty_param_substs, None, &arena);