rustdoc: Add argument types to the doc

Author: brson

src/rustdoc/doc.rs

@@ -22,7 +22,8 @@ type fndoc = ~{
 };
 
 type argdoc = ~{
-    name: str
+    name: str,
+    ty: option<str>
 };
 
 type retdoc = {

src/rustdoc/extract.rs

@@ -95,7 +95,8 @@ fn argdocs_from_args(args: [ast::arg]) -> [doc::argdoc] {
 
 fn argdoc_from_arg(arg: ast::arg) -> doc::argdoc {
     ~{
-        name: arg.ident
+        name: arg.ident,
+        ty: none
     }
 }
 

src/rustdoc/tystr_pass.rs

@@ -33,43 +33,45 @@ fn fold_fn(
 ) -> doc::fndoc {
 
     let srv = fold.ctxt;
-    let ret_ty = get_ret_ty(srv, doc.id);
 
     ~{
-        return: merge_ret_ty(doc.return, ret_ty)
+        return: merge_ret_ty(srv, doc.id, doc.return),
+        args: merge_arg_tys(srv, doc.id, doc.args)
         with *doc
     }
 }
 
-fn get_ret_ty(srv: astsrv::srv, id: doc::ast_id) -> str {
-    astsrv::exec(srv) {|ctxt|
-        alt ctxt.map.get(id) {
-          ast_map::node_item(@{
-            node: ast::item_fn(decl, _, _), _
-          }) {
-            pprust::ty_to_str(decl.output)
-          }
-        }
-    }
-}
-
 fn merge_ret_ty(
-    doc: option<doc::retdoc>,
-    tystr: str
+    srv: astsrv::srv,
+    fn_id: doc::ast_id,
+    doc: option<doc::retdoc>
 ) -> option<doc::retdoc> {
+    let ty = get_ret_ty(srv, fn_id);
     alt doc {
       some(doc) {
         fail "unimplemented";
       }
       none. {
         some({
             desc: none,
-            ty: some(tystr)
+            ty: some(ty)
         })
       }
     }
 }
 
+fn get_ret_ty(srv: astsrv::srv, id: doc::ast_id) -> str {
+    astsrv::exec(srv) {|ctxt|
+        alt ctxt.map.get(id) {
+          ast_map::node_item(@{
+            node: ast::item_fn(decl, _, _), _
+          }) {
+            pprust::ty_to_str(decl.output)
+          }
+        }
+    }
+}
+
 #[test]
 fn should_add_fn_ret_types() {
     let source = "fn a() -> int { }";
@@ -79,3 +81,43 @@ fn should_add_fn_ret_types() {
     assert option::get(doc.topmod.fns[0].return).ty == some("int");
 }
 
+fn merge_arg_tys(
+    srv: astsrv::srv,
+    fn_id: doc::ast_id,
+    args: [doc::argdoc]
+) -> [doc::argdoc] {
+    let tys = get_arg_tys(srv, fn_id);
+    vec::map2(args, tys) {|arg, ty|
+        // Sanity check that we're talking about the same args
+        assert arg.name == tuple::first(ty);
+        ~{
+            ty: some(tuple::second(ty))
+            with *arg
+        }
+    }
+}
+
+fn get_arg_tys(srv: astsrv::srv, fn_id: doc::ast_id) -> [(str, str)] {
+    astsrv::exec(srv) {|ctxt|
+        alt ctxt.map.get(fn_id) {
+          ast_map::node_item(@{
+            node: ast::item_fn(decl, _, _), _
+          }) {
+            vec::map(decl.inputs) {|arg|
+                (arg.ident, pprust::ty_to_str(arg.ty))
+            }
+          }
+        }
+    }
+}
+
+#[test]
+fn should_add_arg_types() {
+    let source = "fn a(b: int, c: bool) { }";
+    let srv = astsrv::mk_srv_from_str(source);
+    let doc = extract::from_srv(srv, "");
+    let doc = run(srv, doc);
+    let fn_ = doc.topmod.fns[0];
+    assert fn_.args[0].ty == some("int");
+    assert fn_.args[1].ty == some("bool");
+}