Merge remote-tracking branch 'remotes/origin/incoming' into incoming

Author: erickt

src/libcore/comm.rs

@@ -17,8 +17,8 @@ use vec;
 
 use pipes::{recv, try_recv, wait_many, peek, PacketHeader};
 
-// NOTE Making this public exposes some plumbing from pipes. Needs
-// some refactoring
+// FIXME #5160: Making this public exposes some plumbing from
+// pipes. Needs some refactoring
 pub use pipes::Selectable;
 
 /// A trait for things that can send multiple messages.

src/libcore/core.rc

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -41,7 +41,7 @@ Implicitly, all crates behave as if they included the following prologue:
        url = "https://github.com/mozilla/rust/tree/master/src/libcore")];
 
 #[comment = "The Rust core library"];
-#[license = "MIT"];
+#[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 
 

src/libcore/num/strconv.rs

@@ -478,17 +478,16 @@ pub pure fn from_str_bytes_common<T:NumCast+Zero+One+Ord+Copy+Div<T,T>+
         }
     }
 
-    // XXX: Bytevector constant from str
     if special {
-        if buf == str::to_bytes("inf") || buf == str::to_bytes("+inf") {
+        if buf == str::inf_buf || buf == str::positive_inf_buf {
             return NumStrConv::inf();
-        } else if buf == str::to_bytes("-inf") {
+        } else if buf == str::negative_inf_buf {
             if negative {
                 return NumStrConv::neg_inf();
             } else {
                 return None;
             }
-        } else if buf == str::to_bytes("NaN") {
+        } else if buf == str::nan_buf {
             return NumStrConv::NaN();
         }
     }

src/libcore/str.rs

@@ -1832,6 +1832,13 @@ const tag_five_b: uint = 248u;
 const max_five_b: uint = 67108864u;
 const tag_six_b: uint = 252u;
 
+// Constants used for converting strs to floats
+pub const inf_buf: [u8*3] = ['i' as u8, 'n' as u8, 'f' as u8];
+pub const positive_inf_buf: [u8*4] = ['+' as u8, 'i' as u8,
+                                      'n' as u8, 'f' as u8];
+pub const negative_inf_buf: [u8*4] = ['-' as u8, 'i' as u8,
+                                      'n' as u8, 'f' as u8];
+pub const nan_buf: [u8*3] = ['N' as u8, 'a' as u8, 'N' as u8];
 
 /**
  * Work with the byte buffer of a string.

src/libfuzzer/fuzzer.rc

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -15,7 +15,7 @@
        url = "https://github.com/mozilla/rust/tree/master/src/libfuzzer")];
 
 #[comment = "The Rust fuzzer library"];
-#[license = "MIT"];
+#[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 #[no_core];
 

src/librust/rust.rc

@@ -17,6 +17,7 @@
        uuid = "4a24da33-5cc8-4037-9352-2cbe9bd9d27c",
        url = "https://github.com/mozilla/rust/tree/master/src/rust")];
 
+#[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 
 extern mod core(vers = "0.6");

src/librustc/middle/astencode.rs

@@ -451,9 +451,17 @@ impl tr for ast::def {
 
 impl tr for ty::AutoAdjustment {
     fn tr(&self, xcx: @ExtendedDecodeContext) -> ty::AutoAdjustment {
-        ty::AutoAdjustment {
-            autoderefs: self.autoderefs,
-            autoref: self.autoref.map(|ar| ar.tr(xcx)),
+        match self {
+            &ty::AutoAddEnv(r, s) => {
+                ty::AutoAddEnv(r.tr(xcx), s)
+            }
+
+            &ty::AutoDerefRef(ref adr) => {
+                ty::AutoDerefRef(ty::AutoDerefRef {
+                    autoderefs: adr.autoderefs,
+                    autoref: adr.autoref.map(|ar| ar.tr(xcx)),
+                })
+            }
         }
     }
 }

src/librustc/middle/borrowck/gather_loans.rs

@@ -299,17 +299,27 @@ pub impl GatherLoanCtxt {
                expr_repr(self.tcx(), expr), adjustment);
         let _i = indenter();
 
-        match adjustment.autoref {
-            None => {
+        match *adjustment {
+            ty::AutoAddEnv(*) => {
+                debug!("autoaddenv -- no autoref");
+                return;
+            }
+
+            ty::AutoDerefRef(
+                ty::AutoDerefRef {
+                    autoref: None, _ }) => {
                 debug!("no autoref");
                 return;
             }
 
-            Some(ref autoref) => {
+            ty::AutoDerefRef(
+                ty::AutoDerefRef {
+                    autoref: Some(ref autoref),
+                    autoderefs: autoderefs}) => {
                 let mcx = &mem_categorization_ctxt {
                     tcx: self.tcx(),
                     method_map: self.bccx.method_map};
-                let mut cmt = mcx.cat_expr_autoderefd(expr, adjustment);
+                let mut cmt = mcx.cat_expr_autoderefd(expr, autoderefs);
                 debug!("after autoderef, cmt=%s", self.bccx.cmt_to_repr(cmt));
 
                 match autoref.kind {

src/librustc/middle/borrowck/mod.rs

@@ -480,9 +480,20 @@ pub impl BorrowckCtxt {
     }
 
     fn cat_expr_autoderefd(&self, expr: @ast::expr,
-                           adj: @ty::AutoAdjustment)
-                        -> cmt {
-        cat_expr_autoderefd(self.tcx, self.method_map, expr, adj)
+                           adj: @ty::AutoAdjustment) -> cmt {
+        match *adj {
+            ty::AutoAddEnv(*) => {
+                // no autoderefs
+                cat_expr_unadjusted(self.tcx, self.method_map, expr)
+            }
+
+            ty::AutoDerefRef(
+                ty::AutoDerefRef {
+                    autoderefs: autoderefs, _}) => {
+                cat_expr_autoderefd(self.tcx, self.method_map, expr,
+                                    autoderefs)
+            }
+        }
     }
 
     fn cat_def(&self,

src/librustc/middle/mem_categorization.rs

@@ -241,12 +241,12 @@ pub fn cat_expr_autoderefd(
     tcx: ty::ctxt,
     method_map: typeck::method_map,
     expr: @ast::expr,
-    adj: @ty::AutoAdjustment) -> cmt {
-
+    autoderefs: uint) -> cmt
+{
     let mcx = &mem_categorization_ctxt {
         tcx: tcx, method_map: method_map
     };
-    return mcx.cat_expr_autoderefd(expr, adj);
+    return mcx.cat_expr_autoderefd(expr, autoderefs);
 }
 
 pub fn cat_def(
@@ -361,28 +361,38 @@ pub impl mem_categorization_ctxt {
                 self.cat_expr_unadjusted(expr)
             }
 
-            Some(adjustment) => {
-                match adjustment.autoref {
-                    Some(_) => {
-                        // Equivalent to &*expr or something similar.
-                        // This is an rvalue, effectively.
-                        let expr_ty = ty::expr_ty(self.tcx, expr);
-                        self.cat_rvalue(expr, expr_ty)
-                    }
-                    None => {
-                        // Equivalent to *expr or something similar.
-                        self.cat_expr_autoderefd(expr, adjustment)
-                    }
-                }
+            Some(@ty::AutoAddEnv(*)) => {
+                // Convert a bare fn to a closure by adding NULL env.
+                // Result is an rvalue.
+                let expr_ty = ty::expr_ty_adjusted(self.tcx, expr);
+                self.cat_rvalue(expr, expr_ty)
+            }
+
+            Some(
+                @ty::AutoDerefRef(
+                    ty::AutoDerefRef {
+                        autoref: Some(_), _})) => {
+                // Equivalent to &*expr or something similar.
+                // Result is an rvalue.
+                let expr_ty = ty::expr_ty_adjusted(self.tcx, expr);
+                self.cat_rvalue(expr, expr_ty)
+            }
+
+            Some(
+                @ty::AutoDerefRef(
+                    ty::AutoDerefRef {
+                        autoref: None, autoderefs: autoderefs})) => {
+                // Equivalent to *expr or something similar.
+                self.cat_expr_autoderefd(expr, autoderefs)
             }
         }
     }
 
     fn cat_expr_autoderefd(&self,
                            expr: @ast::expr,
-                           adjustment: &ty::AutoAdjustment) -> cmt {
+                           autoderefs: uint) -> cmt {
         let mut cmt = self.cat_expr_unadjusted(expr);
-        for uint::range(1, adjustment.autoderefs+1) |deref| {
+        for uint::range(1, autoderefs+1) |deref| {
             cmt = self.cat_deref(expr, cmt, deref);
         }
         return cmt;