---

yaml
---
r: 273689
b: refs/heads/beta
c: 7b69ad9
h: refs/heads/master
i:
  273687: 42d969c

Author: nodakai

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: deee0f73da885a71ebf9c8d29213c663dba467b9
+refs/heads/beta: 7b69ad91585cebb50a1b6cae0d8d9a3ac83d78ff
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/mk/crates.mk

@@ -123,7 +123,7 @@ DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts \
                 test rustc_lint rustc_front
 
 
-TOOL_DEPS_compiletest := test getopts log
+TOOL_DEPS_compiletest := test getopts
 TOOL_DEPS_rustdoc := rustdoc
 TOOL_DEPS_rustc := rustc_driver
 TOOL_DEPS_rustbook := std rustdoc

branches/beta/mk/main.mk

@@ -493,7 +493,7 @@ endif
 LD_LIBRARY_PATH_ENV_HOSTDIR$(1)_T_$(2)_H_$(3) := \
     $$(CURDIR)/$$(HLIB$(1)_H_$(3)):$$(CFG_LLVM_INST_DIR_$(3))/lib
 LD_LIBRARY_PATH_ENV_TARGETDIR$(1)_T_$(2)_H_$(3) := \
-    $$(CURDIR)/$$(TLIB$(1)_T_$(2)_H_$(CFG_BUILD))
+    $$(CURDIR)/$$(TLIB1_T_$(2)_H_$(CFG_BUILD))
 
 HOST_RPATH_VAR$(1)_T_$(2)_H_$(3) := \
   $$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3))=$$(LD_LIBRARY_PATH_ENV_HOSTDIR$(1)_T_$(2)_H_$(3)):$$$$$$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3))

branches/beta/src/librustc/ty/mod.rs

@@ -1202,7 +1202,6 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
         }
     }
 
