---

yaml
---
r: 65265
b: refs/heads/master
c: 1009c21
h: refs/heads/master
i:
  65263: c94ebea
v: v3

Author: Lenny222

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: b5ab1012f1f5786f550e511ba1302a22c85fcd71
+refs/heads/master: 1009c21ad7b1db366a5c600946652cc490598ec1
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/doc/rust.md

@@ -2435,11 +2435,10 @@ match x {
 }
 ~~~~
 
-Patterns that bind variables default to binding to a copy or move of the matched value
-(depending on the matched value's type).
-This can be made explicit using the ```copy``` keyword,
-changed to bind to a borrowed pointer by using the ```ref``` keyword,
-or to a mutable borrowed pointer using ```ref mut```.
+Patterns that bind variables default to binding to a copy of the matched value. This can be made
+explicit using the ```copy``` keyword, changed to bind to a borrowed pointer by using the ```ref```
+keyword, or to a mutable borrowed pointer using ```ref mut```, or the value can be moved into
+the new binding using ```move```.
 
 A pattern that's just an identifier,
 like `Nil` in the previous answer,

trunk/src/librustc/back/link.rs

@@ -727,17 +727,6 @@ pub fn mangle_internal_name_by_type_only(ccx: @CrateContext,
           path_name(ccx.sess.ident_of(hash))]);
 }
 
-pub fn mangle_internal_name_by_type_and_seq(ccx: @CrateContext,
-                                         t: ty::t,
-                                         name: &str) -> ~str {
-    let s = ppaux::ty_to_str(ccx.tcx, t);
-    let hash = get_symbol_hash(ccx, t);
-    return mangle(ccx.sess,
-        ~[path_name(ccx.sess.ident_of(s)),
-          path_name(ccx.sess.ident_of(hash)),
-          path_name((ccx.names)(name))]);
-}
-
 pub fn mangle_internal_name_by_path_and_seq(ccx: @CrateContext,
                                             path: path,
                                             flav: &str) -> ~str {

trunk/src/librustc/driver/driver.rs

@@ -811,7 +811,7 @@ pub fn optgroups() -> ~[getopts::groups::OptGroup] {
                           for detail)", "FEATURE"),
   optopt("", "android-cross-path",
          "The path to the Android NDK", "PATH"),
-  optmulti("W", "warn",
+  optflagopt("W", "warn",
                         "Set lint warnings", "OPT"),
   optmulti("A", "allow",
                         "Set lint allowed", "OPT"),

trunk/src/librustc/middle/trans/foreign.rs

@@ -845,26 +845,6 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                                              T_ptr(T_nil()));
             Store(bcx, morestack_addr, fcx.llretptr.get());
         }
