---

yaml
---
r: 3036
b: refs/heads/master
c: f6d7d75
h: refs/heads/master
v: v3

Author: lkuper

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 1d1010cac090e1b2d79500e32144a2e87c39e13e
+refs/heads/master: f6d7d756993c9dbba9134683397fff600deb3f00

trunk/src/comp/middle/typeck.rs

@@ -2287,21 +2287,13 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
             alt (anon_obj.with_obj) {
                 case (none) { }
                 case (some(?e)) {
-                    // This had better have object type.  TOOD: report an
+                    // This had better have object type.  TODO: report an
                     // error if the user is trying to extend a non-object
                     // with_obj.
                     check_expr(fcx, e);
                 }
             }
 
-            // Typecheck the methods.
-            for (@ast::method method in anon_obj.methods) {
-                check_method(fcx.ccx, method);
-            }
-
-            auto t = next_ty_var(fcx);
-
-
             // FIXME: These next three functions are largely ripped off from
             // similar ones in collect::.  Is there a better way to do this?
 
@@ -2328,11 +2320,28 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
                                                   anon_obj.methods);
             }
 
-            auto methods = get_anon_obj_method_types(fcx.ccx, anon_obj);
+            auto method_types = get_anon_obj_method_types(fcx.ccx, anon_obj);
             auto ot = ty::mk_obj(fcx.ccx.tcx,
-                                 ty::sort_methods(methods));
+                                 ty::sort_methods(method_types));
             write::ty_only_fixup(fcx, a.id, ot);
 
+            // Write the methods into the node type table.  (This happens in
+            // collect::convert for regular objects.)
+            auto i = 0u;
+            while (i < vec::len[@ast::method](anon_obj.methods)) {
+                write::ty_only(fcx.ccx.tcx, anon_obj.methods.(i).node.ann.id,
+                               ty::method_ty_to_fn_ty(fcx.ccx.tcx,
+                                                      method_types.(i)));
+                i += 1u;
+            }
+
+            // Typecheck the methods.
+            for (@ast::method method in anon_obj.methods) {
+                check_method(fcx.ccx, method);
+            }
+
+            auto t = next_ty_var(fcx);
+
             // Now remove the info from the stack.
             vec::pop[obj_info](fcx.ccx.obj_infos);
         }

trunk/src/rt/rust.cpp

@@ -120,6 +120,6 @@ rust_start(uintptr_t main_fn, int argc, char **argv, void* crate_map) {
 // indent-tabs-mode: nil
 // c-basic-offset: 4
 // buffer-file-coding-system: utf-8-unix
-// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
+// compile-command: "make -k -C .. 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
 // End:
 //

trunk/src/rt/rust_log.cpp

@@ -176,7 +176,7 @@ size_t parse_logging_spec(char* spec, log_directive* dirs) {
 }
 
 void update_module_map(const mod_entry* map, log_directive* dirs,
-                       size_t n_dirs, size_t *n_matches) {
+                       size_t n_dirs) {
     for (const mod_entry* cur = map; cur->name; cur++) {
         size_t level = default_log_level, longest_match = 0;
         for (size_t d = 0; d < n_dirs; d++) {
@@ -187,28 +187,18 @@ void update_module_map(const mod_entry* map, log_directive* dirs,
             }
         }
         *cur->state = level;
-        (*n_matches)++;
     }
 }
 
 void update_crate_map(const cratemap* map, log_directive* dirs,
-                      size_t n_dirs, size_t *n_matches) {
+                      size_t n_dirs) {
     // First update log levels for this crate
-    update_module_map(map->entries, dirs, n_dirs, n_matches);
+    update_module_map(map->entries, dirs, n_dirs);
     // Then recurse on linked crates
     // FIXME this does double work in diamond-shaped deps. could keep
     //   a set of visited addresses, if it turns out to be actually slow
     for (size_t i = 0; map->children[i]; i++) {
-        update_crate_map(map->children[i], dirs, n_dirs, n_matches);
-    }
-}
-
-void print_crate_log_map(const cratemap* map) {
-    for (const mod_entry* cur = map->entries; cur->name; cur++) {
-        printf("  %s\n", cur->name);
-    }
-    for (size_t i = 0; map->children[i]; i++) {
-        print_crate_log_map(map->children[i]);
+        update_crate_map(map->children[i], dirs, n_dirs);
     }
 }
 
@@ -228,61 +218,33 @@ size_t log_rt_kern;
 size_t log_rt_backtrace;
 
 static const mod_entry _rt_module_map[] =
-    {{"::rt::mem", &log_rt_mem},
-     {"::rt::comm", &log_rt_comm},
-     {"::rt::task", &log_rt_task},
-     {"::rt::dom", &log_rt_dom},
-     {"::rt::trace", &log_rt_trace},
-     {"::rt::cache", &log_rt_cache},
-     {"::rt::upcall", &log_rt_upcall},
-     {"::rt::timer", &log_rt_timer},
-     {"::rt::gc", &log_rt_gc},
-     {"::rt::stdlib", &log_rt_stdlib},
-     {"::rt::kern", &log_rt_kern},
-     {"::rt::backtrace", &log_rt_backtrace},
+    {{"rt::mem", &log_rt_mem},
+     {"rt::comm", &log_rt_comm},
+     {"rt::task", &log_rt_task},
+     {"rt::dom", &log_rt_dom},
+     {"rt::trace", &log_rt_trace},
+     {"rt::cache", &log_rt_cache},
+     {"rt::upcall", &log_rt_upcall},
+     {"rt::timer", &log_rt_timer},
+     {"rt::gc", &log_rt_gc},
+     {"rt::stdlib", &log_rt_stdlib},
+     {"rt::kern", &log_rt_kern},
+     {"rt::backtrace", &log_rt_backtrace},
      {NULL, NULL}};
 
 void update_log_settings(void* crate_map, char* settings) {
     char* buffer = NULL;
     log_directive dirs[256];
     size_t n_dirs = 0;
-
     if (settings) {
-
-        if (strcmp(settings, "::help") == 0 ||
-            strcmp(settings, "?") == 0) {
-            printf("\nCrate log map:\n\n");
-            print_crate_log_map((const cratemap*)crate_map);
-            printf("\n");
-            exit(1);
-        }
-
         size_t buflen = strlen(settings) + 1;
         buffer = (char*)malloc(buflen);
         strncpy(buffer, settings, buflen);
         n_dirs = parse_logging_spec(buffer, &dirs[0]);
     }
 
-    size_t n_matches = 0;
-    update_module_map(_rt_module_map, &dirs[0], n_dirs, &n_matches);
-    update_crate_map((const cratemap*)crate_map, &dirs[0],
-                     n_dirs, &n_matches);
-
-    if (n_matches < n_dirs) {
-        printf("warning: got %d RUST_LOG specs, enabled %d flags.",
-               n_dirs, n_matches);
-    }
+    update_module_map(_rt_module_map, &dirs[0], n_dirs);
+    update_crate_map((const cratemap*)crate_map, &dirs[0], n_dirs);
 
     free(buffer);
 }
-
-//
-// Local Variables:
-// mode: C++
-// fill-column: 78;
-// indent-tabs-mode: nil
-// c-basic-offset: 4
-// buffer-file-coding-system: utf-8-unix
-// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
-// End:
-//