Merge branch 'master' of github.com:graydon/rust into fastcall

Author: Eric Holk

mk/stage3.mk

@@ -1,13 +1,8 @@
-stage3/std.o: $(STDLIB_CRATE) $(STDLIB_INPUTS) \
+stage3/$(CFG_STDLIB): $(STDLIB_CRATE) $(STDLIB_INPUTS) \
               stage2/rustc$(X) stage2/$(CFG_STDLIB) stage2/intrinsics.bc \
               $(LREQ) $(MKFILES)
-	@$(call E, compile: $@)
-	$(STAGE2) -c --shared -o $@ $<
-
-stage3/$(CFG_STDLIB): stage2/std.o stage2/glue.o
-	@$(call E, link: $@)
-	$(Q)gcc $(CFG_GCCISH_CFLAGS) stage2/glue.o $(CFG_GCCISH_LINK_FLAGS) -o \
-        $@ $< -Lstage2 -Lrt -lrustrt
+	@$(call E, compile_and_link: $@)
+	$(STAGE2)  --shared -o $@ $<
 
 stage3/librustc.o: $(COMPILER_CRATE) $(COMPILER_INPUTS) $(SREQ2)
 	@$(call E, compile: $@)

src/comp/back/abi.rs

@@ -104,7 +104,7 @@ const int closure_elt_bindings = 2;
 
 const int closure_elt_ty_params = 3;
 
-const uint ivec_default_length = 8u;
+const uint ivec_default_length = 4u;
 
 const uint ivec_elt_len = 0u;
 

src/comp/back/link.rs

