---

yaml
---
r: 114524
b: refs/heads/master
c: 85d9cfb
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 1fc29ef0c8c35eacf7d72e5eb0e7c961009ab4c9
+refs/heads/master: 85d9cfb809d8191a03e84c5754e2e778281e5ce9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17

trunk/src/doc/tutorial.md

@@ -1106,7 +1106,7 @@ let ys = xs;
 
 xs = Nil;
 
-// `xs` can't be used again
+// `xs` can be used again
 ~~~
 
 A destructor call will only occur for a variable that has not been moved from,

trunk/src/librustc/middle/check_match.rs

@@ -863,18 +863,9 @@ fn default(cx: &MatchCheckCtxt, r: &[@Pat]) -> Option<Vec<@Pat> > {
 
 fn check_local(cx: &mut MatchCheckCtxt, loc: &Local) {
     visit::walk_local(cx, loc, ());
-
-    let name = match loc.source {
-        LocalLet => "local",
-        LocalFor => "`for` loop"
-    };
-
-    let mut spans = vec![];
-    find_refutable(cx, loc.pat, &mut spans);
-
-    for span in spans.iter() {
-        cx.tcx.sess.span_err(*span,
-                             format!("refutable pattern in {} binding", name).as_slice());
+    if is_refutable(cx, loc.pat) {
+        cx.tcx.sess.span_err(loc.pat.span,
+                             "refutable pattern in local binding");
     }
 
     // Check legality of move bindings.
@@ -888,65 +879,53 @@ fn check_fn(cx: &mut MatchCheckCtxt,
             sp: Span) {
     visit::walk_fn(cx, kind, decl, body, sp, ());
     for input in decl.inputs.iter() {
-        let mut spans = vec![];
-        find_refutable(cx, input.pat, &mut spans);
-
-        for span in spans.iter() {
-            cx.tcx.sess.span_err(*span,
+        if is_refutable(cx, input.pat) {
+            cx.tcx.sess.span_err(input.pat.span,
                                  "refutable pattern in function argument");
         }
     }
 }
 
-fn find_refutable(cx: &MatchCheckCtxt, pat: &Pat, spans: &mut Vec<Span>) {
-    macro_rules! this_pattern {
-        () => {
-            {
-                spans.push(pat.span);
-                return
-            }
-        }
-    }
+fn is_refutable(cx: &MatchCheckCtxt, pat: &Pat) -> bool {
     let opt_def = cx.tcx.def_map.borrow().find_copy(&pat.id);
     match opt_def {
       Some(DefVariant(enum_id, _, _)) => {
         if ty::enum_variants(cx.tcx, enum_id).len() != 1u {
-            this_pattern!()
+            return true;
         }
       }
-      Some(DefStatic(..)) => this_pattern!(),
+      Some(DefStatic(..)) => return true,
       _ => ()
     }
 
     match pat.node {
       PatUniq(sub) | PatRegion(sub) | PatIdent(_, _, Some(sub)) => {
-        find_refutable(cx, sub, spans)
+        is_refutable(cx, sub)
       }
-      PatWild | PatWildMulti | PatIdent(_, _, None) => {}
+      PatWild | PatWildMulti | PatIdent(_, _, None) => { false }
       PatLit(lit) => {
           match lit.node {
             ExprLit(lit) => {
                 match lit.node {
-                    LitNil => {}    // `()`
-                    _ => this_pattern!(),
+                    LitNil => false,    // `()`
+                    _ => true,
                 }
             }
-            _ => this_pattern!(),
+            _ => true,
           }
       }
-      PatRange(_, _) => { this_pattern!() }
+      PatRange(_, _) => { true }
       PatStruct(_, ref fields, _) => {
-          for f in fields.iter() {
-              find_refutable(cx, f.pat, spans);
-          }
+        fields.iter().any(|f| is_refutable(cx, f.pat))
       }
-      PatTup(ref elts) | PatEnum(_, Some(ref elts))=> {
-          for elt in elts.iter() {
-              find_refutable(cx, *elt, spans)
-          }
+      PatTup(ref elts) => {
+        elts.iter().any(|elt| is_refutable(cx, *elt))
+      }
+      PatEnum(_, Some(ref args)) => {
+        args.iter().any(|a| is_refutable(cx, *a))
       }
-      PatEnum(_,_) => {}
-      PatVec(..) => { this_pattern!() }
+      PatEnum(_,_) => { false }
+      PatVec(..) => { true }
     }
 }
 

trunk/src/librustc/middle/privacy.rs

@@ -297,23 +297,6 @@ impl<'a> Visitor<()> for EmbargoVisitor<'a> {
                 }
             }
 
-            ast::ItemTy(ref ty, _) if public_first => {
-                match ty.node {
-                    ast::TyPath(_, _, id) => {
-                        match self.tcx.def_map.borrow().get_copy(&id) {
-                            ast::DefPrimTy(..) => {},
-                            def => {
-                                let did = def_id_of_def(def);
-                                if is_local(did) {
-                                    self.exported_items.insert(did.node);
-                                }
-                            }
-                        }
-                    }
-                    _ => {}
-                }
-            }
-
             _ => {}
         }
 

trunk/src/libserialize/json.rs

@@ -1434,36 +1434,6 @@ impl<T: Iterator<char>> Parser<T> {
                         },
                     },
                     _ => return self.error(InvalidEscape),
-/*=======
-                    'u' => {
-                        // Parse \u1234.
-                        let mut i = 0u;
-                        let mut n = 0u;
-                        while i < 4u && !self.eof() {
-                            self.bump();
-                            n = match self.ch_or_null() {
-                                c @ '0' .. '9' => n * 16u + (c as uint) - ('0' as uint),
-                                'a' | 'A' => n * 16u + 10u,
-                                'b' | 'B' => n * 16u + 11u,
-                                'c' | 'C' => n * 16u + 12u,
-                                'd' | 'D' => n * 16u + 13u,
-                                'e' | 'E' => n * 16u + 14u,
-                                'f' | 'F' => n * 16u + 15u,
-                                _ => return self.error(UnrecognizedHex)
-                            };
-
-                            i += 1u;
-                        }
-
-                        // Error out if we didn't parse 4 digits.
-                        if i != 4u {
-                            return self.error(NotFourDigit);
-                        }
-
-                        res.push_char(char::from_u32(n as u32).unwrap());
-                    }
-                    _ => return self.error(InvalidEscape),
->>>>>>> Add a streaming parser to serialize::json.*/
                 }
                 escape = false;
             } else if self.ch_is('\\') {

trunk/src/libstd/str.rs

@@ -16,25 +16,24 @@ Unicode string manipulation (`str` type)
 
 Rust's string type is one of the core primitive types of the language. While
 represented by the name `str`, the name `str` is not actually a valid type in
-Rust. Each string must also be decorated with a pointer. `String` is used
-for an owned string, so there is only one commonly-used `str` type in Rust:
-`&str`.
+Rust. Each string must also be decorated with its ownership. This means that
+there is one common kind of string in Rust:
 
-`&str` is the borrowed string type. This type of string can only be created
-from other strings, unless it is a static string (see below). As the word
-"borrowed" implies, this type of string is owned elsewhere, and this string
-cannot be moved out of.
+* `&str` - This is the borrowed string type. This type of string can only be
+           created from the other kind of string. As the name "borrowed"
+           implies, this type of string is owned elsewhere, and this string
+           cannot be moved out of.
 
-As an example, here's some code that uses a string.
+As an example, here's the one kind of string.
 
 ```rust
 fn main() {
     let borrowed_string = "This string is borrowed with the 'static lifetime";
 }
 ```
 
-From the example above, you can see that Rust's string literals have the
-`'static` lifetime. This is akin to C's concept of a static string.
+From the example above, you can see that Rust has 1 different kind of string
+literal. The "borrowed literal" is akin to C's concept of a static string.
 
 String literals are allocated statically in the rodata of the
 executable/library. The string then has the type `&'static str` meaning that
@@ -510,7 +509,7 @@ pub fn from_utf8_lossy<'a>(v: &'a [u8]) -> MaybeOwned<'a> {
 Section: MaybeOwned
 */
 
-/// A `MaybeOwned` is a string that can hold either a `String` or a `&str`.
+/// A MaybeOwned is a string that can hold either a String or a &str.
 /// This can be useful as an optimization when an allocation is sometimes
 /// needed but not always.
 pub enum MaybeOwned<'a> {
@@ -520,7 +519,7 @@ pub enum MaybeOwned<'a> {
     Owned(String)
 }
 
-/// `SendStr` is a specialization of `MaybeOwned` to be sendable
+/// SendStr is a specialization of `MaybeOwned` to be sendable
 pub type SendStr = MaybeOwned<'static>;
 
 impl<'a> MaybeOwned<'a> {

trunk/src/libsyntax/ast.rs

@@ -417,14 +417,6 @@ pub enum Stmt_ {
     StmtMac(Mac, bool),
 }
 
-/// Where a local declaration came from: either a true `let ... =
-/// ...;`, or one desugared from the pattern of a for loop.
-#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)]
-pub enum LocalSource {
-    LocalLet,
-    LocalFor,
-}
-
 // FIXME (pending discussion of #1697, #2178...): local should really be
 // a refinement on pat.
 /// Local represents a `let` statement, e.g., `let <pat>:<ty> = <expr>;`
@@ -435,7 +427,6 @@ pub struct Local {
     pub init: Option<@Expr>,
     pub id: NodeId,
     pub span: Span,
-    pub source: LocalSource,
 }
 
 pub type Decl = Spanned<Decl_>;

trunk/src/libsyntax/ext/build.rs

@@ -439,7 +439,6 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
             init: Some(ex),
             id: ast::DUMMY_NODE_ID,
             span: sp,
-            source: ast::LocalLet,
         };
         let decl = respan(sp, ast::DeclLocal(local));
         @respan(sp, ast::StmtDecl(@decl, ast::DUMMY_NODE_ID))
@@ -463,7 +462,6 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
             init: Some(ex),
             id: ast::DUMMY_NODE_ID,
             span: sp,
-            source: ast::LocalLet,
         };
         let decl = respan(sp, ast::DeclLocal(local));
         @respan(sp, ast::StmtDecl(@decl, ast::DUMMY_NODE_ID))

