More keyword paring and migration in runtime, docs, code modes.

11 files changed, 116 insertions, 110 deletions

diff --git a/RELEASES.txt b/RELEASES.txt
index c39ecf2391b..303789f5536 100644
--- a/RELEASES.txt
+++ b/RELEASES.txt
@@ -23,8 +23,10 @@ Version 0.3  (June 2012) - not yet!
     * Type reflection
 
   * Removal of various obsolete features
-    * Keywords: be, prove, syntax, note, mutable, do, bind
-    * Constructs: do-while loops, fn binding, resources
+    * Keywords: 'be', 'prove', 'syntax', 'note', 'mutable',
+                'bind', 'crust', 'native' (now 'extern')
+    * Constructs: do-while loops ('do' repurposed),
+                  fn binding, resources
 
   * Compiler reorganization
     * Syntax-layer of compiler split into separate crate
@@ -39,7 +41,7 @@ Version 0.3  (June 2012) - not yet!
     * Extensive work on libuv interface
     * Much vector code moved to libraries
     * Syntax extensions: #line, #col, #file, #mod,
-      #stringify, #include, #include_str, #include_bin.
+      #stringify, #include, #include_str, #include_bin
 
   * Tool improvements
     * Cargo automatically resolves dependencies
diff --git a/doc/lib/codemirror-rust.js b/doc/lib/codemirror-rust.js
index 626351e236c..6a1ec766453 100644
--- a/doc/lib/codemirror-rust.js
+++ b/doc/lib/codemirror-rust.js
@@ -7,12 +7,12 @@ CodeMirror.defineMode("rust", function() {
     "let": "let", "fn": "fn", "for": "for", "alt": "alt", "iface": "iface",
     "impl": "impl", "type": "type", "enum": "enum", "mod": "mod",
     "as": "op", "true": "atom", "false": "atom", "assert": "op", "check": "op",
-    "claim": "op", "native": "ignore", "unsafe": "ignore", "import": "else-style",
+    "claim": "op", "extern": "ignore", "unsafe": "ignore", "import": "else-style",
     "export": "else-style", "copy": "op", "log": "op", "log_err": "op",
     "use": "op", "bind": "op", "self": "atom"
   };
   var typeKeywords = function() {
-    var keywords = {"fn": "fn", "block": "fn", "obj": "obj"};
+    var keywords = {"fn": "fn"};
     var atoms = "bool uint int i8 i16 i32 i64 u8 u16 u32 u64 float f32 f64 str char".split(" ");
     for (var i = 0, e = atoms.length; i < e; ++i) keywords[atoms[i]] = "atom";
     return keywords;
diff --git a/doc/rust.md b/doc/rust.md
index bb9da7aaf9b..697dd3cb48a 100644
--- a/doc/rust.md
+++ b/doc/rust.md
@@ -210,17 +210,16 @@ The keywords in [source files](#source-files) are the following strings:
 
 ~~~~~~~~ {.keyword}
 alt assert
-be break
-check claim class const cont copy crust
+break
+check claim class const cont copy
 drop
-else enum export
+else enum export extern
 fail false fn for
 if iface impl import
 let log loop
 mod mut
-native new
 pure
-resource ret
+ret
 true trait type
 unchecked unsafe
 while
@@ -575,7 +574,7 @@ of [attributes](#attributes) attached to it.
 
 ~~~~~~~~ {.ebnf .gram}
 item : mod_item | fn_item | type_item | enum_item
-     | res_item | iface_item | impl_item | native_mod_item ;
+     | res_item | iface_item | impl_item | foreign_mod_item ;
 ~~~~~~~~
 
 An _item_ is a component of a crate; some module items can be defined in crate
@@ -1039,29 +1038,29 @@ Similarly, [interface](#interfaces) bounds can be specified for type
 parameters to allow methods of that interface to be called on values
 of that type.
 
-#### Crust functions
+#### Extern functions
 
-Crust functions are part of Rust's foreign function interface,
-providing the opposite functionality to [native modules](#native-modules).
-Whereas native modules allow Rust code to call foreign
-code, crust functions allow foreign code to call Rust code. They are
-defined the same as any other Rust function, except that they are
-prepended with the `crust` keyword.
+Extern functions are part of Rust's foreign function interface, providing
+the opposite functionality to [foreign modules](#foreign-modules). Whereas
+foreign modules allow Rust code to call foreign code, extern functions with
+bodies defined in Rust code _can be called by foreign code_. They are defined the
+same as any other Rust function, except that they are prepended with the
+`extern` keyword.
 
 ~~~
-crust fn new_vec() -> [int] { [] }
+extern fn new_vec() -> [int] { [] }
 ~~~
 
-Crust functions may not be called from Rust code, but their value
+Extern functions may not be called from Rust code, but their value
 may be taken as an unsafe `u8` pointer.
 
 ~~~
-# crust fn new_vec() -> [int] { [] }
+# extern fn new_vec() -> [int] { [] }
 let fptr: *u8 = new_vec;
 ~~~
 
-The primary motivation of crust functions is to create callbacks
-for native functions that expect to receive function pointers.
+The primary motivation of extern functions is to create callbacks
+for foreign functions that expect to receive function pointers.
 
 ### Type definitions
 
@@ -1298,49 +1297,51 @@ impl of seq<bool> for u32 {
 }
 ~~~~
 
-### Native modules
+### Foreign modules
 
 ~~~ {.ebnf .gram}
-native_mod_item : "native mod" ident '{' native_mod '} ;
-native_mod : [ native_fn ] * ;
+foreign_mod_item : "extern mod" ident '{' foreign_mod '} ;
+foreign_mod : [ foreign_fn ] * ;
 ~~~
 
-Native modules form the basis for Rust's foreign function interface. A native
-module describes functions in external, non-Rust libraries. Functions within
-native modules are declared the same as other Rust functions, with the exception
-that they may not have a body and are instead terminated by a semi-colon.
+Foreign modules form the basis for Rust's foreign function interface. A
+foreign module describes functions in external, non-Rust
+libraries. Functions within foreign modules are declared the same as other
+Rust functions, with the exception that they may not have a body and are
+instead terminated by a semi-colon.
 
 ~~~
 # import libc::{c_char, FILE};
 # #[nolink]
 
-native mod c {
+extern mod c {
     fn fopen(filename: *c_char, mode: *c_char) -> *FILE;
 }
 ~~~
 
-Functions within native modules may be called by Rust code as it would any
+Functions within foreign modules may be called by Rust code as it would any
 normal function and the Rust compiler will automatically translate between
-the Rust ABI and the native ABI.
+the Rust ABI and the foreign ABI.
 
-The name of the native module has special meaning to the Rust compiler in
+The name of the foreign module has special meaning to the Rust compiler in
 that it will treat the module name as the name of a library to link to,
 performing the linking as appropriate for the target platform. The name
-given for the native module will be transformed in a platform-specific
-way to determine the name of the library. For example, on Linux the name
-of the native module is prefixed with 'lib' and suffixed with '.so', so
-the native mod 'rustrt' would be linked to a library named 'librustrt.so'.
+given for the foreign module will be transformed in a platform-specific way
+to determine the name of the library. For example, on Linux the name of the
+foreign module is prefixed with 'lib' and suffixed with '.so', so the
+foreign mod 'rustrt' would be linked to a library named 'librustrt.so'.
 
-A number of [attributes](#attributes) control the behavior of native mods.
+A number of [attributes](#attributes) control the behavior of foreign
+modules.
 
-By default native mods assume that the library they are calling use
-the standard C "cdecl" ABI. Other ABI's may be specified using the `abi`
+By default foreign modules assume that the library they are calling use the
+standard C "cdecl" ABI. Other ABI's may be specified using the `abi`
 attribute as in
 
 ~~~{.xfail-test}
 // Interface to the Windows API
 #[abi = "stdcall"]
-native mod kernel32 { }
+extern mod kernel32 { }
 ~~~
 
 The `link_name` attribute allows the default library naming behavior to
@@ -1348,13 +1349,13 @@ be overriden by explicitly specifying the name of the library.
 
 ~~~{.xfail-test}
 #[link_name = "crypto"]
-native mod mycrypto { }
+extern mod mycrypto { }
 ~~~
 
 The `nolink` attribute tells the Rust compiler not to perform any linking
-for the native module. This is particularly useful for creating native
-mods for libc, which tends to not follow standard library naming conventions
-and is linked to all Rust programs anyway.
+for the foreign module. This is particularly useful for creating foreign
+modules for libc, which tends to not follow standard library naming
+conventions and is linked to all Rust programs anyway.
 
 ## Attributes
 
@@ -1752,8 +1753,8 @@ A type cast expression is denoted with the binary operator `as`.
 Executing an `as` expression casts the value on the left-hand side to the type
 on the right-hand side.
 
-A numeric value can be cast to any numeric type.  A native pointer value can
-be cast to or from any integral type or native pointer type.  Any other cast
+A numeric value can be cast to any numeric type.  An unsafe pointer value can
+be cast to or from any integral type or unsafe pointer type.  Any other cast
 is unsupported and will fail to compile.
 
 An example of an `as` expression:
diff --git a/doc/tutorial.md b/doc/tutorial.md
index 7088362388b..3aaa7f30c21 100644
--- a/doc/tutorial.md
+++ b/doc/tutorial.md
@@ -2106,7 +2106,7 @@ OpenSSL libraries installed, it should 'just work'.
 ~~~~ {.xfail-test}
 use std;
 
-native mod crypto {
+extern mod crypto {
     fn SHA1(src: *u8, sz: uint, out: *u8) -> *u8;
 }
 
@@ -2128,20 +2128,23 @@ fn main(args: [str]) {
 }
 ~~~~
 
-## Native modules
+## Foreign modules
 
 Before we can call `SHA1`, we have to declare it. That is what this
 part of the program is responsible for:
 
 ~~~~ {.xfail-test}
-native mod crypto {
+extern mod crypto {
     fn SHA1(src: *u8, sz: uint, out: *u8) -> *u8;
 }
 ~~~~
 
-A `native` module declaration tells the compiler that the program
-should be linked with a library by that name, and that the given list
-of functions are available in that library.
+An `extern` module declaration containing function signatures introduces
+the functions listed as _foreign functions_, that are implemented in some
+other language (usually C) and accessed through Rust's foreign function
+interface (FFI). An extern module like this is called a foreign module, and
+implicitly tells the compiler to link with a library with the same name as
+the module, and that it will find the foreign functions in that library.
 
 In this case, it'll change the name `crypto` to a shared library name
 in a platform-specific way (`libcrypto.so` on Linux, for example), and
@@ -2150,38 +2153,38 @@ actual library, you can use the `"link_name"` attribute, like:
 
 ~~~~ {.xfail-test}
 #[link_name = "crypto"]
-native mod something {
+extern mod something {
     fn SHA1(src: *u8, sz: uint, out: *u8) -> *u8;
 }
 ~~~~
 
-## Native calling conventions
+## Foreign calling conventions
 
-Most native C code use the cdecl calling convention, so that is what
-Rust uses by default when calling native functions. Some native functions,
-most notably the Windows API, use other calling conventions, so Rust
-provides a way to hint to the compiler which is expected by using
-the `"abi"` attribute:
+Most foreign code will be C code, which usually uses the `cdecl` calling
+convention, so that is what Rust uses by default when calling foreign
+functions. Some foreign functions, most notably the Windows API, use other
+calling conventions, so Rust provides a way to hint to the compiler which
+is expected by using the `"abi"` attribute:
 
 ~~~~
 #[cfg(target_os = "win32")]
 #[abi = "stdcall"]
-native mod kernel32 {
+extern mod kernel32 {
     fn SetEnvironmentVariableA(n: *u8, v: *u8) -> int;
 }
 ~~~~
 
-The `"abi"` attribute applies to a native mod (it can not be applied
+The `"abi"` attribute applies to a foreign module (it can not be applied
 to a single function within a module), and must be either `"cdecl"`
 or `"stdcall"`. Other conventions may be defined in the future.
 
 ## Unsafe pointers
 
-The native `SHA1` function is declared to take three arguments, and
+The foreign `SHA1` function is declared to take three arguments, and
 return a pointer.
 
 ~~~~ {.xfail-test}
-# native mod crypto {
+# extern mod crypto {
 fn SHA1(src: *u8, sz: uint, out: *u8) -> *u8;
 # }
 ~~~~
@@ -2295,7 +2298,7 @@ use std;
 type timeval = {mut tv_sec: uint,
                 mut tv_usec: uint};
 #[nolink]
-native mod libc {
+extern mod libc {
     fn gettimeofday(tv: *timeval, tz: *()) -> i32;
 }
 fn unix_time_in_microseconds() -> u64 unsafe {
@@ -2307,8 +2310,8 @@ fn unix_time_in_microseconds() -> u64 unsafe {
 # fn main() { assert #fmt("%?", unix_time_in_microseconds()) != ""; }
 ~~~~
 
-The `#[nolink]` attribute indicates that there's no native library to link
-in. The standard C library is already linked with Rust programs.
+The `#[nolink]` attribute indicates that there's no foreign library to
+link in. The standard C library is already linked with Rust programs.
 
 A `timeval`, in C, is a struct with two 32-bit integers. Thus, we
 define a record type with the same contents, and declare
diff --git a/src/etc/emacs/rust-mode.el b/src/etc/emacs/rust-mode.el
index 412a43d796e..e8240ae7faf 100644
--- a/src/etc/emacs/rust-mode.el
+++ b/src/etc/emacs/rust-mode.el
@@ -52,21 +52,21 @@
 (defvar rust-punc-chars "()[].,{}:;")
 (defvar rust-value-keywords
   (let ((table (make-hash-table :test 'equal)))
-    (dolist (word '("mod" "type" "resource" "fn" "enum" "iface" "impl"))
+    (dolist (word '("mod" "const" "class" "type"
+					"trait" "fn" "enum" "iface"
+					"impl"))
       (puthash word 'def table))
     (dolist (word '("assert"
-                    "be" "break"
-                    "check" "claim" "class" "const" "cont" "copy" "crust"
+                    "break"
+                    "check" "claim" "cont" "copy"
                     "drop"
-                    "else" "export"
+                    "else" "export" "extern"
                     "fail" "for"
                     "if" "import"
                     "let" "log" "loop"
-                    "mut"
-                    "native" "new"
+                    "new"
                     "pure"
                     "ret"
-                    "trait"
                     "unchecked" "unsafe"
                     "while"))
       (puthash word t table))
diff --git a/src/etc/vim/syntax/rust.vim b/src/etc/vim/syntax/rust.vim
index 94b889e010f..7c339ed0856 100644
--- a/src/etc/vim/syntax/rust.vim
+++ b/src/etc/vim/syntax/rust.vim
@@ -14,21 +14,21 @@ if !exists("main_syntax")
   let main_syntax='rust'
 endif
 
-syn keyword   rustKeyword     alt as assert be bind break
-syn keyword   rustKeyword     check claim cont const copy else export fail
-syn keyword   rustKeyword     for if impl import in inline lambda let log
-syn keyword   rustKeyword     loop mod mut mutable native note of prove pure
-syn keyword   rustKeyword     ret self syntax to unchecked
+syn keyword   rustKeyword     alt as assert break
+syn keyword   rustKeyword     check claim cont const copy else export extern fail
+syn keyword   rustKeyword     for if impl import in let log
+syn keyword   rustKeyword     loop mod mut of pure
+syn keyword   rustKeyword     ret self to unchecked
 syn keyword   rustKeyword     unsafe use while with
 " FIXME: Scoped impl's name is also fallen in this category
-syn keyword   rustKeyword     mod iface resource class enum type nextgroup=rustIdentifier skipwhite
+syn keyword   rustKeyword     mod iface trait class enum type nextgroup=rustIdentifier skipwhite
 syn keyword   rustKeyword     fn nextgroup=rustFuncName skipwhite
 
 syn match     rustIdentifier  "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
 syn match     rustFuncName    "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
 
 " Reserved words
-syn keyword   rustKeyword     m32 m64 m128 f80 f16 f128 class trait
+syn keyword   rustKeyword     m32 m64 m128 f80 f16 f128
 
 syn keyword   rustType        any int uint float char bool u8 u16 u32 u64 f32
 syn keyword   rustType        f64 i8 i16 i32 i64 str
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 0586a3c2d52..8ab37e95d21 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -285,7 +285,7 @@ fn restricted_keyword_table() -> hashmap<str, ()> {
     let keys = [
         "alt",
         "assert",
-        "be", "break",
+        "break",
         "check", "claim", "class", "const", "cont", "copy", "crust",
         "do", "drop",
         "else", "enum", "export", "extern",
diff --git a/src/rt/rust_builtin.cpp b/src/rt/rust_builtin.cpp
index ad729494c45..38e387735f9 100644
--- a/src/rt/rust_builtin.cpp
+++ b/src/rt/rust_builtin.cpp
@@ -1,4 +1,4 @@
-/* Native builtins. */
+/* Foreign builtins. */
 
 #include "rust_sched_loop.h"
 #include "rust_task.h"
diff --git a/src/rt/rust_task.h b/src/rt/rust_task.h
index 2a58725c6a4..e46b624c936 100644
--- a/src/rt/rust_task.h
+++ b/src/rt/rust_task.h
@@ -10,7 +10,7 @@
    * Managing the dynamically resizing list of Rust stack segments
 
    * Switching between running Rust code on the Rust segmented stack and
-   native C code on large stacks owned by the scheduler
+   foreign C code on large stacks owned by the scheduler
 
    The lifetime of a rust_task object closely mirrors that of a running Rust
    task object, but they are not identical. In particular, the rust_task is an
diff --git a/src/rt/rust_upcall.cpp b/src/rt/rust_upcall.cpp
index fae3e7e2943..965d38fa70c 100644
--- a/src/rt/rust_upcall.cpp
+++ b/src/rt/rust_upcall.cpp
@@ -40,7 +40,7 @@ extern "C" void record_sp_limit(void *limit);
 
 /**********************************************************************
  * Switches to the C-stack and invokes |fn_ptr|, passing |args| as argument.
- * This is used by the C compiler to call native functions and by other
+ * This is used by the C compiler to call foreign functions and by other
  * upcalls to switch to the C stack.  The return value is passed through a
  * field in the args parameter. This upcall is specifically for switching
  * to the shim functions generated by rustc.
@@ -58,7 +58,7 @@ upcall_call_shim_on_c_stack(void *args, void *fn_ptr) {
         task->call_on_c_stack(args, fn_ptr);
     } catch (...) {
         // Logging here is not reliable
-        assert(false && "Native code threw an exception");
+        assert(false && "Foreign code threw an exception");
     }
 
     task->record_stack_limit();
diff --git a/src/rt/rust_uv.cpp b/src/rt/rust_uv.cpp
index 0ad59a73161..1873ae33e9c 100644
--- a/src/rt/rust_uv.cpp
+++ b/src/rt/rust_uv.cpp
@@ -8,11 +8,11 @@
 #include "rust_log.h"
 #include "uv.h"
 
-// crust fn pointers
-typedef void (*crust_async_op_cb)(uv_loop_t* loop, void* data,
+// extern fn pointers
+typedef void (*extern_async_op_cb)(uv_loop_t* loop, void* data,
         uv_async_t* op_handle);
-typedef void (*crust_simple_cb)(uint8_t* id_buf, void* loop_data);
-typedef void (*crust_close_cb)(uint8_t* id_buf, void* handle,
+typedef void (*extern_simple_cb)(uint8_t* id_buf, void* loop_data);
+typedef void (*extern_close_cb)(uint8_t* id_buf, void* handle,
         void* data);
 
 // data types
@@ -20,8 +20,8 @@ typedef void (*crust_close_cb)(uint8_t* id_buf, void* handle,
 
 struct handle_data {
     uint8_t id_buf[RUST_UV_HANDLE_LEN];
-    crust_simple_cb cb;
-    crust_close_cb close_cb;
+    extern_simple_cb cb;
+    extern_close_cb close_cb;
 };
 
 // helpers
@@ -37,7 +37,7 @@ current_kernel_free(void* ptr) {
 }
 
 static handle_data*
-new_handle_data_from(uint8_t* buf, crust_simple_cb cb) {
+new_handle_data_from(uint8_t* buf, extern_simple_cb cb) {
     handle_data* data = (handle_data*)current_kernel_malloc(
             sizeof(handle_data),
             "handle_data");
@@ -48,39 +48,39 @@ new_handle_data_from(uint8_t* buf, crust_simple_cb cb) {
 
 // libuv callback impls
 static void
-native_crust_async_op_cb(uv_async_t* handle, int status) {
-    crust_async_op_cb cb = (crust_async_op_cb)handle->data;
+foreign_extern_async_op_cb(uv_async_t* handle, int status) {
+    extern_async_op_cb cb = (extern_async_op_cb)handle->data;
     void* loop_data = handle->loop->data;
     cb(handle->loop, loop_data, handle);
 }
 
 static void
-native_async_cb(uv_async_t* handle, int status) {
+foreign_async_cb(uv_async_t* handle, int status) {
     handle_data* handle_d = (handle_data*)handle->data;
     void* loop_data = handle->loop->data;
     handle_d->cb(handle_d->id_buf, loop_data);
 }
 
 static void
-native_timer_cb(uv_timer_t* handle, int status) {
+foreign_timer_cb(uv_timer_t* handle, int status) {
     handle_data* handle_d = (handle_data*)handle->data;
     void* loop_data = handle->loop->data;
     handle_d->cb(handle_d->id_buf, loop_data);
 }
 
 static void
-native_close_cb(uv_handle_t* handle) {
+foreign_close_cb(uv_handle_t* handle) {
     handle_data* data = (handle_data*)handle->data;
     data->close_cb(data->id_buf, handle, handle->loop->data);
 }
 
 static void
-native_close_op_cb(uv_handle_t* op_handle) {
+foreign_close_op_cb(uv_handle_t* op_handle) {
     current_kernel_free(op_handle);
     // uv_run() should return after this..
 }
 
-// native fns bound in rust
+// foreign fns bound in rust
 extern "C" void
 rust_uv_free(void* ptr) {
     current_kernel_free(ptr);
@@ -122,11 +122,11 @@ rust_uv_loop_set_data(uv_loop_t* loop, void* data) {
 }
 
 extern "C" void*
-rust_uv_bind_op_cb(uv_loop_t* loop, crust_async_op_cb cb) {
+rust_uv_bind_op_cb(uv_loop_t* loop, extern_async_op_cb cb) {
     uv_async_t* async = (uv_async_t*)current_kernel_malloc(
             sizeof(uv_async_t),
             "uv_async_t");
-    uv_async_init(loop, async, native_crust_async_op_cb);
+    uv_async_init(loop, async, foreign_extern_async_op_cb);
     async->data = (void*)cb;
     // decrement the ref count, so that our async bind
     // doesn't count towards keeping the loop alive
@@ -136,7 +136,7 @@ rust_uv_bind_op_cb(uv_loop_t* loop, crust_async_op_cb cb) {
 
 extern "C" void
 rust_uv_stop_op_cb(uv_handle_t* op_handle) {
-    uv_close(op_handle, native_close_op_cb);
+    uv_close(op_handle, foreign_close_op_cb);
 }
 
 extern "C" void
@@ -150,10 +150,10 @@ rust_uv_close(uv_handle_t* handle, uv_close_cb cb) {
 }
 
 extern "C" void
-rust_uv_hilvl_close(uv_handle_t* handle, crust_close_cb cb) {
+rust_uv_hilvl_close(uv_handle_t* handle, extern_close_cb cb) {
     handle_data* data = (handle_data*)handle->data;
     data->close_cb = cb;
-    uv_close(handle, native_close_cb);
+    uv_close(handle, foreign_close_cb);
 }
 
 extern "C" void
@@ -181,12 +181,12 @@ rust_uv_async_init(uv_loop_t* loop_handle,
 }
 
 extern "C" void*
-rust_uv_hilvl_async_init(uv_loop_t* loop, crust_simple_cb cb,
+rust_uv_hilvl_async_init(uv_loop_t* loop, extern_simple_cb cb,
         uint8_t* buf) {
     uv_async_t* async = (uv_async_t*)current_kernel_malloc(
             sizeof(uv_async_t),
             "uv_async_t");
-    uv_async_init(loop, async, native_async_cb);
+    uv_async_init(loop, async, foreign_async_cb);
     handle_data* data = new_handle_data_from(buf, cb);
     async->data = data;
 
@@ -194,7 +194,7 @@ rust_uv_hilvl_async_init(uv_loop_t* loop, crust_simple_cb cb,
 }
 
 extern "C" void*
-rust_uv_hilvl_timer_init(uv_loop_t* loop, crust_simple_cb cb,
+rust_uv_hilvl_timer_init(uv_loop_t* loop, extern_simple_cb cb,
         uint8_t* buf) {
     uv_timer_t* new_timer = (uv_timer_t*)current_kernel_malloc(
             sizeof(uv_timer_t),
@@ -209,7 +209,7 @@ rust_uv_hilvl_timer_init(uv_loop_t* loop, crust_simple_cb cb,
 extern "C" void
 rust_uv_hilvl_timer_start(uv_timer_t* the_timer, uint32_t timeout,
         uint32_t repeat) {
-    uv_timer_start(the_timer, native_timer_cb, timeout, repeat);
+    uv_timer_start(the_timer, foreign_timer_cb, timeout, repeat);
 }
 
 extern "C" int