---

yaml
---
r: 3127
b: refs/heads/master
c: 89ba649
h: refs/heads/master
i:
  3125: 9ed50af
  3123: ab1120a
  3119: 89f72a6
v: v3

Author: Eric Holk

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: b8a5440b2de600c47ed9c9c3d7a376807b57a579
+refs/heads/master: 89ba649c3a4f61d6f33c9f5541a92f44e46eb69c

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

@@ -2181,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 {