---

yaml
---
r: 82271
b: refs/heads/master
c: b0f6c29
h: refs/heads/master
i:
  82269: 47430f8
  82267: 9fecb1e
  82263: 9d210ee
  82255: 8bcd89c
  82239: 2e35ff4
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 34d123db4eb03c1b2378b6248ebea5f0f40f2a4f
+refs/heads/master: b0f6c29b4f10bafa59723714161a393a204f9c13
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729

trunk/src/libextra/base64.rs

@@ -64,11 +64,11 @@ impl<'self> ToBase64 for &'self [u8] {
      *
      * ```rust
      * extern mod extra;
-     * use extra::base64::{ToBase64, STANDARD};
+     * use extra::base64::{ToBase64, standard};
      *
      * fn main () {
-     *     let str = [52,32].to_base64(STANDARD);
-     *     println!("base 64 output: {}", str);
+     *     let str = [52,32].to_base64(standard);
+     *     println!("{}", str);
      * }
      * ```
      */
@@ -172,19 +172,16 @@ impl<'self> FromBase64 for &'self str {
      *
      * ```rust
      * extern mod extra;
-     * use extra::base64::{ToBase64, FromBase64, STANDARD};
+     * use extra::base64::{ToBase64, FromBase64, standard};
      * use std::str;
      *
      * fn main () {
-     *     let hello_str = bytes!("Hello, World").to_base64(STANDARD);
-     *     println!("base64 output: {}", hello_str);
-     *     let res = hello_str.from_base64();
-     *     if res.is_ok() {
-     *       let optBytes = str::from_utf8_opt(res.unwrap());
-     *       if optBytes.is_some() {
-     *         println!("decoded from base64: {}", optBytes.unwrap());
-     *       }
-     *     }
+     *     let hello_str = "Hello, World".to_base64(standard);
+     *     println!("{}", hello_str);
+     *     let bytes = hello_str.from_base64();
+     *     println!("{:?}", bytes);
+     *     let result_str = str::from_utf8(bytes);
+     *     println!("{}", result_str);
      * }
      * ```
      */

trunk/src/librustc/driver/driver.rs

@@ -263,9 +263,10 @@ pub fn phase_3_run_analysis_passes(sess: Session,
                                           method_map, ty_cx));
 
     let maps = (external_exports, last_private_map);
-    time(time_passes, "privacy checking", maps, |(a, b)|
-         middle::privacy::check_crate(ty_cx, &method_map, &exp_map2,
-                                      a, b, crate));
+    let exported_items =
+        time(time_passes, "privacy checking", maps, |(a, b)|
+             middle::privacy::check_crate(ty_cx, &method_map, &exp_map2,
+                                          a, b, crate));
 
     time(time_passes, "effect checking", (), |_|
          middle::effect::check_crate(ty_cx, method_map, crate));
@@ -300,7 +301,8 @@ pub fn phase_3_run_analysis_passes(sess: Session,
 
     let reachable_map =
         time(time_passes, "reachability checking", (), |_|
-             reachable::find_reachable(ty_cx, method_map, crate));
+             reachable::find_reachable(ty_cx, method_map, exp_map2,
+                                       &exported_items));
 
     time(time_passes, "lint checking", (), |_|
          lint::check_crate(ty_cx, crate));

trunk/src/librustc/middle/effect.rs

@@ -11,14 +11,19 @@
 //! Enforces the Rust effect system. Currently there is just one effect,
 /// `unsafe`.
 
+use middle::ty::{ty_bare_fn, ty_closure, ty_ptr};
 use middle::ty;
 use middle::typeck::method_map;
 use util::ppaux;
 
+use syntax::ast::{UnDeref, ExprCall, ExprInlineAsm, ExprMethodCall};
+use syntax::ast::{ExprUnary, unsafe_fn, ExprPath};
 use syntax::ast;
 use syntax::codemap::Span;
+use syntax::visit::{fk_item_fn, fk_method};
 use syntax::visit;
-use syntax::visit::Visitor;
+use syntax::visit::{Visitor,fn_kind};
+use syntax::ast::{fn_decl,Block,NodeId,Expr};
 
 #[deriving(Eq)]
 enum UnsafeContext {
@@ -27,26 +32,29 @@ enum UnsafeContext {
     UnsafeBlock(ast::NodeId),
 }
 
+struct Context {
+    /// The method map.
+    method_map: method_map,
+    /// Whether we're in an unsafe context.
+    unsafe_context: UnsafeContext,
+}
+
 fn type_is_unsafe_function(ty: ty::t) -> bool {
     match ty::get(ty).sty {
-        ty::ty_bare_fn(ref f) => f.purity == ast::unsafe_fn,
-        ty::ty_closure(ref f) => f.purity == ast::unsafe_fn,
+        ty_bare_fn(ref f) => f.purity == unsafe_fn,
+        ty_closure(ref f) => f.purity == unsafe_fn,
         _ => false,
     }
 }
 
 struct EffectCheckVisitor {
     tcx: ty::ctxt,
-
-    /// The method map.
-    method_map: method_map,
-    /// Whether we're in an unsafe context.
-    unsafe_context: UnsafeContext,
+    context: @mut Context,
 }
 
 impl EffectCheckVisitor {
     fn require_unsafe(&mut self, span: Span, description: &str) {
-        match self.unsafe_context {
+        match self.context.unsafe_context {
             SafeContext => {
                 // Report an error.
                 self.tcx.sess.span_err(span,
@@ -61,125 +69,113 @@ impl EffectCheckVisitor {
             UnsafeFn => {}
         }
     }
-
-    fn check_str_index(&mut self, e: @ast::Expr) {
-        let base_type = match e.node {
-            ast::ExprIndex(_, base, _) => ty::node_id_to_type(self.tcx, base.id),
-            _ => return
-        };
-        debug2!("effect: checking index with base type {}",
-                ppaux::ty_to_str(self.tcx, base_type));
-        match ty::get(base_type).sty {
-            ty::ty_estr(*) => {
-                self.tcx.sess.span_err(e.span,
-                    "modification of string types is not allowed");
-            }
-            _ => {}
-        }
-    }
 }
 
 impl Visitor<()> for EffectCheckVisitor {
-    fn visit_fn(&mut self, fn_kind: &visit::fn_kind, fn_decl: &ast::fn_decl,
-                block: &ast::Block, span: Span, node_id: ast::NodeId, _:()) {
-
-        let (is_item_fn, is_unsafe_fn) = match *fn_kind {
-            visit::fk_item_fn(_, _, purity, _) =>
-                (true, purity == ast::unsafe_fn),
-            visit::fk_method(_, _, method) =>
-                (true, method.purity == ast::unsafe_fn),
-            _ => (false, false),
-        };
-
-        let old_unsafe_context = self.unsafe_context;
-        if is_unsafe_fn {
-            self.unsafe_context = UnsafeFn
-        } else if is_item_fn {
-            self.unsafe_context = SafeContext
-        }
+    fn visit_fn(&mut self, fn_kind:&fn_kind, fn_decl:&fn_decl,
+                block:&Block, span:Span, node_id:NodeId, _:()) {
+
+            let (is_item_fn, is_unsafe_fn) = match *fn_kind {
+                fk_item_fn(_, _, purity, _) => (true, purity == unsafe_fn),
+                fk_method(_, _, method) => (true, method.purity == unsafe_fn),
+                _ => (false, false),
+            };
+
+            let old_unsafe_context = self.context.unsafe_context;
+            if is_unsafe_fn {
+                self.context.unsafe_context = UnsafeFn
+            } else if is_item_fn {
+                self.context.unsafe_context = SafeContext
+            }
 
-        visit::walk_fn(self, fn_kind, fn_decl, block, span, node_id, ());
+            visit::walk_fn(self,
+                           fn_kind,
+                            fn_decl,
+                            block,
+                            span,
+                            node_id,
+                            ());
 
-        self.unsafe_context = old_unsafe_context
+            self.context.unsafe_context = old_unsafe_context
     }
 
-    fn visit_block(&mut self, block: &ast::Block, _:()) {
-        let old_unsafe_context = self.unsafe_context;
-        let is_unsafe = match block.rules {
-            ast::UnsafeBlock(*) => true, ast::DefaultBlock => false
-        };
-        if is_unsafe && self.unsafe_context == SafeContext {
-            self.unsafe_context = UnsafeBlock(block.id)
-        }
+    fn visit_block(&mut self, block:&Block, _:()) {
+
+            let old_unsafe_context = self.context.unsafe_context;
+            let is_unsafe = match block.rules {
+                ast::UnsafeBlock(*) => true, ast::DefaultBlock => false
+            };
+            if is_unsafe && self.context.unsafe_context == SafeContext {
+                self.context.unsafe_context = UnsafeBlock(block.id)
+            }
 
-        visit::walk_block(self, block, ());
+            visit::walk_block(self, block, ());
 
-        self.unsafe_context = old_unsafe_context
+            self.context.unsafe_context = old_unsafe_context
     }
 
-    fn visit_expr(&mut self, expr: @ast::Expr, _:()) {
-        match expr.node {
-            ast::ExprMethodCall(callee_id, _, _, _, _, _) => {
-                let base_type = ty::node_id_to_type(self.tcx, callee_id);
-                debug2!("effect: method call case, base type is {}",
-                       ppaux::ty_to_str(self.tcx, base_type));
-                if type_is_unsafe_function(base_type) {
-                    self.require_unsafe(expr.span,
-                                        "invocation of unsafe method")
+    fn visit_expr(&mut self, expr:@Expr, _:()) {
+
+            match expr.node {
+                ExprMethodCall(callee_id, _, _, _, _, _) => {
+                    let base_type = ty::node_id_to_type(self.tcx, callee_id);
+                    debug2!("effect: method call case, base type is {}",
+                           ppaux::ty_to_str(self.tcx, base_type));
+                    if type_is_unsafe_function(base_type) {
+                        self.require_unsafe(expr.span,
+                                       "invocation of unsafe method")
+                    }
                 }
-            }
-            ast::ExprCall(base, _, _) => {
-                let base_type = ty::node_id_to_type(self.tcx, base.id);
-                debug2!("effect: call case, base type is {}",
-                       ppaux::ty_to_str(self.tcx, base_type));
-                if type_is_unsafe_function(base_type) {
-                    self.require_unsafe(expr.span, "call to unsafe function")
+                ExprCall(base, _, _) => {
+                    let base_type = ty::node_id_to_type(self.tcx, base.id);
+                    debug2!("effect: call case, base type is {}",
+                           ppaux::ty_to_str(self.tcx, base_type));
+                    if type_is_unsafe_function(base_type) {
+                        self.require_unsafe(expr.span, "call to unsafe function")
+                    }
                 }
-            }
-            ast::ExprUnary(_, ast::UnDeref, base) => {
-                let base_type = ty::node_id_to_type(self.tcx, base.id);
-                debug2!("effect: unary case, base type is {}",
-                        ppaux::ty_to_str(self.tcx, base_type));
-                match ty::get(base_type).sty {
-                    ty::ty_ptr(_) => {
-                        self.require_unsafe(expr.span,
-                                            "dereference of unsafe pointer")
+                ExprUnary(_, UnDeref, base) => {
+                    let base_type = ty::node_id_to_type(self.tcx, base.id);
+                    debug2!("effect: unary case, base type is {}",
+                           ppaux::ty_to_str(self.tcx, base_type));
+                    match ty::get(base_type).sty {
+                        ty_ptr(_) => {
+                            self.require_unsafe(expr.span,
+                                           "dereference of unsafe pointer")
+                        }
+                        _ => {}
                     }
-                    _ => {}
                 }
-            }
-            ast::ExprAssign(base, _) | ast::ExprAssignOp(_, _, base, _) => {
-                self.check_str_index(base);
-            }
-            ast::ExprAddrOf(ast::MutMutable, base) => {
-                self.check_str_index(base);
-            }
-            ast::ExprInlineAsm(*) => {
-                self.require_unsafe(expr.span, "use of inline assembly")
-            }
-            ast::ExprPath(*) => {
-                match ty::resolve_expr(self.tcx, expr) {
-                    ast::DefStatic(_, true) => {
-                        self.require_unsafe(expr.span, "use of mutable static")
+                ExprInlineAsm(*) => {
+                    self.require_unsafe(expr.span, "use of inline assembly")
+                }
+                ExprPath(*) => {
+                    match ty::resolve_expr(self.tcx, expr) {
+                        ast::DefStatic(_, true) => {
+                            self.require_unsafe(expr.span, "use of mutable static")
+                        }
+                        _ => {}
                     }
-                    _ => {}
                 }
+                _ => {}
             }
-            _ => {}
-        }
 
-        visit::walk_expr(self, expr, ());
+            visit::walk_expr(self, expr, ());
     }
 }
 
 pub fn check_crate(tcx: ty::ctxt,
                    method_map: method_map,
                    crate: &ast::Crate) {
-    let mut visitor = EffectCheckVisitor {
-        tcx: tcx,
+    let context = @mut Context {
         method_map: method_map,
         unsafe_context: SafeContext,
     };
 
+    let mut visitor = EffectCheckVisitor {
+        tcx: tcx,
+        context: context,
+    };
+
     visit::walk_crate(&mut visitor, crate, ());
 }

trunk/src/librustc/middle/privacy.rs

@@ -31,6 +31,10 @@ use syntax::visit::Visitor;
 
 type Context<'self> = (&'self method_map, &'self resolve::ExportMap2);
 
+// A set of all nodes in the ast which can be considered "publicly exported" in
+// the sense that they are accessible from anywhere in any hierarchy.
+pub type ExportedItems = HashSet<ast::NodeId>;
+
 // This visitor is used to determine the parent of all nodes in question when it
 // comes to privacy. This is used to determine later on if a usage is actually
 // valid or not.
@@ -137,7 +141,7 @@ impl<'self> Visitor<()> for ParentVisitor<'self> {
 // This visitor is used to determine which items of the ast are embargoed,
 // otherwise known as not exported.
 struct EmbargoVisitor<'self> {
-    exported_items: &'self mut HashSet<ast::NodeId>,
+    exported_items: &'self mut ExportedItems,
     exp_map2: &'self resolve::ExportMap2,
     path_all_public: bool,
 }
@@ -239,7 +243,7 @@ struct PrivacyVisitor<'self> {
     curitem: ast::NodeId,
 
     // Results of previous analyses necessary for privacy checking.
-    exported_items: &'self HashSet<ast::NodeId>,
+    exported_items: &'self ExportedItems,
     method_map: &'self method_map,
     parents: &'self HashMap<ast::NodeId, ast::NodeId>,
     external_exports: resolve::ExternalExports,
@@ -785,7 +789,7 @@ pub fn check_crate(tcx: ty::ctxt,
                    exp_map2: &resolve::ExportMap2,
                    external_exports: resolve::ExternalExports,
                    last_private_map: resolve::LastPrivateMap,
-                   crate: &ast::Crate) {
+                   crate: &ast::Crate) -> ExportedItems {
     let mut parents = HashMap::new();
     let mut exported_items = HashSet::new();
 
@@ -802,7 +806,7 @@ pub fn check_crate(tcx: ty::ctxt,
     {
         // Initialize the exported items with resolve's id for the "root crate"
         // to resolve references to `super` leading to the root and such.
-        exported_items.insert(0);
+        exported_items.insert(ast::CRATE_NODE_ID);
         let mut visitor = EmbargoVisitor {
             exported_items: &mut exported_items,
             exp_map2: exp_map2,
@@ -824,4 +828,5 @@ pub fn check_crate(tcx: ty::ctxt,
         };
         visit::walk_crate(&mut visitor, crate, ());
     }
+    return exported_items;
 }