From bae482185173d11d9aae2497ba3764947f196675 Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Tue, 29 Jan 2013 16:26:16 -0800 Subject: [PATCH] librustc: De-export typeck. rs=deexporting --- src/librustc/middle/typeck/astconv.rs | 28 +-- src/librustc/middle/typeck/check/mod.rs | 171 +++++++++--------- src/librustc/middle/typeck/coherence.rs | 32 ++-- src/librustc/middle/typeck/collect.rs | 151 ++++++++-------- src/librustc/middle/typeck/infer/combine.rs | 57 +++--- src/librustc/middle/typeck/infer/glb.rs | 4 +- src/librustc/middle/typeck/infer/lattice.rs | 53 +++--- src/librustc/middle/typeck/infer/lub.rs | 11 +- src/librustc/middle/typeck/infer/mod.rs | 127 +++++-------- .../middle/typeck/infer/region_inference.rs | 11 +- src/librustc/middle/typeck/infer/resolve.rs | 36 ++-- src/librustc/middle/typeck/infer/sub.rs | 9 +- src/librustc/middle/typeck/infer/to_str.rs | 22 +-- src/librustc/middle/typeck/infer/unify.rs | 31 ++-- src/librustc/middle/typeck/mod.rs | 67 ++----- src/librustc/middle/typeck/rscope.rs | 25 +-- 16 files changed, 377 insertions(+), 458 deletions(-) diff --git a/src/librustc/middle/typeck/astconv.rs b/src/librustc/middle/typeck/astconv.rs index e845904956d9..4e4fc564c238 100644 --- a/src/librustc/middle/typeck/astconv.rs +++ b/src/librustc/middle/typeck/astconv.rs @@ -81,9 +81,10 @@ pub trait ast_conv { fn ty_infer(span: span) -> ty::t; } -fn get_region_reporting_err(tcx: ty::ctxt, - span: span, - res: Result) -> ty::Region { +pub fn get_region_reporting_err(tcx: ty::ctxt, + span: span, + res: Result) + -> ty::Region { match res { result::Ok(r) => r, @@ -94,7 +95,7 @@ fn get_region_reporting_err(tcx: ty::ctxt, } } -fn ast_region_to_region( +pub fn ast_region_to_region( self: AC, rscope: RS, span: span, a_r: @ast::region) -> ty::Region { let res = match a_r.node { @@ -107,7 +108,7 @@ fn ast_region_to_region( get_region_reporting_err(self.tcx(), span, res) } -fn ast_path_to_substs_and_ty( +pub fn ast_path_to_substs_and_ty( self: AC, rscope: RS, did: ast::def_id, path: @ast::path) -> ty_param_substs_and_ty { @@ -174,13 +175,13 @@ pub fn ast_path_to_ty( return {substs: substs, ty: ty}; } -const NO_REGIONS: uint = 1; -const NO_TPS: uint = 2; +pub const NO_REGIONS: uint = 1; +pub const NO_TPS: uint = 2; // Parses the programmer's textual representation of a type into our // internal notion of a type. `getter` is a function that returns the type // corresponding to a definition ID: -fn ast_ty_to_ty( +pub fn ast_ty_to_ty( self: AC, rscope: RS, &&ast_ty: @ast::Ty) -> ty::t { fn ast_mt_to_mt( @@ -405,7 +406,7 @@ fn ast_ty_to_ty( return typ; } -fn ty_of_arg( +pub fn ty_of_arg( self: AC, rscope: RS, a: ast::arg, expected_ty: Option) -> ty::arg { @@ -451,10 +452,10 @@ fn ty_of_arg( arg {mode: mode, ty: ty} } -type expected_tys = Option<{inputs: ~[ty::arg], - output: ty::t}>; +pub type expected_tys = Option<{inputs: ~[ty::arg], + output: ty::t}>; -fn ty_of_fn_decl( +pub fn ty_of_fn_decl( self: AC, rscope: RS, ast_proto: ast::Proto, purity: ast::purity, @@ -463,8 +464,7 @@ fn ty_of_fn_decl( opt_region: Option<@ast::region>, decl: ast::fn_decl, expected_tys: expected_tys, - span: span) -> ty::FnTy -{ + span: span) -> ty::FnTy { debug!("ty_of_fn_decl"); do indent { // resolve the function bound region in the original region diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index 8ca9af3cd234..d3a56055a5a6 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -156,7 +156,7 @@ pub type self_info = { /// Here, the function `foo()` and the closure passed to /// `bar()` will each have their own `fn_ctxt`, but they will /// share the inherited fields. -struct inherited { +pub struct inherited { infcx: @infer::InferCtxt, locals: HashMap, node_types: HashMap, @@ -164,7 +164,7 @@ struct inherited { adjustments: HashMap } -enum FnKind { ForLoop, DoBlock, Vanilla } +pub enum FnKind { ForLoop, DoBlock, Vanilla } pub struct fn_ctxt { // var_bindings, locals and next_var_id are shared @@ -206,7 +206,7 @@ pub struct fn_ctxt { ccx: @crate_ctxt, } -fn blank_inherited(ccx: @crate_ctxt) -> @inherited { +pub fn blank_inherited(ccx: @crate_ctxt) -> @inherited { @inherited { infcx: infer::new_infer_ctxt(ccx.tcx), locals: HashMap(), @@ -217,8 +217,8 @@ fn blank_inherited(ccx: @crate_ctxt) -> @inherited { } // Used by check_const and check_enum_variants -fn blank_fn_ctxt(ccx: @crate_ctxt, rty: ty::t, - region_bnd: ast::node_id) -> @fn_ctxt { +pub fn blank_fn_ctxt(ccx: @crate_ctxt, rty: ty::t, + region_bnd: ast::node_id) -> @fn_ctxt { // It's kind of a kludge to manufacture a fake function context // and statement context, but we might as well do write the code only once @fn_ctxt { @@ -242,11 +242,11 @@ pub fn check_item_types(ccx: @crate_ctxt, crate: @ast::crate) { visit::visit_crate(*crate, (), visit); } -fn check_bare_fn(ccx: @crate_ctxt, - decl: &ast::fn_decl, - body: ast::blk, - id: ast::node_id, - self_info: Option) { +pub fn check_bare_fn(ccx: @crate_ctxt, + decl: &ast::fn_decl, + body: ast::blk, + id: ast::node_id, + self_info: Option) { let fty = ty::node_id_to_type(ccx.tcx, id); match ty::get(fty).sty { ty::ty_fn(ref fn_ty) => { @@ -257,13 +257,13 @@ fn check_bare_fn(ccx: @crate_ctxt, } } -fn check_fn(ccx: @crate_ctxt, - self_info: Option, - fn_ty: &ty::FnTy, - decl: &ast::fn_decl, - body: ast::blk, - fn_kind: FnKind, - old_fcx: Option<@fn_ctxt>) { +pub fn check_fn(ccx: @crate_ctxt, + self_info: Option, + fn_ty: &ty::FnTy, + decl: &ast::fn_decl, + body: ast::blk, + fn_kind: FnKind, + old_fcx: Option<@fn_ctxt>) { let tcx = ccx.tcx; let indirect_ret = match fn_kind { @@ -487,8 +487,8 @@ fn check_fn(ccx: @crate_ctxt, } } -fn check_method(ccx: @crate_ctxt, method: @ast::method, - self_ty: ty::t, self_impl_def_id: ast::def_id) { +pub fn check_method(ccx: @crate_ctxt, method: @ast::method, + self_ty: ty::t, self_impl_def_id: ast::def_id) { let self_info = {self_ty: self_ty, self_id: method.self_id, def_id: self_impl_def_id, @@ -496,8 +496,8 @@ fn check_method(ccx: @crate_ctxt, method: @ast::method, check_bare_fn(ccx, &method.decl, method.body, method.id, Some(self_info)); } -fn check_no_duplicate_fields(tcx: ty::ctxt, fields: - ~[(ast::ident, span)]) { +pub fn check_no_duplicate_fields(tcx: ty::ctxt, + fields: ~[(ast::ident, span)]) { let field_names = HashMap(); for fields.each |p| { @@ -516,11 +516,10 @@ fn check_no_duplicate_fields(tcx: ty::ctxt, fields: } } } - } -fn check_struct(ccx: @crate_ctxt, struct_def: @ast::struct_def, - id: ast::node_id, span: span) { +pub fn check_struct(ccx: @crate_ctxt, struct_def: @ast::struct_def, + id: ast::node_id, span: span) { let tcx = ccx.tcx; let self_ty = ty::node_id_to_type(tcx, id); @@ -542,7 +541,7 @@ fn check_struct(ccx: @crate_ctxt, struct_def: @ast::struct_def, check_instantiable(ccx.tcx, span, id); } -fn check_item(ccx: @crate_ctxt, it: @ast::item) { +pub fn check_item(ccx: @crate_ctxt, it: @ast::item) { debug!("check_item(it.id=%d, it.ident=%s)", it.id, ty::item_path_str(ccx.tcx, local_def(it.id))); @@ -617,7 +616,7 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) { } } -impl @fn_ctxt: ast_conv { +pub impl @fn_ctxt: ast_conv { fn tcx() -> ty::ctxt { self.ccx.tcx } fn ccx() -> @crate_ctxt { self.ccx } @@ -630,7 +629,7 @@ impl @fn_ctxt: ast_conv { } } -impl @fn_ctxt { +pub impl @fn_ctxt { fn infcx() -> @infer::InferCtxt { self.inh.infcx } fn search_in_scope_regions(br: ty::bound_region) -> Result @@ -650,7 +649,7 @@ impl @fn_ctxt { } } -impl @fn_ctxt: region_scope { +pub impl @fn_ctxt: region_scope { fn anon_region(span: span) -> Result { result::Ok(self.infcx().next_region_var_nb(span)) } @@ -662,7 +661,7 @@ impl @fn_ctxt: region_scope { } } -impl @fn_ctxt { +pub impl @fn_ctxt { fn tag() -> ~str { fmt!("%x", ptr::addr_of(&(*self)) as uint) } fn local_ty(span: span, nid: ast::node_id) -> ty::t { @@ -874,7 +873,7 @@ impl @fn_ctxt { } } -fn do_autoderef(fcx: @fn_ctxt, sp: span, t: ty::t) -> (ty::t, uint) { +pub fn do_autoderef(fcx: @fn_ctxt, sp: span, t: ty::t) -> (ty::t, uint) { /*! * * Autoderefs the type `t` as many times as possible, returning @@ -931,7 +930,7 @@ fn do_autoderef(fcx: @fn_ctxt, sp: span, t: ty::t) -> (ty::t, uint) { } // AST fragment checking -fn check_lit(fcx: @fn_ctxt, lit: @ast::lit) -> ty::t { +pub fn check_lit(fcx: @fn_ctxt, lit: @ast::lit) -> ty::t { let tcx = fcx.ccx.tcx; match lit.node { @@ -961,37 +960,33 @@ pub fn valid_range_bounds(ccx: @crate_ctxt, from: @ast::expr, to: @ast::expr) pub fn check_expr_has_type( fcx: @fn_ctxt, expr: @ast::expr, - expected: ty::t) -> bool -{ + expected: ty::t) -> bool { do check_expr_with_unifier(fcx, expr, Some(expected)) { demand::suptype(fcx, expr.span, expected, fcx.expr_ty(expr)); } } -fn check_expr_coercable_to_type( +pub fn check_expr_coercable_to_type( fcx: @fn_ctxt, expr: @ast::expr, - expected: ty::t) -> bool -{ + expected: ty::t) -> bool { do check_expr_with_unifier(fcx, expr, Some(expected)) { demand::coerce(fcx, expr.span, expected, expr) } } -fn check_expr_with_hint( +pub fn check_expr_with_hint( fcx: @fn_ctxt, expr: @ast::expr, - expected: ty::t) -> bool -{ + expected: ty::t) -> bool { check_expr_with_unifier(fcx, expr, Some(expected), || ()) } -fn check_expr_with_opt_hint( +pub fn check_expr_with_opt_hint( fcx: @fn_ctxt, expr: @ast::expr, - expected: Option) -> bool -{ + expected: Option) -> bool { check_expr_with_unifier(fcx, expr, expected, || ()) } -fn check_expr(fcx: @fn_ctxt, expr: @ast::expr) -> bool { +pub fn check_expr(fcx: @fn_ctxt, expr: @ast::expr) -> bool { check_expr_with_unifier(fcx, expr, None, || ()) } @@ -1060,11 +1055,11 @@ pub fn impl_self_ty(vcx: &VtableContext, // Only for fields! Returns for methods> // Indifferent to privacy flags -fn lookup_field_ty(tcx: ty::ctxt, - class_id: ast::def_id, - items: &[ty::field_ty], - fieldname: ast::ident, - substs: &ty::substs) -> Option { +pub fn lookup_field_ty(tcx: ty::ctxt, + class_id: ast::def_id, + items: &[ty::field_ty], + fieldname: ast::ident, + substs: &ty::substs) -> Option { let o_field = vec::find(items, |f| f.ident == fieldname); do o_field.map() |f| { @@ -1079,15 +1074,14 @@ pub enum DerefArgs { DoDerefArgs } -fn break_here() { +pub fn break_here() { debug!("break here!"); } -fn check_expr_with_unifier(fcx: @fn_ctxt, - expr: @ast::expr, - expected: Option, - unifier: fn()) -> bool -{ +pub fn check_expr_with_unifier(fcx: @fn_ctxt, + expr: @ast::expr, + expected: Option, + unifier: fn()) -> bool { debug!(">> typechecking %s", fcx.expr_to_str(expr)); // A generic function to factor out common logic from call and @@ -2522,7 +2516,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt, return bot; } -fn require_integral(fcx: @fn_ctxt, sp: span, t: ty::t) { +pub fn require_integral(fcx: @fn_ctxt, sp: span, t: ty::t) { if !type_is_integral(fcx, sp, t) { fcx.type_error_message(sp, |actual| { fmt!("mismatched types: expected integral type but found `%s`", @@ -2531,13 +2525,13 @@ fn require_integral(fcx: @fn_ctxt, sp: span, t: ty::t) { } } -fn check_decl_initializer(fcx: @fn_ctxt, nid: ast::node_id, - init: @ast::expr) -> bool { +pub fn check_decl_initializer(fcx: @fn_ctxt, nid: ast::node_id, + init: @ast::expr) -> bool { let local_ty = fcx.local_ty(init.span, nid); return check_expr_coercable_to_type(fcx, init, local_ty); } -fn check_decl_local(fcx: @fn_ctxt, local: @ast::local) -> bool { +pub fn check_decl_local(fcx: @fn_ctxt, local: @ast::local) -> bool { let mut bot = false; let tcx = fcx.ccx.tcx; @@ -2563,7 +2557,7 @@ fn check_decl_local(fcx: @fn_ctxt, local: @ast::local) -> bool { return bot; } -fn check_stmt(fcx: @fn_ctxt, stmt: @ast::stmt) -> bool { +pub fn check_stmt(fcx: @fn_ctxt, stmt: @ast::stmt) -> bool { let mut node_id; let mut bot = false; match stmt.node { @@ -2590,7 +2584,7 @@ fn check_stmt(fcx: @fn_ctxt, stmt: @ast::stmt) -> bool { return bot; } -fn check_block_no_value(fcx: @fn_ctxt, blk: ast::blk) -> bool { +pub fn check_block_no_value(fcx: @fn_ctxt, blk: ast::blk) -> bool { let bot = check_block(fcx, blk); if !bot { let blkty = fcx.node_ty(blk.node.id); @@ -2604,9 +2598,9 @@ pub fn check_block(fcx0: @fn_ctxt, blk: ast::blk) -> bool { check_block_with_expected(fcx0, blk, None) } -fn check_block_with_expected(fcx0: @fn_ctxt, - blk: ast::blk, - expected: Option) -> bool { +pub fn check_block_with_expected(fcx0: @fn_ctxt, + blk: ast::blk, + expected: Option) -> bool { let fcx = match blk.node.rules { ast::unsafe_blk => @fn_ctxt {purity: ast::unsafe_fn,.. copy *fcx0}, ast::default_blk => fcx0 @@ -2647,15 +2641,18 @@ fn check_block_with_expected(fcx0: @fn_ctxt, } } -fn check_const(ccx: @crate_ctxt, _sp: span, e: @ast::expr, id: ast::node_id) { +pub fn check_const(ccx: @crate_ctxt, + _sp: span, + e: @ast::expr, + id: ast::node_id) { let rty = ty::node_id_to_type(ccx.tcx, id); let fcx = blank_fn_ctxt(ccx, rty, e.id); let declty = fcx.ccx.tcx.tcache.get(local_def(id)).ty; check_const_with_ty(fcx, _sp, e, declty); } -fn check_const_with_ty(fcx: @fn_ctxt, _sp: span, e: @ast::expr, - declty: ty::t) { +pub fn check_const_with_ty(fcx: @fn_ctxt, _sp: span, e: @ast::expr, + declty: ty::t) { check_expr(fcx, e); let cty = fcx.expr_ty(e); demand::suptype(fcx, e.span, declty, cty); @@ -2674,9 +2671,9 @@ fn check_const_with_ty(fcx: @fn_ctxt, _sp: span, e: @ast::expr, /// enum foo { Some(@foo) } /// /// is representable, but not instantiable. -fn check_instantiable(tcx: ty::ctxt, - sp: span, - item_id: ast::node_id) { +pub fn check_instantiable(tcx: ty::ctxt, + sp: span, + item_id: ast::node_id) { let item_ty = ty::node_id_to_type(tcx, item_id); if !ty::is_instantiable(tcx, item_ty) { tcx.sess.span_err(sp, fmt!("this type cannot be instantiated \ @@ -2686,10 +2683,10 @@ fn check_instantiable(tcx: ty::ctxt, } } -fn check_enum_variants(ccx: @crate_ctxt, - sp: span, - +vs: ~[ast::variant], - id: ast::node_id) { +pub fn check_enum_variants(ccx: @crate_ctxt, + sp: span, + +vs: ~[ast::variant], + id: ast::node_id) { fn do_check(ccx: @crate_ctxt, sp: span, vs: ~[ast::variant], id: ast::node_id, disr_vals: &mut ~[int], disr_val: &mut int, variants: &mut ~[ty::VariantInfo]) { @@ -2806,8 +2803,10 @@ pub fn lookup_def(fcx: @fn_ctxt, sp: span, id: ast::node_id) -> ast::def { } // Returns the type parameter count and the type for the given definition. -fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) -> - ty_param_bounds_and_ty { +pub fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, + sp: span, + defn: ast::def) + -> ty_param_bounds_and_ty { match defn { ast::def_arg(nid, _, _) | ast::def_local(nid, _) | @@ -2949,23 +2948,23 @@ pub fn structure_of(fcx: @fn_ctxt, sp: span, typ: ty::t) -> ty::sty { /*bad*/copy ty::get(structurally_resolved_type(fcx, sp, typ)).sty } -fn type_is_integral(fcx: @fn_ctxt, sp: span, typ: ty::t) -> bool { +pub fn type_is_integral(fcx: @fn_ctxt, sp: span, typ: ty::t) -> bool { let typ_s = structurally_resolved_type(fcx, sp, typ); return ty::type_is_integral(typ_s); } -fn type_is_scalar(fcx: @fn_ctxt, sp: span, typ: ty::t) -> bool { +pub fn type_is_scalar(fcx: @fn_ctxt, sp: span, typ: ty::t) -> bool { let typ_s = structurally_resolved_type(fcx, sp, typ); return ty::type_is_scalar(typ_s); } -fn type_is_c_like_enum(fcx: @fn_ctxt, sp: span, typ: ty::t) -> bool { +pub fn type_is_c_like_enum(fcx: @fn_ctxt, sp: span, typ: ty::t) -> bool { let typ_s = structurally_resolved_type(fcx, sp, typ); return ty::type_is_c_like_enum(fcx.ccx.tcx, typ_s); } -fn ast_expr_vstore_to_vstore(fcx: @fn_ctxt, e: @ast::expr, n: uint, - v: ast::expr_vstore) -> ty::vstore { +pub fn ast_expr_vstore_to_vstore(fcx: @fn_ctxt, e: @ast::expr, n: uint, + v: ast::expr_vstore) -> ty::vstore { match v { ast::expr_vstore_fixed(None) => ty::vstore_fixed(n), ast::expr_vstore_fixed(Some(u)) => { @@ -2985,7 +2984,7 @@ fn ast_expr_vstore_to_vstore(fcx: @fn_ctxt, e: @ast::expr, n: uint, } // Returns true if b contains a break that can exit from b -fn may_break(cx: ty::ctxt, id: ast::node_id, b: ast::blk) -> bool { +pub fn may_break(cx: ty::ctxt, id: ast::node_id, b: ast::blk) -> bool { // First: is there an unlabeled break immediately // inside the loop? (loop_query(b, |e| { @@ -3007,10 +3006,10 @@ fn may_break(cx: ty::ctxt, id: ast::node_id, b: ast::blk) -> bool { }})) } -fn check_bounds_are_used(ccx: @crate_ctxt, - span: span, - tps: ~[ast::ty_param], - ty: ty::t) { +pub fn check_bounds_are_used(ccx: @crate_ctxt, + span: span, + tps: ~[ast::ty_param], + ty: ty::t) { debug!("check_bounds_are_used(n_tps=%u, ty=%s)", tps.len(), ppaux::ty_to_str(ccx.tcx, ty)); @@ -3041,7 +3040,7 @@ fn check_bounds_are_used(ccx: @crate_ctxt, } } -fn check_intrinsic_type(ccx: @crate_ctxt, it: @ast::foreign_item) { +pub fn check_intrinsic_type(ccx: @crate_ctxt, it: @ast::foreign_item) { fn param(ccx: @crate_ctxt, n: uint) -> ty::t { ty::mk_param(ccx.tcx, n, local_def(0)) } diff --git a/src/librustc/middle/typeck/coherence.rs b/src/librustc/middle/typeck/coherence.rs index 4cd2eaaf003c..153d09e82e61 100644 --- a/src/librustc/middle/typeck/coherence.rs +++ b/src/librustc/middle/typeck/coherence.rs @@ -65,15 +65,16 @@ use core::vec::{len, push}; use core::vec; use std::map::HashMap; -struct UniversalQuantificationResult { +pub struct UniversalQuantificationResult { monotype: t, type_variables: ~[ty::t], bounds: @~[param_bounds] } -fn get_base_type(inference_context: @InferCtxt, span: span, original_type: t) - -> Option { - +pub fn get_base_type(inference_context: @InferCtxt, + span: span, + original_type: t) + -> Option { let resolved_type; match resolve_type(inference_context, original_type, @@ -118,11 +119,10 @@ fn get_base_type(inference_context: @InferCtxt, span: span, original_type: t) } // Returns the def ID of the base type, if there is one. -fn get_base_type_def_id(inference_context: @InferCtxt, - span: span, - original_type: t) - -> Option { - +pub fn get_base_type_def_id(inference_context: @InferCtxt, + span: span, + original_type: t) + -> Option { match get_base_type(inference_context, span, original_type) { None => { return None; @@ -144,7 +144,7 @@ fn get_base_type_def_id(inference_context: @InferCtxt, } -fn method_to_MethodInfo(ast_method: @method) -> @MethodInfo { +pub fn method_to_MethodInfo(ast_method: @method) -> @MethodInfo { @{ did: local_def(ast_method.id), n_tps: ast_method.tps.len(), @@ -153,7 +153,7 @@ fn method_to_MethodInfo(ast_method: @method) -> @MethodInfo { } } -struct CoherenceInfo { +pub struct CoherenceInfo { // Contains implementations of methods that are inherent to a type. // Methods in these implementations don't need to be exported. inherent_methods: HashMap>, @@ -164,14 +164,14 @@ struct CoherenceInfo { } -fn CoherenceInfo() -> CoherenceInfo { +pub fn CoherenceInfo() -> CoherenceInfo { CoherenceInfo { inherent_methods: HashMap(), extension_methods: HashMap(), } } -fn CoherenceChecker(crate_context: @crate_ctxt) -> CoherenceChecker { +pub fn CoherenceChecker(crate_context: @crate_ctxt) -> CoherenceChecker { CoherenceChecker { crate_context: crate_context, inference_context: new_infer_ctxt(crate_context.tcx), @@ -181,7 +181,7 @@ fn CoherenceChecker(crate_context: @crate_ctxt) -> CoherenceChecker { } } -struct CoherenceChecker { +pub struct CoherenceChecker { crate_context: @crate_ctxt, inference_context: @InferCtxt, @@ -196,7 +196,7 @@ struct CoherenceChecker { privileged_implementations: HashMap, } -impl CoherenceChecker { +pub impl CoherenceChecker { fn check_coherence(crate: @crate) { // Check implementations and traits. This populates the tables // containing the inherent methods and extension methods. It also @@ -1011,7 +1011,7 @@ impl CoherenceChecker { } } -fn check_coherence(crate_context: @crate_ctxt, crate: @crate) { +pub fn check_coherence(crate_context: @crate_ctxt, crate: @crate) { let coherence_checker = @CoherenceChecker(crate_context); (*coherence_checker).check_coherence(crate); } diff --git a/src/librustc/middle/typeck/collect.rs b/src/librustc/middle/typeck/collect.rs index 8374a65f63c3..3693a2779b8a 100644 --- a/src/librustc/middle/typeck/collect.rs +++ b/src/librustc/middle/typeck/collect.rs @@ -61,7 +61,7 @@ use syntax::codemap; use syntax::print::pprust::path_to_str; use syntax::visit; -fn collect_item_types(ccx: @crate_ctxt, crate: @ast::crate) { +pub fn collect_item_types(ccx: @crate_ctxt, crate: @ast::crate) { // FIXME (#2592): hooking into the "intrinsic" root module is crude. // There ought to be a better approach. Attributes? @@ -114,7 +114,7 @@ fn collect_item_types(ccx: @crate_ctxt, crate: @ast::crate) { })); } -impl @crate_ctxt { +pub impl @crate_ctxt { fn to_ty( rs: RS, ast_ty: @ast::Ty) -> ty::t { @@ -122,7 +122,7 @@ impl @crate_ctxt { } } -impl @crate_ctxt: ast_conv { +pub impl @crate_ctxt: ast_conv { fn tcx() -> ty::ctxt { self.tcx } fn ccx() -> @crate_ctxt { self } @@ -151,11 +151,11 @@ impl @crate_ctxt: ast_conv { } } -fn get_enum_variant_types(ccx: @crate_ctxt, - enum_ty: ty::t, - variants: ~[ast::variant], - ty_params: ~[ast::ty_param], - rp: Option) { +pub fn get_enum_variant_types(ccx: @crate_ctxt, + enum_ty: ty::t, + variants: ~[ast::variant], + ty_params: ~[ast::ty_param], + rp: Option) { let tcx = ccx.tcx; // Create a set of parameter types shared among all the variants. @@ -237,7 +237,9 @@ fn get_enum_variant_types(ccx: @crate_ctxt, } } -fn ensure_trait_methods(ccx: @crate_ctxt, id: ast::node_id, trait_ty: ty::t) { +pub fn ensure_trait_methods(ccx: @crate_ctxt, + id: ast::node_id, + trait_ty: ty::t) { fn store_methods(ccx: @crate_ctxt, id: ast::node_id, stuff: ~[T], f: &fn(v: &T) -> ty::method) { ty::store_trait_methods(ccx.tcx, id, @vec::map(stuff, f)); @@ -318,11 +320,11 @@ fn ensure_trait_methods(ccx: @crate_ctxt, id: ast::node_id, trait_ty: ty::t) { } } -fn ensure_supertraits(ccx: @crate_ctxt, - id: ast::node_id, - sp: codemap::span, - rp: Option, - trait_refs: &[@ast::trait_ref]) { +pub fn ensure_supertraits(ccx: @crate_ctxt, + id: ast::node_id, + sp: codemap::span, + rp: Option, + trait_refs: &[@ast::trait_ref]) { let tcx = ccx.tcx; if tcx.supertraits.contains_key(local_def(id)) { return; } @@ -355,13 +357,12 @@ fn ensure_supertraits(ccx: @crate_ctxt, * - trait_substs: the substitutions used on the type of the trait * - self_ty: the self type of the impl */ -fn compare_impl_method(tcx: ty::ctxt, - impl_tps: uint, - cm: &ConvertedMethod, - trait_m: &ty::method, - trait_substs: &ty::substs, - self_ty: ty::t) -{ +pub fn compare_impl_method(tcx: ty::ctxt, + impl_tps: uint, + cm: &ConvertedMethod, + trait_m: &ty::method, + trait_substs: &ty::substs, + self_ty: ty::t) { debug!("compare_impl_method()"); let _indenter = indenter(); @@ -503,12 +504,12 @@ fn compare_impl_method(tcx: ty::ctxt, } } -fn check_methods_against_trait(ccx: @crate_ctxt, - tps: ~[ast::ty_param], - rp: Option, - selfty: ty::t, - a_trait_ty: @ast::trait_ref, - impl_ms: ~[ConvertedMethod]) { +pub fn check_methods_against_trait(ccx: @crate_ctxt, + tps: ~[ast::ty_param], + rp: Option, + selfty: ty::t, + a_trait_ty: @ast::trait_ref, + impl_ms: ~[ConvertedMethod]) { let tcx = ccx.tcx; let (did, tpt) = instantiate_trait_ref(ccx, a_trait_ty, rp); @@ -554,10 +555,10 @@ fn check_methods_against_trait(ccx: @crate_ctxt, } } // fn -fn convert_field(ccx: @crate_ctxt, - rp: Option, - bounds: @~[ty::param_bounds], - v: @ast::struct_field) { +pub fn convert_field(ccx: @crate_ctxt, + rp: Option, + bounds: @~[ty::param_bounds], + v: @ast::struct_field) { let tt = ccx.to_ty(type_rscope(rp), v.node.ty); write_ty_to_tcx(ccx.tcx, v.node.id, tt); /* add the field to the tcache */ @@ -567,17 +568,18 @@ fn convert_field(ccx: @crate_ctxt, ty: tt}); } -struct ConvertedMethod { +pub struct ConvertedMethod { mty: ty::method, id: ast::node_id, span: span, body_id: ast::node_id } -fn convert_methods(ccx: @crate_ctxt, - ms: ~[@ast::method], - rp: Option, - rcvr_bounds: @~[ty::param_bounds]) -> ~[ConvertedMethod] { +pub fn convert_methods(ccx: @crate_ctxt, + ms: ~[@ast::method], + rp: Option, + rcvr_bounds: @~[ty::param_bounds]) + -> ~[ConvertedMethod] { let tcx = ccx.tcx; do vec::map(ms) |m| { @@ -598,10 +600,10 @@ fn convert_methods(ccx: @crate_ctxt, } } -fn ensure_no_ty_param_bounds(ccx: @crate_ctxt, - span: span, - ty_params: &[ast::ty_param], - thing: &static/str) { +pub fn ensure_no_ty_param_bounds(ccx: @crate_ctxt, + span: span, + ty_params: &[ast::ty_param], + thing: &static/str) { for ty_params.each |ty_param| { if ty_param.bounds.len() > 0 { ccx.tcx.sess.span_err( @@ -612,7 +614,7 @@ fn ensure_no_ty_param_bounds(ccx: @crate_ctxt, } } -fn convert(ccx: @crate_ctxt, it: @ast::item) { +pub fn convert(ccx: @crate_ctxt, it: @ast::item) { let tcx = ccx.tcx; let rp = tcx.region_paramd_items.find(it.id); debug!("convert: item %s with id %d rp %?", @@ -683,12 +685,12 @@ fn convert(ccx: @crate_ctxt, it: @ast::item) { } } -fn convert_struct(ccx: @crate_ctxt, - rp: Option, - struct_def: @ast::struct_def, - +tps: ~[ast::ty_param], - tpt: ty::ty_param_bounds_and_ty, - id: ast::node_id) { +pub fn convert_struct(ccx: @crate_ctxt, + rp: Option, + struct_def: @ast::struct_def, + +tps: ~[ast::ty_param], + tpt: ty::ty_param_bounds_and_ty, + id: ast::node_id) { let tcx = ccx.tcx; do option::iter(&struct_def.dtor) |dtor| { @@ -755,7 +757,7 @@ fn convert_struct(ccx: @crate_ctxt, } } -fn convert_foreign(ccx: @crate_ctxt, i: @ast::foreign_item) { +pub fn convert_foreign(ccx: @crate_ctxt, i: @ast::foreign_item) { // As above, this call populates the type table with the converted // type of the foreign item. We simply write it into the node type // table. @@ -764,9 +766,9 @@ fn convert_foreign(ccx: @crate_ctxt, i: @ast::foreign_item) { ccx.tcx.tcache.insert(local_def(i.id), tpt); } -fn ty_of_method(ccx: @crate_ctxt, - m: @ast::method, - rp: Option) -> ty::method { +pub fn ty_of_method(ccx: @crate_ctxt, + m: @ast::method, + rp: Option) -> ty::method { {ident: m.ident, tps: ty_param_bounds(ccx, /*bad*/copy m.tps), fty: ty_of_fn_decl(ccx, type_rscope(rp), ast::ProtoBare, @@ -778,10 +780,10 @@ fn ty_of_method(ccx: @crate_ctxt, def_id: local_def(m.id)} } -fn ty_of_ty_method(self: @crate_ctxt, - m: ast::ty_method, - rp: Option, - id: ast::def_id) -> ty::method { +pub fn ty_of_ty_method(self: @crate_ctxt, + m: ast::ty_method, + rp: Option, + id: ast::def_id) -> ty::method { {ident: m.ident, tps: ty_param_bounds(self, /*bad*/copy m.tps), fty: ty_of_fn_decl(self, type_rscope(rp), ast::ProtoBare, @@ -799,8 +801,8 @@ fn ty_of_ty_method(self: @crate_ctxt, it's bound to a valid trait type. Returns the def_id for the defining trait. Fails if the type is a type other than an trait type. */ -fn instantiate_trait_ref(ccx: @crate_ctxt, t: @ast::trait_ref, - rp: Option) +pub fn instantiate_trait_ref(ccx: @crate_ctxt, t: @ast::trait_ref, + rp: Option) -> (ast::def_id, ty_param_substs_and_ty) { let sp = t.path.span, err = ~"can only implement trait types", @@ -823,7 +825,7 @@ fn instantiate_trait_ref(ccx: @crate_ctxt, t: @ast::trait_ref, } } -fn ty_of_item(ccx: @crate_ctxt, it: @ast::item) +pub fn ty_of_item(ccx: @crate_ctxt, it: @ast::item) -> ty::ty_param_bounds_and_ty { let def_id = local_def(it.id); @@ -916,7 +918,7 @@ fn ty_of_item(ccx: @crate_ctxt, it: @ast::item) } } -fn ty_of_foreign_item(ccx: @crate_ctxt, it: @ast::foreign_item) +pub fn ty_of_foreign_item(ccx: @crate_ctxt, it: @ast::foreign_item) -> ty::ty_param_bounds_and_ty { match /*bad*/copy it.node { ast::foreign_item_fn(fn_decl, _, params) => { @@ -937,9 +939,9 @@ fn ty_of_foreign_item(ccx: @crate_ctxt, it: @ast::foreign_item) // of a newtyped Ty or a region) to ty's notion of ty param bounds, which can // either be user-defined traits, or one of the four built-in traits (formerly // known as kinds): Const, Copy, Durable, and Send. -fn compute_bounds(ccx: @crate_ctxt, - ast_bounds: @~[ast::ty_param_bound]) - -> ty::param_bounds { +pub fn compute_bounds(ccx: @crate_ctxt, + ast_bounds: @~[ast::ty_param_bound]) + -> ty::param_bounds { @do vec::flat_map(*ast_bounds) |b| { match b { &TraitTyParamBound(b) => { @@ -973,10 +975,8 @@ fn compute_bounds(ccx: @crate_ctxt, } } -fn ty_param_bounds(ccx: @crate_ctxt, - params: ~[ast::ty_param]) -> @~[ty::param_bounds] { - - +pub fn ty_param_bounds(ccx: @crate_ctxt, + params: ~[ast::ty_param]) -> @~[ty::param_bounds] { @do params.map |param| { match ccx.tcx.ty_param_bounds.find(param.id) { Some(bs) => bs, @@ -989,10 +989,11 @@ fn ty_param_bounds(ccx: @crate_ctxt, } } -fn ty_of_foreign_fn_decl(ccx: @crate_ctxt, - decl: ast::fn_decl, - +ty_params: ~[ast::ty_param], - def_id: ast::def_id) -> ty::ty_param_bounds_and_ty { +pub fn ty_of_foreign_fn_decl(ccx: @crate_ctxt, + decl: ast::fn_decl, + +ty_params: ~[ast::ty_param], + def_id: ast::def_id) + -> ty::ty_param_bounds_and_ty { let bounds = ty_param_bounds(ccx, ty_params); let rb = in_binding_rscope(empty_rscope); let input_tys = decl.inputs.map(|a| ty_of_arg(ccx, rb, *a, None) ); @@ -1012,7 +1013,7 @@ fn ty_of_foreign_fn_decl(ccx: @crate_ctxt, return tpt; } -fn mk_ty_params(ccx: @crate_ctxt, atps: ~[ast::ty_param]) +pub fn mk_ty_params(ccx: @crate_ctxt, atps: ~[ast::ty_param]) -> {bounds: @~[ty::param_bounds], params: ~[ty::t]} { let mut i = 0u; @@ -1026,10 +1027,10 @@ fn mk_ty_params(ccx: @crate_ctxt, atps: ~[ast::ty_param]) })} } -fn mk_substs(ccx: @crate_ctxt, - +atps: ~[ast::ty_param], - rp: Option) - -> {bounds: @~[ty::param_bounds], substs: ty::substs} { +pub fn mk_substs(ccx: @crate_ctxt, + +atps: ~[ast::ty_param], + rp: Option) + -> {bounds: @~[ty::param_bounds], substs: ty::substs} { let {bounds, params} = mk_ty_params(ccx, atps); let self_r = rscope::bound_self_region(rp); { diff --git a/src/librustc/middle/typeck/infer/combine.rs b/src/librustc/middle/typeck/infer/combine.rs index d1c57a21a3b2..819348e744ec 100644 --- a/src/librustc/middle/typeck/infer/combine.rs +++ b/src/librustc/middle/typeck/infer/combine.rs @@ -72,9 +72,12 @@ use syntax::ast::{Onceness, purity, ret_style}; use syntax::ast; use syntax::codemap::span; -fn macros() { include!("macros.rs"); } // FIXME(#3114): Macro import/export. +pub fn macros() { + // FIXME(#3114): Macro import/export. + include!("macros.rs"); +} -trait Combine { +pub trait Combine { fn infcx() -> @InferCtxt; fn tag() -> ~str; fn a_is_expected() -> bool; @@ -112,9 +115,8 @@ pub struct CombineFields { span: span, } -fn expected_found( - self: &C, +a: T, +b: T) -> ty::expected_found -{ +pub fn expected_found( + self: &C, +a: T, +b: T) -> ty::expected_found { if self.a_is_expected() { ty::expected_found {expected: move a, found: move b} } else { @@ -131,7 +133,8 @@ pub fn eq_tys(self: &C, a: ty::t, b: ty::t) -> ures { } } -fn eq_regions(self: &C, a: ty::Region, b: ty::Region) -> ures { +pub fn eq_regions(self: &C, a: ty::Region, b: ty::Region) + -> ures { debug!("eq_regions(%s, %s)", a.inf_str(self.infcx()), b.inf_str(self.infcx())); @@ -153,7 +156,7 @@ fn eq_regions(self: &C, a: ty::Region, b: ty::Region) -> ures { } } -fn eq_opt_regions( +pub fn eq_opt_regions( self: &C, a: Option, b: Option) -> cres> { @@ -181,7 +184,7 @@ fn eq_opt_regions( } } -fn super_substs( +pub fn super_substs( self: &C, did: ast::def_id, a: &ty::substs, b: &ty::substs) -> cres { @@ -243,7 +246,7 @@ fn super_substs( } } -fn super_tps( +pub fn super_tps( self: &C, as_: &[ty::t], bs: &[ty::t]) -> cres<~[ty::t]> { // Note: type parameters are always treated as *invariant* @@ -261,7 +264,7 @@ fn super_tps( } } -fn super_self_tys( +pub fn super_self_tys( self: &C, a: Option, b: Option) -> cres> { // Note: the self type parameter is (currently) always treated as @@ -284,9 +287,8 @@ fn super_self_tys( } } -fn super_protos( - self: &C, p1: ast::Proto, p2: ast::Proto) -> cres -{ +pub fn super_protos( + self: &C, p1: ast::Proto, p2: ast::Proto) -> cres { if p1 == p2 { Ok(p1) } else { @@ -294,7 +296,7 @@ fn super_protos( } } -fn super_flds( +pub fn super_flds( self: &C, a: ty::field, b: ty::field) -> cres { if a.ident == b.ident { @@ -307,7 +309,7 @@ fn super_flds( } } -fn super_modes( +pub fn super_modes( self: &C, a: ast::mode, b: ast::mode) -> cres { @@ -326,10 +328,9 @@ fn super_args( } } -fn super_vstores( +pub fn super_vstores( self: &C, vk: ty::terr_vstore_kind, - a: ty::vstore, b: ty::vstore) -> cres -{ + a: ty::vstore, b: ty::vstore) -> cres { debug!("%s.super_vstores(a=%?, b=%?)", self.tag(), a, b); match (a, b) { @@ -349,9 +350,8 @@ fn super_vstores( } } -fn super_fn_metas( - self: &C, a_f: &ty::FnMeta, b_f: &ty::FnMeta) -> cres -{ +pub fn super_fn_metas( + self: &C, a_f: &ty::FnMeta, b_f: &ty::FnMeta) -> cres { let p = if_ok!(self.protos(a_f.proto, b_f.proto)); let r = if_ok!(self.contraregions(a_f.region, b_f.region)); let purity = if_ok!(self.purities(a_f.purity, b_f.purity)); @@ -363,9 +363,8 @@ fn super_fn_metas( bounds: a_f.bounds}) // XXX: This is wrong! } -fn super_fn_sigs( - self: &C, a_f: &ty::FnSig, b_f: &ty::FnSig) -> cres -{ +pub fn super_fn_sigs( + self: &C, a_f: &ty::FnSig, b_f: &ty::FnSig) -> cres { fn argvecs(self: &C, +a_args: ~[ty::arg], +b_args: ~[ty::arg]) -> cres<~[ty::arg]> @@ -385,17 +384,15 @@ fn super_fn_sigs( } } -fn super_fns( - self: &C, a_f: &ty::FnTy, b_f: &ty::FnTy) -> cres -{ +pub fn super_fns( + self: &C, a_f: &ty::FnTy, b_f: &ty::FnTy) -> cres { let m = if_ok!(self.fn_metas(&a_f.meta, &b_f.meta)); let s = if_ok!(self.fn_sigs(&a_f.sig, &b_f.sig)); Ok(FnTyBase {meta: m, sig: s}) } -fn super_tys( - self: &C, a: ty::t, b: ty::t) -> cres -{ +pub fn super_tys( + self: &C, a: ty::t, b: ty::t) -> cres { let tcx = self.infcx().tcx; return match (/*bad*/copy ty::get(a).sty, /*bad*/copy ty::get(b).sty) { // The "subtype" ought to be handling cases involving bot or var: diff --git a/src/librustc/middle/typeck/infer/glb.rs b/src/librustc/middle/typeck/infer/glb.rs index aa718cbe36c3..58d9f1019aeb 100644 --- a/src/librustc/middle/typeck/infer/glb.rs +++ b/src/librustc/middle/typeck/infer/glb.rs @@ -25,9 +25,9 @@ use util::ppaux::mt_to_str; use std::list; -enum Glb = CombineFields; // "greatest lower bound" (common subtype) +pub enum Glb = CombineFields; // "greatest lower bound" (common subtype) -impl Glb: Combine { +pub impl Glb: Combine { fn infcx() -> @InferCtxt { self.infcx } fn tag() -> ~str { ~"glb" } fn a_is_expected() -> bool { self.a_is_expected } diff --git a/src/librustc/middle/typeck/infer/lattice.rs b/src/librustc/middle/typeck/infer/lattice.rs index 6ae10b120fe7..f061aeb459ba 100644 --- a/src/librustc/middle/typeck/infer/lattice.rs +++ b/src/librustc/middle/typeck/infer/lattice.rs @@ -49,15 +49,15 @@ use middle::typeck::infer::to_str::InferStr; use std::list; -trait LatticeValue { +pub trait LatticeValue { static fn sub(cf: &CombineFields, a: &self, b: &self) -> ures; static fn lub(cf: &CombineFields, a: &self, b: &self) -> cres; static fn glb(cf: &CombineFields, a: &self, b: &self) -> cres; } -type LatticeOp = &fn(cf: &CombineFields, a: &T, b: &T) -> cres; +pub type LatticeOp = &fn(cf: &CombineFields, a: &T, b: &T) -> cres; -impl ty::t: LatticeValue { +pub impl ty::t: LatticeValue { static fn sub(cf: &CombineFields, a: &ty::t, b: &ty::t) -> ures { Sub(*cf).tys(*a, *b).to_ures() } @@ -71,7 +71,7 @@ impl ty::t: LatticeValue { } } -impl FnMeta: LatticeValue { +pub impl FnMeta: LatticeValue { static fn sub(cf: &CombineFields, a: &FnMeta, b: &FnMeta) -> ures { Sub(*cf).fn_metas(a, b).to_ures() @@ -88,7 +88,7 @@ impl FnMeta: LatticeValue { } } -impl CombineFields { +pub impl CombineFields { fn var_sub_var>>( &self, @@ -309,17 +309,17 @@ impl CombineFields { // This is common code used by both LUB and GLB to compute the LUB/GLB // for pairs of variables or for variables and values. -trait LatticeDir { +pub trait LatticeDir { fn combine_fields() -> CombineFields; fn bnd(b: &Bounds) -> Option; fn with_bnd(b: &Bounds, +t: T) -> Bounds; } -trait TyLatticeDir { +pub trait TyLatticeDir { fn ty_bot(t: ty::t) -> cres; } -impl Lub: LatticeDir { +pub impl Lub: LatticeDir { fn combine_fields() -> CombineFields { *self } fn bnd(b: &Bounds) -> Option { b.ub } fn with_bnd(b: &Bounds, +t: T) -> Bounds { @@ -327,13 +327,13 @@ impl Lub: LatticeDir { } } -impl Lub: TyLatticeDir { +pub impl Lub: TyLatticeDir { fn ty_bot(t: ty::t) -> cres { Ok(t) } } -impl Glb: LatticeDir { +pub impl Glb: LatticeDir { fn combine_fields() -> CombineFields { *self } fn bnd(b: &Bounds) -> Option { b.lb } fn with_bnd(b: &Bounds, +t: T) -> Bounds { @@ -341,17 +341,16 @@ impl Glb: LatticeDir { } } -impl Glb: TyLatticeDir { +pub impl Glb: TyLatticeDir { fn ty_bot(_t: ty::t) -> cres { Ok(ty::mk_bot(self.infcx.tcx)) } } -fn super_lattice_tys( +pub fn super_lattice_tys( self: &L, a: ty::t, - b: ty::t) -> cres -{ + b: ty::t) -> cres { debug!("%s.lattice_tys(%s, %s)", self.tag(), a.inf_str(self.infcx()), b.inf_str(self.infcx())); @@ -392,9 +391,9 @@ fn super_lattice_tys( } } -type LatticeDirOp = &fn(a: &T, b: &T) -> cres; +pub type LatticeDirOp = &fn(a: &T, b: &T) -> cres; -enum LatticeVarResult { +pub enum LatticeVarResult { VarResult(V), ValueResult(T) } @@ -414,15 +413,14 @@ enum LatticeVarResult { * the variables and return the unified variable, in which case the * result is a variable. This is indicated with a `VarResult` * return. */ -fn lattice_vars>>( +pub fn lattice_vars>>( self: &L, // defines whether we want LUB or GLB +a_vid: V, // first variable +b_vid: V, // second variable lattice_dir_op: LatticeDirOp) // LUB or GLB operation on types - -> cres> -{ + -> cres> { let nde_a = self.infcx().get(a_vid); let nde_b = self.infcx().get(b_vid); let a_vid = nde_a.root; @@ -461,15 +459,14 @@ fn lattice_vars>>( +pub fn lattice_var_and_t>>( self: &L, +a_id: V, b: &T, lattice_dir_op: LatticeDirOp) - -> cres -{ + -> cres { let nde_a = self.infcx().get(a_id); let a_id = nde_a.root; let a_bounds = &nde_a.possible_types; @@ -506,7 +503,7 @@ fn lattice_var_and_t(self: &T, isr: isr_alist) -> ~[RegionVid] { +pub fn var_ids(self: &T, isr: isr_alist) -> ~[RegionVid] { let mut result = ~[]; for list::each(isr) |pair| { match pair.second() { @@ -521,7 +518,7 @@ fn var_ids(self: &T, isr: isr_alist) -> ~[RegionVid] { return result; } -fn is_var_in_set(new_vars: &[RegionVid], r: ty::Region) -> bool { +pub fn is_var_in_set(new_vars: &[RegionVid], r: ty::Region) -> bool { match r { ty::re_infer(ty::ReVar(ref v)) => new_vars.contains(v), _ => false diff --git a/src/librustc/middle/typeck/infer/lub.rs b/src/librustc/middle/typeck/infer/lub.rs index a6ae3cdb4fdb..f24d245db58e 100644 --- a/src/librustc/middle/typeck/infer/lub.rs +++ b/src/librustc/middle/typeck/infer/lub.rs @@ -24,16 +24,19 @@ use std::list; use syntax::ast::{Many, Once, extern_fn, m_const, impure_fn, noreturn}; use syntax::ast::{pure_fn, ret_style, return_val, unsafe_fn}; -fn macros() { include!("macros.rs"); } // FIXME(#3114): Macro import/export. +pub fn macros() { + // FIXME(#3114): Macro import/export. + include!("macros.rs"); +} -enum Lub = CombineFields; // least-upper-bound: common supertype +pub enum Lub = CombineFields; // least-upper-bound: common supertype -impl Lub { +pub impl Lub { fn bot_ty(b: ty::t) -> cres { Ok(b) } fn ty_bot(b: ty::t) -> cres { self.bot_ty(b) } // commutative } -impl Lub: Combine { +pub impl Lub: Combine { fn infcx() -> @InferCtxt { self.infcx } fn tag() -> ~str { ~"lub" } fn a_is_expected() -> bool { self.a_is_expected } diff --git a/src/librustc/middle/typeck/infer/mod.rs b/src/librustc/middle/typeck/infer/mod.rs index cab40ce21b15..7cc09733c20f 100644 --- a/src/librustc/middle/typeck/infer/mod.rs +++ b/src/librustc/middle/typeck/infer/mod.rs @@ -242,16 +242,23 @@ section on "Type Combining" below for details. */ -#[legacy_exports]; #[warn(deprecated_mode)]; #[warn(deprecated_pattern)]; use core::prelude::*; +pub use middle::ty::IntVarValue; +pub use middle::typeck::infer::resolve::resolve_and_force_all_but_regions; +pub use middle::typeck::infer::resolve::{force_all, not_regions}; +pub use middle::typeck::infer::resolve::{force_ivar}; +pub use middle::typeck::infer::resolve::{force_tvar, force_rvar}; +pub use middle::typeck::infer::resolve::{resolve_ivar, resolve_all}; +pub use middle::typeck::infer::resolve::{resolve_nested_tvar}; +pub use middle::typeck::infer::resolve::{resolve_rvar}; + use middle::ty::{TyVid, IntVid, FloatVid, RegionVid, Vid}; use middle::ty::{mk_fn, type_is_bot}; use middle::ty::{ty_int, ty_uint, get, terr_fn, TyVar, IntVar, FloatVar}; -use middle::ty::IntVarValue; use middle::ty; use middle::typeck::check::regionmanip::{replace_bound_regions_in_fn_sig}; use middle::typeck::infer::coercion::Coerce; @@ -259,11 +266,6 @@ use middle::typeck::infer::combine::{Combine, CombineFields, eq_tys}; use middle::typeck::infer::glb::Glb; use middle::typeck::infer::lub::Lub; use middle::typeck::infer::region_inference::{RegionVarBindings}; -use middle::typeck::infer::resolve::{force_all, not_regions}; -use middle::typeck::infer::resolve::{force_tvar, force_rvar, force_ivar}; -use middle::typeck::infer::resolve::{resolve_and_force_all_but_regions}; -use middle::typeck::infer::resolve::{resolve_ivar, resolve_all}; -use middle::typeck::infer::resolve::{resolve_nested_tvar, resolve_rvar}; use middle::typeck::infer::resolve::{resolver}; use middle::typeck::infer::sub::Sub; use middle::typeck::infer::to_str::InferStr; @@ -288,69 +290,26 @@ use syntax::ast_util::dummy_sp; use syntax::ast_util; use syntax::codemap::span; -export InferCtxt; -export new_infer_ctxt; -export mk_subty, can_mk_subty; -export mk_subr; -export mk_eqty; -export mk_coercety, can_mk_coercety; -export resolve_nested_tvar, resolve_rvar, resolve_ivar, resolve_all; -export force_tvar, force_rvar, force_ivar, force_all; -export resolve_and_force_all_but_regions, not_regions; -export resolve_type, resolve_region; -export resolve_borrowings; -export cres, fres, fixup_err, fixup_err_to_str; -export root, to_str; -export int_ty_set_all; -export combine; -export glb; -export integral; -export lattice; -export lub; -export region_inference; -export resolve; -export sub; -export coercion; -export to_str; -export unify; -export uok; -export cyclic_ty, unresolved_ty, region_var_bound_by_region_var; -export Bound, Bounds; -export ures; -export CoerceResult; -export infer_ctxt; -export fixup_err; -export IntVarValue, IntType, UintType; +pub mod combine; +pub mod glb; +pub mod lattice; +pub mod lub; +pub mod region_inference; +pub mod resolve; +pub mod sub; +pub mod to_str; +pub mod unify; +pub mod coercion; -#[legacy_exports] -mod combine; -#[legacy_exports] -mod glb; -#[legacy_exports] -mod lattice; -#[legacy_exports] -mod lub; -#[legacy_exports] -mod region_inference; -#[legacy_exports] -mod resolve; -#[legacy_exports] -mod sub; -#[legacy_exports] -mod to_str; -#[legacy_exports] -mod unify; -mod coercion; +pub type Bound = Option; +pub type Bounds = {lb: Bound, ub: Bound}; -type Bound = Option; -type Bounds = {lb: Bound, ub: Bound}; +pub type cres = Result; // "combine result" +pub type ures = cres<()>; // "unify result" +pub type fres = Result; // "fixup result" +pub type CoerceResult = cres>; -type cres = Result; // "combine result" -type ures = cres<()>; // "unify result" -type fres = Result; // "fixup result" -type CoerceResult = cres>; - -struct InferCtxt { +pub struct InferCtxt { tcx: ty::ctxt, // We instantiate ValsAndBindings with bounds because the @@ -371,7 +330,7 @@ struct InferCtxt { region_vars: RegionVarBindings, } -enum fixup_err { +pub enum fixup_err { unresolved_int_ty(IntVid), unresolved_ty(TyVid), cyclic_ty(TyVid), @@ -379,7 +338,7 @@ enum fixup_err { region_var_bound_by_region_var(RegionVid, RegionVid) } -fn fixup_err_to_str(f: fixup_err) -> ~str { +pub fn fixup_err_to_str(f: fixup_err) -> ~str { match f { unresolved_int_ty(_) => ~"unconstrained integral type", unresolved_ty(_) => ~"unconstrained type", @@ -399,7 +358,7 @@ fn new_ValsAndBindings() -> ValsAndBindings { } } -fn new_infer_ctxt(tcx: ty::ctxt) -> @InferCtxt { +pub fn new_infer_ctxt(tcx: ty::ctxt) -> @InferCtxt { @InferCtxt { tcx: tcx, @@ -416,8 +375,8 @@ fn new_infer_ctxt(tcx: ty::ctxt) -> @InferCtxt { } } -fn mk_subty(cx: @InferCtxt, a_is_expected: bool, span: span, - a: ty::t, b: ty::t) -> ures { +pub fn mk_subty(cx: @InferCtxt, a_is_expected: bool, span: span, + a: ty::t, b: ty::t) -> ures { debug!("mk_subty(%s <: %s)", a.inf_str(cx), b.inf_str(cx)); do indent { do cx.commit { @@ -426,7 +385,7 @@ fn mk_subty(cx: @InferCtxt, a_is_expected: bool, span: span, }.to_ures() } -fn can_mk_subty(cx: @InferCtxt, a: ty::t, b: ty::t) -> ures { +pub fn can_mk_subty(cx: @InferCtxt, a: ty::t, b: ty::t) -> ures { debug!("can_mk_subty(%s <: %s)", a.inf_str(cx), b.inf_str(cx)); do indent { do cx.probe { @@ -435,8 +394,8 @@ fn can_mk_subty(cx: @InferCtxt, a: ty::t, b: ty::t) -> ures { }.to_ures() } -fn mk_subr(cx: @InferCtxt, a_is_expected: bool, span: span, - a: ty::Region, b: ty::Region) -> ures { +pub fn mk_subr(cx: @InferCtxt, a_is_expected: bool, span: span, + a: ty::Region, b: ty::Region) -> ures { debug!("mk_subr(%s <: %s)", a.inf_str(cx), b.inf_str(cx)); do indent { do cx.commit { @@ -445,8 +404,8 @@ fn mk_subr(cx: @InferCtxt, a_is_expected: bool, span: span, }.to_ures() } -fn mk_eqty(cx: @InferCtxt, a_is_expected: bool, span: span, - a: ty::t, b: ty::t) -> ures { +pub fn mk_eqty(cx: @InferCtxt, a_is_expected: bool, span: span, + a: ty::t, b: ty::t) -> ures { debug!("mk_eqty(%s <: %s)", a.inf_str(cx), b.inf_str(cx)); do indent { do cx.commit { @@ -456,9 +415,8 @@ fn mk_eqty(cx: @InferCtxt, a_is_expected: bool, span: span, }.to_ures() } -fn mk_coercety(cx: @InferCtxt, a_is_expected: bool, span: span, - a: ty::t, b: ty::t) -> CoerceResult -{ +pub fn mk_coercety(cx: @InferCtxt, a_is_expected: bool, span: span, + a: ty::t, b: ty::t) -> CoerceResult { debug!("mk_coercety(%s -> %s)", a.inf_str(cx), b.inf_str(cx)); do indent { do cx.commit { @@ -467,7 +425,7 @@ fn mk_coercety(cx: @InferCtxt, a_is_expected: bool, span: span, } } -fn can_mk_coercety(cx: @InferCtxt, a: ty::t, b: ty::t) -> ures { +pub fn can_mk_coercety(cx: @InferCtxt, a: ty::t, b: ty::t) -> ures { debug!("can_mk_coercety(%s -> %s)", a.inf_str(cx), b.inf_str(cx)); do indent { do cx.probe { @@ -478,13 +436,12 @@ fn can_mk_coercety(cx: @InferCtxt, a: ty::t, b: ty::t) -> ures { } // See comment on the type `resolve_state` below -fn resolve_type(cx: @InferCtxt, a: ty::t, modes: uint) - -> fres { +pub fn resolve_type(cx: @InferCtxt, a: ty::t, modes: uint) -> fres { resolver(cx, modes).resolve_type_chk(a) } -fn resolve_region(cx: @InferCtxt, r: ty::Region, modes: uint) - -> fres { +pub fn resolve_region(cx: @InferCtxt, r: ty::Region, modes: uint) + -> fres { resolver(cx, modes).resolve_region_chk(r) } diff --git a/src/librustc/middle/typeck/infer/region_inference.rs b/src/librustc/middle/typeck/infer/region_inference.rs index 1113029a1370..5d602ab88bbc 100644 --- a/src/librustc/middle/typeck/infer/region_inference.rs +++ b/src/librustc/middle/typeck/infer/region_inference.rs @@ -565,11 +565,6 @@ use std::list::{List, Nil, Cons}; use syntax::codemap::span; use syntax::codemap; -export RegionVarBindings; -export make_subregion; -export lub_regions; -export glb_regions; - enum Constraint { ConstrainVarSubVar(RegionVid, RegionVid), ConstrainRegSubVar(Region, RegionVid), @@ -638,7 +633,7 @@ enum UndoLogEntry { type CombineMap = HashMap; -struct RegionVarBindings { +pub struct RegionVarBindings { tcx: ty::ctxt, var_spans: DVec, constraints: HashMap, @@ -663,7 +658,7 @@ struct RegionVarBindings { values: Cell<~[GraphNodeValue]>, } -fn RegionVarBindings(tcx: ty::ctxt) -> RegionVarBindings { +pub fn RegionVarBindings(tcx: ty::ctxt) -> RegionVarBindings { RegionVarBindings { tcx: tcx, var_spans: DVec(), @@ -684,7 +679,7 @@ fn CombineMap() -> CombineMap { return HashMap(); } -impl RegionVarBindings { +pub impl RegionVarBindings { fn in_snapshot(&self) -> bool { self.undo_log.len() > 0 } diff --git a/src/librustc/middle/typeck/infer/resolve.rs b/src/librustc/middle/typeck/infer/resolve.rs index b25c4db8a90b..2801b30ee7f7 100644 --- a/src/librustc/middle/typeck/infer/resolve.rs +++ b/src/librustc/middle/typeck/infer/resolve.rs @@ -63,26 +63,26 @@ use syntax::ast; use core::uint; use core::vec; -const resolve_nested_tvar: uint = 0b0000000001; -const resolve_rvar: uint = 0b0000000010; -const resolve_ivar: uint = 0b0000000100; -const resolve_fvar: uint = 0b0000001000; -const resolve_fnvar: uint = 0b0000010000; -const resolve_all: uint = 0b0000011111; -const force_tvar: uint = 0b0000100000; -const force_rvar: uint = 0b0001000000; -const force_ivar: uint = 0b0010000000; -const force_fvar: uint = 0b0100000000; -const force_fnvar: uint = 0b1000000000; -const force_all: uint = 0b1111100000; +pub const resolve_nested_tvar: uint = 0b0000000001; +pub const resolve_rvar: uint = 0b0000000010; +pub const resolve_ivar: uint = 0b0000000100; +pub const resolve_fvar: uint = 0b0000001000; +pub const resolve_fnvar: uint = 0b0000010000; +pub const resolve_all: uint = 0b0000011111; +pub const force_tvar: uint = 0b0000100000; +pub const force_rvar: uint = 0b0001000000; +pub const force_ivar: uint = 0b0010000000; +pub const force_fvar: uint = 0b0100000000; +pub const force_fnvar: uint = 0b1000000000; +pub const force_all: uint = 0b1111100000; -const not_regions: uint = !(force_rvar | resolve_rvar); +pub const not_regions: uint = !(force_rvar | resolve_rvar); -const try_resolve_tvar_shallow: uint = 0; -const resolve_and_force_all_but_regions: uint = +pub const try_resolve_tvar_shallow: uint = 0; +pub const resolve_and_force_all_but_regions: uint = (resolve_all | force_all) & not_regions; -struct ResolveState { +pub struct ResolveState { infcx: @InferCtxt, modes: uint, mut err: Option, @@ -90,7 +90,7 @@ struct ResolveState { mut type_depth: uint } -fn resolver(infcx: @InferCtxt, modes: uint) -> ResolveState { +pub fn resolver(infcx: @InferCtxt, modes: uint) -> ResolveState { ResolveState { infcx: infcx, modes: modes, @@ -100,7 +100,7 @@ fn resolver(infcx: @InferCtxt, modes: uint) -> ResolveState { } } -impl ResolveState { +pub impl ResolveState { fn should(&self, mode: uint) -> bool { (self.modes & mode) == mode } diff --git a/src/librustc/middle/typeck/infer/sub.rs b/src/librustc/middle/typeck/infer/sub.rs index 4252580ac46c..158cbb41abd5 100644 --- a/src/librustc/middle/typeck/infer/sub.rs +++ b/src/librustc/middle/typeck/infer/sub.rs @@ -25,11 +25,14 @@ use std::list::Nil; use std::list; use syntax::ast::{m_const, purity, ret_style}; -fn macros() { include!("macros.rs"); } // FIXME(#3114): Macro import/export. +pub fn macros() { + // FIXME(#3114): Macro import/export. + include!("macros.rs"); +} -enum Sub = CombineFields; // "subtype", "subregion" etc +pub enum Sub = CombineFields; // "subtype", "subregion" etc -impl Sub: Combine { +pub impl Sub: Combine { fn infcx() -> @InferCtxt { self.infcx } fn tag() -> ~str { ~"sub" } fn a_is_expected() -> bool { self.a_is_expected } diff --git a/src/librustc/middle/typeck/infer/to_str.rs b/src/librustc/middle/typeck/infer/to_str.rs index a6d316db4287..e100392bba9a 100644 --- a/src/librustc/middle/typeck/infer/to_str.rs +++ b/src/librustc/middle/typeck/infer/to_str.rs @@ -28,19 +28,19 @@ pub trait InferStr { fn inf_str(&self, cx: &InferCtxt) -> ~str; } -impl ty::t : InferStr { +pub impl ty::t : InferStr { fn inf_str(&self, cx: &InferCtxt) -> ~str { ty_to_str(cx.tcx, *self) } } -impl FnMeta : InferStr { +pub impl FnMeta : InferStr { fn inf_str(&self, _cx: &InferCtxt) -> ~str { fmt!("%?", *self) } } -impl FnSig : InferStr { +pub impl FnSig : InferStr { fn inf_str(&self, cx: &InferCtxt) -> ~str { fmt!("(%s) -> %s", str::connect(self.inputs.map(|a| a.ty.inf_str(cx)), ", "), @@ -48,25 +48,25 @@ impl FnSig : InferStr { } } -impl FnTyBase : InferStr { +pub impl FnTyBase : InferStr { fn inf_str(&self, cx: &InferCtxt) -> ~str { fmt!("%s%s", self.meta.inf_str(cx), self.sig.inf_str(cx)) } } -impl ty::mt : InferStr { +pub impl ty::mt : InferStr { fn inf_str(&self, cx: &InferCtxt) -> ~str { mt_to_str(cx.tcx, *self) } } -impl ty::Region : InferStr { +pub impl ty::Region : InferStr { fn inf_str(&self, _cx: &InferCtxt) -> ~str { fmt!("%?", *self) } } -impl Bound : InferStr { +pub impl Bound : InferStr { fn inf_str(&self, cx: &InferCtxt) -> ~str { match *self { Some(ref v) => v.inf_str(cx), @@ -75,7 +75,7 @@ impl Bound : InferStr { } } -impl Bounds : InferStr { +pub impl Bounds : InferStr { fn inf_str(&self, cx: &InferCtxt) -> ~str { fmt!("{%s <: %s}", self.lb.inf_str(cx), @@ -83,7 +83,7 @@ impl Bounds : InferStr { } } -impl VarValue : InferStr { +pub impl VarValue : InferStr { fn inf_str(&self, cx: &InferCtxt) -> ~str { match *self { Redirect(ref vid) => fmt!("Redirect(%s)", vid.to_str()), @@ -93,13 +93,13 @@ impl VarValue : InferStr { } } -impl IntVarValue : InferStr { +pub impl IntVarValue : InferStr { fn inf_str(&self, _cx: &InferCtxt) -> ~str { self.to_str() } } -impl ast::float_ty : InferStr { +pub impl ast::float_ty : InferStr { fn inf_str(&self, _cx: &InferCtxt) -> ~str { self.to_str() } diff --git a/src/librustc/middle/typeck/infer/unify.rs b/src/librustc/middle/typeck/infer/unify.rs index b2b1188388f4..db3dab297a75 100644 --- a/src/librustc/middle/typeck/infer/unify.rs +++ b/src/librustc/middle/typeck/infer/unify.rs @@ -21,28 +21,28 @@ use middle::typeck::infer::to_str::InferStr; use syntax::ast; use util::common::{indent, indenter}; -enum VarValue { +pub enum VarValue { Redirect(V), Root(T, uint), } -struct ValsAndBindings { +pub struct ValsAndBindings { vals: SmallIntMap>, mut bindings: ~[(V, VarValue)], } -struct Node { +pub struct Node { root: V, possible_types: T, rank: uint, } -trait UnifyVid { +pub trait UnifyVid { static fn appropriate_vals_and_bindings(infcx: &v/InferCtxt) -> &v/ValsAndBindings; } -impl InferCtxt { +pub impl InferCtxt { fn get>( &self, +vid: V) -> Node @@ -135,14 +135,13 @@ impl InferCtxt { // Code to handle simple variables like ints, floats---anything that // doesn't have a subtyping relationship we need to worry about. -trait SimplyUnifiable { +pub trait SimplyUnifiable { static fn to_type_err(expected_found) -> ty::type_err; } -fn mk_err(+a_is_expected: bool, - +a_t: T, - +b_t: T) -> ures -{ +pub fn mk_err(+a_is_expected: bool, + +a_t: T, + +b_t: T) -> ures { if a_is_expected { Err(SimplyUnifiable::to_type_err( ty::expected_found {expected: a_t, found: b_t})) @@ -152,7 +151,7 @@ fn mk_err(+a_is_expected: bool, } } -impl InferCtxt { +pub impl InferCtxt { fn simple_vars>>( &self, @@ -227,7 +226,7 @@ impl InferCtxt { // ______________________________________________________________________ -impl ty::TyVid : UnifyVid> { +pub impl ty::TyVid : UnifyVid> { static fn appropriate_vals_and_bindings(infcx: &v/InferCtxt) -> &v/ValsAndBindings> { @@ -235,7 +234,7 @@ impl ty::TyVid : UnifyVid> { } } -impl ty::IntVid : UnifyVid> { +pub impl ty::IntVid : UnifyVid> { static fn appropriate_vals_and_bindings(infcx: &v/InferCtxt) -> &v/ValsAndBindings> { @@ -243,7 +242,7 @@ impl ty::IntVid : UnifyVid> { } } -impl IntVarValue : SimplyUnifiable { +pub impl IntVarValue : SimplyUnifiable { static fn to_type_err(err: expected_found) -> ty::type_err { @@ -251,7 +250,7 @@ impl IntVarValue : SimplyUnifiable { } } -impl ty::FloatVid : UnifyVid> { +pub impl ty::FloatVid : UnifyVid> { static fn appropriate_vals_and_bindings(infcx: &v/InferCtxt) -> &v/ValsAndBindings> { @@ -259,7 +258,7 @@ impl ty::FloatVid : UnifyVid> { } } -impl ast::float_ty : SimplyUnifiable { +pub impl ast::float_ty : SimplyUnifiable { static fn to_type_err(err: expected_found) -> ty::type_err { diff --git a/src/librustc/middle/typeck/mod.rs b/src/librustc/middle/typeck/mod.rs index 142f1e989a03..c264d8e08063 100644 --- a/src/librustc/middle/typeck/mod.rs +++ b/src/librustc/middle/typeck/mod.rs @@ -48,8 +48,6 @@ independently: */ -#[legacy_exports]; - use core::prelude::*; use metadata::csearch; @@ -81,45 +79,13 @@ use syntax::print::pprust::*; use syntax::visit; use syntax::{ast, ast_util, ast_map}; -export check; -export check_crate; -export infer; -export method_map; -export method_origin; -export method_map_entry; -export vtable_map; -export vtable_res; -export vtable_origin; -export method_static, method_param, method_trait, method_self; -export vtable_static, vtable_param, vtable_trait; -export provided_methods_map; -export coherence; -export check; -export rscope; -export astconv; -export infer; -export collect; -export coherence; -export deriving; -export crate_ctxt; -export write_ty_to_tcx, write_substs_to_tcx; -export no_params; -export isr_alist; -export require_same_types; -export lookup_def_ccx, lookup_def_tcx; - -#[legacy_exports] #[path = "check/mod.rs"] pub mod check; -#[legacy_exports] pub mod rscope; -#[legacy_exports] pub mod astconv; #[path = "infer/mod.rs"] pub mod infer; -#[legacy_exports] pub mod collect; -#[legacy_exports] pub mod coherence; #[auto_encode] @@ -142,7 +108,7 @@ pub enum method_origin { // with a bounded trait. #[auto_encode] #[auto_decode] -struct method_param { +pub struct method_param { // the trait containing the method to be invoked trait_id: ast::def_id, @@ -199,7 +165,7 @@ pub enum vtable_origin { vtable_trait(ast::def_id, ~[ty::t]), } -impl vtable_origin { +pub impl vtable_origin { fn to_str(tcx: ty::ctxt) -> ~str { match self { vtable_static(def_id, ref tys, ref vtable_res) => { @@ -222,7 +188,7 @@ impl vtable_origin { } } -type vtable_map = HashMap; +pub type vtable_map = HashMap; struct crate_ctxt__ { // A mapping from method call sites to traits that have that method. @@ -238,13 +204,13 @@ pub enum crate_ctxt { } // Functions that write types into the node type table -fn write_ty_to_tcx(tcx: ty::ctxt, node_id: ast::node_id, ty: ty::t) { +pub fn write_ty_to_tcx(tcx: ty::ctxt, node_id: ast::node_id, ty: ty::t) { debug!("write_ty_to_tcx(%d, %s)", node_id, ppaux::ty_to_str(tcx, ty)); smallintmap::insert(*tcx.node_types, node_id as uint, ty); } -fn write_substs_to_tcx(tcx: ty::ctxt, - node_id: ast::node_id, - +substs: ~[ty::t]) { +pub fn write_substs_to_tcx(tcx: ty::ctxt, + node_id: ast::node_id, + +substs: ~[ty::t]) { if substs.len() > 0u { debug!("write_substs_to_tcx(%d, %?)", node_id, substs.map(|t| ppaux::ty_to_str(tcx, *t))); @@ -252,7 +218,7 @@ fn write_substs_to_tcx(tcx: ty::ctxt, } } -fn lookup_def_tcx(tcx: ty::ctxt, sp: span, id: ast::node_id) -> ast::def { +pub fn lookup_def_tcx(tcx: ty::ctxt, sp: span, id: ast::node_id) -> ast::def { match tcx.def_map.find(id) { Some(x) => x, _ => { @@ -261,15 +227,16 @@ fn lookup_def_tcx(tcx: ty::ctxt, sp: span, id: ast::node_id) -> ast::def { } } -fn lookup_def_ccx(ccx: @crate_ctxt, sp: span, id: ast::node_id) -> ast::def { +pub fn lookup_def_ccx(ccx: @crate_ctxt, sp: span, id: ast::node_id) + -> ast::def { lookup_def_tcx(ccx.tcx, sp, id) } -fn no_params(t: ty::t) -> ty::ty_param_bounds_and_ty { +pub fn no_params(t: ty::t) -> ty::ty_param_bounds_and_ty { {bounds: @~[], region_param: None, ty: t} } -fn require_same_types( +pub fn require_same_types( tcx: ty::ctxt, maybe_infcx: Option<@infer::InferCtxt>, t1_is_expected: bool, @@ -303,7 +270,7 @@ fn require_same_types( // a list of mapping from in-scope-region-names ("isr") to the // corresponding ty::Region -type isr_alist = @List<(ty::bound_region, ty::Region)>; +pub type isr_alist = @List<(ty::bound_region, ty::Region)>; trait get_and_find_region { fn get(br: ty::bound_region) -> ty::Region; @@ -397,10 +364,10 @@ fn check_for_main_fn(ccx: @crate_ctxt) { } } -fn check_crate(tcx: ty::ctxt, - trait_map: resolve::TraitMap, - crate: @ast::crate) - -> (method_map, vtable_map) { +pub fn check_crate(tcx: ty::ctxt, + trait_map: resolve::TraitMap, + crate: @ast::crate) + -> (method_map, vtable_map) { let ccx = @crate_ctxt_(crate_ctxt__ { trait_map: trait_map, diff --git a/src/librustc/middle/typeck/rscope.rs b/src/librustc/middle/typeck/rscope.rs index f1655f2a363b..244f05a8f7e0 100644 --- a/src/librustc/middle/typeck/rscope.rs +++ b/src/librustc/middle/typeck/rscope.rs @@ -18,14 +18,14 @@ use syntax::ast; use syntax::codemap::span; use syntax::parse::token::special_idents; -trait region_scope { +pub trait region_scope { fn anon_region(span: span) -> Result; fn self_region(span: span) -> Result; fn named_region(span: span, id: ast::ident) -> Result; } -enum empty_rscope { empty_rscope } -impl empty_rscope: region_scope { +pub enum empty_rscope { empty_rscope } +pub impl empty_rscope: region_scope { fn anon_region(_span: span) -> Result { result::Ok(ty::re_static) } @@ -39,8 +39,8 @@ impl empty_rscope: region_scope { } } -enum type_rscope = Option; -impl type_rscope: region_scope { +pub enum type_rscope = Option; +pub impl type_rscope: region_scope { fn anon_region(_span: span) -> Result { match *self { Some(_) => result::Ok(ty::re_bound(ty::br_self)), @@ -59,19 +59,20 @@ impl type_rscope: region_scope { } } -fn bound_self_region(rp: Option) -> Option { +pub fn bound_self_region(rp: Option) + -> Option { match rp { Some(_) => Some(ty::re_bound(ty::br_self)), None => None } } -enum anon_rscope = {anon: ty::Region, base: region_scope}; -fn in_anon_rscope(self: RS, r: ty::Region) +pub enum anon_rscope = {anon: ty::Region, base: region_scope}; +pub fn in_anon_rscope(self: RS, r: ty::Region) -> @anon_rscope { @anon_rscope({anon: r, base: self as region_scope}) } -impl @anon_rscope: region_scope { +pub impl @anon_rscope: region_scope { fn anon_region(_span: span) -> Result { result::Ok(self.anon) } @@ -83,16 +84,16 @@ impl @anon_rscope: region_scope { } } -struct binding_rscope { +pub struct binding_rscope { base: region_scope, mut anon_bindings: uint, } -fn in_binding_rscope(self: RS) +pub fn in_binding_rscope(self: RS) -> @binding_rscope { let base = self as region_scope; @binding_rscope { base: base, anon_bindings: 0 } } -impl @binding_rscope: region_scope { +pub impl @binding_rscope: region_scope { fn anon_region(_span: span) -> Result { let idx = self.anon_bindings; self.anon_bindings += 1;