trunk/src/libsyntax/ext/expand.rs

@@ -147,17 +147,11 @@ pub fn expand_expr(e: @ast::Expr, fld: &mut MacroExpander) -> @ast::Expr {
             //       ['<ident>:] loop {
             //         match i.next() {
             //           None => break,
-            //           Some(mut value) => {
-            //             let <src_pat> = value;
-            //             <src_loop_block>
-            //           }
+            //           Some(<src_pat>) => <src_loop_block>
             //         }
             //       }
             //     }
             //   }
-            //
-            // (The use of the `let` is to give better error messages
-            // when the pattern is refutable.)
 
             let local_ident = token::gensym_ident("__i"); // FIXME #13573
             let next_ident = fld.cx.ident_of("next");
@@ -173,33 +167,11 @@ pub fn expand_expr(e: @ast::Expr, fld: &mut MacroExpander) -> @ast::Expr {
                 fld.cx.arm(span, vec!(none_pat), break_expr)
             };
 
-            // let <src_pat> = value;
-            let value_ident = token::gensym_ident("__value");
-            // this is careful to use src_pat.span so that error
-            // messages point exact at that.
-            let local = @ast::Local {
-                ty: fld.cx.ty_infer(src_pat.span),
-                pat: src_pat,
-                init: Some(fld.cx.expr_ident(src_pat.span, value_ident)),
-                id: ast::DUMMY_NODE_ID,
-                span: src_pat.span,
-                source: ast::LocalFor
-            };
-            let local = codemap::respan(src_pat.span, ast::DeclLocal(local));
-            let local = @codemap::respan(span, ast::StmtDecl(@local, ast::DUMMY_NODE_ID));
-
-            // { let ...; <src_loop_block> }
-            let block = fld.cx.block(span, vec![local],
-                                     Some(fld.cx.expr_block(src_loop_block)));
-
-            // `Some(mut value) => { ... }`
-            // Note the _'s in the name will stop any unused mutability warnings.
-            let value_pat = fld.cx.pat_ident_binding_mode(span, value_ident,
-                                                          ast::BindByValue(ast::MutMutable));
+            // `Some(<src_pat>) => <src_loop_block>`
             let some_arm =
                 fld.cx.arm(span,
-                           vec!(fld.cx.pat_enum(span, some_path, vec!(value_pat))),
-                           fld.cx.expr_block(block));
+                           vec!(fld.cx.pat_enum(span, some_path, vec!(src_pat))),
+                           fld.cx.expr_block(src_loop_block));
 
             // `match i.next() { ... }`
             let match_expr = {
@@ -697,8 +669,7 @@ fn expand_non_macro_stmt(s: &Stmt, fld: &mut MacroExpander)
                         pat: pat,
                         init: init,
                         id: id,
-                        span: span,
-                        source: source,
+                        span: span
                     } = **local;
                     // expand the pat (it might contain exprs... #:(o)>
                     let expanded_pat = fld.fold_pat(pat);