-        ~"memcpy32" => {
-            let dst_ptr = get_param(decl, first_real_arg);
-            let src_ptr = get_param(decl, first_real_arg + 1);
-            let size = get_param(decl, first_real_arg + 2);
-            let align = C_i32(1);
-            let volatile = C_i1(false);
-            let llfn = *bcx.ccx().intrinsics.get(
-                &~"llvm.memcpy.p0i8.p0i8.i32");
-            Call(bcx, llfn, [dst_ptr, src_ptr, size, align, volatile]);
-        }
-        ~"memcpy64" => {
-            let dst_ptr = get_param(decl, first_real_arg);
-            let src_ptr = get_param(decl, first_real_arg + 1);
-            let size = get_param(decl, first_real_arg + 2);
-            let align = C_i32(1);
-            let volatile = C_i1(false);
-            let llfn = *bcx.ccx().intrinsics.get(
-                &~"llvm.memcpy.p0i8.p0i8.i64");
-            Call(bcx, llfn, [dst_ptr, src_ptr, size, align, volatile]);
-        }
         ~"memmove32" => {
             let dst_ptr = get_param(decl, first_real_arg);
             let src_ptr = get_param(decl, first_real_arg + 1);

trunk/src/librustc/middle/trans/glue.rs

@@ -683,7 +683,12 @@ pub fn declare_tydesc(ccx: @CrateContext, t: ty::t) -> @mut tydesc_info {
     let llsize = llsize_of(ccx, llty);
     let llalign = llalign_of(ccx, llty);
     let addrspace = declare_tydesc_addrspace(ccx, t);
-    let name = @mangle_internal_name_by_type_and_seq(ccx, t, "tydesc");
+    // FIXME #6574: this triggers duplicate LLVM symbols
+    let name = @(if false /*ccx.sess.opts.debuginfo*/ {
+        mangle_internal_name_by_type_only(ccx, t, "tydesc")
+    } else {
+        mangle_internal_name_by_seq(ccx, "tydesc")
+    });
     note_unique_llvm_symbol(ccx, name);
     debug!("+++ declare_tydesc %s %s", ppaux::ty_to_str(ccx.tcx, t), *name);
     let gvar = str::as_c_str(*name, |buf| {
@@ -712,7 +717,12 @@ pub fn declare_generic_glue(ccx: @CrateContext, t: ty::t, llfnty: TypeRef,
                             name: ~str) -> ValueRef {
     let _icx = ccx.insn_ctxt("declare_generic_glue");
     let name = name;
-    let fn_nm = @mangle_internal_name_by_type_and_seq(ccx, t, (~"glue_" + name));
+    // FIXME #6574 this triggers duplicate LLVM symbols
+    let fn_nm = @(if false /*ccx.sess.opts.debuginfo*/ {
+        mangle_internal_name_by_type_only(ccx, t, (~"glue_" + name))
+    } else {
+        mangle_internal_name_by_seq(ccx, (~"glue_" + name))
+    });
     debug!("%s is for type %s", *fn_nm, ppaux::ty_to_str(ccx.tcx, t));
     note_unique_llvm_symbol(ccx, fn_nm);
     let llfn = decl_cdecl_fn(ccx.llmod, *fn_nm, llfnty);

trunk/src/librustc/middle/trans/type_use.rs

@@ -135,7 +135,7 @@ pub fn type_uses_for(ccx: @CrateContext, fn_id: def_id, n_tps: uint)
                 ~"visit_tydesc"  | ~"forget" | ~"frame_address" |
                 ~"morestack_addr" => 0,
 
-                ~"memcpy32" | ~"memcpy64" | ~"memmove32" | ~"memmove64" => 0,
+                ~"memmove32" | ~"memmove64" => 0,
 
                 ~"sqrtf32" | ~"sqrtf64" | ~"powif32" | ~"powif64" |
                 ~"sinf32"  | ~"sinf64"  | ~"cosf32"  | ~"cosf64"  |

trunk/src/librustc/middle/typeck/check/mod.rs

@@ -3451,152 +3451,122 @@ pub fn check_intrinsic_type(ccx: @mut CrateCtxt, it: @ast::foreign_item) {
 
     let tcx = ccx.tcx;
     let (n_tps, inputs, output) = match *ccx.tcx.sess.str_of(it.ident) {
-        ~"size_of" |
-        ~"pref_align_of" | ~"min_align_of" => (1u, ~[], ty::mk_uint()),
-        ~"init" => (1u, ~[], param(ccx, 0u)),
-        ~"uninit" => (1u, ~[], param(ccx, 0u)),
-        ~"forget" => (1u, ~[ param(ccx, 0) ], ty::mk_nil()),
-        ~"transmute" => (2, ~[ param(ccx, 0) ], param(ccx, 1)),
-        ~"move_val" | ~"move_val_init" => {
-            (1u,
-             ~[
-                ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)), param(ccx, 0)),
-                param(ccx, 0u)
-              ],
-           ty::mk_nil())
-        }
-        ~"needs_drop" => (1u, ~[], ty::mk_bool()),
-
-        ~"atomic_cxchg"    | ~"atomic_cxchg_acq"| ~"atomic_cxchg_rel" => {
-          (0,
+      ~"size_of" |
+      ~"pref_align_of" | ~"min_align_of" => (1u, ~[], ty::mk_uint()),
+      ~"init" => (1u, ~[], param(ccx, 0u)),
+      ~"uninit" => (1u, ~[], param(ccx, 0u)),
+      ~"forget" => (1u, ~[ param(ccx, 0) ], ty::mk_nil()),
+      ~"transmute" => (2, ~[ param(ccx, 0) ], param(ccx, 1)),
+      ~"move_val" | ~"move_val_init" => {
+          (1u,
            ~[
-              ty::mk_mut_rptr(tcx,
-                              ty::re_bound(ty::br_anon(0)),
-                              ty::mk_int()),
-              ty::mk_int(),
-              ty::mk_int()
-           ],
-           ty::mk_int())
-        }
-        ~"atomic_load"     | ~"atomic_load_acq" => {
-          (0,
-           ~[
-              ty::mk_imm_rptr(tcx, ty::re_bound(ty::br_anon(0)), ty::mk_int())
-           ],
-          ty::mk_int())
-        }
-        ~"atomic_store"    | ~"atomic_store_rel" => {
-          (0,
-           ~[
-              ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)), ty::mk_int()),
-              ty::mk_int()
-           ],
-           ty::mk_nil())
-        }
-        ~"atomic_xchg"     | ~"atomic_xadd"     | ~"atomic_xsub"     |
-        ~"atomic_xchg_acq" | ~"atomic_xadd_acq" | ~"atomic_xsub_acq" |
-        ~"atomic_xchg_rel" | ~"atomic_xadd_rel" | ~"atomic_xsub_rel" => {
-          (0,
-           ~[
-              ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)), ty::mk_int()),
-              ty::mk_int()
-           ],
-           ty::mk_int())
-        }
-
-        ~"get_tydesc" => {
-          // FIXME (#3730): return *intrinsic::tydesc, not *()
-          (1u, ~[], ty::mk_nil_ptr(ccx.tcx))
-        }
-        ~"visit_tydesc" => {
-          let tydesc_name = special_idents::tydesc;
-          assert!(tcx.intrinsic_defs.contains_key(&tydesc_name));
-          let (_, tydesc_ty) = tcx.intrinsic_defs.get_copy(&tydesc_name);
-          let (_, visitor_object_ty) = ty::visitor_object_ty(tcx);
-          let td_ptr = ty::mk_ptr(ccx.tcx, ty::mt {
-              ty: tydesc_ty,
-              mutbl: ast::m_imm
-          });
-          (0, ~[ td_ptr, visitor_object_ty ], ty::mk_nil())
-        }
-        ~"frame_address" => {
-          let fty = ty::mk_closure(ccx.tcx, ty::ClosureTy {
-              purity: ast::impure_fn,
-              sigil: ast::BorrowedSigil,
-              onceness: ast::Once,
-              region: ty::re_bound(ty::br_anon(0)),
-              bounds: ty::EmptyBuiltinBounds(),
-              sig: ty::FnSig {
-                  bound_lifetime_names: opt_vec::Empty,
-                  inputs: ~[ty::mk_imm_ptr(ccx.tcx, ty::mk_mach_uint(ast::ty_u8))],
-                  output: ty::mk_nil()
-              }
-          });
-          (0u, ~[fty], ty::mk_nil())
-        }
-        ~"morestack_addr" => {
-          (0u, ~[], ty::mk_nil_ptr(ccx.tcx))
-        }
-        ~"memcpy32" => {
-          (0,
-           ~[
-              ty::mk_ptr(tcx, ty::mt {
-                  ty: ty::mk_u8(),
-                  mutbl: ast::m_mutbl
-              }),
-              ty::mk_ptr(tcx, ty::mt {
-                  ty: ty::mk_u8(),
-                  mutbl: ast::m_imm
-              }),
-              ty::mk_u32()
-           ],
-           ty::mk_nil())
-        }
-        ~"memcpy64" => {
-          (0,
-           ~[
-              ty::mk_ptr(tcx, ty::mt {
-                  ty: ty::mk_u8(),
-                  mutbl: ast::m_mutbl
-              }),
-              ty::mk_ptr(tcx, ty::mt {
-                  ty: ty::mk_u8(),
-                  mutbl: ast::m_imm
-              }),
-              ty::mk_u64()
-           ],
-           ty::mk_nil())
-        }
-        ~"memmove32" => {
-          (0,
-           ~[
-              ty::mk_ptr(tcx, ty::mt {
-                  ty: ty::mk_u8(),
-                  mutbl: ast::m_mutbl
-              }),
-              ty::mk_ptr(tcx, ty::mt {
-                  ty: ty::mk_u8(),
-                  mutbl: ast::m_imm
-              }),
-              ty::mk_u32()
-           ],
-           ty::mk_nil())
-        }
-        ~"memmove64" => {
-          (0,
-           ~[
-              ty::mk_ptr(tcx, ty::mt {
-                  ty: ty::mk_u8(),
-                  mutbl: ast::m_mutbl
-              }),
-              ty::mk_ptr(tcx, ty::mt {
-                  ty: ty::mk_u8(),
-                  mutbl: ast::m_imm
-              }),
-              ty::mk_u64()
-           ],
-           ty::mk_nil())
-        }
+              ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)), param(ccx, 0)),
+              param(ccx, 0u)
+            ],
+         ty::mk_nil())
+      }
+      ~"needs_drop" => (1u, ~[], ty::mk_bool()),
+
+      ~"atomic_cxchg"    | ~"atomic_cxchg_acq"| ~"atomic_cxchg_rel" => {
+        (0,
+         ~[
+            ty::mk_mut_rptr(tcx,
+                            ty::re_bound(ty::br_anon(0)),
+                            ty::mk_int()),
+            ty::mk_int(),
+            ty::mk_int()
+         ],
+         ty::mk_int())
+      }
+      ~"atomic_load"     | ~"atomic_load_acq" => {
+        (0,
+         ~[
+            ty::mk_imm_rptr(tcx, ty::re_bound(ty::br_anon(0)), ty::mk_int())
+         ],
+        ty::mk_int())
+      }
+      ~"atomic_store"    | ~"atomic_store_rel" => {
+        (0,
+         ~[
+            ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)), ty::mk_int()),
+            ty::mk_int()
+         ],
+         ty::mk_nil())
+      }
+      ~"atomic_xchg"     | ~"atomic_xadd"     | ~"atomic_xsub"     |
+      ~"atomic_xchg_acq" | ~"atomic_xadd_acq" | ~"atomic_xsub_acq" |
+      ~"atomic_xchg_rel" | ~"atomic_xadd_rel" | ~"atomic_xsub_rel" => {
+        (0,
+         ~[
+            ty::mk_mut_rptr(tcx, ty::re_bound(ty::br_anon(0)), ty::mk_int()),
+            ty::mk_int()
+         ],
+         ty::mk_int())
+      }
+
+      ~"get_tydesc" => {
+        // FIXME (#3730): return *intrinsic::tydesc, not *()
+        (1u, ~[], ty::mk_nil_ptr(ccx.tcx))
+      }
+      ~"visit_tydesc" => {
+        let tydesc_name = special_idents::tydesc;
+        assert!(tcx.intrinsic_defs.contains_key(&tydesc_name));
+        let (_, tydesc_ty) = tcx.intrinsic_defs.get_copy(&tydesc_name);
+        let (_, visitor_object_ty) = ty::visitor_object_ty(tcx);
+        let td_ptr = ty::mk_ptr(ccx.tcx, ty::mt {
+            ty: tydesc_ty,
+            mutbl: ast::m_imm
+        });
+        (0, ~[ td_ptr, visitor_object_ty ], ty::mk_nil())
+      }
+      ~"frame_address" => {
+        let fty = ty::mk_closure(ccx.tcx, ty::ClosureTy {
+            purity: ast::impure_fn,
+            sigil: ast::BorrowedSigil,
+            onceness: ast::Once,
+            region: ty::re_bound(ty::br_anon(0)),
+            bounds: ty::EmptyBuiltinBounds(),
+            sig: ty::FnSig {
+                bound_lifetime_names: opt_vec::Empty,
+                inputs: ~[ty::mk_imm_ptr(ccx.tcx, ty::mk_mach_uint(ast::ty_u8))],
+                output: ty::mk_nil()
+            }
+        });
+        (0u, ~[fty], ty::mk_nil())
+      }
+      ~"morestack_addr" => {
+        (0u, ~[], ty::mk_nil_ptr(ccx.tcx))
+      }
+      ~"memmove32" => {
+        (0,
+         ~[
+            ty::mk_ptr(tcx, ty::mt {
+                ty: ty::mk_u8(),
+                mutbl: ast::m_mutbl
+            }),
+            ty::mk_ptr(tcx, ty::mt {
+                ty: ty::mk_u8(),
+                mutbl: ast::m_imm
+            }),
+            ty::mk_u32()
+         ],
+         ty::mk_nil())
+      }
+      ~"memmove64" => {
+        (0,
+         ~[
+            ty::mk_ptr(tcx, ty::mt {
+                ty: ty::mk_u8(),
+                mutbl: ast::m_mutbl
+            }),
+            ty::mk_ptr(tcx, ty::mt {
+                ty: ty::mk_u8(),
+                mutbl: ast::m_imm
+            }),
+            ty::mk_u64()
+         ],
+         ty::mk_nil())
+      }
         ~"sqrtf32" => (0, ~[ ty::mk_f32() ], ty::mk_f32()),
         ~"sqrtf64" => (0, ~[ ty::mk_f64() ], ty::mk_f64()),
         ~"powif32" => {

trunk/src/librustc/rustc.rc

@@ -228,9 +228,14 @@ pub fn run_compiler(args: &~[~str], demitter: diagnostic::Emitter) {
         return;
     }
 
+    // Display the available lint options if "-W help" or only "-W" is given.
     let lint_flags = vec::append(getopts::opt_strs(matches, "W"),
                                  getopts::opt_strs(matches, "warn"));
-    if lint_flags.contains(&~"help") {
+
+    let show_lint_options = lint_flags.contains(&~"help") ||
+        (opt_present(matches, "W") && lint_flags.is_empty());
+
+    if show_lint_options {
         describe_warnings();
         return;
     }