---

yaml
---
r: 32156
b: refs/heads/dist-snap
c: 8ef4551
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: dab3339971d91946fd99c9613dc7d51a9d1fb922
+refs/heads/dist-snap: 8ef455190494d2fd9a6bb013efd2e59622af2bc4
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/src/libstd/ebml.rs

@@ -320,7 +320,7 @@ enum ebml_serializer_tag {
 
 trait serializer_priv {
     fn _emit_tagged_uint(t: ebml_serializer_tag, v: uint);
-    fn _emit_label(label: &str);
+    fn _emit_label(label: ~str);
 }
 
 impl ebml::writer: serializer_priv {
@@ -330,7 +330,7 @@ impl ebml::writer: serializer_priv {
         self.wr_tagged_u32(t as uint, v as u32);
     }
 
-    fn _emit_label(label: &str) {
+    fn _emit_label(label: ~str) {
         // There are various strings that we have access to, such as
         // the name of a record field, which do not actually appear in
         // the serialized EBML (normally).  This is just for
@@ -365,11 +365,11 @@ impl ebml::writer: serialization::serializer {
 
     fn emit_str(v: &str) { self.wr_tagged_str(es_str as uint, v) }
 
-    fn emit_enum(name: &str, f: fn()) {
+    fn emit_enum(name: ~str, f: fn()) {
         self._emit_label(name);
         self.wr_tag(es_enum as uint, f)
     }
-    fn emit_enum_variant(_v_name: &str, v_id: uint, _cnt: uint, f: fn()) {
+    fn emit_enum_variant(_v_name: ~str, v_id: uint, _cnt: uint, f: fn()) {
         self._emit_tagged_uint(es_enum_vid, v_id);
         self.wr_tag(es_enum_body as uint, f)
     }
@@ -389,7 +389,7 @@ impl ebml::writer: serialization::serializer {
     fn emit_box(f: fn()) { f() }
     fn emit_uniq(f: fn()) { f() }
     fn emit_rec(f: fn()) { f() }
-    fn emit_rec_field(f_name: &str, _f_idx: uint, f: fn()) {
+    fn emit_rec_field(f_name: ~str, _f_idx: uint, f: fn()) {
         self._emit_label(f_name);
         f()
     }

branches/dist-snap/src/libstd/net_tcp.rs

@@ -153,7 +153,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
           0i32 => {
             log(debug, ~"tcp_init successful");
             match input_ip {
-              _ipv4 => {
+              ipv4 => {
                 log(debug, ~"dealing w/ ipv4 connection..");
                 let connect_req_ptr =
                     ptr::addr_of((*socket_data_ptr).connect_req);

branches/dist-snap/src/libstd/prettyprint.rs

@@ -67,11 +67,11 @@ impl Writer: serializer {
         self.write_str(fmt!("%?", v));
     }
 
-    fn emit_enum(_name: &str, f: fn()) {
+    fn emit_enum(_name: ~str, f: fn()) {
         f();
     }
 
-    fn emit_enum_variant(v_name: &str, _v_id: uint, sz: uint, f: fn()) {
+    fn emit_enum_variant(v_name: ~str, _v_id: uint, sz: uint, f: fn()) {
         self.write_str(v_name);
         if sz > 0u { self.write_str(~"("); }
         f();
@@ -110,7 +110,7 @@ impl Writer: serializer {
         self.write_str(~"}");
     }
 
-    fn emit_rec_field(f_name: &str, f_idx: uint, f: fn()) {
+    fn emit_rec_field(f_name: ~str, f_idx: uint, f: fn()) {
         if f_idx > 0u { self.write_str(~", "); }
         self.write_str(f_name);
         self.write_str(~": ");

branches/dist-snap/src/libstd/serialization.rs

@@ -26,15 +26,15 @@ trait serializer {
     fn emit_str(v: &str);
 
     // Compound types:
-    fn emit_enum(name: &str, f: fn());
-    fn emit_enum_variant(v_name: &str, v_id: uint, sz: uint, f: fn());
+    fn emit_enum(name: ~str, f: fn());
+    fn emit_enum_variant(v_name: ~str, v_id: uint, sz: uint, f: fn());
     fn emit_enum_variant_arg(idx: uint, f: fn());
     fn emit_vec(len: uint, f: fn());
     fn emit_vec_elt(idx: uint, f: fn());
     fn emit_box(f: fn());
     fn emit_uniq(f: fn());
     fn emit_rec(f: fn());
-    fn emit_rec_field(f_name: &str, f_idx: uint, f: fn());
+    fn emit_rec_field(f_name: ~str, f_idx: uint, f: fn());
     fn emit_tup(sz: uint, f: fn());
     fn emit_tup_elt(idx: uint, f: fn());
 }

branches/dist-snap/src/libsyntax/ast.rs

@@ -830,6 +830,7 @@ type foreign_item =
 #[auto_serialize]
 enum foreign_item_ {
     foreign_item_fn(fn_decl, purity, ~[ty_param]),
+    foreign_item_const(@ty)
 }
 
 // The data we save and restore about an inlined item or method.  This is not

branches/dist-snap/src/libsyntax/fold.rs

@@ -196,6 +196,9 @@ fn noop_fold_foreign_item(&&ni: @foreign_item, fld: ast_fold)
                                   purity,
                                   fold_ty_params(typms, fld))
                 }
+                foreign_item_const(t) => {
+                  foreign_item_const(fld.fold_ty(t))
+                }
               },
           id: fld.new_id(ni.id),
           span: fld.new_span(ni.span)};

branches/dist-snap/src/libsyntax/parse/parser.rs

@@ -32,32 +32,32 @@ import ast::{_mod, add, alt_check, alt_exhaustive, arg, arm, attribute,
              expr_move, expr_path, expr_rec, expr_repeat, expr_ret, expr_swap,
              expr_struct, expr_tup, expr_unary, expr_unary_move, expr_vec,
              expr_vstore, expr_while, extern_fn, field, fn_decl, foreign_item,
-             foreign_item_fn, foreign_mod, ident, impure_fn, infer, inherited,
-             init_assign, init_move, initializer, item, item_,
-             item_class, item_const, item_enum, item_fn, item_foreign_mod,
-             item_impl, item_mac, item_mod, item_trait, item_ty, lit, lit_,
-             lit_bool, lit_float, lit_int, lit_int_unsuffixed, lit_nil,
-             lit_str, lit_uint, local, m_const, m_imm, m_mutbl, mac_, mac_aq,
-             mac_ellipsis, mac_invoc, mac_invoc_tt, mac_var, matcher,
-             match_nonterminal, match_seq, match_tok, method, mode, mt, mul,
-             mutability, named_field, neg, noreturn, not, pat, pat_box,
-             pat_enum, pat_ident, pat_lit, pat_range, pat_rec, pat_struct,
-             pat_tup, pat_uniq, pat_wild, path, private, proto, proto_bare,
-             proto_block, proto_box, proto_uniq, provided, public, pure_fn,
-             purity, re_anon, re_named, region, rem, required, ret_style,
-             return_val, self_ty, shl, shr, stmt, stmt_decl, stmt_expr,
-             stmt_semi, struct_def, struct_field, struct_variant_kind,
-             subtract, sty_box, sty_by_ref, sty_region, sty_static, sty_uniq,
-             sty_value, token_tree, trait_method, trait_ref, tt_delim, tt_seq,
-             tt_tok, tt_nonterminal, ty, ty_, ty_bot, ty_box, ty_field, ty_fn,
-             ty_infer, ty_mac, ty_method, ty_nil, ty_param, ty_param_bound,
-             ty_path, ty_ptr, ty_rec, ty_rptr, ty_tup, ty_u32, ty_uniq,
-             ty_vec, ty_fixed_length, tuple_variant_kind, unchecked_blk, uniq,
-             unnamed_field, unsafe_blk, unsafe_fn, variant, view_item,
-             view_item_, view_item_export, view_item_import, view_item_use,
-             view_path, view_path_glob, view_path_list, view_path_simple,
-             visibility, vstore, vstore_box, vstore_fixed, vstore_slice,
-             vstore_uniq};
+             foreign_item_const, foreign_item_fn, foreign_mod, ident,
+             impure_fn, infer, inherited, init_assign, init_move, initializer,
+             item, item_, item_class, item_const, item_enum, item_fn,
+             item_foreign_mod, item_impl, item_mac, item_mod, item_trait,
+             item_ty, lit, lit_, lit_bool, lit_float, lit_int,
+             lit_int_unsuffixed, lit_nil, lit_str, lit_uint, local, m_const,
+             m_imm, m_mutbl, mac_, mac_aq, mac_ellipsis, mac_invoc,
+             mac_invoc_tt, mac_var, matcher, match_nonterminal, match_seq,
+             match_tok, method, mode, mt, mul, mutability, named_field, neg,
+             noreturn, not, pat, pat_box, pat_enum, pat_ident, pat_lit,
+             pat_range, pat_rec, pat_struct, pat_tup, pat_uniq, pat_wild,
+             path, private, proto, proto_bare, proto_block, proto_box,
+             proto_uniq, provided, public, pure_fn, purity, re_anon, re_named,
+             region, rem, required, ret_style, return_val, self_ty, shl, shr,
+             stmt, stmt_decl, stmt_expr, stmt_semi, struct_def, struct_field,
+             struct_variant_kind, subtract, sty_box, sty_by_ref, sty_region,
+             sty_static, sty_uniq, sty_value, token_tree, trait_method,
+             trait_ref, tt_delim, tt_seq, tt_tok, tt_nonterminal, ty, ty_,
+             ty_bot, ty_box, ty_field, ty_fn, ty_infer, ty_mac, ty_method,
+             ty_nil, ty_param, ty_param_bound, ty_path, ty_ptr, ty_rec,
+             ty_rptr, ty_tup, ty_u32, ty_uniq, ty_vec, ty_fixed_length,
+             tuple_variant_kind, unchecked_blk, uniq, unnamed_field,
+             unsafe_blk, unsafe_fn, variant, view_item, view_item_,
+             view_item_export, view_item_import, view_item_use, view_path,
+             view_path_glob, view_path_list, view_path_simple, visibility,
+             vstore, vstore_box, vstore_fixed, vstore_slice, vstore_uniq};
 
 export file_type;
 export parser;
@@ -2843,6 +2843,21 @@ struct parser {
                  span: mk_sp(lo, hi)};
     }
 
+    fn parse_item_foreign_const(+attrs: ~[attribute]) -> @foreign_item {
+        let lo = self.span.lo;
+        self.expect_keyword(~"const");
+        let ident = self.parse_ident();
+        self.expect(token::COLON);
+        let ty = self.parse_ty(false);
+        let hi = self.span.hi;
+        self.expect(token::SEMI);
+        return @{ident: ident,
+                 attrs: attrs,
+                 node: foreign_item_const(move ty),
+                 id: self.get_id(),
+                 span: mk_sp(lo, hi)};
+    }
+
     fn parse_fn_purity() -> purity {
         if self.eat_keyword(~"fn") { impure_fn }
         else if self.eat_keyword(~"pure") {
@@ -2855,9 +2870,12 @@ struct parser {
         else { self.unexpected(); }
     }
 
-    fn parse_foreign_item(+attrs: ~[attribute]) ->
-        @foreign_item {
-        self.parse_item_foreign_fn(attrs)
+    fn parse_foreign_item(+attrs: ~[attribute]) -> @foreign_item {
+        if self.is_keyword(~"const") {
+            self.parse_item_foreign_const(move attrs)
+        } else {
+            self.parse_item_foreign_fn(move attrs)
+        }
     }
 
     fn parse_foreign_mod_items(+first_item_attrs: ~[attribute]) ->

branches/dist-snap/src/libsyntax/print/pprust.rs

@@ -421,6 +421,14 @@ fn print_foreign_item(s: ps, item: @ast::foreign_item) {
         word(s.s, ~";");
         end(s); // end the outer fn box
       }
+      ast::foreign_item_const(t) => {
+        head(s, ~"const");
+        print_ident(s, item.ident);
+        word_space(s, ~":");
+        print_type(s, t);
+        word(s.s, ~";");
+        end(s); // end the head-ibox
+      }
     }
 }
 

branches/dist-snap/src/libsyntax/visit.rs

@@ -254,6 +254,9 @@ fn visit_foreign_item<E>(ni: @foreign_item, e: E, v: vt<E>) {
         v.visit_ty_params(tps, e, v);
         visit_fn_decl(fd, e, v);
       }
+      foreign_item_const(t) => {
+        v.visit_ty(t, e, v);
+      }
     }
 }
 

branches/dist-snap/src/rustc/metadata/encoder.rs

@@ -803,6 +803,14 @@ fn encode_info_for_foreign_item(ecx: @encode_ctxt, ebml_w: ebml::writer,
         }
         encode_path(ecx, ebml_w, path, ast_map::path_name(nitem.ident));
       }
+      foreign_item_const(t) => {
+        encode_def_id(ebml_w, local_def(nitem.id));
+        encode_family(ebml_w, 'c');
+        encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, nitem.id));
+        encode_symbol(ecx, ebml_w, nitem.id);
+        encode_path(ecx, ebml_w, path, ast_map::path_name(nitem.ident));
+        ebml_w.end_tag();
+      }
     }
     ebml_w.end_tag();
 }

branches/dist-snap/src/rustc/middle/lint.rs

@@ -420,6 +420,7 @@ fn check_item_ctypes(cx: ty::ctxt, it: @ast::item) {
               ast::foreign_item_fn(decl, _, tps) => {
                 check_foreign_fn(cx, it.id, decl);
               }
+              ast::foreign_item_const(*) => {}  // XXX: Not implemented.
             }
         }
       }

branches/dist-snap/src/rustc/middle/resolve3.rs

@@ -25,23 +25,23 @@ import syntax::ast::{enum_variant_kind, expr, expr_again, expr_assign_op};
 import syntax::ast::{expr_binary, expr_break, expr_cast, expr_field, expr_fn};
 import syntax::ast::{expr_fn_block, expr_index, expr_loop};
 import syntax::ast::{expr_path, expr_struct, expr_unary, fn_decl};
-import syntax::ast::{foreign_item, foreign_item_fn, ge, gt, ident, trait_ref};
-import syntax::ast::{impure_fn, inherited, item, item_class, item_const};
-import syntax::ast::{item_enum, item_fn, item_mac, item_foreign_mod};
-import syntax::ast::{item_impl, item_mod, item_trait, item_ty, le, local};
-import syntax::ast::{local_crate, lt, method, mul, ne, neg, node_id, pat};
-import syntax::ast::{pat_enum, pat_ident, path, prim_ty, pat_box, pat_uniq};
+import syntax::ast::{foreign_item, foreign_item_const, foreign_item_fn, ge};
+import syntax::ast::{gt, ident, impure_fn, inherited, item, item_class};
+import syntax::ast::{item_const, item_enum, item_fn, item_foreign_mod};
+import syntax::ast::{item_impl, item_mac, item_mod, item_trait, item_ty, le};
+import syntax::ast::{local, local_crate, lt, method, mul, ne, neg, node_id};
+import syntax::ast::{pat, pat_enum, pat_ident, path, prim_ty, pat_box};
 import syntax::ast::{pat_lit, pat_range, pat_rec, pat_struct, pat_tup};
-import syntax::ast::{pat_wild, private, provided, public, required, rem};
-import syntax::ast::{self_ty_};
-import syntax::ast::{shl, stmt_decl, struct_field, struct_variant_kind};
-import syntax::ast::{sty_static, subtract, tuple_variant_kind, ty};
-import syntax::ast::{ty_bool, ty_char, ty_f, ty_f32, ty_f64, ty_float, ty_i};
-import syntax::ast::{ty_i16, ty_i32, ty_i64, ty_i8, ty_int, ty_param};
-import syntax::ast::{ty_path, ty_str, ty_u, ty_u16, ty_u32, ty_u64, ty_u8};
-import syntax::ast::{ty_uint, variant, view_item, view_item_export};
-import syntax::ast::{view_item_import, view_item_use, view_path_glob};
-import syntax::ast::{view_path_list, view_path_simple, visibility};
+import syntax::ast::{pat_uniq, pat_wild, private, provided, public, required};
+import syntax::ast::{rem, self_ty_, shl, stmt_decl, struct_field};
+import syntax::ast::{struct_variant_kind, sty_static, subtract, trait_ref};
+import syntax::ast::{tuple_variant_kind, ty, ty_bool, ty_char, ty_f, ty_f32};
+import syntax::ast::{ty_f64, ty_float, ty_i, ty_i16, ty_i32, ty_i64, ty_i8};
+import syntax::ast::{ty_int, ty_param, ty_path, ty_str, ty_u, ty_u16, ty_u32};
+import syntax::ast::{ty_u64, ty_u8, ty_uint, variant, view_item};
+import syntax::ast::{view_item_export, view_item_import, view_item_use};
+import syntax::ast::{view_path_glob, view_path_list, view_path_simple};
+import syntax::ast::{visibility};
 import syntax::ast_util::{def_id_of_def, dummy_sp, local_def, new_def_hash};
 import syntax::ast_util::{path_to_ident, walk_pat, trait_method_to_ty_method};
 import syntax::attr::{attr_metas, contains_name};
@@ -1213,26 +1213,27 @@ struct Resolver {
                                                 vt<ReducedGraphParent>) {
 
         let name = foreign_item.ident;
+        let (name_bindings, new_parent) =
+            self.add_child(name, parent, ~[ValueNS], foreign_item.span);
 
         match foreign_item.node {
             foreign_item_fn(fn_decl, purity, type_parameters) => {
-              let (name_bindings, new_parent) = self.add_child(name, parent,
-                                              ~[ValueNS], foreign_item.span);
-
                 let def = def_fn(local_def(foreign_item.id), purity);
                 (*name_bindings).define_value(Public, def, foreign_item.span);
 
                 do self.with_type_parameter_rib
-                        (HasTypeParameters(&type_parameters,
-                                           foreign_item.id,
-                                           0u,
-                                           NormalRibKind)) || {
-
+                        (HasTypeParameters(&type_parameters, foreign_item.id,
+                                           0u, NormalRibKind)) {
                     visit_foreign_item(foreign_item, new_parent, visitor);
                 }
             }
-        }
+            foreign_item_const(item_type) => {
+                let def = def_const(local_def(foreign_item.id));
+                (*name_bindings).define_value(Public, def, foreign_item.span);
 
+                visit_foreign_item(foreign_item, new_parent, visitor);
+            }
+        }
     }
 
     fn build_reduced_graph_for_block(block: blk,
@@ -2953,6 +2954,10 @@ struct Resolver {
                                                        visitor);
                                 }
                             }
+                            foreign_item_const(item_type) => {
+                                visit_foreign_item(foreign_item, (),
+                                                   visitor);
+                            }
                         }
                     }
                 }

