trans: use types from argument patterns instead of the function signature.

This fixes ICEs caused by late-bound lifetimes ending up in argument
datum types and being used in cleanup - user Drop impl's would then
fail to monomorphize if the type was used to look up the impl of a
method call - which happens in trans now, I presume for multidispatch.

src/librustc/middle/trans/base.rs

@@ -50,7 +50,7 @@ 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, monomorphize_type};
+use middle::trans::common::{NodeInfo, Result, SubstP};
 use middle::trans::common::{node_id_type, param_substs, return_type_is_void};
 use middle::trans::common::{tydesc_info, type_is_immediate};
 use middle::trans::common::{type_is_zero_size, val_ty};
@@ -1794,7 +1794,6 @@ pub fn trans_closure(ccx: &CrateContext,
                      param_substs: &param_substs,
                      fn_ast_id: ast::NodeId,
                      _attributes: &[ast::Attribute],
-                     arg_types: Vec<ty::t>,
                      output_type: ty::FnOutput,
                      abi: Abi,
                      has_env: bool,
@@ -1829,9 +1828,19 @@ pub fn trans_closure(ccx: &CrateContext,
 
     // Set up arguments to the function.
     let monomorphized_arg_types =
-        arg_types.iter()
-                 .map(|at| monomorphize_type(bcx, *at))
-                 .collect::<Vec<_>>();
+        decl.inputs.iter()
+                   .map(|arg| node_id_type(bcx, arg.id))
+                   .collect::<Vec<_>>();
+    let monomorphized_arg_types = match is_unboxed_closure {
+        NotUnboxedClosure => monomorphized_arg_types,
+
+        // Tuple up closure argument types for the "rust-call" ABI.
+        IsUnboxedClosure => vec![if monomorphized_arg_types.is_empty() {
+            ty::mk_nil()
+        } else {
+            ty::mk_tup(ccx.tcx(), monomorphized_arg_types)
+        }]
+    };
     for monomorphized_arg_type in monomorphized_arg_types.iter() {
         debug!("trans_closure: monomorphized_arg_type: {}",
                ty_to_string(ccx.tcx(), *monomorphized_arg_type));
@@ -1933,7 +1942,6 @@ pub fn trans_fn(ccx: &CrateContext,
     debug!("trans_fn(param_substs={})", param_substs.repr(ccx.tcx()));
     let _icx = push_ctxt("trans_fn");
     let fn_ty = ty::node_id_to_type(ccx.tcx(), id);
-    let arg_types = ty::ty_fn_args(fn_ty);
     let output_type = ty::ty_fn_ret(fn_ty);
     let abi = ty::ty_fn_abi(fn_ty);
     trans_closure(ccx,
@@ -1943,7 +1951,6 @@ pub fn trans_fn(ccx: &CrateContext,
                   param_substs,
                   id,
                   attrs,
-                  arg_types,
                   output_type,
                   abi,
                   false,

src/librustc/middle/trans/closure.rs

@@ -408,7 +408,6 @@ pub fn trans_expr_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                   bcx.fcx.param_substs,
                   id,
                   [],
-                  ty::ty_fn_args(fty),
                   ty::ty_fn_ret(fty),
                   ty::ty_fn_abi(fty),
                   true,
@@ -501,7 +500,6 @@ pub fn trans_unboxed_closure<'blk, 'tcx>(
                   bcx.fcx.param_substs,
                   id,
                   [],
-                  ty::ty_fn_args(function_type),
                   ty::ty_fn_ret(function_type),
                   ty::ty_fn_abi(function_type),
                   true,

src/librustc/middle/typeck/check/writeback.rs

@@ -53,6 +53,7 @@ pub fn resolve_type_vars_in_fn(fcx: &FnCtxt,
     let mut wbcx = WritebackCx::new(fcx);
     wbcx.visit_block(blk);
     for arg in decl.inputs.iter() {
+        wbcx.visit_node_id(ResolvingPattern(arg.pat.span), arg.id);
         wbcx.visit_pat(&*arg.pat);
 
         // Privacy needs the type for the whole pattern, not just each binding

src/test/run-pass/regions-no-bound-in-argument-cleanup.rs

@@ -0,0 +1,30 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(unsafe_destructor)]
+
+pub struct Foo<T>;
+
+impl<T> Iterator<T> for Foo<T> {
+    fn next(&mut self) -> Option<T> {
+        None
+    }
+}
+
+#[unsafe_destructor]
+impl<T> Drop for Foo<T> {
+    fn drop(&mut self) {
+        self.next();
+    }
+}
+
+pub fn foo<'a>(_: Foo<&'a ()>) {}
+
+pub fn main() {}