---

yaml
---
r: 96246
b: refs/heads/dist-snap
c: 9ba473f
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: ae5a13d64321e49b8a35c120d7f2fa0d5578d8fa
+refs/heads/dist-snap: 9ba473f86f900bf5a5009bf0695b6d9618df83ca
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/front/feature_gate.rs

@@ -23,6 +23,7 @@ use syntax::attr::AttrMetaMethods;
 use syntax::codemap::Span;
 use syntax::visit;
 use syntax::visit::Visitor;
+use syntax::parse::token;
 
 use driver::session::Session;
 
@@ -36,6 +37,7 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("once_fns", Active),
     ("asm", Active),
     ("managed_boxes", Active),
+    ("non_ascii_idents", Active),
 
     // These are used to test this portion of the compiler, they don't actually
     // mean anything
@@ -76,6 +78,15 @@ impl Context {
 }
 
 impl Visitor<()> for Context {
+    fn visit_ident(&mut self, sp: Span, id: ast::Ident, _: ()) {
+        let s = token::ident_to_str(&id);
+
+        if !s.is_ascii() {
+            self.gate_feature("non_ascii_idents", sp,
+                              "non-ascii idents are not fully supported.");
+        }
+    }
+
     fn visit_view_item(&mut self, i: &ast::view_item, _: ()) {
         match i.node {
             ast::view_item_use(ref paths) => {

branches/dist-snap/src/librustc/middle/typeck/infer/region_inference/mod.rs

@@ -24,7 +24,6 @@ use middle::graph::{Direction, NodeIndex};
 use util::common::indenter;
 use util::ppaux::{Repr};
 
-use std::cell::Cell;
 use std::hashmap::{HashMap, HashSet};
 use std::uint;
 use std::vec;
@@ -106,16 +105,15 @@ pub struct RegionVarBindings {
     undo_log: ~[UndoLogEntry],
 
     // This contains the results of inference.  It begins as an empty
-    // cell and only acquires a value after inference is complete.
-    // We use a cell vs a mutable option to circumvent borrowck errors.
-    values: Cell<~[VarValue]>,
+    // option and only acquires a value after inference is complete.
+    values: Option<~[VarValue]>,
 }
 
 pub fn RegionVarBindings(tcx: ty::ctxt) -> RegionVarBindings {
     RegionVarBindings {
         tcx: tcx,
         var_origins: ~[],
-        values: Cell::new_empty(),
+        values: None,
         constraints: HashMap::new(),
         lubs: HashMap::new(),
         glbs: HashMap::new(),
@@ -226,7 +224,7 @@ impl RegionVarBindings {
                           constraint: Constraint,
                           origin: SubregionOrigin) {
         // cannot add constraints once regions are resolved
-        assert!(self.values.is_empty());
+        assert!(self.values.is_none());
 
         debug!("RegionVarBindings: add_constraint({:?})", constraint);
 
@@ -242,7 +240,7 @@ impl RegionVarBindings {
                           sub: Region,
                           sup: Region) {
         // cannot add constraints once regions are resolved
-        assert!(self.values.is_empty());
+        assert!(self.values.is_none());
 
         debug!("RegionVarBindings: make_subregion({:?}, {:?})", sub, sup);
         match (sub, sup) {
@@ -277,7 +275,7 @@ impl RegionVarBindings {
                        b: Region)
                        -> Region {
         // cannot add constraints once regions are resolved
-        assert!(self.values.is_empty());
+        assert!(self.values.is_none());
 
         debug!("RegionVarBindings: lub_regions({:?}, {:?})", a, b);
         match (a, b) {
@@ -300,7 +298,7 @@ impl RegionVarBindings {
                        b: Region)
                        -> Region {
         // cannot add constraints once regions are resolved
-        assert!(self.values.is_empty());
+        assert!(self.values.is_none());
 
         debug!("RegionVarBindings: glb_regions({:?}, {:?})", a, b);
         match (a, b) {
@@ -319,14 +317,14 @@ impl RegionVarBindings {
     }
 
     pub fn resolve_var(&mut self, rid: RegionVid) -> ty::Region {
-        if self.values.is_empty() {
-            self.tcx.sess.span_bug(
+        let v = match self.values {
+            None => self.tcx.sess.span_bug(
                 self.var_origins[rid.to_uint()].span(),
                 format!("Attempt to resolve region variable before values have \
-                      been computed!"));
-        }
+                      been computed!")),
+            Some(ref values) => values[rid.to_uint()]
+        };
 
-        let v = self.values.with_ref(|values| values[rid.to_uint()]);
         debug!("RegionVarBindings: resolve_var({:?}={})={:?}",
                rid, rid.to_uint(), v);
         match v {
@@ -482,7 +480,7 @@ impl RegionVarBindings {
         debug!("RegionVarBindings: resolve_regions()");
         let mut errors = opt_vec::Empty;
         let v = self.infer_variable_values(&mut errors);
-        self.values.put_back(v);
+        self.values = Some(v);
         errors
     }
 }

branches/dist-snap/src/libstd/ascii.rs

@@ -55,6 +55,74 @@ impl Ascii {
     pub fn eq_ignore_case(self, other: Ascii) -> bool {
         ASCII_LOWER_MAP[self.chr] == ASCII_LOWER_MAP[other.chr]
     }
+
+    // the following methods are like ctype, and the implementation is inspired by musl
+
+    /// Check if the character is a letter (a-z, A-Z)
+    #[inline]
+    pub fn is_alpha(&self) -> bool {
+        (self.chr >= 0x41 && self.chr <= 0x5A) || (self.chr >= 0x61 && self.chr <= 0x7A)
+    }
+
+    /// Check if the character is a number (0-9)
+    #[inline]
+    pub fn is_digit(&self) -> bool {
+        self.chr >= 0x31 && self.chr <= 0x39
+    }
+
+    /// Check if the character is a letter or number
+    #[inline]
+    pub fn is_alnum(&self) -> bool {
+        self.is_alpha() || self.is_digit()
+    }
+
+    /// Check if the character is a space or horizontal tab
+    #[inline]
+    pub fn is_blank(&self) -> bool {
+        self.chr == ' ' as u8 || self.chr == '\t' as u8
+    }
+
+    /// Check if the character is a control character
+    #[inline]
+    pub fn is_control(&self) -> bool {
+        self.chr <= 0x20 || self.chr == 0x7F
+    }
+
+    /// Checks if the character is printable (except space)
+    #[inline]
+    pub fn is_graph(&self) -> bool {
+        (self.chr - 0x21) < 0x5E
+    }
+
+    /// Checks if the character is printable (including space)
+    #[inline]
+    pub fn is_print(&self) -> bool {
+        (self.chr - 0x20) < 0x5F
+    }
+
+    /// Checks if the character is lowercase
+    #[inline]
+    pub fn is_lower(&self) -> bool {
+        (self.chr - 'a' as u8) < 26
+    }
+
+    /// Checks if the character is uppercase
+    #[inline]
+    pub fn is_upper(&self) -> bool {
+        (self.chr - 'A' as u8) < 26
+    }
+
+    /// Checks if the character is punctuation
+    #[inline]
+    pub fn is_punctuation(&self) -> bool {
+        self.is_graph() && !self.is_alnum()
+    }
+
+    /// Checks if the character is a valid hex digit
+    #[inline]
+    pub fn is_hex(&self) -> bool {
+        self.is_digit() || ((self.chr | 32u8) - 'a' as u8) < 6
+    }
 }
 
 impl ToStr for Ascii {