---

yaml
---
r: 132062
b: refs/heads/dist-snap
c: febfb75
h: refs/heads/master
v: v3

Author: Jakub Wieczorek

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 457a3c991d79b971be07fce75f9d0c12848fb37c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 6e3e0a83aa9f704df7017199233774c4021d9a5d
+refs/heads/dist-snap: febfb752d2775bb1e875634e45058e27a36dd714
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcore/iter.rs

@@ -1962,19 +1962,7 @@ pub struct Range<A> {
     one: A
 }
 
-/// Returns an iterator over the given range [start, stop) (that is, starting
-/// at start (inclusive), and ending at stop (exclusive)).
-///
-/// # Example
-///
-/// ```rust
-/// let array = [0, 1, 2, 3, 4];
-///
-/// for i in range(0, 5u) {
-///     println!("{}", i);
-///     assert_eq!(i,  array[i]);
-/// }
-/// ```
+/// Return an iterator over the range [start, stop)
 #[inline]
 pub fn range<A: Add<A, A> + PartialOrd + Clone + One>(start: A, stop: A) -> Range<A> {
     Range{state: start, stop: stop, one: One::one()}

branches/dist-snap/src/libregex_macros/lib.rs

@@ -34,7 +34,6 @@ use syntax::ext::build::AstBuilder;
 use syntax::ext::base::{ExtCtxt, MacResult, MacExpr, DummyResult};
 use syntax::parse::token;
 use syntax::print::pprust;
-use syntax::fold::Folder;
 
 use rustc::plugin::Registry;
 
@@ -616,7 +615,7 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
 /// Otherwise, logs an error with cx.span_err and returns None.
 fn parse(cx: &mut ExtCtxt, tts: &[ast::TokenTree]) -> Option<String> {
     let mut parser = cx.new_parser_from_tts(tts);
-    let entry = cx.expander().fold_expr(parser.parse_expr());
+    let entry = cx.expand_expr(parser.parse_expr());
     let regex = match entry.node {
         ast::ExprLit(lit) => {
             match lit.node {

branches/dist-snap/src/librustc/middle/trans/_match.rs

@@ -202,12 +202,12 @@ use middle::resolve::DefMap;
 use middle::trans::adt;
 use middle::trans::base::*;
 use middle::trans::build::*;
-use middle::trans::build;
 use middle::trans::callee;
 use middle::trans::cleanup;
 use middle::trans::cleanup::CleanupMethods;
 use middle::trans::common::*;
 use middle::trans::consts;
+use middle::trans::controlflow;
 use middle::trans::datum::*;
 use middle::trans::expr::Dest;
 use middle::trans::expr;
@@ -220,12 +220,14 @@ use util::ppaux::{Repr, vec_map_to_string};
 
 use std;
 use std::collections::HashMap;
+use std::cell::Cell;
 use std::rc::Rc;
 use std::gc::{Gc};
 use syntax::ast;
 use syntax::ast::Ident;
 use syntax::codemap::Span;
 use syntax::fold::Folder;
+use syntax::parse::token::InternedString;
 
 #[deriving(PartialEq)]
 pub enum VecLenOpt {
@@ -299,6 +301,20 @@ fn trans_opt<'a>(mut bcx: &'a Block<'a>, o: &Opt) -> opt_result<'a> {
     }
 }
 
+fn variant_opt(bcx: &Block, pat_id: ast::NodeId) -> Opt {
+    let ccx = bcx.ccx();
+    let def = ccx.tcx.def_map.borrow().get_copy(&pat_id);
+    match def {
+        def::DefVariant(enum_id, var_id, _) => {
+            let variant = ty::enum_variant_with_id(ccx.tcx(), enum_id, var_id);
+            var(variant.disr_val, adt::represent_node(bcx, pat_id), var_id)
+        }
+        _ => {
+            ccx.sess().bug("non-variant or struct in variant_opt()");
+        }
+    }
+}
+
 #[deriving(Clone)]
 pub enum TransBindingMode {
     TrByCopy(/* llbinding */ ValueRef),
@@ -614,15 +630,26 @@ fn get_options(bcx: &Block, m: &[Match], col: uint) -> Vec<Opt> {
             ast::PatLit(l) => {
                 add_to_set(ccx.tcx(), &mut found, lit(l));
             }
-            ast::PatIdent(..) | ast::PatEnum(..) | ast::PatStruct(..) => {
+            ast::PatIdent(..) => {
                 // This is either an enum variant or a variable binding.
                 let opt_def = ccx.tcx.def_map.borrow().find_copy(&cur.id);
                 match opt_def {
-                    Some(def::DefVariant(enum_id, var_id, _)) => {
-                        let variant = ty::enum_variant_with_id(ccx.tcx(), enum_id, var_id);
+                    Some(def::DefVariant(..)) => {
+                        add_to_set(ccx.tcx(), &mut found,
+                                   variant_opt(bcx, cur.id));
+                    }
+                    _ => {}
+                }
+            }
+            ast::PatEnum(..) | ast::PatStruct(..) => {
+                // This could be one of: a tuple-like enum variant, a
+                // struct-like enum variant, or a struct.
+                let opt_def = ccx.tcx.def_map.borrow().find_copy(&cur.id);
+                match opt_def {
+                    Some(def::DefFn(..)) |
+                    Some(def::DefVariant(..)) => {
                         add_to_set(ccx.tcx(), &mut found,
-                                   var(variant.disr_val,
-                                       adt::represent_node(bcx, cur.id), var_id));
+                                   variant_opt(bcx, cur.id));
                     }
                     _ => {}
                 }
@@ -768,33 +795,56 @@ fn any_irrefutable_adt_pat(bcx: &Block, m: &[Match], col: uint) -> bool {
     })
 }
 
+struct DynamicFailureHandler<'a> {
+    bcx: &'a Block<'a>,
+    sp: Span,
+    msg: InternedString,
+    finished: Cell<Option<BasicBlockRef>>,
+}
+
+impl<'a> DynamicFailureHandler<'a> {
+    fn handle_fail(&self) -> BasicBlockRef {
+        match self.finished.get() {
+            Some(bb) => return bb,
+            _ => (),
+        }
+
+        let fcx = self.bcx.fcx;
+        let fail_cx = fcx.new_block(false, "case_fallthrough", None);
+        controlflow::trans_fail(fail_cx, self.sp, self.msg.clone());
+        self.finished.set(Some(fail_cx.llbb));
+        fail_cx.llbb
+    }
+}
+
 /// What to do when the pattern match fails.
 enum FailureHandler<'a> {
     Infallible,
     JumpToBasicBlock(BasicBlockRef),
-    Unreachable
+    DynamicFailureHandlerClass(Box<DynamicFailureHandler<'a>>),
 }
 
 impl<'a> FailureHandler<'a> {
     fn is_infallible(&self) -> bool {
         match *self {
             Infallible => true,
-            _ => false
+            _ => false,
         }
     }
 
     fn is_fallible(&self) -> bool {
         !self.is_infallible()
     }
 
-    fn handle_fail(&self, bcx: &Block) {
+    fn handle_fail(&self) -> BasicBlockRef {
         match *self {
-            Infallible =>
-                fail!("attempted to fail in infallible failure handler!"),
-            JumpToBasicBlock(basic_block) =>
-                Br(bcx, basic_block),
-            Unreachable =>
-                build::Unreachable(bcx)
+            Infallible => {
+                fail!("attempted to fail in infallible failure handler!")
+            }
+            JumpToBasicBlock(basic_block) => basic_block,
+            DynamicFailureHandlerClass(ref dynamic_failure_handler) => {
+                dynamic_failure_handler.handle_fail()
+            }
         }
     }
 }
@@ -955,7 +1005,7 @@ fn compile_guard<'a, 'b>(
             // condition explicitly rather than (possibly) falling back to
             // the default arm.
             &JumpToBasicBlock(_) if m.len() == 1 && has_genuine_default => {
-                chk.handle_fail(bcx);
+                Br(bcx, chk.handle_fail());
             }
             _ => {
                 compile_submatch(bcx, m, vals, chk, has_genuine_default);
@@ -980,7 +1030,7 @@ fn compile_submatch<'a, 'b>(
     let mut bcx = bcx;
     if m.len() == 0u {
         if chk.is_fallible() {
-            chk.handle_fail(bcx);
+            Br(bcx, chk.handle_fail());
         }
         return;
     }
@@ -1251,7 +1301,7 @@ fn compile_submatch_continue<'a, 'b>(
             // condition explicitly rather than (eventually) falling back to
             // the last default arm.
             &JumpToBasicBlock(_) if defaults.len() == 1 && has_genuine_default => {
-                chk.handle_fail(else_cx);
+                Br(else_cx, chk.handle_fail());
             }
             _ => {
                 compile_submatch(else_cx,
@@ -1345,10 +1395,21 @@ fn trans_match_inner<'a>(scope_cx: &'a Block<'a>,
     }
 
     let t = node_id_type(bcx, discr_expr.id);
-    let chk = if ty::type_is_empty(tcx, t) {
-        Unreachable
-    } else {
-        Infallible
+    let chk = {
+        if ty::type_is_empty(tcx, t) {
+            // Special case for empty types
+            let fail_cx = Cell::new(None);
+            let fail_handler = box DynamicFailureHandler {
+                bcx: scope_cx,
+                sp: discr_expr.span,
+                msg: InternedString::new("scrutinizing value that can't \
+                                          exist"),
+                finished: fail_cx,
+            };
+            DynamicFailureHandlerClass(fail_handler)
+        } else {
+            Infallible
+        }
     };
 
     let arm_datas: Vec<ArmData> = arms.iter().map(|arm| ArmData {

branches/dist-snap/src/libsyntax/ext/base.rs

@@ -20,11 +20,9 @@ use parse::token;
 use parse::token::{InternedString, intern, str_to_ident};
 use util::small_vector::SmallVector;
 use ext::mtwt;
-use fold::Folder;
 
 use std::collections::HashMap;
 use std::gc::{Gc, GC};
-use std::rc::Rc;
 
 // new-style macro! tt code:
 //
@@ -106,9 +104,9 @@ pub type IdentMacroExpanderFn =
 /// just into the compiler's internal macro table, for `make_def`).
 pub trait MacResult {
     /// Define a new macro.
-    // this should go away; the idea that a macro might expand into
-    // either a macro definition or an expression, depending on what
-    // the context wants, is kind of silly.
+    // this particular flavor should go away; the idea that a macro might
+    // expand into either a macro definition or an expression, depending
+    // on what the context wants, is kind of silly.
     fn make_def(&self) -> Option<MacroDef> {
         None
     }
@@ -316,7 +314,7 @@ impl BlockInfo {
 
 /// The base map of methods for expanding syntax extension
 /// AST nodes into full ASTs
-fn initial_syntax_expander_table() -> SyntaxEnv {
+pub fn syntax_expander_table() -> SyntaxEnv {
     // utility function to simplify creating NormalTT syntax extensions
     fn builtin_normal_expander(f: MacroExpanderFn) -> SyntaxExtension {
         NormalTT(box BasicMacroExpander {
@@ -433,9 +431,7 @@ pub struct ExtCtxt<'a> {
 
     pub mod_path: Vec<ast::Ident> ,
     pub trace_mac: bool,
-    pub exported_macros: Vec<Gc<ast::Item>>,
-
-    pub syntax_env: SyntaxEnv,
+    pub exported_macros: Vec<Gc<ast::Item>>
 }
 
 impl<'a> ExtCtxt<'a> {
@@ -449,18 +445,22 @@ impl<'a> ExtCtxt<'a> {
             ecfg: ecfg,
             trace_mac: false,
             exported_macros: Vec::new(),
-            syntax_env: initial_syntax_expander_table(),
         }
     }
 
-    #[deprecated = "Replaced with `expander().fold_expr()`"]
-    pub fn expand_expr(&mut self, e: Gc<ast::Expr>) -> Gc<ast::Expr> {
-        self.expander().fold_expr(e)
-    }
-
-    /// Returns a `Folder` for deeply expanding all macros in a AST node.
-    pub fn expander<'b>(&'b mut self) -> expand::MacroExpander<'b, 'a> {
-        expand::MacroExpander { cx: self }
+    pub fn expand_expr(&mut self, mut e: Gc<ast::Expr>) -> Gc<ast::Expr> {
+        loop {
+            match e.node {
+                ast::ExprMac(..) => {
+                    let mut expander = expand::MacroExpander {
+                        extsbox: syntax_expander_table(),
+                        cx: self,
+                    };
+                    e = expand::expand_expr(e, &mut expander);
+                }
+                _ => return e
+            }
+        }
     }
 
     pub fn new_parser_from_tts(&self, tts: &[ast::TokenTree])
@@ -570,7 +570,7 @@ impl<'a> ExtCtxt<'a> {
 pub fn expr_to_string(cx: &mut ExtCtxt, expr: Gc<ast::Expr>, err_msg: &str)
                    -> Option<(InternedString, ast::StrStyle)> {
     // we want to be able to handle e.g. concat("foo", "bar")
-    let expr = cx.expander().fold_expr(expr);
+    let expr = cx.expand_expr(expr);
     match expr.node {
         ast::ExprLit(l) => match l.node {
             ast::LitStr(ref s, style) => return Some(((*s).clone(), style)),
@@ -627,7 +627,7 @@ pub fn get_exprs_from_tts(cx: &mut ExtCtxt,
     let mut p = cx.new_parser_from_tts(tts);
     let mut es = Vec::new();
     while p.token != token::EOF {
-        es.push(cx.expander().fold_expr(p.parse_expr()));
+        es.push(cx.expand_expr(p.parse_expr()));
         if p.eat(&token::COMMA) {
             continue;
         }
@@ -642,13 +642,10 @@ pub fn get_exprs_from_tts(cx: &mut ExtCtxt,
 /// In order to have some notion of scoping for macros,
 /// we want to implement the notion of a transformation
 /// environment.
-///
+
 /// This environment maps Names to SyntaxExtensions.
-pub struct SyntaxEnv {
-    chain: Vec<MapChainFrame> ,
-}
 
-// impl question: how to implement it? Initially, the
+//impl question: how to implement it? Initially, the
 // env will contain only macros, so it might be painful
 // to add an empty frame for every context. Let's just
 // get it working, first....
@@ -660,11 +657,15 @@ pub struct SyntaxEnv {
 
 struct MapChainFrame {
     info: BlockInfo,
-    map: HashMap<Name, Rc<SyntaxExtension>>,
+    map: HashMap<Name, SyntaxExtension>,
+}
+
+pub struct SyntaxEnv {
+    chain: Vec<MapChainFrame> ,
 }
 
 impl SyntaxEnv {
-    fn new() -> SyntaxEnv {
+    pub fn new() -> SyntaxEnv {
         let mut map = SyntaxEnv { chain: Vec::new() };
         map.push_frame();
         map
@@ -691,18 +692,18 @@ impl SyntaxEnv {
         unreachable!()
     }
 
-    pub fn find(&self, k: &Name) -> Option<Rc<SyntaxExtension>> {
+    pub fn find<'a>(&'a self, k: &Name) -> Option<&'a SyntaxExtension> {
         for frame in self.chain.iter().rev() {
             match frame.map.find(k) {
-                Some(v) => return Some(v.clone()),
+                Some(v) => return Some(v),
                 None => {}
             }
         }
         None
     }
 
     pub fn insert(&mut self, k: Name, v: SyntaxExtension) {
-        self.find_escape_frame().map.insert(k, Rc::new(v));
+        self.find_escape_frame().map.insert(k, v);
     }
 
     pub fn info<'a>(&'a mut self) -> &'a mut BlockInfo {