branches/dist-snap/src/rustc/middle/trans/base.rs

@@ -5414,9 +5414,22 @@ fn get_item_val(ccx: @crate_ctxt, id: ast::node_id) -> ValueRef {
           }
           ast_map::node_foreign_item(ni, _, pth) => {
             exprt = true;
-            register_fn(ccx, ni.span,
-                        vec::append(*pth, ~[path_name(ni.ident)]),
-                        ni.id)
+            match ni.node {
+                ast::foreign_item_fn(*) => {
+                    register_fn(ccx, ni.span,
+                                vec::append(*pth, ~[path_name(ni.ident)]),
+                                ni.id)
+                }
+                ast::foreign_item_const(*) => {
+                    let typ = ty::node_id_to_type(ccx.tcx, ni.id);
+                    let ident = ccx.sess.parse_sess.interner.get(ni.ident);
+                    let g = do str::as_c_str(*ident) |buf| {
+                        llvm::LLVMAddGlobal(ccx.llmod, type_of(ccx, typ), buf)
+                    };
+                    ccx.item_symbols.insert(ni.id, copy *ident);
+                    g
+                }
+            }
           }
           ast_map::node_ctor(nm, _, ctor, _, pt) => {
             let my_path = vec::append(*pt, ~[path_name(nm)]);

branches/dist-snap/src/rustc/middle/trans/foreign.rs

@@ -789,6 +789,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt,
               }
           }
         }
+        ast::foreign_item_const(*) => {}
       }
     }
 }