Change 'native' and 'crust' to 'extern'.

This comes with a terminology change. All linkage-symbols are 'extern'
now, including rust syms in other crates. Some extern ABIs are
merely "foreign". The term "native" is retired, not clear/useful.

What was "crust" is now "extern" applied to a _definition_. This
is a bit of an overloading, but should be unambiguous: it means
that the definition should be made available to some non-rust ABI.

Author: graydon

src/libcore/os.rs

@@ -167,8 +167,8 @@ mod global_env {
                 sched:  some({
                     mode: task::single_threaded,
                     // FIXME (#2621): This would be a good place to use a
-                    // very small native stack
-                    native_stack_size: none
+                    // very small foreign stack
+                    foreign_stack_size: none
                 })
                 with task::get_opts(builder)
             });

src/libcore/task.rs

@@ -104,17 +104,17 @@ Scheduler configuration options
 
 * sched_mode - The operating mode of the scheduler
 
-* native_stack_size - The size of the native stack, in bytes
+* foreign_stack_size - The size of the foreign stack, in bytes
 
-    Rust code runs on Rust-specific stacks. When Rust code calls native code
-    (via functions in native modules) it switches to a typical, large stack
+    Rust code runs on Rust-specific stacks. When Rust code calls foreign code
+    (via functions in foreign modules) it switches to a typical, large stack
     appropriate for running code written in languages like C. By default these
-    native stacks have unspecified size, but with this option their size can
+    foreign stacks have unspecified size, but with this option their size can
     be precisely specified.
 "]
 type sched_opts = {
     mode: sched_mode,
-    native_stack_size: option<uint>
+    foreign_stack_size: option<uint>
 };
 
 #[doc = "
@@ -140,7 +140,7 @@ Task configuration options
     into a new scheduler with the specific properties required.
 
     This is of particular importance for libraries which want to call
-    into native code that blocks. Without doing so in a different
+    into foreign code that blocks. Without doing so in a different
     scheduler other tasks will be impeded or even blocked indefinitely.
 
 "]