@@ -732,7 +703,6 @@ fn expand_non_macro_stmt(s: &Stmt, fld: &mut MacroExpander)
                             init: new_init_opt,
                             id: id,
                             span: span,
-                            source: source
                         };
                     SmallVector::one(@Spanned {
                         node: StmtDecl(@Spanned {

trunk/src/libsyntax/fold.rs

@@ -288,7 +288,6 @@ pub trait Folder {
             pat: self.fold_pat(l.pat),
             init: l.init.map(|e| self.fold_expr(e)),
             span: self.new_span(l.span),
-            source: l.source,
         }
     }
 

trunk/src/libsyntax/parse/parser.rs

@@ -34,7 +34,7 @@ use ast::{Ident, NormalFn, Inherited, Item, Item_, ItemStatic};
 use ast::{ItemEnum, ItemFn, ItemForeignMod, ItemImpl};
 use ast::{ItemMac, ItemMod, ItemStruct, ItemTrait, ItemTy, Lit, Lit_};
 use ast::{LitBool, LitFloat, LitFloatUnsuffixed, LitInt, LitChar};
-use ast::{LitIntUnsuffixed, LitNil, LitStr, LitUint, Local, LocalLet};
+use ast::{LitIntUnsuffixed, LitNil, LitStr, LitUint, Local};
 use ast::{MutImmutable, MutMutable, Mac_, MacInvocTT, Matcher, MatchNonterminal};
 use ast::{MatchSeq, MatchTok, Method, MutTy, BiMul, Mutability};
 use ast::{NamedField, UnNeg, NoReturn, UnNot, P, Pat, PatEnum};
@@ -3034,7 +3034,6 @@ impl<'a> Parser<'a> {
             init: init,
             id: ast::DUMMY_NODE_ID,
             span: mk_sp(lo, self.last_span.hi),
-            source: LocalLet,
         }
     }