Use the same type of record in ty::ty_fn and ty::method

Removes some more code duplication.

Author: marijnh

src/comp/metadata/decoder.rs

@@ -253,13 +253,10 @@ fn get_tag_variants(_data: @[u8], def: ast::def_id, tcx: ty::ctxt,
         let ctor_ty = item_type(item, external_crate_id, tcx, extres);
         let arg_tys: [ty::t] = [];
         alt ty::struct(tcx, ctor_ty) {
-          ty::ty_fn(_, args, _, _, _) {
-            for a: ty::arg in args { arg_tys += [a.ty]; }
-          }
-          _ {
-            // Nullary tag variant.
-
+          ty::ty_fn(f) {
+            for a: ty::arg in f.inputs { arg_tys += [a.ty]; }
           }
+          _ { /* Nullary tag variant. */ }
         }
         infos += [@{args: arg_tys, ctor_ty: ctor_ty, id: did}];
     }

src/comp/metadata/tydecode.rs

@@ -165,10 +165,7 @@ fn parse_constr<copy T>(st: @pstate, sd: str_def, pser: arg_parser<T>) ->
 }
 
 fn parse_ty_rust_fn(st: @pstate, sd: str_def, p: ast::proto) -> ty::t {
-    let func = parse_ty_fn(st, sd);
-    ret ty::mk_fn(st.tcx, p,
-                  func.args, func.ty, func.cf,
-                  func.cs);
+    ret ty::mk_fn(st.tcx, {proto: p with parse_ty_fn(st, sd)});
 }
 
 fn parse_ty(st: @pstate, sd: str_def) -> ty::t {
@@ -256,7 +253,7 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t {
       }
       'N' {
         let func = parse_ty_fn(st, sd);
-        ret ty::mk_native_fn(st.tcx, func.args, func.ty);
+        ret ty::mk_native_fn(st.tcx, func.inputs, func.output);
       }
       'O' {
         assert (next(st) as char == '[');
@@ -270,14 +267,8 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t {
             while peek(st) as char != '[' {
                 name += str::unsafe_from_byte(next(st));
             }
-            let func = parse_ty_fn(st, sd);
-            methods +=
-                [{proto: proto,
-                  ident: name,
-                  inputs: func.args,
-                  output: func.ty,
-                  cf: func.cf,
-                  constrs: func.cs}];
+            methods += [{ident: name,
+                         fty: {proto: proto with parse_ty_fn(st, sd)}}];
         }
         st.pos += 1u;
         ret ty::mk_obj(st.tcx, methods);
@@ -365,8 +356,7 @@ fn parse_hex(st: @pstate) -> uint {
     ret n;
 }
 
-fn parse_ty_fn(st: @pstate, sd: str_def) ->
-   {args: [ty::arg], ty: ty::t, cf: ast::ret_style, cs: [@ty::constr]} {
+fn parse_ty_fn(st: @pstate, sd: str_def) -> ty::fn_ty {
     assert (next(st) as char == '[');
     let inputs: [ty::arg] = [];
     while peek(st) as char != ']' {
@@ -383,7 +373,8 @@ fn parse_ty_fn(st: @pstate, sd: str_def) ->
     st.pos += 1u; // eat the ']'
     let cs = parse_constrs(st, sd);
     let (ret_style, ret_ty) = parse_ret_ty(st, sd);
-    ret {args: inputs, ty: ret_ty, cf: ret_style, cs: cs};
+    ret {proto: ast::proto_bare, inputs: inputs, output: ret_ty,
+         ret_style: ret_style, constraints: cs};
 }
 
 

src/comp/metadata/tyencode.rs

@@ -143,20 +143,21 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
         }
         w.write_char(']');
       }
-      ty::ty_fn(proto, args, out, cf, constrs) {
-        enc_proto(w, proto);
-        enc_ty_fn(w, cx, args, out, cf, constrs);
+      ty::ty_fn(f) {
+        enc_proto(w, f.proto);
+        enc_ty_fn(w, cx, f);
       }
       ty::ty_native_fn(args, out) {
         w.write_char('N');
-        enc_ty_fn(w, cx, args, out, return_val, []);
+        enc_ty_fn(w, cx, {proto: proto_bare, inputs: args, output: out,
+                          ret_style: return_val, constraints: []});
       }
       ty::ty_obj(methods) {
         w.write_str("O[");
         for m: ty::method in methods {
-            enc_proto(w, m.proto);
+            enc_proto(w, m.fty.proto);
             w.write_str(m.ident);
-            enc_ty_fn(w, cx, m.inputs, m.output, m.cf, m.constrs);
+            enc_ty_fn(w, cx, m.fty);
         }
         w.write_char(']');
       }
@@ -202,10 +203,9 @@ fn enc_proto(w: io::writer, proto: proto) {
     }
 }
 
-fn enc_ty_fn(w: io::writer, cx: @ctxt, args: [ty::arg], out: ty::t,
-             cf: ret_style, constrs: [@ty::constr]) {
+fn enc_ty_fn(w: io::writer, cx: @ctxt, ft: ty::fn_ty) {
     w.write_char('[');
-    for arg: ty::arg in args {
+    for arg: ty::arg in ft.inputs {
         alt arg.mode {
           by_mut_ref. { w.write_char('&'); }
           by_move. { w.write_char('-'); }
@@ -217,16 +217,16 @@ fn enc_ty_fn(w: io::writer, cx: @ctxt, args: [ty::arg], out: ty::t,
     }
     w.write_char(']');
     let colon = true;
-    for c: @ty::constr in constrs {
+    for c: @ty::constr in ft.constraints {
         if colon {
             w.write_char(':');
             colon = false;
         } else { w.write_char(';'); }
         enc_constr(w, cx, c);
     }
-    alt cf {
+    alt ft.ret_style {
       noreturn. { w.write_char('!'); }
-      _ { enc_ty(w, cx, out); }
+      _ { enc_ty(w, cx, ft.output); }
     }
 }
 

src/comp/middle/alias.rs

@@ -518,9 +518,9 @@ fn ty_can_unsafely_include(cx: ctx, needle: unsafe_ty, haystack: ty::t,
             for t in ts { if helper(tcx, needle, t, mut) { ret true; } }
             ret false;
           }
-          ty::ty_fn(ast::proto_bare., _, _, _, _) { ret false; }
+          ty::ty_fn({proto: ast::proto_bare., _}) { ret false; }
           // These may contain anything.
-          ty::ty_fn(_, _, _, _, _) | ty::ty_obj(_) { ret true; }
+          ty::ty_fn(_) | ty::ty_obj(_) { ret true; }
           // A type param may include everything, but can only be
           // treated as opaque downstream, and is thus safe unless we
           // saw mutable fields, in which case the whole thing can be
@@ -558,7 +558,7 @@ fn copy_is_expensive(tcx: ty::ctxt, ty: ty::t) -> bool {
           ty::ty_ptr(_) { 1u }
           ty::ty_box(_) { 3u }
           ty::ty_constr(t, _) | ty::ty_res(_, t, _) { score_ty(tcx, t) }
-          ty::ty_fn(_, _, _, _, _) | ty::ty_native_fn(_, _) |
+          ty::ty_fn(_) | ty::ty_native_fn(_, _) |
           ty::ty_obj(_) { 4u }
           ty::ty_str. | ty::ty_vec(_) | ty::ty_param(_, _) { 50u }
           ty::ty_uniq(mt) { 1u + score_ty(tcx, mt.ty) }

src/comp/middle/block_use.rs

@@ -13,7 +13,7 @@ fn check_crate(tcx: ty::ctxt, crate: @crate) {
 fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) {
     if !cx.allow_block {
         alt ty::struct(cx.tcx, ty::expr_ty(cx.tcx, ex)) {
-          ty::ty_fn(proto_block., _, _, _, _) {
+          ty::ty_fn({proto: proto_block., _}) {
             cx.tcx.sess.span_err(ex.span, "expressions with block type \
                 can only appear in callee or (by-ref) argument position");
           }

src/comp/middle/fn_usage.rs

@@ -32,7 +32,7 @@ fn fn_usage_expr(expr: @ast::expr,
         if !ctx.generic_bare_fn_legal
             && ty::expr_has_ty_params(ctx.tcx, expr) {
             alt ty::struct(ctx.tcx, ty::expr_ty(ctx.tcx, expr)) {
-              ty::ty_fn(ast::proto_bare., _, _, _, _) {
+              ty::ty_fn({proto: ast::proto_bare., _}) {
                 ctx.tcx.sess.span_fatal(
                     expr.span,
                     "generic bare functions can only be called or bound");

src/comp/middle/gc.rs

@@ -145,21 +145,9 @@ fn type_is_gc_relevant(cx: ty::ctxt, ty: ty::t) -> bool {
         ret type_is_gc_relevant(cx, tm.ty);
       }
       ty::ty_constr(sub, _) { ret type_is_gc_relevant(cx, sub); }
-
-
-
-
-
-      ty::ty_box(_) | ty::ty_uniq(_) | ty::ty_fn(_, _, _, _, _) |
+      ty::ty_box(_) | ty::ty_uniq(_) | ty::ty_fn(_) |
       ty::ty_native_fn(_, _) | ty::ty_obj(_) | ty::ty_param(_, _) |
-      ty::ty_res(_, _, _) {
-        ret true;
-      }
-
-
-
-
-
+      ty::ty_res(_, _, _) { ret true; }
       ty::ty_var(_) {
         fail "ty_var in type_is_gc_relevant";
       }

src/comp/middle/shape.rs

@@ -416,7 +416,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t, ty_param_map: [uint],
             }
         }
       }
-      ty::ty_fn(_, _, _, _, _) {
+      ty::ty_fn(_) {
         s += [shape_fn];
       }
       ty::ty_opaque_closure. {

src/comp/middle/trans.rs

@@ -168,7 +168,7 @@ fn type_of_inner(cx: @crate_ctxt, sp: span, t: ty::t)
         }
         T_struct(tys)
       }
-      ty::ty_fn(_, _, _, _, _) {
+      ty::ty_fn(_) {
         // FIXME: could be a constraint on ty_fn
         check returns_non_ty_var(cx, t);
         T_fn_pair(cx, type_of_fn_from_ty(cx, sp, t, 0u))
@@ -232,7 +232,7 @@ fn type_of_ty_param_kinds_and_ty(lcx: @local_ctxt, sp: span,
     let cx = lcx.ccx;
     let t = tpt.ty;
     alt ty::struct(cx.tcx, t) {
-      ty::ty_fn(_, _, _, _, _) | ty::ty_native_fn(_, _) {
+      ty::ty_fn(_) | ty::ty_native_fn(_, _) {
         check returns_non_ty_var(cx, t);
         ret type_of_fn_from_ty(cx, sp, t, vec::len(tpt.kinds));
       }
@@ -482,7 +482,7 @@ fn simplify_type(ccx: @crate_ctxt, typ: ty::t) -> ty::t {
           ty::ty_uniq(_) {
             ret ty::mk_imm_uniq(ccx.tcx, ty::mk_nil(ccx.tcx));
           }
-          ty::ty_fn(_, _, _, _, _) {
+          ty::ty_fn(_) {
             ret ty::mk_tup(ccx.tcx,
                            [ty::mk_imm_box(ccx.tcx, ty::mk_nil(ccx.tcx)),
                             ty::mk_imm_box(ccx.tcx, ty::mk_nil(ccx.tcx))]);
@@ -1321,7 +1321,7 @@ fn make_take_glue(cx: @block_ctxt, v: ValueRef, t: ty::t) {
         Store(bcx, s, v);
         bcx
       }
-      ty::ty_native_fn(_, _) | ty::ty_fn(_, _, _, _, _) {
+      ty::ty_native_fn(_, _) | ty::ty_fn(_) {
         trans_closure::make_fn_glue(bcx, v, t, take_ty)
       }
       ty::ty_opaque_closure. {
@@ -1396,7 +1396,7 @@ fn make_free_glue(bcx: @block_ctxt, v: ValueRef, t: ty::t) {
         // they must be freed.
         trans_shared_free(bcx, v)
       }
-      ty::ty_native_fn(_, _) | ty::ty_fn(_, _, _, _, _) {
+      ty::ty_native_fn(_, _) | ty::ty_fn(_) {
         trans_closure::make_fn_glue(bcx, v, t, free_ty)
       }
       ty::ty_opaque_closure. {
@@ -1425,7 +1425,7 @@ fn make_drop_glue(bcx: @block_ctxt, v0: ValueRef, t: ty::t) {
           ty::ty_res(did, inner, tps) {
             trans_res_drop(bcx, v0, did, inner, tps)
           }
-          ty::ty_native_fn(_, _) | ty::ty_fn(_, _, _, _, _) {
+          ty::ty_native_fn(_, _) | ty::ty_fn(_) {
             trans_closure::make_fn_glue(bcx, v0, t, drop_ty)
           }
           ty::ty_opaque_closure. {
@@ -1635,7 +1635,7 @@ fn iter_structural_ty(cx: @block_ctxt, av: ValueRef, t: ty::t,
         let ccx = bcx_ccx(cx);
         let cx = cx;
         alt ty::struct(ccx.tcx, fn_ty) {
-          ty::ty_fn(_, args, _, _, _) {
+          ty::ty_fn({inputs: args, _}) {
             let j = 0u;
             let v_id = variant.id;
             for a: ty::arg in args {
@@ -2762,7 +2762,7 @@ fn trans_object_field_inner(bcx: @block_ctxt, o: ValueRef,
     vtbl = PointerCast(bcx, vtbl, vtbl_type);
 
     let v = GEPi(bcx, vtbl, [0, ix as int]);
-    let fn_ty: ty::t = ty::method_ty_to_fn_ty(tcx, mths[ix]);
+    let fn_ty: ty::t = ty::mk_fn(tcx, mths[ix].fty);
     let ret_ty = ty::ty_fn_ret(tcx, fn_ty);
     // FIXME: constrain ty_obj?
     check non_ty_var(ccx, ret_ty);
@@ -3558,7 +3558,7 @@ fn trans_expr(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt {
       }
       ast::expr_fn_block(decl, body) {
         alt ty::struct(tcx, ty::expr_ty(tcx, e)) {
-          ty::ty_fn(proto, _, _, _, _) {
+          ty::ty_fn({proto, _}) {
             let cap_clause = { copies: [], moves: [] };
             ret trans_closure::trans_expr_fn(
                 bcx, decl, body, e.span, e.id, cap_clause, dest);
@@ -4443,7 +4443,7 @@ fn copy_args_to_allocas(fcx: @fn_ctxt, bcx: @block_ctxt, args: [ast::arg],
 
 fn arg_tys_of_fn(ccx: @crate_ctxt, id: ast::node_id) -> [ty::arg] {
     alt ty::struct(ccx.tcx, ty::node_id_to_type(ccx.tcx, id)) {
-      ty::ty_fn(_, arg_tys, _, _, _) { ret arg_tys; }
+      ty::ty_fn({inputs, _}) { inputs }
     }
 }
 
@@ -5107,7 +5107,7 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef,
 
     let main_takes_argv =
         alt ty::struct(ccx.tcx, main_node_type) {
-          ty::ty_fn(_, args, _, _, _) { vec::len(args) != 0u }
+          ty::ty_fn({inputs, _}) { vec::len(inputs) != 0u }
         };
 
     let llfn = create_main(ccx, sp, main_llfn, main_takes_argv);

src/comp/middle/trans_closure.rs

@@ -516,19 +516,19 @@ fn make_fn_glue(
     };
 
     ret alt ty::struct(tcx, t) {
-      ty::ty_native_fn(_, _) | ty::ty_fn(ast::proto_bare., _, _, _, _) {
+      ty::ty_native_fn(_, _) | ty::ty_fn({proto: ast::proto_bare., _}) {
         bcx
       }
-      ty::ty_fn(ast::proto_block., _, _, _, _) {
+      ty::ty_fn({proto: ast::proto_block., _}) {
         bcx
       }
-      ty::ty_fn(ast::proto_send., _, _, _, _) {
+      ty::ty_fn({proto: ast::proto_send., _}) {
         fn_env({ |bcx, box_cell_v|
             let box_ty = trans_closure::send_opaque_closure_box_ty(tcx);
             glue_fn(bcx, box_cell_v, box_ty)
         })
       }
-      ty::ty_fn(ast::proto_shared(_), _, _, _, _) {
+      ty::ty_fn({proto: ast::proto_shared(_), _}) {
         fn_env({ |bcx, box_cell_v|
             let box_ty = trans_closure::shared_opaque_closure_box_ty(tcx);
             glue_fn(bcx, box_cell_v, box_ty)

src/comp/middle/trans_objects.rs

@@ -631,8 +631,8 @@ fn process_bkwding_mthd(cx: @local_ctxt, sp: span, m: @ty::method,
     // return type, if necessary.
     let llretptr = fcx.llretptr;
     let ccx = cx.ccx;
-    if ty::type_contains_params(ccx.tcx, m.output) {
-        let m_output = m.output;
+    if ty::type_contains_params(ccx.tcx, m.fty.output) {
+        let m_output = m.fty.output;
         check non_ty_var(ccx, m_output);
         let llretty = type_of_inner(ccx, sp, m_output);
         llretptr = PointerCast(bcx, llretptr, T_ptr(llretty));
@@ -676,7 +676,7 @@ fn process_bkwding_mthd(cx: @local_ctxt, sp: span, m: @ty::method,
     // function (they're in fcx.llargs) to llouter_mthd_args.
 
     let a: uint = 2u; // retptr, env come first
-    for arg: ty::arg in m.inputs {
+    for arg: ty::arg in m.fty.inputs {
         llouter_mthd_args += [llvm::LLVMGetParam(llbackwarding_fn, a)];
         a += 1u;
     }
@@ -725,8 +725,8 @@ fn process_fwding_mthd(cx: @local_ctxt, sp: span, m: @ty::method,
     // return type, if necessary.
     let llretptr = fcx.llretptr;
     let ccx = cx.ccx;
-    if ty::type_contains_params(ccx.tcx, m.output) {
-        let m_output = m.output;
+    if ty::type_contains_params(ccx.tcx, m.fty.output) {
+        let m_output = m.fty.output;
         check non_ty_var(ccx, m_output);
         let llretty = type_of_inner(ccx, sp, m_output);
         llretptr = PointerCast(bcx, llretptr, T_ptr(llretty));
@@ -828,7 +828,7 @@ fn process_fwding_mthd(cx: @local_ctxt, sp: span, m: @ty::method,
     // function (they're in fcx.llargs) to llorig_mthd_args.
 
     let a: uint = 2u; // retptr, env come first
-    for arg: ty::arg in m.inputs {
+    for arg: ty::arg in m.fty.inputs {
         llorig_mthd_args += [llvm::LLVMGetParam(llforwarding_fn, a)];
         a += 1u;
     }
@@ -877,9 +877,10 @@ fn process_normal_mthd(cx: @local_ctxt, m: @ast::method, self_ty: ty::t,
     let llfnty = T_nil();
     let ccx = cx.ccx;
     alt ty::struct(cx.ccx.tcx, node_id_type(cx.ccx, m.id)) {
-      ty::ty_fn(_, inputs, output, rs, _) {
-        check non_ty_var(ccx, output);
-        llfnty = type_of_fn(ccx, m.span, true, inputs, output,
+      ty::ty_fn(f) {
+        let out = f.output;
+        check non_ty_var(ccx, out);
+        llfnty = type_of_fn(ccx, m.span, true, f.inputs, out,
                             vec::len(ty_params));
       }
     }
@@ -930,9 +931,9 @@ fn populate_self_stack(bcx: @block_ctxt, self_stack: ValueRef,
 
 fn type_of_meth(ccx: @crate_ctxt, sp: span, m: @ty::method,
                 tps: [ast::ty_param]) -> TypeRef {
-    let out_ty = m.output;
+    let out_ty = m.fty.output;
     check non_ty_var(ccx, out_ty);
-    type_of_fn(ccx, sp, true, m.inputs, out_ty, vec::len(tps))
+    type_of_fn(ccx, sp, true, m.fty.inputs, out_ty, vec::len(tps))
 }
 
 //