---

yaml
---
r: 3130
b: refs/heads/master
c: 02018fe
h: refs/heads/master
v: v3

Author: Eric Holk

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 14c5900a701bf5d08f9512cbac52a8bf7dc8f4ef
+refs/heads/master: 02018fed427cf3d2954603392712a5822bf7a9b5

trunk/mk/stage3.mk

@@ -1,8 +1,13 @@
-stage3/$(CFG_STDLIB): $(STDLIB_CRATE) $(STDLIB_INPUTS) \
+stage3/std.o: $(STDLIB_CRATE) $(STDLIB_INPUTS) \
               stage2/rustc$(X) stage2/$(CFG_STDLIB) stage2/intrinsics.bc \
               $(LREQ) $(MKFILES)
-	@$(call E, compile_and_link: $@)
-	$(STAGE2)  --shared -o $@ $<
+	@$(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
 
 stage3/librustc.o: $(COMPILER_CRATE) $(COMPILER_INPUTS) $(SREQ2)
 	@$(call E, compile: $@)

trunk/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 = 4u;
+const uint ivec_default_length = 8u;
 
 const uint ivec_elt_len = 0u;
 

trunk/src/comp/back/link.rs

@@ -209,7 +209,7 @@ mod write {
  *
  * There are a few issues to handle:
  *
- *  - Linnkers operate on a flat namespace, so we have to flatten names.
+ *  - Linkers 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 different crates but with same names "within" the crate need
+ *  - Symbols in dirrerent 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 mandatory): name and vers.
+ *  - Consider two exported tags as special (and madatory): 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.
  *

trunk/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 d =
+    auto def_map =
         time(time_passes, "resolution",
              bind resolve::resolve_crate(sess, crate));
-    auto ty_cx = ty::mk_ctxt(sess, d._0, d._1);
+    auto ty_cx = ty::mk_ctxt(sess, def_map);
     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, crate));
+         bind middle::alias::check_crate(@ty_cx, def_map, 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 d = resolve::resolve_crate(sess, crate);
-            auto ty_cx = ty::mk_ctxt(sess, d._0, d._1);
+            auto def_map = resolve::resolve_crate(sess, crate);
+            auto ty_cx = ty::mk_ctxt(sess, def_map);
             typeck::check_crate(ty_cx, crate);
             mode = ppaux::mo_typed(ty_cx);
         }
@@ -399,34 +399,37 @@ fn main(vec[str] args) {
         let str prog = "gcc";
         // The invocations of gcc share some flags across platforms
 
-        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;
-
+        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"];
         alt (sess.get_targ_cfg().os) {
             case (session::os_win32) {
-                shared_cmd = "-shared";
-                gcc_args = common_args + ["-march=i686", "-O2"];
+                gcc_args =
+                    common_cflags +
+                        ["-march=i686", "-O2", glu, main, "-o",
+                         saved_out_filename, saved_out_filename + ".o"] +
+                        common_libs;
             }
             case (session::os_macos) {
-                shared_cmd = "-dynamiclib";
-                gcc_args = common_args + ["-arch i386", "-O0", "-m32"];
+                gcc_args =
+                    common_cflags +
+                        ["-arch i386", "-O0", "-m32", glu, main, "-o",
+                         saved_out_filename, saved_out_filename + ".o"] +
+                        common_libs;
             }
             case (session::os_linux) {
-                shared_cmd = "-shared";
-                gcc_args = common_args + ["-march=i686", "-O2", "-m32"];
+                gcc_args =
+                    common_cflags +
+                        ["-march=i686", "-O2", "-m32", glu, main, "-o",
+                         saved_out_filename, saved_out_filename + ".o"] +
+                        common_libs;
             }
         }
-        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
 

trunk/src/comp/front/ast.rs

@@ -359,17 +359,19 @@ 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);
 
-type constr = spanned[constr_];
+// 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]];
 
-/* The parser generates ast::constrs; resolve generates
- a mapping from each function to a list of ty::constr_defs,
- corresponding to these. */
+type constr_use = spanned[constr_general[ident]];
 
 type arg = rec(mode mode, @ty ty, ident ident, def_id id);
 

trunk/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[@ty::constr_def] {
-    let vec[@ty::constr_def] res = [];
+fn parse_constrs(@pstate st, str_def sd) -> vec[@ast::constr] {
+    let vec[@ast::constr] res = [];
     alt (peek(st) as char) {
         case (':') {
             do  {
@@ -92,7 +92,7 @@ fn parse_constrs(@pstate st, str_def sd) -> vec[@ty::constr_def] {
     ret res;
 }
 
-fn parse_constr(@pstate st, str_def sd) -> @ty::constr_def {
+fn parse_constr(@pstate st, str_def sd) -> @ast::constr {
     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[@ty::constr_def]) {
+   tup(vec[ty::arg], ty::t, ast::controlflow, vec[@ast::constr]) {
     assert (next(st) as char == '[');
     let vec[ty::arg] inputs = [];
     while (peek(st) as char != ']') {

trunk/src/comp/front/parser.rs

@@ -5,9 +5,6 @@ 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;
@@ -819,9 +816,14 @@ 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) {
-        auto ex_ext = parse_syntax_ext(p);
-        lo = ex_ext.span.lo;
-        ex = ex_ext.node;
+        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);
     } else if (eat_word(p, "fail")) {
         auto msg;
         alt (p.peek()) {
@@ -915,21 +917,6 @@ 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,
@@ -1436,22 +1423,7 @@ 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 {
-
-        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)) {
+        alt (parse_item(p, [])) {
             case (got_item(?i)) {
                 auto hi = i.span.hi;
                 auto decl = @spanned(lo, hi, ast::decl_item(i));
@@ -1964,26 +1936,6 @@ 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)]; }
@@ -1993,10 +1945,6 @@ 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);
@@ -2233,7 +2181,13 @@ 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_view_item(p)) {
+    } 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")) {
         auto vi = parse_view_item(p);
         ret spanned(lo, vi.span.hi, ast::cdir_view_item(vi));
     } else {