---

yaml
---
r: 2914
b: refs/heads/master
c: 3a6b557
h: refs/heads/master
v: v3

Author: lkuper

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 1377e9b341a03915c48a564fb30e70022d04c78f
+refs/heads/master: 3a6b5576acbcd0ee2ae3e28847d0b41e2b82ed32

trunk/mk/pp.mk

@@ -1,7 +1,10 @@
+
+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 $(wildcard $(addprefix $(S)src/comp/, \
-                          *.rs */*.rs */*/*.rs));  \
+	for i in $(PP_INPUTS);  \
     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,10 +29,17 @@ 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 {
@@ -112,19 +119,21 @@ fn compile_input(session::session sess,
 }
 
 fn pretty_print_input(session::session sess, eval::env env, str input,
-                      bool typed) {
+                      pp_mode ppm) {
     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;
-    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;
+    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; }
     }
 
     pprust::print_file(sess, crate.node.module, input, std::io::stdout(),
@@ -150,8 +159,7 @@ options:
     -o <filename>      write output to <filename>
     --glue             generate glue.bc file
     --shared           compile a shared-library crate
-    --pretty           pretty-print the input instead of compiling
-    --typed-pretty     pretty-print the input with types instead of compiling
+    --pretty [type]    pretty-print the input 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)
@@ -304,12 +312,21 @@ 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"),
-                 optflag("pretty"), optflag("typed-pretty"),
+                 optflagopt("pretty"),
                  optflag("ls"), optflag("parse-only"),
                  optflag("O"), optopt("OptLevel"),
                  optflag("shared"), optmulti("L"),
@@ -365,42 +382,50 @@ fn main(vec[str] args) {
     auto ifile = match.free.(0);
     let str saved_out_filename = "";
     auto env = default_environment(sess, binary, ifile);
-    auto pretty = opt_present(match, "pretty");
-    auto typed_pretty = opt_present(match, "typed-pretty");
+    auto pretty = option::map[str,pp_mode](bind parse_pretty(sess, _),
+        getopts::opt_default(match, "pretty", "normal"));
     auto ls = opt_present(match, "ls");
-    if (pretty || typed_pretty) {
-        pretty_print_input(sess, env, ifile, typed_pretty);
-        ret;
-    } else if (ls) {
+
+    alt (pretty) {
+        case (some[pp_mode](?ppm)) {
+            pretty_print_input(sess, env, ifile, ppm);
+            ret;
+        }
+        case (none[pp_mode]) { /* continue */ }
+    }
+
+    if (ls) {
         front::creader::list_file_metadata(ifile, std::io::stdout());
         ret;
-    } 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);
+    }
+
+    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);
         }
     }
 
     // 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,6 +338,7 @@ 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);
@@ -503,14 +504,6 @@ fn is_constraint_arg(@expr e) -> bool {
     }
 }
 
-fn eq_ty(&@ty a, &@ty b) -> bool {
-    ret std::box::ptr_eq(a,b);
-}
-
-fn hash_ty(&@ty t) -> uint {
-    ret t.span.lo << 16u + t.span.hi;
-}
-
 //
 // Local Variables:
 // mode: rust