---

yaml
---
r: 145870
b: refs/heads/try2
c: 8015f9c
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: caf7b678dd2f07918b47120aa73a1bca51d12da1
+refs/heads/try2: 8015f9c27ec342dbf0b28c9c0c4769d8b3bcfc9f
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/compiletest/errors.rs

@@ -8,24 +8,29 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::io;
-
 pub struct ExpectedError { line: uint, kind: ~str, msg: ~str }
 
 // Load any test directives embedded in the file
 pub fn load_errors(testfile: &Path) -> ~[ExpectedError] {
+    use std::rt::io::Open;
+    use std::rt::io::file::FileInfo;
+    use std::rt::io::buffered::BufferedReader;
+
     let mut error_patterns = ~[];
-    let rdr = io::file_reader(testfile).unwrap();
+    let mut rdr = BufferedReader::new(testfile.open_reader(Open).unwrap());
     let mut line_num = 1u;
-    while !rdr.eof() {
-        let ln = rdr.read_line();
+    loop {
+        let ln = match rdr.read_line() {
+            Some(ln) => ln, None => break,
+        };
         error_patterns.push_all_move(parse_expected(line_num, ln));
         line_num += 1u;
     }
     return error_patterns;
 }
 
 fn parse_expected(line_num: uint, line: ~str) -> ~[ExpectedError] {
+    let line = line.trim();
     let error_tag = ~"//~";
     let mut idx;
     match line.find_str(error_tag) {

branches/try2/src/compiletest/header.rs

@@ -12,8 +12,6 @@ use common::config;
 use common;
 use util;
 
-use std::io;
-
 pub struct TestProps {
     // Lines that should be expected, in order, on standard out
     error_patterns: ~[~str],
@@ -104,17 +102,23 @@ pub fn is_test_ignored(config: &config, testfile: &Path) -> bool {
     !val
 }
 
-fn iter_header(testfile: &Path, it: &fn(~str) -> bool) -> bool {
-    let rdr = io::file_reader(testfile).unwrap();
-    while !rdr.eof() {
-        let ln = rdr.read_line();
+fn iter_header(testfile: &Path, it: &fn(&str) -> bool) -> bool {
+    use std::rt::io::Open;
+    use std::rt::io::file::FileInfo;
+    use std::rt::io::buffered::BufferedReader;
+
+    let mut rdr = BufferedReader::new(testfile.open_reader(Open).unwrap());
+    loop {
+        let ln = match rdr.read_line() {
+            Some(ln) => ln, None => break
+        };
 
         // Assume that any directives will be found before the first
         // module or function. This doesn't seem to be an optimization
         // with a warm page cache. Maybe with a cold one.
         if ln.starts_with("fn") || ln.starts_with("mod") {
             return true;
-        } else { if !(it(ln)) { return false; } }
+        } else { if !(it(ln.trim())) { return false; } }
     }
     return true;
 }

branches/try2/src/compiletest/procsrv.rs

@@ -57,7 +57,7 @@ pub fn run(lib_path: &str,
     });
 
     for input in input.iter() {
-        proc.input().write_str(*input);
+        proc.input().write(input.as_bytes());
     }
     let output = proc.finish_with_output();
 

branches/try2/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!("{}", str);
+     *     let str = [52,32].to_base64(STANDARD);
+     *     println!("base 64 output: {}", str);
      * }
      * ```
      */
@@ -172,16 +172,19 @@ 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 = "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);
+     *     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());
+     *       }
+     *     }
      * }
      * ```
      */

branches/try2/src/librustc/middle/effect.rs

@@ -11,19 +11,14 @@
 //! 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,fn_kind};
-use syntax::ast::{fn_decl,Block,NodeId,Expr};
+use syntax::visit::Visitor;
 
 #[deriving(Eq)]
 enum UnsafeContext {
@@ -32,29 +27,26 @@ 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_bare_fn(ref f) => f.purity == unsafe_fn,
-        ty_closure(ref f) => f.purity == unsafe_fn,
+        ty::ty_bare_fn(ref f) => f.purity == ast::unsafe_fn,
+        ty::ty_closure(ref f) => f.purity == ast::unsafe_fn,
         _ => false,
     }
 }
 
 struct EffectCheckVisitor {
     tcx: ty::ctxt,
-    context: @mut Context,
+
+    /// The method map.
+    method_map: method_map,
+    /// Whether we're in an unsafe context.
+    unsafe_context: UnsafeContext,
 }
 
 impl EffectCheckVisitor {
     fn require_unsafe(&mut self, span: Span, description: &str) {
-        match self.context.unsafe_context {
+        match self.unsafe_context {
             SafeContext => {
                 // Report an error.
                 self.tcx.sess.span_err(span,
@@ -69,112 +61,124 @@ 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:&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
-            }
+    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
+        }
 
-            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.context.unsafe_context = old_unsafe_context
+        self.unsafe_context = old_unsafe_context
     }
 
-    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)
-            }
+    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)
+        }
 
-            visit::walk_block(self, block, ());
+        visit::walk_block(self, block, ());
 
-            self.context.unsafe_context = old_unsafe_context
+        self.unsafe_context = old_unsafe_context
     }
 
-    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")
-                    }
+    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")
                 }
-                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::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")
                 }
-                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::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")
                     }
+                    _ => {}
                 }
-                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")
-                        }
-                        _ => {}
+            }
+            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")
                     }
+                    _ => {}
                 }
-                _ => {}
             }
+            _ => {}
+        }
 
-            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 context = @mut Context {
-        method_map: method_map,
-        unsafe_context: SafeContext,
-    };
-
     let mut visitor = EffectCheckVisitor {
         tcx: tcx,
-        context: context,
+        method_map: method_map,
+        unsafe_context: SafeContext,
     };
 
     visit::walk_crate(&mut visitor, crate, ());