librustc: De-export front, borrowck, and typeck/check. rs=deexporting

Author: pcwalton

src/librustc/front/intrinsic.rs

@@ -12,8 +12,6 @@
 // and injected into each crate the compiler builds. Keep it small.
 
 mod intrinsic {
-    #[legacy_exports];
-
     pub use intrinsic::rusti::visit_tydesc;
 
     // FIXME (#3727): remove this when the interface has settled and the
@@ -30,7 +28,7 @@ mod intrinsic {
         // Remaining fields not listed
     };
 
-    trait TyVisitor {
+    pub trait TyVisitor {
         fn visit_bot(&self) -> bool;
         fn visit_nil(&self) -> bool;
         fn visit_bool(&self) -> bool;
@@ -125,9 +123,8 @@ mod intrinsic {
     }
 
     #[abi = "rust-intrinsic"]
-    extern mod rusti {
-        #[legacy_exports];
-        fn get_tydesc<T>() -> *();
-        fn visit_tydesc(++td: *TyDesc, &&tv: TyVisitor);
+    pub extern mod rusti {
+        pub fn get_tydesc<T>() -> *();
+        pub fn visit_tydesc(++td: *TyDesc, &&tv: TyVisitor);
     }
 }

src/librustc/front/test.rs

@@ -193,8 +193,6 @@ fn add_test_module(cx: test_ctxt, +m: ast::_mod) -> ast::_mod {
 We're going to be building a module that looks more or less like:
 
 mod __test {
-    #[legacy_exports];
-
   fn main(args: ~[str]) -> int {
     std::test::test_main(args, tests())
   }

src/librustc/middle/borrowck/check_loans.rs

@@ -19,11 +19,11 @@
 
 use core::prelude::*;
 
-use middle::borrowck::{Loan, bckerr, borrowck_ctxt, cmt, inherent_mutability};
+use middle::borrowck::{Loan, bckerr, borrowck_ctxt, inherent_mutability};
 use middle::borrowck::{req_maps, root_map_key, save_and_restore};
 use middle::mem_categorization::{cat_arg, cat_binding, cat_comp, cat_deref};
 use middle::mem_categorization::{cat_local, cat_rvalue, cat_self};
-use middle::mem_categorization::{cat_special, gc_ptr, loan_path, lp_arg};
+use middle::mem_categorization::{cat_special, cmt, gc_ptr, loan_path, lp_arg};
 use middle::mem_categorization::{lp_comp, lp_deref, lp_local};
 use middle::ty::{CopyValue, MoveValue, ReadValue};
 use middle::ty;
@@ -41,8 +41,6 @@ use syntax::codemap::span;
 use syntax::print::pprust;
 use syntax::visit;
 
-export check_loans;
-
 enum check_loan_ctxt = @{
     bccx: borrowck_ctxt,
     req_maps: req_maps,
@@ -65,9 +63,9 @@ enum purity_cause {
     pc_cmt(bckerr)
 }
 
-fn check_loans(bccx: borrowck_ctxt,
-               req_maps: req_maps,
-               crate: @ast::crate) {
+pub fn check_loans(bccx: borrowck_ctxt,
+                   req_maps: req_maps,
+                   crate: @ast::crate) {
     let clcx = check_loan_ctxt(@{bccx: bccx,
                                  req_maps: req_maps,
                                  reported: HashMap(),

src/librustc/middle/borrowck/gather_loans.rs

@@ -40,8 +40,6 @@ use syntax::codemap::span;
 use syntax::print::pprust;
 use syntax::visit;
 
-export gather_loans;
-
 /// Context used while gathering loans:
 ///
 /// - `bccx`: the the borrow check context
@@ -76,7 +74,7 @@ enum gather_loan_ctxt = @{bccx: borrowck_ctxt,
                           mut root_ub: ast::node_id,
                           mut ignore_adjustments: LinearSet<ast::node_id>};
 
-fn gather_loans(bccx: borrowck_ctxt, crate: @ast::crate) -> req_maps {
+pub fn gather_loans(bccx: borrowck_ctxt, crate: @ast::crate) -> req_maps {
     let glcx = gather_loan_ctxt(@{bccx: bccx,
                                   req_maps: {req_loan_map: HashMap(),
                                              pure_map: HashMap()},

src/librustc/middle/borrowck/loan.rs

@@ -43,22 +43,20 @@ XXX --- much more needed, don't have time to write this all up now
 
 use core::prelude::*;
 
-use middle::borrowck::{Loan, bckerr, bckres, borrowck_ctxt, cmt, err_mutbl};
+use middle::borrowck::{Loan, bckerr, bckres, borrowck_ctxt, err_mutbl};
 use middle::borrowck::{err_out_of_scope};
 use middle::mem_categorization::{cat_arg, cat_binding, cat_discr, cat_comp};
 use middle::mem_categorization::{cat_deref, cat_discr, cat_local, cat_self};
-use middle::mem_categorization::{cat_special, cat_stack_upvar, comp_field};
-use middle::mem_categorization::{comp_index, comp_variant, gc_ptr};
-use middle::mem_categorization::{region_ptr};
+use middle::mem_categorization::{cat_special, cat_stack_upvar, cmt};
+use middle::mem_categorization::{comp_field, comp_index, comp_variant};
+use middle::mem_categorization::{gc_ptr, region_ptr};
 use middle::ty;
 use util::common::indenter;
 
 use core::result::{Err, Ok, Result};
 use syntax::ast::{m_const, m_imm, m_mutbl};
 use syntax::ast;
 
-export public_methods;
-
 impl borrowck_ctxt {
     fn loan(cmt: cmt,
             scope_region: ty::Region,

src/librustc/middle/borrowck/mod.rs

@@ -224,8 +224,6 @@ Borrowck results in two maps.
   given a memory location and not used as immediates.
  */
 
-#[legacy_exports];
-
 use core::prelude::*;
 
 use middle::liveness;
@@ -251,20 +249,16 @@ use syntax::codemap::span;
 use syntax::print::pprust;
 use syntax::visit;
 
-#[legacy_exports]
 pub mod check_loans;
-#[legacy_exports]
 pub mod gather_loans;
-#[legacy_exports]
 pub mod loan;
-#[legacy_exports]
 pub mod preserve;
 
-fn check_crate(tcx: ty::ctxt,
-               method_map: typeck::method_map,
-               last_use_map: liveness::last_use_map,
-               crate: @ast::crate)
-            -> (root_map, mutbl_map, write_guard_map) {
+pub fn check_crate(tcx: ty::ctxt,
+                   method_map: typeck::method_map,
+                   last_use_map: liveness::last_use_map,
+                   crate: @ast::crate)
+                -> (root_map, mutbl_map, write_guard_map) {
 
     let bccx = borrowck_ctxt_(@{tcx: tcx,
                                 method_map: method_map,
@@ -308,26 +302,26 @@ fn check_crate(tcx: ty::ctxt,
 // ----------------------------------------------------------------------
 // Type definitions
 
-type borrowck_ctxt_ = {tcx: ty::ctxt,
-                       method_map: typeck::method_map,
-                       last_use_map: liveness::last_use_map,
-                       root_map: root_map,
-                       mutbl_map: mutbl_map,
-                       write_guard_map: write_guard_map,
-                       stmt_map: stmt_set,
-
-                       // Statistics:
-                       mut loaned_paths_same: uint,
-                       mut loaned_paths_imm: uint,
-                       mut stable_paths: uint,
-                       mut req_pure_paths: uint,
-                       mut guaranteed_paths: uint};
-
-enum borrowck_ctxt {
+pub type borrowck_ctxt_ = {tcx: ty::ctxt,
+                           method_map: typeck::method_map,
+                           last_use_map: liveness::last_use_map,
+                           root_map: root_map,
+                           mutbl_map: mutbl_map,
+                           write_guard_map: write_guard_map,
+                           stmt_map: stmt_set,
+
+                           // Statistics:
+                           mut loaned_paths_same: uint,
+                           mut loaned_paths_imm: uint,
+                           mut stable_paths: uint,
+                           mut req_pure_paths: uint,
+                           mut guaranteed_paths: uint};
+
+pub enum borrowck_ctxt {
     borrowck_ctxt_(@borrowck_ctxt_)
 }
 
-struct RootInfo {
+pub struct RootInfo {
     scope: ast::node_id,
     // This will be true if we need to freeze this box at runtime. This will
     // result in a call to `borrow_as_imm()` and `return_to_mut()`.
@@ -337,29 +331,30 @@ struct RootInfo {
 // a map mapping id's of expressions of gc'd type (@T, @[], etc) where
 // the box needs to be kept live to the id of the scope for which they
 // must stay live.
-type root_map = HashMap<root_map_key, RootInfo>;
+pub type root_map = HashMap<root_map_key, RootInfo>;
 
 // the keys to the root map combine the `id` of the expression with
 // the number of types that it is autodereferenced.  So, for example,
 // if you have an expression `x.f` and x has type ~@T, we could add an
 // entry {id:x, derefs:0} to refer to `x` itself, `{id:x, derefs:1}`
 // to refer to the deref of the unique pointer, and so on.
 #[deriving_eq]
-struct root_map_key {
+pub struct root_map_key {
     id: ast::node_id,
     derefs: uint
 }
 
 // set of ids of local vars / formal arguments that are modified / moved.
 // this is used in trans for optimization purposes.
-type mutbl_map = HashMap<ast::node_id, ()>;
+pub type mutbl_map = HashMap<ast::node_id, ()>;
 
 // A set containing IDs of expressions of gc'd type that need to have a write
 // guard.
-type write_guard_map = HashMap<root_map_key, ()>;
+pub type write_guard_map = HashMap<root_map_key, ()>;
 
-// Errors that can occur"]
-enum bckerr_code {
+// Errors that can occur
+#[deriving_eq]
+pub enum bckerr_code {
     err_mut_uniq,
     err_mut_variant,
     err_root_not_permitted,
@@ -368,61 +363,16 @@ enum bckerr_code {
     err_out_of_scope(ty::Region, ty::Region) // superscope, subscope
 }
 
-impl bckerr_code : cmp::Eq {
-    pure fn eq(&self, other: &bckerr_code) -> bool {
-        match (*self) {
-            err_mut_uniq => {
-                match (*other) {
-                    err_mut_uniq => true,
-                    _ => false
-                }
-            }
-            err_mut_variant => {
-                match (*other) {
-                    err_mut_variant => true,
-                    _ => false
-                }
-            }
-            err_root_not_permitted => {
-                match (*other) {
-                    err_root_not_permitted => true,
-                    _ => false
-                }
-            }
-            err_mutbl(e0a) => {
-                match (*other) {
-                    err_mutbl(e0b) => e0a == e0b,
-                    _ => false
-                }
-            }
-            err_out_of_root_scope(e0a, e1a) => {
-                match (*other) {
-                    err_out_of_root_scope(e0b, e1b) =>
-                        e0a == e0b && e1a == e1b,
-                    _ => false
-                }
-            }
-            err_out_of_scope(e0a, e1a) => {
-                match (*other) {
-                    err_out_of_scope(e0b, e1b) => e0a == e0b && e1a == e1b,
-                    _ => false
-                }
-            }
-        }
-    }
-    pure fn ne(&self, other: &bckerr_code) -> bool { !(*self).eq(other) }
-}
-
 // Combination of an error code and the categorization of the expression
 // that caused it
 #[deriving_eq]
-struct bckerr {
+pub struct bckerr {
     cmt: cmt,
     code: bckerr_code
 }
 
 // shorthand for something that fails with `bckerr` or succeeds with `T`
-type bckres<T> = Result<T, bckerr>;
+pub type bckres<T> = Result<T, bckerr>;
 
 /// a complete record of a loan that was granted
 pub struct Loan {lp: @loan_path, cmt: cmt, mutbl: ast::mutability}
@@ -438,7 +388,8 @@ pub type req_maps = {
     pure_map: HashMap<ast::node_id, bckerr>
 };
 
-fn save_and_restore<T:Copy,U>(save_and_restore_t: &mut T, f: fn() -> U) -> U {
+pub fn save_and_restore<T:Copy,U>(save_and_restore_t: &mut T,
+                                  f: fn() -> U) -> U {
     let old_save_and_restore_t = *save_and_restore_t;
     let u = f();
     *save_and_restore_t = old_save_and_restore_t;
@@ -447,20 +398,20 @@ fn save_and_restore<T:Copy,U>(save_and_restore_t: &mut T, f: fn() -> U) -> U {
 
 /// Creates and returns a new root_map
 
-impl root_map_key : to_bytes::IterBytes {
+pub impl root_map_key : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
         to_bytes::iter_bytes_2(&self.id, &self.derefs, lsb0, f);
     }
 }
 
-fn root_map() -> root_map {
+pub fn root_map() -> root_map {
     return HashMap();
 }
 
 // ___________________________________________________________________________
 // Misc
 
-impl borrowck_ctxt {
+pub impl borrowck_ctxt {
     fn is_subregion_of(r_sub: ty::Region, r_sup: ty::Region) -> bool {
         region::is_subregion_of(self.tcx.region_map, r_sub, r_sup)
     }
@@ -632,7 +583,7 @@ impl borrowck_ctxt {
 // assuming it is embedded in an immutable context.  In general, the
 // mutability can be "overridden" if the component is embedded in a
 // mutable structure.
-fn inherent_mutability(ck: comp_kind) -> mutability {
+pub fn inherent_mutability(ck: comp_kind) -> mutability {
     match ck {
       comp_tuple | comp_anon_field | comp_variant(_) => m_imm,
       comp_field(_, m) | comp_index(_, m)            => m

src/librustc/middle/borrowck/preserve.rs

@@ -16,22 +16,21 @@
 use core::prelude::*;
 
 use middle::borrowck::{RootInfo, bckerr, bckerr_code, bckres, borrowck_ctxt};
-use middle::borrowck::{cmt, err_mut_uniq, err_mut_variant};
+use middle::borrowck::{err_mut_uniq, err_mut_variant};
 use middle::borrowck::{err_out_of_root_scope, err_out_of_scope};
 use middle::borrowck::{err_root_not_permitted, root_map_key};
 use middle::mem_categorization::{cat_arg, cat_binding, cat_comp, cat_deref};
 use middle::mem_categorization::{cat_discr, cat_local, cat_self, cat_special};
-use middle::mem_categorization::{cat_stack_upvar, comp_field, comp_index};
-use middle::mem_categorization::{comp_variant, gc_ptr, region_ptr};
+use middle::mem_categorization::{cat_stack_upvar, cmt, comp_field};
+use middle::mem_categorization::{comp_index, comp_variant, gc_ptr};
+use middle::mem_categorization::{region_ptr};
 use middle::ty;
 use util::common::indenter;
 
 use syntax::ast::{m_const, m_imm, m_mutbl};
 use syntax::ast;
 
-export public_methods, preserve_condition, pc_ok, pc_if_pure;
-
-enum preserve_condition {
+pub enum preserve_condition {
     pc_ok,
     pc_if_pure(bckerr)
 }