---

yaml
---
r: 2912
b: refs/heads/master
c: 5cd10d2
h: refs/heads/master
v: v3

Author: paulstansifer

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 12f86e6f2f5e7a5fc4ea61f3c63c790be100688f
+refs/heads/master: 5cd10d2fef8ffa68903b18726f19ac52a04725cc

trunk/mk/pp.mk

@@ -1,10 +1,7 @@
-
-PP_INPUTS := $(wildcard $(addprefix $(S)src/lib/,*.rs */*.rs)) \
-             $(wildcard $(addprefix $(S)src/comp/,*.rs */*.rs */*/*.rs))
-
 reformat: $(SREQ1)
 	@$(call E, reformat [stage1]: $@)
-	for i in $(PP_INPUTS);  \
+	for i in $(wildcard $(addprefix $(S)src/comp/, \
+                          *.rs */*.rs */*/*.rs));  \
     do $(call CFG_RUN_TARG,stage1, stage1/rustc$(X)) \
        --pretty $$i >$$i.tmp && mv $$i.tmp $$i; \
     done

trunk/src/comp/driver/rustc.rs

@@ -29,17 +29,10 @@ import std::getopts;
 import std::getopts::optopt;
 import std::getopts::optmulti;
 import std::getopts::optflag;
-import std::getopts::optflagopt;
 import std::getopts::opt_present;
 
 import back::link::output_type;
 
-tag pp_mode {
-    ppm_normal;
-    ppm_typed;
-    ppm_identified;
-}
-
 fn default_environment(session::session sess,
                        str argv0,
                        str input) -> eval::env {
@@ -119,21 +112,19 @@ fn compile_input(session::session sess,
 }
 
 fn pretty_print_input(session::session sess, eval::env env, str input,
-                      pp_mode ppm) {
+                      bool typed) {
     auto def = tup(ast::local_crate, 0);
     auto p = front::parser::new_parser(sess, env, def, input, 0u, 0u);
     auto crate = front::parser::parse_crate_from_source_file(p);
 
     auto mode;
-    alt (ppm) {
-        case (ppm_typed) {
-            auto def_map = resolve::resolve_crate(sess, crate);
-            auto ty_cx = ty::mk_ctxt(sess, def_map);
-            typeck::check_crate(ty_cx, crate);
-            mode = pprust::mo_typed(ty_cx);
-        }
-        case (ppm_normal) { mode = pprust::mo_untyped; }
-        case (ppm_identified) { mode = pprust::mo_identified; }
+    if (typed) {
+        auto def_map = resolve::resolve_crate(sess, crate);
+        auto ty_cx = ty::mk_ctxt(sess, def_map);
+        typeck::check_crate(ty_cx, crate);
+        mode = pprust::mo_typed(ty_cx);
+    } else {
+        mode = pprust::mo_untyped;
     }
 
     pprust::print_file(sess, crate.node.module, input, std::io::stdout(),
@@ -159,7 +150,8 @@ options:
     -o <filename>      write output to <filename>
     --glue             generate glue.bc file
     --shared           compile a shared-library crate
-    --pretty [type]    pretty-print the input instead of compiling
+    --pretty           pretty-print the input instead of compiling
+    --typed-pretty     pretty-print the input with types instead of compiling
     --ls               list the symbols defined by a crate file
     -L <path>          add a directory to the library search path
     --noverify         suppress LLVM verification step (slight speedup)
@@ -312,21 +304,12 @@ fn build_session(@session::options sopts) -> session::session {
     ret sess;
 }
 
-fn parse_pretty(session::session sess, &str name) -> pp_mode {
-    if (str::eq(name, "normal")) { ret ppm_normal; }
-    else if (str::eq(name, "typed")) { ret ppm_typed; }
-    else if (str::eq(name, "identified")) { ret ppm_identified; }
-
-    sess.err("argument to `pretty` must be one of `normal`, `typed`, or " +
-             "`identified`");
-}
-
 fn main(vec[str] args) {
 
     auto opts = [optflag("h"), optflag("help"),
                  optflag("v"), optflag("version"),
                  optflag("glue"), optflag("emit-llvm"),
-                 optflagopt("pretty"),
+                 optflag("pretty"), optflag("typed-pretty"),
                  optflag("ls"), optflag("parse-only"),
                  optflag("O"), optopt("OptLevel"),
                  optflag("shared"), optmulti("L"),
@@ -382,50 +365,42 @@ fn main(vec[str] args) {
     auto ifile = match.free.(0);
     let str saved_out_filename = "";
     auto env = default_environment(sess, binary, ifile);
-    auto pretty = option::map[str,pp_mode](bind parse_pretty(sess, _),
-        getopts::opt_default(match, "pretty", "normal"));
+    auto pretty = opt_present(match, "pretty");
+    auto typed_pretty = opt_present(match, "typed-pretty");
     auto ls = opt_present(match, "ls");
-
-    alt (pretty) {
-        case (some[pp_mode](?ppm)) {
-            pretty_print_input(sess, env, ifile, ppm);
-            ret;
-        }
-        case (none[pp_mode]) { /* continue */ }
-    }
-
-    if (ls) {
+    if (pretty || typed_pretty) {
+        pretty_print_input(sess, env, ifile, typed_pretty);
+        ret;
+    } else if (ls) {
         front::creader::list_file_metadata(ifile, std::io::stdout());
         ret;
-    }
-
-    alt (output_file) {
-        case (none) {
-            let vec[str] parts = str::split(ifile, '.' as u8);
-            vec::pop[str](parts);
-            saved_out_filename = parts.(0);
-            alt (sopts.output_type) {
-                case (link::output_type_none) { parts += ["pp"]; }
-                case (link::output_type_bitcode) { parts += ["bc"]; }
-                case (link::output_type_assembly) { parts += ["s"]; }
-
-                // Object and exe output both use the '.o' extension here
-                case (link::output_type_object) { parts += ["o"]; }
-                case (link::output_type_exe) { parts += ["o"]; }
+    } else {
+        alt (output_file) {
+            case (none) {
+                let vec[str] parts = str::split(ifile, '.' as u8);
+                vec::pop[str](parts);
+                saved_out_filename = parts.(0);
+                alt (sopts.output_type) {
+                    case (link::output_type_none) { parts += ["pp"]; }
+                    case (link::output_type_bitcode) { parts += ["bc"]; }
+                    case (link::output_type_assembly) { parts += ["s"]; }
+
+                    // Object and exe output both use the '.o' extension here
+                    case (link::output_type_object) { parts += ["o"]; }
+                    case (link::output_type_exe) { parts += ["o"]; }
+                }
+                auto ofile = str::connect(parts, ".");
+                compile_input(sess, env, ifile, ofile);
+            }
+            case (some(?ofile)) {
+                saved_out_filename = ofile;
+                compile_input(sess, env, ifile, ofile);
             }
-            auto ofile = str::connect(parts, ".");
-            compile_input(sess, env, ifile, ofile);
-        }
-        case (some(?ofile)) {
-            saved_out_filename = ofile;
-            compile_input(sess, env, ifile, ofile);
         }
     }
 
     // If the user wants an exe generated we need to invoke
     // gcc to link the object file with some libs
-    //
-    // TODO: Factor this out of main.
     if (sopts.output_type == link::output_type_exe) {
 
         //FIXME: Should we make the 'stage3's variable here?

trunk/src/comp/front/ast.rs

@@ -338,7 +338,6 @@ tag ty_ {
 tag constr_arg_ {
     carg_base;
     carg_ident(ident);
-    carg_lit(@lit);
 }
 type constr_arg = spanned[constr_arg_];
 type constr_ = rec(path path, vec[@constr_arg] args);
@@ -504,6 +503,14 @@ fn is_constraint_arg(@expr e) -> bool {
     }
 }
 
+fn eq_ty(&@ty a, &@ty b) -> bool {
+    ret a == b;
+}
+
+fn hash_ty(&@ty t) -> uint {
+    ret t.span.lo << 16u + t.span.hi;
+}
+
 //
 // Local Variables:
 // mode: rust

trunk/src/comp/middle/trans.rs

@@ -4,14 +4,6 @@
 // the result of the translation to LLVM -- while others, such as trans_fn,
 // trans_obj, and trans_item, are called only for the side effect of adding a
 // particular definition to the LLVM IR output we're producing.
-//
-// Hopefully useful general knowledge about trans:
-// 
-//   * There's no way to find out the ty::t type of a ValueRef.  Doing so
-//     would be "trying to get the eggs out of an omelette" (credit:
-//     pcwalton).  You can, instead, find out its TypeRef by calling val_ty,
-//     but many TypeRefs correspond to one ty::t; for instance, tup(int, int,
-//     int) and rec(x=int, y=int, z=int) will have the same TypeRef.
 
 import std::int;
 import std::str;

trunk/src/comp/middle/tstate/annotate.rs

@@ -51,7 +51,7 @@ import util::common::log_stmt;
 
 import aux::fn_info;
 import aux::fn_info_map;
-import aux::num_constraints;
+import aux::num_locals;
 import aux::get_fn_info;
 import aux::crate_ctxt;
 import aux::add_node;
@@ -109,19 +109,19 @@ fn init_vecs(&crate_ctxt ccx, @vec[uint] node_ids, uint len) -> () {
     }
 }
 
-fn visit_fn(&crate_ctxt ccx, uint num_constraints, &_fn f,
+fn visit_fn(&crate_ctxt ccx, uint num_locals, &_fn f,
             &span sp, &ident i, &def_id d, &ann a) -> () {
     let vec[uint] node_ids_ = [];
     let @vec[uint] node_ids = @node_ids_;
     node_ids_in_fn(f, sp, i, d, a, node_ids);
-    init_vecs(ccx, node_ids, num_constraints);
+    init_vecs(ccx, node_ids, num_locals);
 }
 
 fn annotate_in_fn(&crate_ctxt ccx, &_fn f, &span sp, &ident i,
                   &def_id f_id, &ann a)
     -> () {
     auto f_info = get_fn_info(ccx, f_id);
-    visit_fn(ccx, num_constraints(f_info), f, sp, i, f_id, a);
+    visit_fn(ccx, num_locals(f_info), f, sp, i, f_id, a);
 }
 
 fn annotate_crate(&crate_ctxt ccx, &crate crate) -> () {