---

yaml
---
r: 135421
b: refs/heads/master
c: 5d8cfd5
h: refs/heads/master
i:
  135419: b2842ba
v: v3

Author: lilyball

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 88d1a22f76a774b2df3c904ceb54c86e58a859c3
+refs/heads/master: 5d8cfd53b513d999ffff22f17e3066a30a8ed949
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ae81c89f34f1ac2cdb596cf216612e94822a8466
 refs/heads/try: 14378ea357c06c23607ca61ade44f60a7a64a1c7

trunk/src/etc/emacs/rust-mode-tests.el

@@ -623,7 +623,7 @@ Convert the line-column information from that list into a buffer position value.
       (move-to-column column)
       (point))))
 
-;;; FIXME: Maybe add an ERT explainer function (something that shows the
+;;; TODO: Maybe add an ERT explainer function (something that shows the
 ;;; surrounding code of the final point, not just the position).
 (defun rust-test-motion (source-code init-pos final-pos manip-func &optional &rest args)
   "Test that MANIP-FUNC moves point from INIT-POS to FINAL-POS.

trunk/src/etc/kate/rust.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE language SYSTEM "language.dtd"
 [
-	<!-- FIXME: Kate's regex engine has very limited support for
+	<!-- TODO: Kate's regex engine has very limited support for
 	predefined char classes, so making rustIdent consistent with actual
 	Rust identifiers will be a bit difficult -->
 	<!ENTITY rustIdent "[a-zA-Z_][a-zA-Z_0-9]*">

trunk/src/etc/vim/syntax/rust.vim

@@ -216,7 +216,7 @@ syn keyword rustTodo contained TODO FIXME XXX NB NOTE
 
 " Folding rules {{{2
 " Trivial folding rules to begin with.
-" FIXME: use the AST to make really good folding
+" TODO: use the AST to make really good folding
 syn region rustFoldBraces start="{" end="}" transparent fold
 
 " Default highlighting {{{1

trunk/src/librustc/lint/builtin.rs

@@ -593,7 +593,6 @@ impl LintPass for UnusedAttribute {
             "static_assert",
             "thread_local",
             "no_debug",
-            "unsafe_no_drop_flag",
 
             // used in resolve
             "prelude_import",

trunk/src/librustc/metadata/common.rs

@@ -214,8 +214,6 @@ pub static tag_reachable_extern_fn_id: uint = 0x91;
 
 pub static tag_items_data_item_stability: uint = 0x92;
 
-pub static tag_items_data_item_repr: uint = 0x93;
-
 #[deriving(Clone, Show)]
 pub struct LinkMeta {
     pub crate_name: String,

trunk/src/librustc/metadata/csearch.rs

@@ -350,12 +350,6 @@ pub fn get_stability(cstore: &cstore::CStore,
     decoder::get_stability(&*cdata, def.node)
 }
 
-pub fn get_repr_attrs(cstore: &cstore::CStore, def: ast::DefId)
-                      -> Vec<attr::ReprAttr> {
-    let cdata = cstore.get_crate_data(def.krate);
-    decoder::get_repr_attrs(&*cdata, def.node)
-}
-
 pub fn is_associated_type(cstore: &cstore::CStore, def: ast::DefId) -> bool {
     let cdata = cstore.get_crate_data(def.krate);
     decoder::is_associated_type(&*cdata, def.node)

trunk/src/librustc/metadata/decoder.rs

@@ -384,17 +384,6 @@ pub fn get_stability(cdata: Cmd, id: ast::NodeId) -> Option<attr::Stability> {
     })
 }
 
-pub fn get_repr_attrs(cdata: Cmd, id: ast::NodeId) -> Vec<attr::ReprAttr> {
-    let item = lookup_item(id, cdata.data());
-    match reader::maybe_get_doc(item, tag_items_data_item_repr).map(|doc| {
-        let mut decoder = reader::Decoder::new(doc);
-        Decodable::decode(&mut decoder).unwrap()
-    }) {
-        Some(attrs) => attrs,
-        None => Vec::new(),
-    }
-}
-
 pub fn get_impl_trait(cdata: Cmd,
                       id: ast::NodeId,
                       tcx: &ty::ctxt) -> Option<Rc<ty::TraitRef>>

trunk/src/librustc/metadata/encoder.rs

@@ -332,7 +332,6 @@ fn encode_enum_variant_info(ecx: &EncodeContext,
         encode_parent_item(rbml_w, local_def(id));
         encode_visibility(rbml_w, variant.node.vis);
         encode_attributes(rbml_w, variant.node.attrs.as_slice());
-        encode_repr_attrs(rbml_w, ecx, variant.node.attrs.as_slice());
 
         let stab = stability::lookup(ecx.tcx, ast_util::local_def(variant.node.id));
         encode_stability(rbml_w, stab);
@@ -949,19 +948,6 @@ fn encode_method_argument_names(rbml_w: &mut Encoder,
     rbml_w.end_tag();
 }
 
-fn encode_repr_attrs(rbml_w: &mut Encoder,
-                     ecx: &EncodeContext,
-                     attrs: &[Attribute]) {
-    let mut repr_attrs = Vec::new();
-    for attr in attrs.iter() {
-        repr_attrs.extend(attr::find_repr_attrs(ecx.tcx.sess.diagnostic(),
-                                                attr).into_iter());
-    }
-    rbml_w.start_tag(tag_items_data_item_repr);
-    repr_attrs.encode(rbml_w);
-    rbml_w.end_tag();
-}
-
 fn encode_inlined_item(ecx: &EncodeContext,
                        rbml_w: &mut Encoder,
                        ii: InlinedItemRef) {
@@ -1151,7 +1137,6 @@ fn encode_info_for_item(ecx: &EncodeContext,
         encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id));
         encode_name(rbml_w, item.ident.name);
         encode_attributes(rbml_w, item.attrs.as_slice());
-        encode_repr_attrs(rbml_w, ecx, item.attrs.as_slice());
         for v in (*enum_definition).variants.iter() {
             encode_variant_id(rbml_w, local_def(v.node.id));
         }
@@ -1198,7 +1183,6 @@ fn encode_info_for_item(ecx: &EncodeContext,
         encode_path(rbml_w, path.clone());
         encode_stability(rbml_w, stab);
         encode_visibility(rbml_w, vis);
-        encode_repr_attrs(rbml_w, ecx, item.attrs.as_slice());
 
         /* Encode def_ids for each field and method
          for methods, write all the stuff get_trait_method

trunk/src/librustc/middle/ty.rs

@@ -583,9 +583,6 @@ pub struct ctxt<'tcx> {
     /// Caches the results of trait selection. This cache is used
     /// for things that do not have to do with the parameters in scope.
     pub selection_cache: traits::SelectionCache,
-
-    /// Caches the representation hints for struct definitions.
-    pub repr_hint_cache: RefCell<DefIdMap<Rc<Vec<attr::ReprAttr>>>>,
 }
 
 pub enum tbox_flag {
@@ -1536,7 +1533,6 @@ pub fn mk_ctxt<'tcx>(s: Session,
         associated_types: RefCell::new(DefIdMap::new()),
         trait_associated_types: RefCell::new(DefIdMap::new()),
         selection_cache: traits::SelectionCache::new(),
-        repr_hint_cache: RefCell::new(DefIdMap::new()),
    }
 }
 
@@ -4330,7 +4326,7 @@ pub fn ty_dtor(cx: &ctxt, struct_id: DefId) -> DtorKind {
 }
 
 pub fn has_dtor(cx: &ctxt, struct_id: DefId) -> bool {
-    cx.destructor_for_type.borrow().contains_key(&struct_id)
+    ty_dtor(cx, struct_id).is_present()
 }
 
 pub fn with_path<T>(cx: &ctxt, id: ast::DefId, f: |ast_map::PathElems| -> T) -> T {
@@ -4517,26 +4513,14 @@ pub fn lookup_simd(tcx: &ctxt, did: DefId) -> bool {
 }
 
 /// Obtain the representation annotation for a struct definition.
-pub fn lookup_repr_hints(tcx: &ctxt, did: DefId) -> Rc<Vec<attr::ReprAttr>> {
-    match tcx.repr_hint_cache.borrow().find(&did) {
-        None => {}
-        Some(ref hints) => return (*hints).clone(),
-    }
+pub fn lookup_repr_hints(tcx: &ctxt, did: DefId) -> Vec<attr::ReprAttr> {
+    let mut acc = Vec::new();
 
-    let acc = if did.krate == LOCAL_CRATE {
-        let mut acc = Vec::new();
-        ty::each_attr(tcx, did, |meta| {
-            acc.extend(attr::find_repr_attrs(tcx.sess.diagnostic(),
-                                             meta).into_iter());
-            true
-        });
-        acc
-    } else {
-        csearch::get_repr_attrs(&tcx.sess.cstore, did)
-    };
+    ty::each_attr(tcx, did, |meta| {
+        acc.extend(attr::find_repr_attrs(tcx.sess.diagnostic(), meta).into_iter());
+        true
+    });
 
-    let acc = Rc::new(acc);
-    tcx.repr_hint_cache.borrow_mut().insert(did, acc.clone());
     acc
 }
 

trunk/src/libsyntax/ast.rs

@@ -521,6 +521,7 @@ pub enum Expr_ {
     ExprLit(P<Lit>),
     ExprCast(P<Expr>, P<Ty>),
     ExprIf(P<Expr>, P<Block>, Option<P<Expr>>),
+    ExprIfLet(P<Pat>, P<Expr>, P<Block>, Option<P<Expr>>),
     // FIXME #6993: change to Option<Name> ... or not, if these are hygienic.
     ExprWhile(P<Expr>, P<Block>, Option<Ident>),
     // FIXME #6993: change to Option<Name> ... or not, if these are hygienic.

trunk/src/libsyntax/attr.rs

@@ -508,7 +508,7 @@ fn int_type_of_word(s: &str) -> Option<IntType> {
     }
 }
 
-#[deriving(PartialEq, Show, Encodable, Decodable)]
+#[deriving(PartialEq, Show)]
 pub enum ReprAttr {
     ReprAny,
     ReprInt(Span, IntType),
@@ -527,7 +527,7 @@ impl ReprAttr {
     }
 }
 
-#[deriving(Eq, Hash, PartialEq, Show, Encodable, Decodable)]
+#[deriving(Eq, Hash, PartialEq, Show)]
 pub enum IntType {
     SignedInt(ast::IntTy),
     UnsignedInt(ast::UintTy)

trunk/src/libsyntax/fold.rs

@@ -1205,6 +1205,12 @@ pub fn noop_fold_expr<T: Folder>(Expr {id, node, span}: Expr, folder: &mut T) ->
                        folder.fold_block(tr),
                        fl.map(|x| folder.fold_expr(x)))
             }
+            ExprIfLet(pat, expr, tr, fl) => {
+                ExprIfLet(folder.fold_pat(pat),
+                          folder.fold_expr(expr),
+                          folder.fold_block(tr),
+                          fl.map(|x| folder.fold_expr(x)))
+            }
             ExprWhile(cond, body, opt_ident) => {
                 ExprWhile(folder.fold_expr(cond),
                           folder.fold_block(body),

trunk/src/libsyntax/parse/classify.rs

@@ -24,6 +24,7 @@ use ast;
 pub fn expr_requires_semi_to_be_stmt(e: &ast::Expr) -> bool {
     match e.node {
         ast::ExprIf(..)
+        | ast::ExprIfLet(..)
         | ast::ExprMatch(..)
         | ast::ExprBlock(_)
         | ast::ExprWhile(..)

trunk/src/libsyntax/parse/parser.rs

@@ -23,7 +23,7 @@ use ast::{DeclLocal, DefaultBlock, UnDeref, BiDiv, EMPTY_CTXT, EnumDef, Explicit
 use ast::{Expr, Expr_, ExprAddrOf, ExprMatch, ExprAgain};
 use ast::{ExprAssign, ExprAssignOp, ExprBinary, ExprBlock, ExprBox};
 use ast::{ExprBreak, ExprCall, ExprCast};
-use ast::{ExprField, ExprTupField, ExprFnBlock, ExprIf, ExprIndex, ExprSlice};
+use ast::{ExprField, ExprTupField, ExprFnBlock, ExprIf, ExprIfLet, ExprIndex, ExprSlice};
 use ast::{ExprLit, ExprLoop, ExprMac};
 use ast::{ExprMethodCall, ExprParen, ExprPath, ExprProc};
 use ast::{ExprRepeat, ExprRet, ExprStruct, ExprTup, ExprUnary, ExprUnboxedFn};
@@ -576,13 +576,10 @@ impl<'a> Parser<'a> {
     /// If the next token is the given keyword, eat it and return
     /// true. Otherwise, return false.
     pub fn eat_keyword(&mut self, kw: keywords::Keyword) -> bool {
-        match self.token {
-            token::IDENT(sid, false) if kw.to_name() == sid.name => {
-                self.bump();
-                true
-            }
-            _ => false
-        }
+        if self.is_keyword(kw) {
+            self.bump();
+            true
+        } else { false }
     }
 
     /// If the given word is not a keyword, signal an error.
@@ -2860,8 +2857,11 @@ impl<'a> Parser<'a> {
         }
     }
 
-    /// Parse an 'if' expression ('if' token already eaten)
+    /// Parse an 'if' or 'if let' expression ('if' token already eaten)
     pub fn parse_if_expr(&mut self) -> P<Expr> {
+        if self.is_keyword(keywords::Let) {
+            return self.parse_if_let_expr();
+        }
         let lo = self.last_span.lo;
         let cond = self.parse_expr_res(RestrictionNoStructLiteral);
         let thn = self.parse_block();
@@ -2875,6 +2875,23 @@ impl<'a> Parser<'a> {
         self.mk_expr(lo, hi, ExprIf(cond, thn, els))
     }
 
+    /// Parse an 'if let' expression ('if' token already eaten)
+    pub fn parse_if_let_expr(&mut self) -> P<Expr> {
+        let lo = self.last_span.lo;
+        self.expect_keyword(keywords::Let);
+        let pat = self.parse_pat();
+        self.expect(&token::EQ);
+        let expr = self.parse_expr_res(RestrictionNoStructLiteral);
+        let thn = self.parse_block();
+        let (hi, els) = if self.eat_keyword(keywords::Else) {
+            let expr = self.parse_else_expr();
+            (expr.span.hi, Some(expr))
+        } else {
+            (thn.span.hi, None)
+        };
+        self.mk_expr(lo, hi, ExprIfLet(pat, expr, thn, els))
+    }
+
     // `|args| expr`
     pub fn parse_lambda_expr(&mut self, capture_clause: CaptureClause)
                              -> P<Expr> {

trunk/src/libsyntax/print/pprust.rs

@@ -1307,6 +1307,19 @@ impl<'a> State<'a> {
                         try!(self.print_block(&**then));
                         self.print_else(e.as_ref().map(|e| &**e))
                     }
+                    // "another else-if-let"
+                    ast::ExprIfLet(ref pat, ref expr, ref then, ref e) => {
+                        try!(self.cbox(indent_unit - 1u));
+                        try!(self.ibox(0u));
+                        try!(word(&mut self.s, " else if let "));
+                        try!(self.print_pat(&**pat));
+                        try!(space(&mut self.s));
+                        try!(self.word_space("="));
+                        try!(self.print_expr(&**expr));
+                        try!(space(&mut self.s));
+                        try!(self.print_block(&**then));
+                        self.print_else(e.as_ref().map(|e| &**e))
+                    }
                     // "final else"
                     ast::ExprBlock(ref b) => {
                         try!(self.cbox(indent_unit - 1u));
@@ -1325,15 +1338,26 @@ impl<'a> State<'a> {
     }
 
     pub fn print_if(&mut self, test: &ast::Expr, blk: &ast::Block,
-                    elseopt: Option<&ast::Expr>, chk: bool) -> IoResult<()> {
+                    elseopt: Option<&ast::Expr>) -> IoResult<()> {
         try!(self.head("if"));
-        if chk { try!(self.word_nbsp("check")); }
         try!(self.print_expr(test));
         try!(space(&mut self.s));
         try!(self.print_block(blk));
         self.print_else(elseopt)
     }
 
+    pub fn print_if_let(&mut self, pat: &ast::Pat, expr: &ast::Expr, blk: &ast::Block,
+                        elseopt: Option<&ast::Expr>) -> IoResult<()> {
+        try!(self.head("if let"));
+        try!(self.print_pat(pat));
+        try!(space(&mut self.s));
+        try!(self.word_space("="));
+        try!(self.print_expr(expr));
+        try!(space(&mut self.s));
+        try!(self.print_block(blk));
+        self.print_else(elseopt)
+    }
+
     pub fn print_mac(&mut self, m: &ast::Mac) -> IoResult<()> {
         match m.node {
             // I think it's reasonable to hide the ctxt here:
@@ -1474,7 +1498,10 @@ impl<'a> State<'a> {
                 try!(self.print_type(&**ty));
             }
             ast::ExprIf(ref test, ref blk, ref elseopt) => {
-                try!(self.print_if(&**test, &**blk, elseopt.as_ref().map(|e| &**e), false));
+                try!(self.print_if(&**test, &**blk, elseopt.as_ref().map(|e| &**e)));
+            }
+            ast::ExprIfLet(ref pat, ref expr, ref blk, ref elseopt) => {
+                try!(self.print_if_let(&**pat, &**expr, &** blk, elseopt.as_ref().map(|e| &**e)));
             }
             ast::ExprWhile(ref test, ref blk, opt_ident) => {
                 for ident in opt_ident.iter() {

trunk/src/libsyntax/visit.rs

@@ -730,13 +730,19 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
             visitor.visit_expr(&**subexpression);
             visitor.visit_block(&**block)
         }
+        ExprIfLet(ref pattern, ref subexpression, ref if_block, ref optional_else) => {
+            visitor.visit_pat(&**pattern);
+            visitor.visit_expr(&**subexpression);
+            visitor.visit_block(&**if_block);
+            walk_expr_opt(visitor, optional_else);
+        }
         ExprForLoop(ref pattern, ref subexpression, ref block, _) => {
             visitor.visit_pat(&**pattern);
             visitor.visit_expr(&**subexpression);
             visitor.visit_block(&**block)
         }
         ExprLoop(ref block, _) => visitor.visit_block(&**block),
-        ExprMatch(ref subexpression, ref arms) => {
+        ExprMatch(ref subexpression, ref arms, _) => {
             visitor.visit_expr(&**subexpression);
             for arm in arms.iter() {
                 visitor.visit_arm(arm)

trunk/src/test/debuginfo/issue12886.rs

@@ -9,13 +9,12 @@
 // except according to those terms.
 
 // ignore-android: FIXME(#10381)
-// ignore-windows failing on 64-bit bots FIXME #17638
 
 // compile-flags:-g
-// gdb-command:break issue12886.rs:30
+// gdb-command:break issue12886.rs:29
 // gdb-command:run
 // gdb-command:next
-// gdb-check:[...]31[...]s
+// gdb-check:[...]30[...]s
 // gdb-command:continue
 
 // IF YOU MODIFY THIS FILE, BE CAREFUL TO ADAPT THE LINE NUMBERS IN THE DEBUGGER COMMANDS