---

yaml
---
r: 64762
b: refs/heads/snap-stage3
c: 0736180
h: refs/heads/master
v: v3

Author: msullivan

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: e82394013d90f1dfe8f3f990809c74e3f149e23e
+refs/heads/snap-stage3: 07361802a22ade7fa2a52c5261817b3cf8ce597d
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/compiletest/runtest.rs

@@ -681,7 +681,7 @@ fn make_out_name(config: &config, testfile: &Path, extension: &str) -> Path {
 }
 
 fn aux_output_dir_name(config: &config, testfile: &Path) -> Path {
-    Path(output_base_name(config, testfile).to_str() + ".libaux")
+    output_base_name(config, testfile).with_filetype("libaux")
 }
 
 fn output_testname(testfile: &Path) -> Path {

branches/snap-stage3/src/librustc/metadata/tydecode.rs

@@ -186,7 +186,7 @@ fn parse_trait_store(st: &mut PState) -> ty::TraitStore {
 }
 
 fn parse_substs(st: &mut PState, conv: conv_did) -> ty::substs {
-    let regions = parse_region_substs(st, |x,y| conv(x,y));
+    let regions = parse_region_substs(st);
 
     let self_ty = parse_opt(st, |st| parse_ty(st, |x,y| conv(x,y)) );
 
@@ -202,7 +202,7 @@ fn parse_substs(st: &mut PState, conv: conv_did) -> ty::substs {
     };
 }
 
-fn parse_region_substs(st: &mut PState, conv: conv_did) -> ty::RegionSubsts {
+fn parse_region_substs(st: &mut PState) -> ty::RegionSubsts {
     match next(st) {
         'e' => ty::ErasedRegions,
         'n' => {

branches/snap-stage3/src/librustc/middle/lint.rs

@@ -827,23 +827,26 @@ fn check_item_non_camel_case_types(cx: &Context, it: &ast::item) {
             !ident.contains_char('_')
     }
 
-    fn check_case(cx: &Context, ident: ast::ident, span: span) {
+    fn check_case(cx: &Context, sort: &str, ident: ast::ident, span: span) {
         if !is_camel_case(cx.tcx, ident) {
-            cx.span_lint(non_camel_case_types, span,
-                         "type, variant, or trait should have \
-                          a camel case identifier");
+            cx.span_lint(
+                non_camel_case_types, span,
+                fmt!("%s `%s` should have a camel case identifier",
+                    sort, cx.tcx.sess.str_of(ident)));
         }
     }
 
     match it.node {
-        ast::item_ty(*) | ast::item_struct(*) |
+        ast::item_ty(*) | ast::item_struct(*) => {
+            check_case(cx, "type", it.ident, it.span)
+        }
         ast::item_trait(*) => {
-            check_case(cx, it.ident, it.span)
+            check_case(cx, "trait", it.ident, it.span)
         }
         ast::item_enum(ref enum_definition, _) => {
-            check_case(cx, it.ident, it.span);
+            check_case(cx, "type", it.ident, it.span);
             for enum_definition.variants.iter().advance |variant| {
-                check_case(cx, variant.node.name, variant.span);
+                check_case(cx, "variant", variant.node.name, variant.span);
             }
         }
         _ => ()

branches/snap-stage3/src/librustc/middle/trans/base.rs

@@ -2453,12 +2453,7 @@ pub fn get_item_val(ccx: @mut CrateContext, id: ast::node_id) -> ValueRef {
             let v = match i.node {
               ast::item_static(_, m, expr) => {
                 let typ = ty::node_id_to_type(ccx.tcx, i.id);
-                let s =
-                    if attr::contains_name(i.attrs, "no_mangle") {
-                        path_elt_to_str(*my_path.last(), token::get_ident_interner())
-                    } else {
-                        mangle_exported_name(ccx, my_path, typ)
-                    };
+                let s = mangle_exported_name(ccx, my_path, typ);
                 // We need the translated value here, because for enums the
                 // LLVM type is not fully determined by the Rust type.
                 let v = consts::const_expr(ccx, expr);

branches/snap-stage3/src/librustc/middle/typeck/coherence.rs

@@ -439,7 +439,7 @@ impl CoherenceChecker {
                                          -> UniversalQuantificationResult {
         let regions = match polytype.generics.region_param {
             None => opt_vec::Empty,
-            Some(r) => {
+            Some(_) => {
                 opt_vec::with(
                     self.inference_context.next_region_var(
                         infer::BoundRegionInCoherence))

branches/snap-stage3/src/snapshots.txt

@@ -1,3 +1,11 @@
+S 2013-07-25 4cf3072
+  macos-i386 f682d6e9ca0d56768bd36a0c05b7e58e12694dff
+  macos-x86_64 2f4e85c9756ba31a04fa8dd1c999fbaf8e1d3d1a
+  winnt-i386 6360e61fb5c432ad1511cb28af8e44cc0106f1aa
+  freebsd-x86_64 5e76c40a64b76e0a065d5b8d51c85dfe38ea833a
+  linux-i386 46961cef9d4efccf5df23a8389d63cf35d35c1d6
+  linux-x86_64 b416ca2644b14403818f0219673f6f8fe189e8b4
+
 S 2013-07-21 e336cbf
   macos-i386 d9666dccc1040ebe298a54acb378902a7472ad0f
   macos-x86_64 808f68916444e3857ef2aab20f8db9db8f4b0b4a

branches/snap-stage3/src/test/compile-fail/lint-non-camel-case-types.rs

@@ -10,25 +10,25 @@
 
 #[forbid(non_camel_case_types)];
 
-struct foo { //~ ERROR type, variant, or trait should have a camel case identifier
+struct foo { //~ ERROR type `foo` should have a camel case identifier
     bar: int,
 }
 
-enum foo2 { //~ ERROR type, variant, or trait should have a camel case identifier
+enum foo2 { //~ ERROR type `foo2` should have a camel case identifier
     Bar
 }
 
-struct foo3 { //~ ERROR type, variant, or trait should have a camel case identifier
+struct foo3 { //~ ERROR type `foo3` should have a camel case identifier
     bar: int
 }
 
-type foo4 = int; //~ ERROR type, variant, or trait should have a camel case identifier
+type foo4 = int; //~ ERROR type `foo4` should have a camel case identifier
 
 enum Foo5 {
-    bar //~ ERROR type, variant, or trait should have a camel case identifier
+    bar //~ ERROR variant `bar` should have a camel case identifier
 }
 
-trait foo6 { //~ ERROR type, variant, or trait should have a camel case identifier
+trait foo6 { //~ ERROR trait `foo6` should have a camel case identifier
 }
 
 fn main() { }