diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 2bd08d2b282..fbd155e0729 100644 --- a/src/libsyntax/ast.rs +++ b/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 diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index ed41d6da694..8bfbb14fc53 100644 --- a/src/libsyntax/fold.rs +++ b/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)}; diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 4656fc6b6fa..84fd0d8cdc9 100644 --- a/src/libsyntax/parse/parser.rs +++ b/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]) -> diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 835d71135d5..418dfbf3349 100644 --- a/src/libsyntax/print/pprust.rs +++ b/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 + } } } diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index bc98e40594a..4195ecf32ce 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -254,6 +254,9 @@ fn visit_foreign_item(ni: @foreign_item, e: E, v: vt) { v.visit_ty_params(tps, e, v); visit_fn_decl(fd, e, v); } + foreign_item_const(t) => { + v.visit_ty(t, e, v); + } } } diff --git a/src/rustc/metadata/encoder.rs b/src/rustc/metadata/encoder.rs index 66d74c377ca..24b259f84f6 100644 --- a/src/rustc/metadata/encoder.rs +++ b/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(); } diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs index 1a26072532a..432c1bba77d 100644 --- a/src/rustc/middle/lint.rs +++ b/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. } } } diff --git a/src/rustc/middle/resolve3.rs b/src/rustc/middle/resolve3.rs index 19436f77430..0de27f61b62 100644 --- a/src/rustc/middle/resolve3.rs +++ b/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) { 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); + } } } } diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs index ab5c5a468bd..a254876f697 100644 --- a/src/rustc/middle/trans/base.rs +++ b/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)]); diff --git a/src/rustc/middle/trans/foreign.rs b/src/rustc/middle/trans/foreign.rs index 8f7881a4d7a..5cbdae9c076 100644 --- a/src/rustc/middle/trans/foreign.rs +++ b/src/rustc/middle/trans/foreign.rs @@ -789,6 +789,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt, } } } + ast::foreign_item_const(*) => {} } } } diff --git a/src/rustc/middle/typeck/collect.rs b/src/rustc/middle/typeck/collect.rs index b87380720ce..c450b995283 100644 --- a/src/rustc/middle/typeck/collect.rs +++ b/src/rustc/middle/typeck/collect.rs @@ -537,12 +537,8 @@ fn convert_foreign(ccx: @crate_ctxt, i: @ast::foreign_item) { // type of the foreign item. We simply write it into the node type // table. let tpt = ty_of_foreign_item(ccx, i); - match i.node { - ast::foreign_item_fn(*) => { - write_ty_to_tcx(ccx.tcx, i.id, tpt.ty); - ccx.tcx.tcache.insert(local_def(i.id), tpt); - } - } + write_ty_to_tcx(ccx.tcx, i.id, tpt.ty); + ccx.tcx.tcache.insert(local_def(i.id), tpt); } fn ty_of_method(ccx: @crate_ctxt, @@ -695,6 +691,14 @@ fn ty_of_foreign_item(ccx: @crate_ctxt, it: @ast::foreign_item) return ty_of_foreign_fn_decl(ccx, fn_decl, purity, params, local_def(it.id)); } + ast::foreign_item_const(t) => { + let rb = in_binding_rscope(empty_rscope); + return { + bounds: @~[], + region_param: none, + ty: ast_ty_to_ty(ccx, rb, t) + }; + } } } diff --git a/src/rustdoc/extract.rs b/src/rustdoc/extract.rs index 6ab1aa78cc0..66b67552b13 100644 --- a/src/rustdoc/extract.rs +++ b/src/rustdoc/extract.rs @@ -130,16 +130,19 @@ fn nmoddoc_from_mod( itemdoc: doc::itemdoc, module_: ast::foreign_mod ) -> doc::nmoddoc { + let mut fns = ~[]; + for module_.items.each |item| { + let itemdoc = mk_itemdoc(item.id, to_str(item.ident)); + match item.node { + ast::foreign_item_fn(*) => { + vec::push(fns, fndoc_from_fn(itemdoc)); + } + ast::foreign_item_const(*) => {} // XXX: Not implemented. + } + } { item: itemdoc, - fns: do vec::map(module_.items) |item| { - let itemdoc = mk_itemdoc(item.id, to_str(item.ident)); - match item.node { - ast::foreign_item_fn(*) => { - fndoc_from_fn(itemdoc) - } - } - }, + fns: fns, index: none } }