Remove arg vectors from main functions. Stop supporting them.

Author: brson

src/cargo/cargo.rs

@@ -1889,7 +1889,8 @@ Commands:
     set-method      Change the method for a source.");
 }
 
-fn main(argv: ~[~str]) {
+fn main() {
+    let argv = os::args();
     let o = build_cargo_options(argv);
 
     if vec::len(o.free) < 2u {

src/compiletest/compiletest.rs

@@ -12,7 +12,8 @@ use common::mode_pretty;
 use common::mode;
 use util::logv;
 
-fn main(++args: ~[~str]) {
+fn main() {
+    let args = os::args();
     let config = parse_config(args);
     log_config(config);
     run_tests(config);

src/etc/combine-tests.py

@@ -19,7 +19,6 @@ def scrub(b):
 run_pass = os.path.join(src_dir, "src", "test", "run-pass")
 run_pass = os.path.abspath(run_pass)
 stage2_tests = []
-take_args = {}
 
 for t in os.listdir(run_pass):
     if t.endswith(".rs") and not (
@@ -30,8 +29,6 @@ def scrub(b):
                 "xfail-fast" in s or
                 "xfail-win32" in s):
             stage2_tests.append(t)
-            if "fn main(args:" in s or "fn main(++args:" in s:
-                take_args[t] = True
         f.close()
 
 stage2_tests.sort()
@@ -64,9 +61,6 @@ def scrub(b):
     p = os.path.join("test", "run-pass", t)
     p = p.replace("\\", "\\\\")
     d.write("    out.write_str(~\"run-pass [stage2]: %s\\n\");\n" % p)
-    if t in take_args:
-        d.write("    t_%d::main(~[~\"arg0\"]);\n" % i)
-    else:
-        d.write("    t_%d::main();\n" % i)
+    d.write("    t_%d::main();\n" % i)
     i += 1
 d.write("}\n")

src/fuzzer/fuzzer.rs

@@ -599,7 +599,8 @@ fn check_variants(files: &[Path], cx: context) {
     }
 }
 
-fn main(args: ~[~str]) {
+fn main() {
+    let args = os::args();
     if vec::len(args) != 2u {
         error!("usage: %s <testdir>", args[0]);
         return;

src/rustc/driver/rustc.rs

@@ -277,7 +277,8 @@ fn monitor(+f: fn~(diagnostic::emitter)) {
     }
 }
 
-fn main(args: ~[~str]) {
+fn main() {
+    let args = os::args();
     do monitor |demitter| {
         run_compiler(args, demitter);
     }

src/rustc/front/test.rs

@@ -415,34 +415,12 @@ fn mk_test_wrapper(cx: test_ctxt,
 }
 
 fn mk_main(cx: test_ctxt) -> @ast::item {
-    let str_pt = path_node(~[cx.sess.ident_of(~"str")]);
-    let str_ty_inner = @{id: cx.sess.next_node_id(),
-                         node: ast::ty_path(str_pt, cx.sess.next_node_id()),
-                         span: dummy_sp()};
-    let str_ty = @{id: cx.sess.next_node_id(),
-                   node: ast::ty_uniq({ty: str_ty_inner, mutbl: ast::m_imm}),
-                   span: dummy_sp()};
-    let args_mt = {ty: str_ty, mutbl: ast::m_imm};
-    let args_ty_inner = @{id: cx.sess.next_node_id(),
-                          node: ast::ty_vec(args_mt),
-                          span: dummy_sp()};
-    let args_ty = {id: cx.sess.next_node_id(),
-                   node: ast::ty_uniq({ty: args_ty_inner, mutbl: ast::m_imm}),
-                   span: dummy_sp()};
-
-
-    let args_arg: ast::arg =
-        {mode: ast::expl(ast::by_val),
-         ty: @args_ty,
-         ident: cx.sess.ident_of(~"args"),
-         id: cx.sess.next_node_id()};
-
     let ret_ty = {id: cx.sess.next_node_id(),
                   node: ast::ty_nil,
                   span: dummy_sp()};
 
     let decl: ast::fn_decl =
-        {inputs: ~[args_arg],
+        {inputs: ~[],
          output: @ret_ty,
          cf: ast::return_val};
 
@@ -465,16 +443,24 @@ fn mk_main(cx: test_ctxt) -> @ast::item {
 }
 
 fn mk_test_main_call(cx: test_ctxt) -> @ast::expr {
-
-    // Get the args passed to main so we can pass the to test_main
-    let args_path = path_node(~[cx.sess.ident_of(~"args")]);
+    // Call os::args to generate the vector of test_descs
+    let args_path = path_node(~[
+        cx.sess.ident_of(~"os"),
+        cx.sess.ident_of(~"args")
+    ]);
 
     let args_path_expr_: ast::expr_ = ast::expr_path(args_path);
 
     let args_path_expr: ast::expr =
         {id: cx.sess.next_node_id(), callee_id: cx.sess.next_node_id(),
          node: args_path_expr_, span: dummy_sp()};
 
+    let args_call_expr_ = ast::expr_call(@args_path_expr, ~[], false);
+
+    let args_call_expr: ast::expr =
+        {id: cx.sess.next_node_id(), callee_id: cx.sess.next_node_id(),
+         node: args_call_expr_, span: dummy_sp()};
+
     // Call __test::test to generate the vector of test_descs
     let test_path = path_node(~[cx.sess.ident_of(~"tests")]);
 
@@ -503,7 +489,7 @@ fn mk_test_main_call(cx: test_ctxt) -> @ast::expr {
 
     let test_main_call_expr_: ast::expr_ =
         ast::expr_call(@test_main_path_expr,
-                       ~[@args_path_expr, @test_call_expr], false);
+                       ~[@args_call_expr, @test_call_expr], false);
 
     let test_main_call_expr: ast::expr =
         {id: cx.sess.next_node_id(), callee_id: cx.sess.next_node_id(),

src/rustc/middle/trans/base.rs

@@ -1953,32 +1953,23 @@ fn register_fn_fuller(ccx: @crate_ctxt, sp: span, path: path,
            ast_map::path_to_str(path, ccx.sess.parse_sess.interner));
 
     let is_main = is_main_name(path) && !ccx.sess.building_library;
-    if is_main { create_main_wrapper(ccx, sp, llfn, node_type); }
+    if is_main { create_main_wrapper(ccx, sp, llfn); }
     llfn
 }
 
 // Create a _rust_main(args: ~[str]) function which will be called from the
 // runtime rust_start function
-fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef,
-                       main_node_type: ty::t) {
+fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef) {
 
     if ccx.main_fn != None::<ValueRef> {
         ccx.sess.span_fatal(sp, ~"multiple 'main' functions");
     }
 
-    let main_takes_argv =
-        // invariant!
-        match ty::get(main_node_type).sty {
-          ty::ty_fn(ref fn_ty) => fn_ty.sig.inputs.len() != 0u,
-          _ => ccx.sess.span_fatal(sp, ~"main has a non-function type")
-        };
-
-    let llfn = create_main(ccx, main_llfn, main_takes_argv);
+    let llfn = create_main(ccx, main_llfn);
     ccx.main_fn = Some(llfn);
     create_entry_fn(ccx, llfn);
 
-    fn create_main(ccx: @crate_ctxt, main_llfn: ValueRef,
-                   takes_argv: bool) -> ValueRef {
+    fn create_main(ccx: @crate_ctxt, main_llfn: ValueRef) -> ValueRef {
         let unit_ty = ty::mk_estr(ccx.tcx, ty::vstore_uniq);
         let vecarg_ty: ty::arg =
             {mode: ast::expl(ast::by_val),
@@ -1998,9 +1989,6 @@ fn create_main_wrapper(ccx: @crate_ctxt, sp: span, main_llfn: ValueRef,
         let lloutputarg = llvm::LLVMGetParam(llfdecl, 0 as c_uint);
         let llenvarg = llvm::LLVMGetParam(llfdecl, 1 as c_uint);
         let mut args = ~[lloutputarg, llenvarg];
-        if takes_argv {
-            args.push(llvm::LLVMGetParam(llfdecl, 2 as c_uint));
-        }
         Call(bcx, main_llfn, args);
 
         build_return(bcx);

src/rustc/middle/typeck.rs

@@ -301,14 +301,12 @@ fn check_main_fn_ty(ccx: @crate_ctxt,
             }
             let mut ok = ty::type_is_nil(fn_ty.sig.output);
             let num_args = vec::len(fn_ty.sig.inputs);
-            ok &= num_args == 0u || num_args == 1u &&
-                arg_is_argv_ty(tcx, fn_ty.sig.inputs[0]);
+            ok &= num_args == 0u;
             if !ok {
                 tcx.sess.span_err(
                     main_span,
                     fmt!("Wrong type in main function: found `%s`, \
-                          expected `extern fn(++v: ~[~str]) -> ()` \
-                          or `extern fn() -> ()`",
+                          expected `fn() -> ()`",
                          ty_to_str(tcx, main_t)));
             }
         }

src/rustdoc/rustdoc.rs

@@ -3,7 +3,8 @@ use doc::Item;
 use pass::Pass;
 use config::Config;
 
-fn main(args: ~[~str]) {
+fn main() {
+    let args = os::args();
 
     if args.contains(&~"-h") || args.contains(&~"--help") {
         config::usage();

src/test/bench/core-map.rs

@@ -142,7 +142,8 @@ fn empty_results() -> Results {
     }
 }
 
-fn main(++args: ~[~str]) {
+fn main() {
+    let args = os::args();
     let num_keys = {
         if args.len() == 2 {
             uint::from_str(args[1]).get()