-    /// Construct a parameter environment given an item, impl item, or trait item
     pub fn for_item(cx: &'a TyCtxt<'tcx>, id: NodeId) -> ParameterEnvironment<'a, 'tcx> {
         match cx.map.find(id) {
             Some(ast_map::NodeImplItem(ref impl_item)) => {
@@ -1342,7 +1341,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
                     }
                     _ => {
                         cx.sess.span_bug(item.span,
-                                         "ParameterEnvironment::for_item():
+                                         "ParameterEnvironment::from_item():
                                           can't create a parameter \
                                           environment for this kind of item")
                     }
@@ -1353,7 +1352,7 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
                 ParameterEnvironment::for_item(cx, cx.map.get_parent(id))
             }
             _ => {
-                cx.sess.bug(&format!("ParameterEnvironment::for_item(): \
+                cx.sess.bug(&format!("ParameterEnvironment::from_item(): \
                                      `{}` is not an item",
                                     cx.map.node_to_string(id)))
             }

branches/beta/src/libsyntax/feature_gate.rs

@@ -199,7 +199,7 @@ const KNOWN_FEATURES: &'static [(&'static str, &'static str, Option<u32>, Status
     ("associated_type_defaults", "1.2.0", Some(29661), Active),
 
     // Allows macros to appear in the type position.
-    ("type_macros", "1.3.0", Some(27336), Active),
+    ("type_macros", "1.3.0", Some(27245), Active),
 
     // allow `repr(simd)`, and importing the various simd intrinsics
     ("repr_simd", "1.4.0", Some(27731), Active),

branches/beta/src/libsyntax_ext/deriving/generic/mod.rs

@@ -209,8 +209,6 @@ use syntax::ptr::P;
 
 use self::ty::{LifetimeBounds, Path, Ptr, PtrTy, Self_, Ty};
 
-use deriving;
-
 pub mod ty;
 
 pub struct TraitDef<'a> {
@@ -383,6 +381,22 @@ fn find_type_parameters(ty: &ast::Ty, ty_param_names: &[ast::Name]) -> Vec<P<ast
     visitor.types
 }
 
+/// Replacement for expr_unreachable which generates intrinsics::unreachable()
+/// instead of unreachable!()
+fn expr_unreachable_intrinsic(cx: &ExtCtxt, sp: Span) -> P<Expr> {
+    let path = cx.std_path(&["intrinsics", "unreachable"]);
+    let call = cx.expr_call_global(
+        sp, path, vec![]);
+    let unreachable = cx.expr_block(P(ast::Block {
+        stmts: vec![],
+        expr: Some(call),
+        id: ast::DUMMY_NODE_ID,
+        rules: ast::BlockCheckMode::Unsafe(ast::CompilerGenerated),
+        span: sp }));
+
+    unreachable
+}
+
 impl<'a> TraitDef<'a> {
     pub fn expand(&self,
                   cx: &mut ExtCtxt,
@@ -1265,11 +1279,15 @@ impl<'a> MethodDef<'a> {
 
             let mut first_ident = None;
             for (&ident, self_arg) in vi_idents.iter().zip(&self_args) {
-                let self_addr = cx.expr_addr_of(sp, self_arg.clone());
-                let variant_value = deriving::call_intrinsic(cx,
-                                                             sp,
-                                                             "discriminant_value",
-                                                             vec![self_addr]);
+                let path = cx.std_path(&["intrinsics", "discriminant_value"]);
+                let call = cx.expr_call_global(
+                    sp, path, vec![cx.expr_addr_of(sp, self_arg.clone())]);
+                let variant_value = cx.expr_block(P(ast::Block {
+                    stmts: vec![],
+                    expr: Some(call),
+                    id: ast::DUMMY_NODE_ID,
+                    rules: ast::BlockCheckMode::Unsafe(ast::CompilerGenerated),
+                    span: sp }));
 
                 let target_ty = cx.ty_ident(sp, cx.ident_of(target_type_name));
                 let variant_disr = cx.expr_cast(sp, variant_value, target_ty);
@@ -1297,9 +1315,7 @@ impl<'a> MethodDef<'a> {
             //Since we know that all the arguments will match if we reach the match expression we
             //add the unreachable intrinsics as the result of the catch all which should help llvm
             //in optimizing it
-            match_arms.push(cx.arm(sp,
-                                   vec![cx.pat_wild(sp)],
-                                   deriving::call_intrinsic(cx, sp, "unreachable", vec![])));
+            match_arms.push(cx.arm(sp, vec![cx.pat_wild(sp)], expr_unreachable_intrinsic(cx, sp)));
 
             // Final wrinkle: the self_args are expressions that deref
             // down to desired l-values, but we cannot actually deref
@@ -1375,7 +1391,7 @@ impl<'a> MethodDef<'a> {
             // derive Debug on such a type could here generate code
             // that needs the feature gate enabled.)
 
-            deriving::call_intrinsic(cx, sp, "unreachable", vec![])
+            expr_unreachable_intrinsic(cx, sp)
         }
         else {
 

branches/beta/src/libsyntax_ext/deriving/hash.rs

@@ -81,13 +81,15 @@ fn hash_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure)
 
     let fields = match *substr.fields {
         Struct(_, ref fs) => fs,
-        EnumMatching(_, _, ref fs) => {
-            let variant_value = deriving::call_intrinsic(cx,
-                                                         trait_span,
-                                                         "discriminant_value",
-                                                         vec![cx.expr_self(trait_span)]);
+        EnumMatching(index, variant, ref fs) => {
+            // Determine the discriminant. We will feed this value to the byte
+            // iteration function.
+            let discriminant = match variant.node.disr_expr {
+                Some(ref d) => d.clone(),
+                None => cx.expr_usize(trait_span, index)
+            };
 
-            stmts.push(call_hash(trait_span, variant_value));
+            stmts.push(call_hash(trait_span, discriminant));
 
             fs
         }

branches/beta/src/libsyntax_ext/deriving/mod.rs

@@ -18,7 +18,6 @@ use syntax::ext::build::AstBuilder;
 use syntax::feature_gate;
 use syntax::codemap::Span;
 use syntax::parse::token::{intern, intern_and_get_ident};
-use syntax::ptr::P;
 
 macro_rules! pathvec {
     ($($x:ident)::+) => (
@@ -272,19 +271,3 @@ fn hygienic_type_parameter(item: &Annotatable, base: &str) -> String {
     typaram
 }
 
-/// Constructs an expression that calls an intrinsic
-fn call_intrinsic(cx: &ExtCtxt,
-                  span: Span,
-                  intrinsic: &str,
-                  args: Vec<P<ast::Expr>>) -> P<ast::Expr> {
-    let path = cx.std_path(&["intrinsics", intrinsic]);
-    let call = cx.expr_call_global(span, path, args);
-
-    cx.expr_block(P(ast::Block {
-        stmts: vec![],
-        expr: Some(call),
-        id: ast::DUMMY_NODE_ID,
-        rules: ast::BlockCheckMode::Unsafe(ast::CompilerGenerated),
-        span: span }))
-}
-

branches/beta/src/test/compile-fail/type-macros-fail.rs

@@ -14,7 +14,7 @@ macro_rules! Id {
 
 struct Foo<T> {
     x: Id!(T)
-    //~^ ERROR: type macros are experimental (see issue #27336)
+    //~^ ERROR: type macros are experimental (see issue #27245)
 }
 
 fn main() {

branches/beta/src/test/run-pass/deriving-hash.rs

@@ -12,7 +12,6 @@
 #![feature(hash_default)]
 
 use std::hash::{Hash, SipHasher, Hasher};
-use std::mem::size_of;
 
 #[derive(Hash)]
 struct Person {
@@ -25,30 +24,12 @@ struct Person {
 #[derive(Hash)] struct __H__H;
 #[derive(Hash)] enum Collision<__H> { __H { __H__H: __H } }
 
-#[derive(Hash)]
-enum E { A=1, B }
-
 fn hash<T: Hash>(t: &T) -> u64 {
     let mut s = SipHasher::new_with_keys(0, 0);
     t.hash(&mut s);
     s.finish()
 }
 
-struct FakeHasher<'a>(&'a mut Vec<u8>);
-impl<'a> Hasher for FakeHasher<'a> {
-    fn finish(&self) -> u64 {
-        unimplemented!()
-    }
-
-    fn write(&mut self, bytes: &[u8]) {
-        self.0.extend(bytes);
-    }
-}
-
-fn fake_hash(v: &mut Vec<u8>, e: E) {
-    e.hash(&mut FakeHasher(v));
-}
-
 fn main() {
     let person1 = Person {
         id: 5,
@@ -62,11 +43,4 @@ fn main() {
     };
     assert_eq!(hash(&person1), hash(&person1));
     assert!(hash(&person1) != hash(&person2));
-
-    // test #21714
-    let mut va = vec![];
-    let mut vb = vec![];
-    fake_hash(&mut va, E::A);
-    fake_hash(&mut vb, E::B);
-    assert!(va != vb);
 }