@@ -408,7 +408,7 @@ fn spawn_sched(mode: sched_mode, +f: fn~()) {
     set_opts(builder, {
         sched: some({
             mode: mode,
-            native_stack_size: none
+            foreign_stack_size: none
         })
         with get_opts(builder)
     });
@@ -542,8 +542,8 @@ fn spawn_raw(opts: task_opts, +f: fn~()) {
     }
 
     fn new_task_in_new_sched(opts: sched_opts) -> *rust_task {
-        if opts.native_stack_size != none {
-            fail "native_stack_size scheduler option unimplemented";
+        if opts.foreign_stack_size != none {
+            fail "foreign_stack_size scheduler option unimplemented";
         }
 
         let num_threads = alt opts.mode {
@@ -804,7 +804,7 @@ native mod testrt {
 #[test]
 fn test_spawn_sched_blocking() {
 
-    // Testing that a task in one scheduler can block natively
+    // Testing that a task in one scheduler can block in foreign code
     // without affecting other schedulers
     iter::repeat(20u) {||
 
@@ -947,7 +947,7 @@ fn test_osmain() {
     let opts = {
         sched: some({
             mode: osmain,
-            native_stack_size: none
+            foreign_stack_size: none
         })
         with get_opts(buildr)
     };

src/libstd/uv_global_loop.rs

@@ -46,7 +46,7 @@ fn get_monitor_task_gl() -> iotask unsafe {
             supervise: false,
             sched: some({
                 mode: task::single_threaded,
-                native_stack_size: none
+                foreign_stack_size: none
             })
             with task::get_opts(builder)
         });

src/libstd/uv_iotask.rs

@@ -34,7 +34,7 @@ fn spawn_iotask(-builder: task::builder) -> iotask {
     set_opts(builder, {
         sched: some({
             mode: single_threaded,
-            native_stack_size: none
+            foreign_stack_size: none
         })
         with get_opts(builder)
     });

src/libstd/uv_ll.rs

@@ -1314,80 +1314,80 @@ mod test {
     #[test]
     #[ignore(cfg(target_os = "freebsd"))]
     fn test_uv_ll_struct_size_uv_tcp_t() {
-        let native_handle_size = rustrt::rust_uv_helper_uv_tcp_t_size();
+        let foreign_handle_size = rustrt::rust_uv_helper_uv_tcp_t_size();
         let rust_handle_size = sys::size_of::<uv_tcp_t>();
         let output = #fmt("uv_tcp_t -- native: %u rust: %u",
-                          native_handle_size as uint, rust_handle_size);
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
-        assert native_handle_size as uint == rust_handle_size;
+        assert foreign_handle_size as uint == rust_handle_size;
     }
     #[test]
     #[ignore(cfg(target_os = "freebsd"))]
     fn test_uv_ll_struct_size_uv_connect_t() {
-        let native_handle_size =
+        let foreign_handle_size =
             rustrt::rust_uv_helper_uv_connect_t_size();
         let rust_handle_size = sys::size_of::<uv_connect_t>();
         let output = #fmt("uv_connect_t -- native: %u rust: %u",
-                          native_handle_size as uint, rust_handle_size);
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
-        assert native_handle_size as uint == rust_handle_size;
+        assert foreign_handle_size as uint == rust_handle_size;
     }
     #[test]
     #[ignore(cfg(target_os = "freebsd"))]
     fn test_uv_ll_struct_size_uv_buf_t() {
-        let native_handle_size =
+        let foreign_handle_size =
             rustrt::rust_uv_helper_uv_buf_t_size();
         let rust_handle_size = sys::size_of::<uv_buf_t>();
         let output = #fmt("uv_buf_t -- native: %u rust: %u",
-                          native_handle_size as uint, rust_handle_size);
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
-        assert native_handle_size as uint == rust_handle_size;
+        assert foreign_handle_size as uint == rust_handle_size;
     }
     #[test]
     #[ignore(cfg(target_os = "freebsd"))]
     fn test_uv_ll_struct_size_uv_write_t() {
-        let native_handle_size =
+        let foreign_handle_size =
             rustrt::rust_uv_helper_uv_write_t_size();
         let rust_handle_size = sys::size_of::<uv_write_t>();
         let output = #fmt("uv_write_t -- native: %u rust: %u",
-                          native_handle_size as uint, rust_handle_size);
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
-        assert native_handle_size as uint == rust_handle_size;
+        assert foreign_handle_size as uint == rust_handle_size;
     }
 
     #[test]
     #[ignore(cfg(target_os = "freebsd"))]
     fn test_uv_ll_struct_size_sockaddr_in() {
-        let native_handle_size =
+        let foreign_handle_size =
             rustrt::rust_uv_helper_sockaddr_in_size();
         let rust_handle_size = sys::size_of::<sockaddr_in>();
         let output = #fmt("sockaddr_in -- native: %u rust: %u",
-                          native_handle_size as uint, rust_handle_size);
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
-        assert native_handle_size as uint == rust_handle_size;
+        assert foreign_handle_size as uint == rust_handle_size;
     }
 
     #[test]
     #[ignore(cfg(target_os = "freebsd"))]
     fn test_uv_ll_struct_size_uv_async_t() {
-        let native_handle_size =
+        let foreign_handle_size =
             rustrt::rust_uv_helper_uv_async_t_size();
         let rust_handle_size = sys::size_of::<uv_async_t>();
         let output = #fmt("uv_async_t -- native: %u rust: %u",
-                          native_handle_size as uint, rust_handle_size);
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
-        assert native_handle_size as uint == rust_handle_size;
+        assert foreign_handle_size as uint == rust_handle_size;
     }
 
     #[test]
     #[ignore(cfg(target_os = "freebsd"))]
     fn test_uv_ll_struct_size_uv_timer_t() {
-        let native_handle_size =
+        let foreign_handle_size =
             rustrt::rust_uv_helper_uv_timer_t_size();
         let rust_handle_size = sys::size_of::<uv_timer_t>();
         let output = #fmt("uv_timer_t -- native: %u rust: %u",
-                          native_handle_size as uint, rust_handle_size);
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
-        assert native_handle_size as uint == rust_handle_size;
+        assert foreign_handle_size as uint == rust_handle_size;
     }
 }

src/libsyntax/ast.rs

@@ -73,7 +73,7 @@ enum def {
     def_fn(def_id, purity),
     def_self(node_id),
     def_mod(def_id),
-    def_native_mod(def_id),
+    def_foreign_mod(def_id),
     def_const(def_id),
     def_arg(node_id, mode),
     def_local(node_id, bool /* is_mutbl */),
@@ -563,7 +563,7 @@ enum purity {
     pure_fn, // declared with "pure fn"
     unsafe_fn, // declared with "unsafe fn"
     impure_fn, // declared with "fn"
-    crust_fn, // declared with "crust fn"
+    extern_fn, // declared with "crust fn"
 }
 
 #[auto_serialize]
@@ -584,16 +584,16 @@ type method = {ident: ident, attrs: [attribute]/~,
 type _mod = {view_items: [@view_item]/~, items: [@item]/~};
 
 #[auto_serialize]
-enum native_abi {
-    native_abi_rust_intrinsic,
-    native_abi_cdecl,
-    native_abi_stdcall,
+enum foreign_abi {
+    foreign_abi_rust_intrinsic,
+    foreign_abi_cdecl,
+    foreign_abi_stdcall,
 }
 
 #[auto_serialize]
-type native_mod =
+type foreign_mod =
     {view_items: [@view_item]/~,
-     items: [@native_item]/~};
+     items: [@foreign_item]/~};
 
 #[auto_serialize]
 type variant_arg = {ty: @ty, id: node_id};
@@ -681,7 +681,7 @@ enum item_ {
     item_const(@ty, @expr),
     item_fn(fn_decl, [ty_param]/~, blk),
     item_mod(_mod),
-    item_native_mod(native_mod),
+    item_foreign_mod(foreign_mod),
     item_ty(@ty, [ty_param]/~, region_param),
     item_enum([variant]/~, [ty_param]/~, region_param),
     item_class([ty_param]/~, /* ty params for class */
@@ -728,16 +728,16 @@ type class_dtor_ = {id: node_id,
                     body: blk};
 
 #[auto_serialize]
-type native_item =
+type foreign_item =
     {ident: ident,
      attrs: [attribute]/~,
-     node: native_item_,
+     node: foreign_item_,
      id: node_id,
      span: span};
 
 #[auto_serialize]
-enum native_item_ {
-    native_item_fn(fn_decl, [ty_param]/~),
+enum foreign_item_ {
+    foreign_item_fn(fn_decl, [ty_param]/~),
 }
 
 // The data we save and restore about an inlined item or method.  This is not
@@ -747,7 +747,7 @@ enum native_item_ {
 enum inlined_item {
     ii_item(@item),
     ii_method(def_id /* impl id */, @method),
-    ii_native(@native_item),
+    ii_foreign(@foreign_item),
     ii_ctor(class_ctor, ident, [ty_param]/~, def_id /* parent id */),
     ii_dtor(class_dtor, ident, [ty_param]/~, def_id /* parent id */)
 }

src/libsyntax/ast_map.rs

@@ -34,7 +34,7 @@ fn path_to_str(p: path) -> str {
 
 enum ast_node {
     node_item(@item, @path),
-    node_native_item(@native_item, native_abi, @path),
+    node_foreign_item(@foreign_item, foreign_abi, @path),
     node_method(@method, def_id /* impl did */, @path /* path to the impl */),
     node_variant(variant, @item, @path),
     node_expr(@expr),
@@ -104,8 +104,8 @@ fn map_decoded_item(diag: span_handler,
     // add it to the table now:
     alt ii {
       ii_item(*) | ii_ctor(*) | ii_dtor(*) { /* fallthrough */ }
-      ii_native(i) {
-        cx.map.insert(i.id, node_native_item(i, native_abi_rust_intrinsic,
+      ii_foreign(i) {
+        cx.map.insert(i.id, node_foreign_item(i, foreign_abi_rust_intrinsic,
                                              @path));
       }
       ii_method(impl_did, m) {
@@ -202,14 +202,14 @@ fn map_item(i: @item, cx: ctx, v: vt) {
                 extend(cx, i.ident)));
         }
       }
-      item_native_mod(nm) {
-        let abi = alt attr::native_abi(i.attrs) {
+      item_foreign_mod(nm) {
+        let abi = alt attr::foreign_abi(i.attrs) {
           either::left(msg) { cx.diag.span_fatal(i.span, msg); }
           either::right(abi) { abi }
         };
         for nm.items.each {|nitem|
             cx.map.insert(nitem.id,
-                          node_native_item(nitem, abi,
+                          node_foreign_item(nitem, abi,
                                            /* FIXME (#2543) */
                                            @copy cx.path));
         }
@@ -228,7 +228,7 @@ fn map_item(i: @item, cx: ctx, v: vt) {
       _ { }
     }
     alt i.node {
-      item_mod(_) | item_native_mod(_) {
+      item_mod(_) | item_foreign_mod(_) {
         vec::push(cx.path, path_mod(i.ident));
       }
       _ { vec::push(cx.path, path_name(i.ident)); }
@@ -269,7 +269,7 @@ fn node_id_to_str(map: map, id: node_id) -> str {
       some(node_item(item, path)) {
         #fmt["item %s (id=%?)", path_ident_to_str(*path, item.ident), id]
       }
-      some(node_native_item(item, abi, path)) {
+      some(node_foreign_item(item, abi, path)) {
         #fmt["native item %s with abi %? (id=%?)",
              path_ident_to_str(*path, item.ident), abi, id]
       }

src/libsyntax/ast_util.rs

@@ -51,7 +51,7 @@ fn variant_def_ids(d: def) -> {enm: def_id, var: def_id} {
 pure fn def_id_of_def(d: def) -> def_id {
     alt d {
       def_fn(id, _) | def_mod(id) |
-      def_native_mod(id) | def_const(id) |
+      def_foreign_mod(id) | def_const(id) |
       def_variant(_, id) | def_ty(id) | def_ty_param(id, _) |
       def_use(id) | def_class(id) { id }
       def_arg(id, _) | def_local(id, _) | def_self(id) |
@@ -321,7 +321,7 @@ impl inlined_item_methods for inlined_item {
     fn ident() -> ident {
         alt self {
           ii_item(i) { /* FIXME (#2543) */ copy i.ident }
-          ii_native(i) { /* FIXME (#2543) */ copy i.ident }
+          ii_foreign(i) { /* FIXME (#2543) */ copy i.ident }
           ii_method(_, m) { /* FIXME (#2543) */ copy m.ident }
           ii_ctor(_, nm, _, _) { /* FIXME (#2543) */ copy nm }
           ii_dtor(_, nm, _, _) { /* FIXME (#2543) */ copy nm }
@@ -331,7 +331,7 @@ impl inlined_item_methods for inlined_item {
     fn id() -> ast::node_id {
         alt self {
           ii_item(i) { i.id }
-          ii_native(i) { i.id }
+          ii_foreign(i) { i.id }
           ii_method(_, m) { m.id }
           ii_ctor(ctor, _, _, _) { ctor.node.id }
           ii_dtor(dtor, _, _, _) { dtor.node.id }
@@ -341,7 +341,7 @@ impl inlined_item_methods for inlined_item {
     fn accept<E>(e: E, v: visit::vt<E>) {
         alt self {
           ii_item(i) { v.visit_item(i, e, v) }
-          ii_native(i) { v.visit_native_item(i, e, v) }
+          ii_foreign(i) { v.visit_foreign_item(i, e, v) }
           ii_method(_, m) { visit::visit_method_helper(m, e, v) }
           ii_ctor(ctor, nm, tps, parent_id) {
               visit::visit_class_ctor_helper(ctor, nm, tps, parent_id, e, v);
@@ -419,7 +419,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
             }
         },
 
-        visit_native_item: fn@(ni: @native_item) {
+        visit_foreign_item: fn@(ni: @foreign_item) {
             vfn(ni.id)
         },