diff --git a/src/libcore/libc.rs b/src/libcore/libc.rs index e3646ef60f5..6a3ed22cea9 100644 --- a/src/libcore/libc.rs +++ b/src/libcore/libc.rs @@ -1221,9 +1221,8 @@ pub mod stdio { #[nolink] #[abi = "cdecl"] pub mod fcntl { + use libc::types::os::arch::c95::{c_int, c_char}; pub extern { - use libc::types::os::arch::c95::{c_int, c_char}; - #[link_name = "_open"] unsafe fn open(path: *c_char, oflag: c_int, mode: c_int) -> c_int; @@ -1562,11 +1561,11 @@ pub mod unistd { #[cfg(target_os = "macos")] #[cfg(target_os = "freebsd")] pub mod bsd44 { + use libc::types::common::c95::{c_void}; + use libc::types::os::arch::c95::{c_char, c_int, c_uint, size_t}; + #[abi = "cdecl"] pub extern { - use libc::types::common::c95::{c_void}; - use libc::types::os::arch::c95::{c_char, c_int, c_uint, size_t}; - unsafe fn sysctl(name: *c_int, namelen: c_uint, oldp: *mut c_void, oldlenp: *mut size_t, newp: *c_void, newlen: size_t) -> c_int; diff --git a/src/libcore/rt/env.rs b/src/libcore/rt/env.rs index 008e31777b0..92e2ec51306 100644 --- a/src/libcore/rt/env.rs +++ b/src/libcore/rt/env.rs @@ -44,4 +44,4 @@ pub fn get() -> &Environment { extern { fn rust_get_rt_env() -> &Environment; -} \ No newline at end of file +} diff --git a/src/libcore/rt/sched.rs b/src/libcore/rt/sched.rs index 69cbbdd2ad4..60dbc8b82da 100644 --- a/src/libcore/rt/sched.rs +++ b/src/libcore/rt/sched.rs @@ -70,7 +70,7 @@ enum CleanupJob { pub impl Scheduler { - static fn new(event_loop: ~EventLoopObject) -> Scheduler { + static pub fn new(event_loop: ~EventLoopObject) -> Scheduler { Scheduler { event_loop: event_loop, task_queue: WorkQueue::new(), @@ -296,7 +296,7 @@ pub struct Task { } impl Task { - static fn new(stack_pool: &mut StackPool, start: ~fn()) -> Task { + static pub fn new(stack_pool: &mut StackPool, start: ~fn()) -> Task { // XXX: Putting main into a ~ so it's a thin pointer and can // be passed to the spawn function. Another unfortunate // allocation diff --git a/src/libcore/rt/stack.rs b/src/libcore/rt/stack.rs index 02c47218ed8..b5e7d4f3aa2 100644 --- a/src/libcore/rt/stack.rs +++ b/src/libcore/rt/stack.rs @@ -37,8 +37,7 @@ fn end(&self) -> *uint { pub struct StackPool(()); impl StackPool { - - static fn new() -> StackPool { StackPool(()) } + static pub fn new() -> StackPool { StackPool(()) } fn take_segment(&self, min_size: uint) -> StackSegment { StackSegment::new(min_size) diff --git a/src/libcore/rt/thread.rs b/src/libcore/rt/thread.rs index be1d86c9cf7..5dccf90096e 100644 --- a/src/libcore/rt/thread.rs +++ b/src/libcore/rt/thread.rs @@ -20,7 +20,7 @@ struct Thread { } impl Thread { - static fn start(main: ~fn()) -> Thread { + static pub fn start(main: ~fn()) -> Thread { fn substart(main: &fn()) -> *raw_thread { unsafe { rust_raw_thread_start(&main) } } diff --git a/src/libcore/task/rt.rs b/src/libcore/task/rt.rs index e95c6d90eee..760812252bc 100644 --- a/src/libcore/task/rt.rs +++ b/src/libcore/task/rt.rs @@ -30,7 +30,7 @@ #[allow(non_camel_case_types)] // runtime type pub type rust_closure = libc::c_void; -extern { +pub extern { #[rust_stack] fn rust_task_yield(task: *rust_task) -> bool; diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index eaf02790537..c4644a61164 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -146,6 +146,7 @@ fn item_family(item: ebml::Doc) -> Family { fn item_visibility(item: ebml::Doc) -> ast::visibility { let visibility = reader::get_doc(item, tag_items_data_item_visibility); + debug!("item visibility for %?", item_family(item)); match reader::doc_as_u8(visibility) as char { 'y' => ast::public, 'n' => ast::private, diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index f507d0d8718..f6eff900164 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -896,6 +896,7 @@ fn add_to_index_(item: @item, ebml_w: writer::Encoder, encode_family(ebml_w, purity_fn_family(mty.fty.purity)); encode_self_type(ebml_w, mty.self_ty); encode_method_sort(ebml_w, 'r'); + encode_visibility(ebml_w, ast::public); ebml_w.end_tag(); } provided(m) => { @@ -911,6 +912,7 @@ fn add_to_index_(item: @item, ebml_w: writer::Encoder, encode_family(ebml_w, purity_fn_family(mty.fty.purity)); encode_self_type(ebml_w, mty.self_ty); encode_method_sort(ebml_w, 'p'); + encode_visibility(ebml_w, m.vis); ebml_w.end_tag(); } } @@ -945,6 +947,11 @@ fn add_to_index_(item: @item, ebml_w: writer::Encoder, let mut m_path = vec::append(~[], path); // :-( m_path += [ast_map::path_name(item.ident)]; encode_path(ecx, ebml_w, m_path, ast_map::path_name(ty_m.ident)); + + // For now, use the item visibility until trait methods can have + // real visibility in the AST. + encode_visibility(ebml_w, item.vis); + ebml_w.end_tag(); } @@ -1033,7 +1040,7 @@ fn encode_info_for_items(ecx: @EncodeContext, ebml_w: writer::Encoder, |ni, cx, v| { visit::visit_foreign_item(ni, cx, v); match ecx.tcx.items.get(&ni.id) { - ast_map::node_foreign_item(_, abi, pt) => { + ast_map::node_foreign_item(_, abi, _, pt) => { encode_info_for_foreign_item(ecx, ebml_w, ni, index, /*bad*/copy *pt, abi); diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs index 3e3b1eb2071..adc1a7ce3f4 100644 --- a/src/librustc/middle/privacy.rs +++ b/src/librustc/middle/privacy.rs @@ -22,15 +22,19 @@ use middle::typeck::{method_static, method_trait}; use core::util::ignore; -use syntax::ast::{def_variant, expr_field, expr_method_call, expr_struct}; -use syntax::ast::{expr_unary, ident, item_struct, item_enum, item_impl}; -use syntax::ast::{item_trait, local_crate, node_id, pat_struct, private}; -use syntax::ast::{provided, public, required}; +use syntax::ast::{decl_item, def, def_fn, def_id, def_static_method}; +use syntax::ast::{def_variant, expr_field, expr_method_call, expr_path}; +use syntax::ast::{expr_struct, expr_unary, ident, inherited, item_enum}; +use syntax::ast::{item_foreign_mod, item_fn, item_impl, item_struct}; +use syntax::ast::{item_trait, local_crate, node_id, pat_struct, path}; +use syntax::ast::{private, provided, public, required, stmt_decl, visibility}; use syntax::ast; -use syntax::ast_map::{node_item, node_method}; +use syntax::ast_map::{node_foreign_item, node_item, node_method}; +use syntax::ast_map::{node_trait_method}; use syntax::ast_map; use syntax::ast_util::{Private, Public, is_local}; use syntax::ast_util::{variant_visibility_to_privacy, visibility_to_privacy}; +use syntax::attr; use syntax::codemap::span; use syntax::visit; @@ -39,18 +43,37 @@ pub fn check_crate(tcx: ty::ctxt, crate: @ast::crate) { let privileged_items = @mut ~[]; - // Adds structs that are privileged to this scope. + // Adds an item to its scope. + let add_privileged_item: @fn(@ast::item, &mut uint) = |item, count| { + match item.node { + item_struct(*) | item_trait(*) | item_enum(*) | + item_fn(*) => { + privileged_items.push(item.id); + *count += 1; + } + item_impl(_, _, _, ref methods) => { + for methods.each |method| { + privileged_items.push(method.id); + *count += 1; + } + privileged_items.push(item.id); + *count += 1; + } + item_foreign_mod(ref foreign_mod) => { + for foreign_mod.items.each |foreign_item| { + privileged_items.push(foreign_item.id); + *count += 1; + } + } + _ => {} + } + }; + + // Adds items that are privileged to this scope. let add_privileged_items: @fn(&[@ast::item]) -> uint = |items| { let mut count = 0; - for items.each |item| { - match item.node { - item_struct(*) | item_trait(*) | item_impl(*) - | item_enum(*) => { - privileged_items.push(item.id); - count += 1; - } - _ => {} - } + for items.each |&item| { + add_privileged_item(item, &mut count); } count }; @@ -84,6 +107,128 @@ pub fn check_crate(tcx: ty::ctxt, } }; + // Returns the ID of the container (impl or trait) that a crate-local + // method belongs to. + let local_method_container_id: + @fn(span: span, method_id: node_id) -> def_id = + |span, method_id| { + match tcx.items.find(&method_id) { + Some(node_method(_, impl_id, _)) => impl_id, + Some(node_trait_method(_, trait_id, _)) => trait_id, + Some(_) => { + tcx.sess.span_bug(span, + fmt!("method was a %s?!", + ast_map::node_id_to_str( + tcx.items, + method_id, + tcx.sess.parse_sess.interner))); + } + None => { + tcx.sess.span_bug(span, ~"method not found in \ + AST map?!"); + } + } + }; + + // Returns true if a crate-local method is private and false otherwise. + let method_is_private: @fn(span: span, method_id: node_id) -> bool = + |span, method_id| { + let check = |vis: visibility, container_id: def_id| { + let mut is_private = false; + if vis == private { + is_private = true; + } else if vis == public { + is_private = false; + } else { + // Look up the enclosing impl. + if container_id.crate != local_crate { + tcx.sess.span_bug(span, + ~"local method isn't in local \ + impl?!"); + } + + match tcx.items.find(&container_id.node) { + Some(node_item(item, _)) => { + match item.node { + item_impl(_, None, _, _) + if item.vis != public => { + is_private = true; + } + _ => {} + } + } + Some(_) => { + tcx.sess.span_bug(span, ~"impl wasn't an item?!"); + } + None => { + tcx.sess.span_bug(span, ~"impl wasn't in AST map?!"); + } + } + } + + is_private + }; + + match tcx.items.find(&method_id) { + Some(node_method(method, impl_id, _)) => { + check(method.vis, impl_id) + } + Some(node_trait_method(trait_method, trait_id, _)) => { + match *trait_method { + required(_) => check(public, trait_id), + provided(method) => check(method.vis, trait_id), + } + } + Some(_) => { + tcx.sess.span_bug(span, + fmt!("method_is_private: method was a %s?!", + ast_map::node_id_to_str( + tcx.items, + method_id, + tcx.sess.parse_sess.interner))); + } + None => { + tcx.sess.span_bug(span, ~"method not found in \ + AST map?!"); + } + } + }; + + // Returns true if the given local item is private and false otherwise. + let local_item_is_private: @fn(span: span, item_id: node_id) -> bool = + |span, item_id| { + let mut f: &fn(node_id) -> bool = |_| false; + f = |item_id| { + match tcx.items.find(&item_id) { + Some(node_item(item, _)) => item.vis != public, + Some(node_foreign_item(_, _, vis, _)) => vis != public, + Some(node_method(method, impl_did, _)) => { + match method.vis { + private => true, + public => false, + inherited => f(impl_did.node) + } + } + Some(node_trait_method(_, trait_did, _)) => f(trait_did.node), + Some(_) => { + tcx.sess.span_bug(span, + fmt!("local_item_is_private: item was \ + a %s?!", + ast_map::node_id_to_str( + tcx.items, + item_id, + tcx.sess + .parse_sess + .interner))); + } + None => { + tcx.sess.span_bug(span, ~"item not found in AST map?!"); + } + } + }; + f(item_id) + }; + // Checks that a private field is in scope. let check_field: @fn(span: span, id: ast::def_id, ident: ast::ident) = |span, id, ident| { @@ -99,6 +244,68 @@ pub fn check_crate(tcx: ty::ctxt, } }; + // Given the ID of a method, checks to ensure it's in scope. + let check_method_common: @fn(span: span, + method_id: def_id, + name: &ident) = + |span, method_id, name| { + if method_id.crate == local_crate { + let is_private = method_is_private(span, method_id.node); + let container_id = local_method_container_id(span, + method_id.node); + if is_private && + (container_id.crate != local_crate || + !privileged_items.contains(&(container_id.node))) { + tcx.sess.span_err(span, + fmt!("method `%s` is private", + *tcx.sess + .parse_sess + .interner + .get(*name))); + } + } else { + let visibility = + csearch::get_method_visibility(tcx.sess.cstore, + method_id); + if visibility != public { + tcx.sess.span_err(span, + fmt!("method `%s` is private", + *tcx.sess.parse_sess.interner + .get(*name))); + } + } + }; + + // Checks that a private path is in scope. + let check_path: @fn(span: span, def: def, path: @path) = + |span, def, path| { + debug!("checking path"); + match def { + def_static_method(method_id, _, _) => { + debug!("found static method def, checking it"); + check_method_common(span, method_id, path.idents.last()) + } + def_fn(def_id, _) => { + if def_id.crate == local_crate { + if local_item_is_private(span, def_id.node) && + !privileged_items.contains(&def_id.node) { + tcx.sess.span_err(span, + fmt!("function `%s` is private", + *tcx.sess + .parse_sess + .interner + .get(copy *path + .idents + .last()))); + } + } else { + // XXX: Check privacy in external crates. + } + } + _ => {} + } + }; + // Checks that a private method is in scope. let check_method: @fn(span: span, origin: &method_origin, @@ -106,79 +313,7 @@ pub fn check_crate(tcx: ty::ctxt, |span, origin, ident| { match *origin { method_static(method_id) => { - if method_id.crate == local_crate { - match tcx.items.find(&method_id.node) { - Some(node_method(method, impl_id, _)) => { - let mut is_private = false; - if method.vis == private { - is_private = true; - } else if method.vis == public { - is_private = false; - } else { - // Look up the enclosing impl. - if impl_id.crate != local_crate { - tcx.sess.span_bug(span, - ~"local method isn't \ - in local impl?!"); - } - - match tcx.items.find(&impl_id.node) { - Some(node_item(item, _)) => { - match item.node { - item_impl(_, None, _, _) - if item.vis != public => { - is_private = true; - } - _ => {} - } - } - Some(_) => { - tcx.sess.span_bug(span, - ~"impl wasn't an \ - item?!"); - } - None => { - tcx.sess.span_bug(span, - ~"impl wasn't in \ - AST map?!"); - } - } - } - - if is_private && - (impl_id.crate != local_crate || - !privileged_items - .contains(&(impl_id.node))) { - tcx.sess.span_err(span, - fmt!("method `%s` is \ - private", - *tcx.sess - .parse_sess - .interner - .get(method - .ident))); - } - } - Some(_) => { - tcx.sess.span_bug(span, ~"method wasn't \ - actually a method?!"); - } - None => { - tcx.sess.span_bug(span, ~"method not found in \ - AST map?!"); - } - } - } else { - let visibility = - csearch::get_method_visibility(tcx.sess.cstore, - method_id); - if visibility != public { - tcx.sess.span_err(span, - fmt!("method `%s` is private", - *tcx.sess.parse_sess.interner - .get(ident))); - } - } + check_method_common(span, method_id, &ident) } method_param(method_param { trait_id: trait_id, @@ -257,6 +392,37 @@ pub fn check_crate(tcx: ty::ctxt, ignore(privileged_items.pop()); } }, + visit_item: |item, method_map, visitor| { + // Do not check privacy inside items with the resolve_unexported + // attribute. This is used for the test runner. + if !attr::contains_name(attr::attr_metas(/*bad*/copy item.attrs), + ~"!resolve_unexported") { + visit::visit_item(item, method_map, visitor); + } + }, + visit_block: |block, method_map, visitor| { + // Gather up all the privileged items. + let mut n_added = 0; + for block.node.stmts.each |stmt| { + match stmt.node { + stmt_decl(decl, _) => { + match decl.node { + decl_item(item) => { + add_privileged_item(item, &mut n_added); + } + _ => {} + } + } + _ => {} + } + } + + visit::visit_block(block, method_map, visitor); + + for n_added.times { + ignore(privileged_items.pop()); + } + }, visit_expr: |expr, method_map: &method_map, visitor| { match expr.node { expr_field(base, ident, _) => { @@ -310,6 +476,9 @@ pub fn check_crate(tcx: ty::ctxt, _ => {} } } + expr_path(path) => { + check_path(expr.span, tcx.def_map.get(&expr.id), path); + } expr_struct(_, ref fields, _) => { match ty::get(ty::expr_ty(tcx, expr)).sty { ty_struct(id, _) => { diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 4836ce062c9..55cf1ae23b8 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -2428,7 +2428,7 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::node_id) -> ValueRef { exprt = true; register_method(ccx, id, pth, m) } - ast_map::node_foreign_item(ni, _, pth) => { + ast_map::node_foreign_item(ni, _, _, pth) => { exprt = true; match ni.node { ast::foreign_item_fn(*) => { diff --git a/src/librustc/middle/trans/callee.rs b/src/librustc/middle/trans/callee.rs index 81d85773ccb..14336a203ce 100644 --- a/src/librustc/middle/trans/callee.rs +++ b/src/librustc/middle/trans/callee.rs @@ -266,6 +266,7 @@ pub fn trans_fn_ref_with_vtables( match map_node { ast_map::node_foreign_item(_, ast::foreign_abi_rust_intrinsic, + _, _) => { must_monomorphise = true; } diff --git a/src/librustc/middle/trans/foreign.rs b/src/librustc/middle/trans/foreign.rs index 8dd55c9a37b..dadd51b3248 100644 --- a/src/librustc/middle/trans/foreign.rs +++ b/src/librustc/middle/trans/foreign.rs @@ -1083,7 +1083,7 @@ fn abi_of_foreign_fn(ccx: @CrateContext, i: @ast::foreign_item) -> ast::foreign_abi { match attr::first_attr_value_str_by_name(i.attrs, ~"abi") { None => match ccx.tcx.items.get(&i.id) { - ast_map::node_foreign_item(_, abi, _) => abi, + ast_map::node_foreign_item(_, abi, _, _) => abi, // ?? _ => fail!(~"abi_of_foreign_fn: not foreign") }, diff --git a/src/librustc/middle/trans/monomorphize.rs b/src/librustc/middle/trans/monomorphize.rs index 320fc3ed77a..feddbabdcad 100644 --- a/src/librustc/middle/trans/monomorphize.rs +++ b/src/librustc/middle/trans/monomorphize.rs @@ -94,7 +94,7 @@ pub fn monomorphic_fn(ccx: @CrateContext, ast_map::node_item(i, pt) => (pt, i.ident, i.span), ast_map::node_variant(ref v, enm, pt) => (pt, (*v).node.name, enm.span), ast_map::node_method(m, _, pt) => (pt, m.ident, m.span), - ast_map::node_foreign_item(i, ast::foreign_abi_rust_intrinsic, pt) + ast_map::node_foreign_item(i, ast::foreign_abi_rust_intrinsic, _, pt) => (pt, i.ident, i.span), ast_map::node_foreign_item(*) => { // Foreign externs don't have to be monomorphized. @@ -181,7 +181,7 @@ pub fn monomorphic_fn(ccx: @CrateContext, ast_map::node_item(*) => { ccx.tcx.sess.bug(~"Can't monomorphize this kind of item") } - ast_map::node_foreign_item(i, _, _) => { + ast_map::node_foreign_item(i, _, _, _) => { let d = mk_lldecl(); foreign::trans_intrinsic(ccx, d, i, pt, psubsts.get(), ref_id); diff --git a/src/librustc/middle/trans/reachable.rs b/src/librustc/middle/trans/reachable.rs index 44464810620..2adf9926f2d 100644 --- a/src/librustc/middle/trans/reachable.rs +++ b/src/librustc/middle/trans/reachable.rs @@ -76,7 +76,7 @@ fn traverse_def_id(cx: ctx, did: def_id) { match n { ast_map::node_item(item, _) => traverse_public_item(cx, item), ast_map::node_method(_, impl_id, _) => traverse_def_id(cx, impl_id), - ast_map::node_foreign_item(item, _, _) => { + ast_map::node_foreign_item(item, _, _, _) => { cx.rmap.insert(item.id, ()); } ast_map::node_variant(ref v, _, _) => { diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs index 593919d108b..77e10b2fbda 100644 --- a/src/librustc/middle/trans/type_use.rs +++ b/src/librustc/middle/trans/type_use.rs @@ -118,7 +118,9 @@ pub fn type_uses_for(ccx: @CrateContext, fn_id: def_id, n_tps: uint) } ast_map::node_foreign_item(i@@foreign_item { node: foreign_item_fn(*), _ }, - abi, _) => { + abi, + _, + _) => { if abi == foreign_abi_rust_intrinsic { let flags = match *cx.ccx.sess.str_of(i.ident) { ~"size_of" | ~"pref_align_of" | ~"min_align_of" | diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 599fa28e242..9520da7a5d2 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -3762,7 +3762,7 @@ pub fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path { vec::append_one(/*bad*/copy *path, item_elt) } - ast_map::node_foreign_item(nitem, _, path) => { + ast_map::node_foreign_item(nitem, _, _, path) => { vec::append_one(/*bad*/copy *path, ast_map::path_name(nitem.ident)) } diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index b9aac4b19ed..dacc9553cd2 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/src/librustc/middle/typeck/collect.rs @@ -139,7 +139,7 @@ fn get_item_ty(&self, id: ast::def_id) -> ty::ty_param_bounds_and_ty { Some(ast_map::node_item(item, _)) => { ty_of_item(self, item) } - Some(ast_map::node_foreign_item(foreign_item, _, _)) => { + Some(ast_map::node_foreign_item(foreign_item, _, _, _)) => { ty_of_foreign_item(self, foreign_item) } ref x => { diff --git a/src/librustdoc/attr_pass.rs b/src/librustdoc/attr_pass.rs index 5e3fdf19ad3..0bf2f50e63f 100644 --- a/src/librustdoc/attr_pass.rs +++ b/src/librustdoc/attr_pass.rs @@ -116,7 +116,7 @@ fn parse_item_attrs( do astsrv::exec(srv) |ctxt| { let attrs = match ctxt.ast_map.get(&id) { ast_map::node_item(item, _) => copy item.attrs, - ast_map::node_foreign_item(item, _, _) => copy item.attrs, + ast_map::node_foreign_item(item, _, _, _) => copy item.attrs, _ => fail!(~"parse_item_attrs: not an item") }; parse_attrs(attrs) diff --git a/src/librustdoc/tystr_pass.rs b/src/librustdoc/tystr_pass.rs index 54197e316da..638274d0bb8 100644 --- a/src/librustdoc/tystr_pass.rs +++ b/src/librustdoc/tystr_pass.rs @@ -74,7 +74,7 @@ fn get_fn_sig(srv: astsrv::Srv, fn_id: doc::AstId) -> Option<~str> { ast_map::node_foreign_item(@ast::foreign_item { ident: ident, node: ast::foreign_item_fn(ref decl, _, ref tys), _ - }, _, _) => { + }, _, _, _) => { Some(pprust::fun_to_str(decl, ident, None, tys, extract::interner())) } diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs index 5266d1b049a..9371055556e 100644 --- a/src/libsyntax/ast_map.rs +++ b/src/libsyntax/ast_map.rs @@ -87,7 +87,7 @@ pub fn path_elt_to_str(pe: path_elt, itr: @ident_interner) -> ~str { pub enum ast_node { node_item(@item, @path), - node_foreign_item(@foreign_item, foreign_abi, @path), + node_foreign_item(@foreign_item, foreign_abi, visibility, @path), node_trait_method(@trait_method, def_id /* trait did */, @path /* path to the trait */), node_method(@method, def_id /* impl did */, @path /* path to the impl */), @@ -170,7 +170,9 @@ pub fn map_decoded_item(diag: @span_handler, match ii { ii_item(*) | ii_dtor(*) => { /* fallthrough */ } ii_foreign(i) => { - cx.map.insert(i.id, node_foreign_item(i, foreign_abi_rust_intrinsic, + cx.map.insert(i.id, node_foreign_item(i, + foreign_abi_rust_intrinsic, + i.vis, // Wrong but OK @path)); } ii_method(impl_did, m) => { @@ -277,10 +279,18 @@ pub fn map_item(i: @item, &&cx: @mut Ctx, v: visit::vt<@mut Ctx>) { Right(abi) => abi }; for nm.items.each |nitem| { + // Compute the visibility for this native item. + let visibility = match nitem.vis { + public => public, + private => private, + inherited => i.vis + }; + cx.map.insert(nitem.id, node_foreign_item( *nitem, abi, + visibility, // FIXME (#2543) if nm.sort == ast::named { extend(cx, i.ident) @@ -380,7 +390,7 @@ pub fn node_id_to_str(map: map, id: node_id, itr: @ident_interner) -> ~str { }; fmt!("%s %s (id=%?)", item_str, path_str, id) } - Some(node_foreign_item(item, abi, path)) => { + Some(node_foreign_item(item, abi, _, path)) => { fmt!("foreign item %s with abi %? (id=%?)", path_ident_to_str(*path, item.ident, itr), abi, id) } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 6f4d9332df8..62e1d20e9b2 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -120,7 +120,7 @@ pub enum item_or_view_item { enum view_item_parse_mode { VIEW_ITEMS_AND_ITEMS_ALLOWED, - VIEW_ITEMS_AND_FOREIGN_ITEMS_ALLOWED, + FOREIGN_ITEMS_ALLOWED, IMPORTS_AND_ITEMS_ALLOWED } @@ -642,9 +642,9 @@ fn parse_ty(&self, colons_before_params: bool) -> @Ty { self.obsolete(*self.last_span, ObsoleteMutVector); } - // Parse the `* e` in `[ int * e ]` + // Parse the `, ..e` in `[ int, ..e ]` // where `e` is a const expression - let t = match self.maybe_parse_fixed_vstore_with_star() { + let t = match self.maybe_parse_fixed_vstore() { None => ty_vec(mt), Some(suffix) => ty_fixed_length_vec(mt, suffix) }; @@ -815,8 +815,14 @@ fn parse_fn_block_arg(&self) -> arg_or_capture_item { }) } - fn maybe_parse_fixed_vstore_with_star(&self) -> Option<@ast::expr> { + fn maybe_parse_fixed_vstore(&self) -> Option<@ast::expr> { if self.eat(&token::BINOP(token::STAR)) { + // XXX: Obsolete; remove after snapshot. + Some(self.parse_expr()) + } else if *self.token == token::COMMA && + self.look_ahead(1) == token::DOTDOT { + self.bump(); + self.bump(); Some(self.parse_expr()) } else { None @@ -3538,7 +3544,12 @@ fn parse_item_foreign_fn(&self, +attrs: ~[attribute]) -> @foreign_item { fn parse_item_foreign_const(&self, vis: ast::visibility, +attrs: ~[attribute]) -> @foreign_item { let lo = self.span.lo; - self.expect_keyword(&~"const"); + + // XXX: Obsolete; remove after snap. + if !self.eat_keyword(&~"const") { + self.expect_keyword(&~"static"); + } + let ident = self.parse_ident(); self.expect(&token::COLON); let ty = self.parse_ty(false); @@ -3567,7 +3578,7 @@ fn parse_fn_purity(&self) -> purity { fn parse_foreign_item(&self, +attrs: ~[attribute]) -> @foreign_item { let vis = self.parse_visibility(); - if self.is_keyword(&~"const") { + if self.is_keyword(&~"const") || self.is_keyword(&~"static") { self.parse_item_foreign_const(vis, attrs) } else { self.parse_item_foreign_fn(attrs) @@ -3585,7 +3596,7 @@ fn parse_foreign_mod_items(&self, sort: ast::foreign_mod_sort, items: _, foreign_items: foreign_items } = self.parse_items_and_view_items(first_item_attrs, - VIEW_ITEMS_AND_FOREIGN_ITEMS_ALLOWED, + FOREIGN_ITEMS_ALLOWED, true); let mut items: ~[@foreign_item] = foreign_items; @@ -3925,17 +3936,24 @@ fn parse_item_or_view_item( visibility = inherited; } - if items_allowed && self.eat_keyword(&~"const") { + if items_allowed && + (self.is_keyword(&~"const") || + (self.is_keyword(&~"static") && + !self.token_is_keyword(&~"fn", &self.look_ahead(1)))) { // CONST ITEM + self.bump(); let (ident, item_, extra_attrs) = self.parse_item_const(); return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, visibility, maybe_append(attrs, extra_attrs))); - } else if foreign_items_allowed && self.is_keyword(&~"const") { + } + if foreign_items_allowed && + (self.is_keyword(&~"const") || self.is_keyword(&~"static")) { // FOREIGN CONST ITEM let item = self.parse_item_foreign_const(visibility, attrs); return iovi_foreign_item(item); - } else if items_allowed && + } + if items_allowed && // FUNCTION ITEM (not sure about lookahead condition...) self.is_keyword(&~"fn") && !self.fn_expr_lookahead(self.look_ahead(1u)) { @@ -3944,7 +3962,8 @@ fn parse_item_or_view_item( return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, visibility, maybe_append(attrs, extra_attrs))); - } else if items_allowed && self.eat_keyword(&~"pure") { + } + if items_allowed && self.eat_keyword(&~"pure") { // PURE FUNCTION ITEM // NB: We parse this as impure for bootstrapping purposes. self.expect_keyword(&~"fn"); @@ -3952,13 +3971,15 @@ fn parse_item_or_view_item( return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, visibility, maybe_append(attrs, extra_attrs))); - } else if foreign_items_allowed && + } + if foreign_items_allowed && (self.is_keyword(&~"fn") || self.is_keyword(&~"pure") || self.is_keyword(&~"unsafe")) { // FOREIGN FUNCTION ITEM (no items allowed) let item = self.parse_item_foreign_fn(attrs); return iovi_foreign_item(item); - } else if items_allowed && self.is_keyword(&~"unsafe") + } + if items_allowed && self.is_keyword(&~"unsafe") && self.look_ahead(1u) != token::LBRACE { // UNSAFE FUNCTION ITEM (where items are allowed) self.bump(); @@ -3967,7 +3988,8 @@ fn parse_item_or_view_item( return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, visibility, maybe_append(attrs, extra_attrs))); - } else if self.eat_keyword(&~"extern") { + } + if self.eat_keyword(&~"extern") { if items_allowed && self.eat_keyword(&~"fn") { // EXTERN FUNCTION ITEM let (ident, item_, extra_attrs) = @@ -3977,47 +3999,62 @@ fn parse_item_or_view_item( maybe_append(attrs, extra_attrs))); } - // EXTERN MODULE ITEM - return self.parse_item_foreign_mod(lo, visibility, attrs, - items_allowed); - } else if items_allowed && self.eat_keyword(&~"mod") { + if !foreign_items_allowed { + // EXTERN MODULE ITEM + return self.parse_item_foreign_mod(lo, visibility, attrs, + items_allowed); + } + } + if items_allowed && !foreign_items_allowed && + self.eat_keyword(&~"mod") { // MODULE ITEM let (ident, item_, extra_attrs) = self.parse_item_mod(attrs); return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, visibility, maybe_append(attrs, extra_attrs))); - } else if items_allowed && self.eat_keyword(&~"type") { + } + if items_allowed && !foreign_items_allowed && + self.eat_keyword(&~"type") { // TYPE ITEM let (ident, item_, extra_attrs) = self.parse_item_type(); return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, visibility, maybe_append(attrs, extra_attrs))); - } else if items_allowed && self.eat_keyword(&~"enum") { + } + if items_allowed && !foreign_items_allowed && + self.eat_keyword(&~"enum") { // ENUM ITEM let (ident, item_, extra_attrs) = self.parse_item_enum(); return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, visibility, maybe_append(attrs, extra_attrs))); - } else if items_allowed && self.eat_keyword(&~"trait") { + } + if items_allowed && !foreign_items_allowed && + self.eat_keyword(&~"trait") { // TRAIT ITEM let (ident, item_, extra_attrs) = self.parse_item_trait(); return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, visibility, maybe_append(attrs, extra_attrs))); - } else if items_allowed && self.eat_keyword(&~"impl") { + } + if items_allowed && !foreign_items_allowed && + self.eat_keyword(&~"impl") { // IMPL ITEM let (ident, item_, extra_attrs) = self.parse_item_impl(visibility); return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, visibility, maybe_append(attrs, extra_attrs))); - } else if items_allowed && self.eat_keyword(&~"struct") { + } + if items_allowed && !foreign_items_allowed && + self.eat_keyword(&~"struct") { // STRUCT ITEM let (ident, item_, extra_attrs) = self.parse_item_struct(); return iovi_item(self.mk_item(lo, self.last_span.hi, ident, item_, visibility, maybe_append(attrs, extra_attrs))); - } else if self.eat_keyword(&~"use") { + } + if !foreign_items_allowed && self.eat_keyword(&~"use") { // USE ITEM let view_item = self.parse_use(); self.expect(&token::SEMI); @@ -4027,7 +4064,8 @@ fn parse_item_or_view_item( vis: visibility, span: mk_sp(lo, self.last_span.hi) }); - } else if macros_allowed && !self.is_any_keyword(© *self.token) + } + if macros_allowed && !self.is_any_keyword(© *self.token) && self.look_ahead(1) == token::NOT && (is_plain_ident(&self.look_ahead(2)) || self.look_ahead(2) == token::LPAREN @@ -4070,16 +4108,16 @@ fn parse_item_or_view_item( let item_ = item_mac(m); return iovi_item(self.mk_item(lo, self.last_span.hi, id, item_, visibility, attrs)); - } else { - // FAILURE TO PARSE ITEM - if visibility != inherited { - let mut s = ~"unmatched visibility `"; - s += if visibility == public { ~"pub" } else { ~"priv" }; - s += ~"`"; - self.span_fatal(*self.last_span, s); - } - return iovi_none; - }; + } + + // FAILURE TO PARSE ITEM + if visibility != inherited { + let mut s = ~"unmatched visibility `"; + s += if visibility == public { ~"pub" } else { ~"priv" }; + s += ~"`"; + self.span_fatal(*self.last_span, s); + } + return iovi_none; } fn parse_item(&self, +attrs: ~[attribute]) -> Option<@ast::item> { @@ -4246,17 +4284,17 @@ fn parse_items_and_view_items(&self, +first_item_attrs: ~[attribute], let items_allowed = match mode { VIEW_ITEMS_AND_ITEMS_ALLOWED | IMPORTS_AND_ITEMS_ALLOWED => true, - VIEW_ITEMS_AND_FOREIGN_ITEMS_ALLOWED => false + FOREIGN_ITEMS_ALLOWED => false }; let restricted_to_imports = match mode { IMPORTS_AND_ITEMS_ALLOWED => true, VIEW_ITEMS_AND_ITEMS_ALLOWED | - VIEW_ITEMS_AND_FOREIGN_ITEMS_ALLOWED => false + FOREIGN_ITEMS_ALLOWED => false }; let foreign_items_allowed = match mode { - VIEW_ITEMS_AND_FOREIGN_ITEMS_ALLOWED => true, + FOREIGN_ITEMS_ALLOWED => true, VIEW_ITEMS_AND_ITEMS_ALLOWED | IMPORTS_AND_ITEMS_ALLOWED => false }; diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 9b8448bc2d9..e2d48979fab 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -424,7 +424,7 @@ pub fn print_type_ex(s: @ps, &&ty: @ast::Ty, print_colons: bool) { ast::m_imm => () } print_type(s, mt.ty); - word(s.s, ~" * "); + word(s.s, ~", .."); print_expr(s, v); word(s.s, ~"]"); } @@ -452,7 +452,7 @@ pub fn print_foreign_item(s: @ps, item: @ast::foreign_item) { end(s); // end the outer fn box } ast::foreign_item_const(t) => { - head(s, ~"const"); + head(s, ~"static"); print_ident(s, item.ident); word_space(s, ~":"); print_type(s, t); @@ -471,7 +471,7 @@ pub fn print_item(s: @ps, &&item: @ast::item) { (s.ann.pre)(ann_node); match /*bad*/ copy item.node { ast::item_const(ty, expr) => { - head(s, visibility_qualified(item.vis, ~"const")); + head(s, visibility_qualified(item.vis, ~"static")); print_ident(s, item.ident); word_space(s, ~":"); print_type(s, ty); diff --git a/src/test/compile-fail/static-method-privacy.rs b/src/test/compile-fail/static-method-privacy.rs new file mode 100644 index 00000000000..d9b4112b1bd --- /dev/null +++ b/src/test/compile-fail/static-method-privacy.rs @@ -0,0 +1,11 @@ +mod a { + pub struct S; + impl S { + static fn new() -> S { S } + } +} + +fn main() { + let _ = a::S::new(); //~ ERROR function `new` is private +} + diff --git a/src/test/pretty/blank-lines.rs b/src/test/pretty/blank-lines.rs index 3fe4fcea8b5..24eb5337d25 100644 --- a/src/test/pretty/blank-lines.rs +++ b/src/test/pretty/blank-lines.rs @@ -9,7 +9,7 @@ // except according to those terms. // pp-exact -fn f() -> [int * 3] { +fn f() -> [int, ..3] { let picard = 0; let data = 1; diff --git a/src/test/run-pass/conditional-compile.rs b/src/test/run-pass/conditional-compile.rs index 3a626ca6ac1..223825f60a7 100644 --- a/src/test/run-pass/conditional-compile.rs +++ b/src/test/run-pass/conditional-compile.rs @@ -121,13 +121,6 @@ pub mod rustrt { mod test_use_statements { #[cfg(bogus)] use flippity_foo; - - pub mod rustrt { - pub extern { - #[cfg(bogus)] - use flippity_foo; - } - } } mod test_methods { diff --git a/src/test/run-pass/import-from-foreign.rs b/src/test/run-pass/import-from-foreign.rs deleted file mode 100644 index feebcdff921..00000000000 --- a/src/test/run-pass/import-from-foreign.rs +++ /dev/null @@ -1,25 +0,0 @@ -// xfail-fast - -// Copyright 2012 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -mod spam { - pub fn ham() { } - pub fn eggs() { } -} - -mod rustrt { - #[abi = "cdecl"] - pub extern { - pub use spam::{ham, eggs}; - } -} - -pub fn main() { rustrt::ham(); rustrt::eggs(); } diff --git a/src/test/run-pass/new-style-constants.rs b/src/test/run-pass/new-style-constants.rs new file mode 100644 index 00000000000..f5c691d512e --- /dev/null +++ b/src/test/run-pass/new-style-constants.rs @@ -0,0 +1,8 @@ +use core::io::println; + +static FOO: int = 3; + +fn main() { + println(fmt!("%d", FOO)); +} + diff --git a/src/test/run-pass/new-style-fixed-length-vec.rs b/src/test/run-pass/new-style-fixed-length-vec.rs new file mode 100644 index 00000000000..44261458a9a --- /dev/null +++ b/src/test/run-pass/new-style-fixed-length-vec.rs @@ -0,0 +1,10 @@ +use core::io::println; + +static FOO: [int, ..3] = [1, 2, 3]; + +fn main() { + println(fmt!("%d %d %d", FOO[0], FOO[1], FOO[2])); +} + + +