Refactoring, annotating FIXMEs in remainder of metadata code

Author: catamorphism

src/librustsyntax/ast.rs

@@ -503,7 +503,7 @@ type constr_arg = spanned<fn_constr_arg>;
 
 #[auto_serialize]
 type constr_general_<ARG, ID> =
-    {path: @path, args: [@spanned<constr_arg_general_<ARG>>], id: ID};
+    {path: @path, args: [@sp_constr_arg<ARG>], id: ID};
 
 // In the front end, constraints have a node ID attached.
 // Typeck turns this to a def_id, using the output of resolve.

src/rustc/metadata/loader.rs

@@ -125,7 +125,7 @@ fn crate_name_from_metas(metas: [@ast::meta_item]) -> str {
         alt attr::get_meta_item_value_str(i) {
           some(n) { n }
           // FIXME: Probably want a warning here since the user
-          // is using the wrong type of meta item
+          // is using the wrong type of meta item (#2406)
           _ { fail }
         }
       }

src/rustc/metadata/tydecode.rs

@@ -63,35 +63,29 @@ fn parse_ret_ty(st: @pstate, conv: conv_did) -> (ast::ret_style, ty::t) {
     }
 }
 
-fn parse_constrs(st: @pstate, conv: conv_did) -> [@ty::constr] {
-    let mut rslt: [@ty::constr] = [];
+fn parse_constrs_gen<T: copy>(st: @pstate, conv: conv_did,
+                                       pser: fn(@pstate)
+  -> ast::constr_arg_general_<T>) -> [@ty::constr_general<T>] {
+    let mut rslt: [@ty::constr_general<T>] = [];
     alt peek(st) {
       ':' {
         loop {
-            next(st);
-            rslt += [parse_constr(st, conv, parse_constr_arg)];
-            if peek(st) != ';' { break; }
+          next(st);
+          rslt += [parse_constr(st, conv, pser)];
+          if peek(st) != ';' { break; }
         }
       }
-      _ { }
+      _ {}
     }
-    ret rslt;
+    rslt
+}
+
+fn parse_constrs(st: @pstate, conv: conv_did) -> [@ty::constr] {
+    parse_constrs_gen(st, conv, parse_constr_arg)
 }
 
-// FIXME less copy-and-paste
 fn parse_ty_constrs(st: @pstate, conv: conv_did) -> [@ty::type_constr] {
-    let mut rslt: [@ty::type_constr] = [];
-    alt peek(st) {
-      ':' {
-        loop {
-            next(st);
-            rslt += [parse_constr(st, conv, parse_ty_constr_arg)];
-            if peek(st) != ';' { break; }
-        }
-      }
-      _ { }
-    }
-    ret rslt;
+    parse_constrs_gen(st, conv, parse_ty_constr_arg)
 }
 
 fn parse_path(st: @pstate) -> @ast::path {
@@ -121,11 +115,11 @@ fn parse_constr_arg(st: @pstate) -> ast::fn_constr_arg {
            an arg index and a lit argument? */
         if c >= '0' && c <= '9' {
             next(st);
-            // FIXME
+            // FIXME #877
             ret ast::carg_ident((c as uint) - 48u);
         } else {
             #error("Lit args are unimplemented");
-            fail; // FIXME
+            fail; // FIXME #877
         }
         /*
           else {
@@ -147,7 +141,8 @@ fn parse_ty_constr_arg(st: @pstate) -> ast::constr_arg_general_<@path> {
 fn parse_constr<T: copy>(st: @pstate, conv: conv_did,
                          pser: fn(@pstate) -> ast::constr_arg_general_<T>)
     -> @ty::constr_general<T> {
-    let sp = ast_util::dummy_sp(); // FIXME: use a real span
+    // FIXME: use real spans and not a bogus one (#2407)
+    let sp = ast_util::dummy_sp();
     let mut args: [@sp_constr_arg<T>] = [];
     let pth = parse_path(st);
     let mut ignore: char = next(st);
@@ -156,7 +151,6 @@ fn parse_constr<T: copy>(st: @pstate, conv: conv_did,
     let mut an_arg: constr_arg_general_<T>;
     loop {
         an_arg = pser(st);
-        // FIXME use a real span
         args += [@respan(sp, an_arg)];
         ignore = next(st);
         if ignore != ';' { break; }

src/rustc/metadata/tyencode.rs

@@ -352,39 +352,39 @@ fn enc_ty_fn(w: io::writer, cx: @ctxt, ft: ty::fn_ty) {
     }
 }
 
-// FIXME less copy-and-paste
-fn enc_constr(w: io::writer, cx: @ctxt, c: @ty::constr) {
+fn enc_constr_gen<T>(w: io::writer, cx: @ctxt,
+                  c: @ty::constr_general<T>,
+                  write_arg: fn(@sp_constr_arg<T>)) {
     w.write_str(path_to_str(c.node.path));
     w.write_char('(');
     w.write_str(cx.ds(c.node.id));
     w.write_char('|');
     let mut semi = false;
     for c.node.args.each {|a|
         if semi { w.write_char(';'); } else { semi = true; }
-        alt a.node {
-          carg_base { w.write_char('*'); }
-          carg_ident(i) { w.write_uint(i); }
-          carg_lit(l) { w.write_str(lit_to_str(l)); }
-        }
+        write_arg(a);
     }
     w.write_char(')');
 }
 
+fn enc_constr(w: io::writer, cx: @ctxt, c: @ty::constr) {
+    enc_constr_gen(w, cx, c, {|a|
+      alt a.node {
+        carg_base     { w.write_char('*'); }
+        carg_ident(i) { w.write_uint(i); }
+        carg_lit(l)   { w.write_str(lit_to_str(l)); }
+      }
+    });
+}
+
 fn enc_ty_constr(w: io::writer, cx: @ctxt, c: @ty::type_constr) {
-    w.write_str(path_to_str(c.node.path));
-    w.write_char('(');
-    w.write_str(cx.ds(c.node.id));
-    w.write_char('|');
-    let mut semi = false;
-    for c.node.args.each {|a|
-        if semi { w.write_char(';'); } else { semi = true; }
-        alt a.node {
-          carg_base { w.write_char('*'); }
-          carg_ident(p) { w.write_str(path_to_str(p)); }
-          carg_lit(l) { w.write_str(lit_to_str(l)); }
-        }
-    }
-    w.write_char(')');
+    enc_constr_gen(w, cx, c, {|a|
+      alt a.node {
+        carg_base     { w.write_char('*'); }
+        carg_ident(p) { w.write_str(path_to_str(p)); }
+        carg_lit(l)  { w.write_str(lit_to_str(l)); }
+      }
+    });
 }
 
 fn enc_bounds(w: io::writer, cx: @ctxt, bs: @[ty::param_bound]) {