@@ -209,7 +209,7 @@ mod write {
  *
  * There are a few issues to handle:
  *
- *  - Linkers operate on a flat namespace, so we have to flatten names.
+ *  - Linnkers operate on a flat namespace, so we have to flatten names.
  *    We do this using the C++ namespace-mangling technique. Foo::bar
  *    symbols and such.
  *
@@ -221,15 +221,15 @@ mod write {
  *    symbols in the same process before you're even hitting birthday-paradox
  *    collision probability.
  *
- *  - Symbols in dirrerent crates but with same names "within" the crate need
+ *  - Symbols in different crates but with same names "within" the crate need
  *    to get different linkage-names.
  *
  * So here is what we do:
  *
  *  - Separate the meta tags into two sets: exported and local. Only work with
  *    the exported ones when considering linkage.
  *
- *  - Consider two exported tags as special (and madatory): name and vers.
+ *  - Consider two exported tags as special (and mandatory): name and vers.
  *    Every crate gets them; if it doesn't name them explicitly we infer them
  *    as basename(crate) and "0.1", respectively. Call these CNAME, CVERS.
  *

src/comp/driver/rustc.rs

@@ -81,18 +81,18 @@ fn compile_input(session::session sess, eval::env env, str input,
     auto crate =
         time(time_passes, "parsing", bind parse_input(sess, p, input));
     if (sess.get_opts().output_type == link::output_type_none) { ret; }
-    auto def_map =
+    auto d =
         time(time_passes, "resolution",
              bind resolve::resolve_crate(sess, crate));
-    auto ty_cx = ty::mk_ctxt(sess, def_map);
+    auto ty_cx = ty::mk_ctxt(sess, d._0, d._1);
     time[()](time_passes, "typechecking",
              bind typeck::check_crate(ty_cx, crate));
     if (sess.get_opts().run_typestate) {
         time(time_passes, "typestate checking",
              bind middle::tstate::ck::check_crate(ty_cx, crate));
     }
     time(time_passes, "alias checking",
-         bind middle::alias::check_crate(@ty_cx, def_map, crate));
+         bind middle::alias::check_crate(@ty_cx, crate));
     auto llmod =
         time[llvm::llvm::ModuleRef](time_passes, "translation",
                                     bind trans::trans_crate(sess, crate,
@@ -109,8 +109,8 @@ fn pretty_print_input(session::session sess, eval::env env, str input,
     auto mode;
     alt (ppm) {
         case (ppm_typed) {
-            auto def_map = resolve::resolve_crate(sess, crate);
-            auto ty_cx = ty::mk_ctxt(sess, def_map);
+            auto d = resolve::resolve_crate(sess, crate);
+            auto ty_cx = ty::mk_ctxt(sess, d._0, d._1);
             typeck::check_crate(ty_cx, crate);
             mode = ppaux::mo_typed(ty_cx);
         }
@@ -399,37 +399,34 @@ fn main(vec[str] args) {
         let str prog = "gcc";
         // The invocations of gcc share some flags across platforms
 
-        let vec[str] common_cflags =
-            ["-fno-strict-aliasing", "-fPIC", "-Wall", "-fno-rtti",
-             "-fno-exceptions", "-g"];
-        let vec[str] common_libs =
-            [stage, "-Lrustllvm", "-Lrt", "-lrustrt", "-lrustllvm", "-lstd",
-             "-lm"];
+        let vec[str] common_args = [stage, "-Lrt", "-lrustrt",
+         "-fno-strict-aliasing", "-fPIC", "-Wall",
+         "-fno-rtti", "-fno-exceptions", "-g", glu, "-o",
+         saved_out_filename, saved_out_filename + ".o"];
+
+       auto shared_cmd;
+
         alt (sess.get_targ_cfg().os) {
             case (session::os_win32) {
-                gcc_args =
-                    common_cflags +
-                        ["-march=i686", "-O2", glu, main, "-o",
-                         saved_out_filename, saved_out_filename + ".o"] +
-                        common_libs;
+                shared_cmd = "-shared";
+                gcc_args = common_args + ["-march=i686", "-O2"];
             }
             case (session::os_macos) {
-                gcc_args =
-                    common_cflags +
-                        ["-arch i386", "-O0", "-m32", glu, main, "-o",
-                         saved_out_filename, saved_out_filename + ".o"] +
-                        common_libs;
+                shared_cmd = "-dynamiclib";
+                gcc_args = common_args + ["-arch i386", "-O0", "-m32"];
             }
             case (session::os_linux) {
-                gcc_args =
-                    common_cflags +
-                        ["-march=i686", "-O2", "-m32", glu, main, "-o",
-                         saved_out_filename, saved_out_filename + ".o"] +
-                        common_libs;
+                shared_cmd = "-shared";
+                gcc_args = common_args + ["-march=i686", "-O2", "-m32"];
             }
         }
-        // We run 'gcc' here
+        if (sopts.shared) {
+           gcc_args += [shared_cmd];
+        } else {
+           gcc_args += ["-Lrustllvm", "-lrustllvm", "-lstd", "-lm", main];
+        }
 
+        // We run 'gcc' here
         run::run_program(prog, gcc_args);
         // Clean up on Darwin
 

src/comp/front/ast.rs

@@ -359,19 +359,17 @@ tag constr_arg_general_[T] { carg_base; carg_ident(T); carg_lit(@lit); }
 
 type constr_arg = constr_arg_general[uint];
 
-type constr_arg_use = constr_arg_general[ident];
-
 type constr_arg_general[T] = spanned[constr_arg_general_[T]];
 
+type constr_ = rec(path path,
+                   vec[@constr_arg_general[uint]] args,
+                   ann ann);
 
-// The ann field is there so that using the def_map in the type
-// context, we can get the def_id for the path.
-type constr_general[T] =
-    rec(path path, vec[@constr_arg_general[T]] args, ann ann);
-
-type constr = spanned[constr_general[uint]];
+type constr = spanned[constr_];
 
-type constr_use = spanned[constr_general[ident]];
+/* The parser generates ast::constrs; resolve generates
+ a mapping from each function to a list of ty::constr_defs,
+ corresponding to these. */
 
 type arg = rec(mode mode, @ty ty, ident ident, def_id id);
 

src/comp/front/creader.rs

@@ -78,8 +78,8 @@ fn parse_ty_or_bang(@pstate st, str_def sd) -> ty_or_bang {
     }
 }
 
-fn parse_constrs(@pstate st, str_def sd) -> vec[@ast::constr] {
-    let vec[@ast::constr] res = [];
+fn parse_constrs(@pstate st, str_def sd) -> vec[@ty::constr_def] {
+    let vec[@ty::constr_def] res = [];
     alt (peek(st) as char) {
         case (':') {
             do  {
@@ -92,7 +92,7 @@ fn parse_constrs(@pstate st, str_def sd) -> vec[@ast::constr] {
     ret res;
 }
 
-fn parse_constr(@pstate st, str_def sd) -> @ast::constr {
+fn parse_constr(@pstate st, str_def sd) -> @ty::constr_def {
     st.tcx.sess.unimpl("Reading constraints " + " isn't implemented");
     /*
     let vec[@ast::constr_arg] args = [];
@@ -318,7 +318,7 @@ fn parse_hex(@pstate st) -> uint {
 }
 
 fn parse_ty_fn(@pstate st, str_def sd) ->
-   tup(vec[ty::arg], ty::t, ast::controlflow, vec[@ast::constr]) {
+   tup(vec[ty::arg], ty::t, ast::controlflow, vec[@ty::constr_def]) {
     assert (next(st) as char == '[');
     let vec[ty::arg] inputs = [];
     while (peek(st) as char != ']') {

src/comp/front/parser.rs

@@ -5,6 +5,9 @@ import std::str;
 import std::option;
 import std::option::some;
 import std::option::none;
+import std::either;
+import std::either::left;
+import std::either::right;
 import std::map::hashmap;
 import driver::session;
 import util::common;
@@ -816,14 +819,9 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
         hi = es.span.hi;
         ex = ast::expr_bind(e, es.node, p.get_ann());
     } else if (p.peek() == token::POUND) {
-        p.bump();
-        auto pth = parse_path(p);
-        auto es =
-            parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
-                      parse_expr, p);
-        hi = es.span.hi;
-        auto ext_span = rec(lo=lo, hi=hi);
-        ex = expand_syntax_ext(p, ext_span, pth, es.node, none);
+        auto ex_ext = parse_syntax_ext(p);
+        lo = ex_ext.span.lo;
+        ex = ex_ext.node;
     } else if (eat_word(p, "fail")) {
         auto msg;
         alt (p.peek()) {
@@ -917,6 +915,21 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
     ret @spanned(lo, hi, ex);
 }
 
+fn parse_syntax_ext(&parser p) -> @ast::expr {
+    auto lo = p.get_lo_pos();
+    expect(p, token::POUND);
+    ret parse_syntax_ext_inner(p, lo);
+}
+
+fn parse_syntax_ext_inner(&parser p, uint lo) -> @ast::expr {
+    auto pth = parse_path(p);
+    auto es = parse_seq(token::LPAREN, token::RPAREN,
+                        some(token::COMMA), parse_expr, p);
+    auto hi = es.span.hi;
+    auto ext_span = rec(lo=lo, hi=hi);
+    auto ex = expand_syntax_ext(p, ext_span, pth, es.node, none);
+    ret @spanned(lo, hi, ex);
+}
 
 /*
  * FIXME: This is a crude approximation of the syntax-extension system,
@@ -1423,7 +1436,22 @@ fn parse_source_stmt(&parser p) -> @ast::stmt {
         auto hi = p.get_span();
         ret @spanned(lo, decl.span.hi, ast::stmt_decl(decl, p.get_ann()));
     } else {
-        alt (parse_item(p, [])) {
+
+        auto item_attrs;
+        alt (parse_attrs_or_ext(p)) {
+            case (none) {
+                item_attrs = [];
+            }
+            case (some(left(?attrs))) {
+                item_attrs = attrs;
+            }
+            case (some(right(?ext))) {
+                ret @spanned(lo, ext.span.hi,
+                             ast::stmt_expr(ext, p.get_ann()));
+            }
+        }
+
+        alt (parse_item(p, item_attrs)) {
             case (got_item(?i)) {
                 auto hi = i.span.hi;
                 auto decl = @spanned(lo, hi, ast::decl_item(i));
@@ -1936,6 +1964,26 @@ fn parse_item(&parser p, vec[ast::attribute] attrs) -> parsed_item {
     } else { ret no_item; }
 }
 
+// A type to distingush between the parsing of item attributes or syntax
+// extensions, which both begin with token.POUND
+type attr_or_ext = option::t[either::t[vec[ast::attribute],
+                                       @ast::expr]];
+
+fn parse_attrs_or_ext(&parser p) -> attr_or_ext {
+    if (p.peek() == token::POUND) {
+        auto lo = p.get_lo_pos();
+        p.bump();
+        if (p.peek() == token::LBRACKET) {
+            auto first_attr = parse_attribute_inner(p, lo);
+            ret some(left([first_attr] + parse_attributes(p)));
+        } else {
+            ret some(right(parse_syntax_ext_inner(p, lo)));
+        }
+    } else {
+        ret none;
+    }
+}
+
 fn parse_attributes(&parser p) -> vec[ast::attribute] {
     let vec[ast::attribute] attrs = [];
     while (p.peek() == token::POUND) { attrs += [parse_attribute(p)]; }
@@ -1945,6 +1993,10 @@ fn parse_attributes(&parser p) -> vec[ast::attribute] {
 fn parse_attribute(&parser p) -> ast::attribute {
     auto lo = p.get_lo_pos();
     expect(p, token::POUND);
+    ret parse_attribute_inner(p, lo);
+}
+
+fn parse_attribute_inner(&parser p, uint lo) -> ast::attribute {
     expect(p, token::LBRACKET);
     auto meta_item = parse_meta_item(p);
     expect(p, token::RBRACKET);
@@ -2181,13 +2233,7 @@ fn parse_crate_directive(&parser p) -> ast::crate_directive {
         auto hi = p.get_hi_pos();
         expect(p, token::RBRACE);
         ret spanned(lo, hi, ast::cdir_let(id, x, v));
-    } else if (is_word(p, "use")) {
-        auto vi = parse_view_item(p);
-        ret spanned(lo, vi.span.hi, ast::cdir_view_item(vi));
-    } else if (is_word(p, "import")) {
-        auto vi = parse_view_item(p);
-        ret spanned(lo, vi.span.hi, ast::cdir_view_item(vi));
-    } else if (is_word(p, "export")) {
+    } else if (is_view_item(p)) {
         auto vi = parse_view_item(p);
         ret spanned(lo, vi.span.hi, ast::cdir_view_item(vi));
     } else {