---

yaml
---
r: 52118
b: refs/heads/dist-snap
c: fa96740
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: 1070cc0109661d9f47a6e2c39ad853041ddf30e2
+refs/heads/dist-snap: fa967409232c06c35fb100aac65ff274d4d6c30d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

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

@@ -105,12 +105,12 @@ impl lint : cmp::Eq {
     pure fn ne(&self, other: &lint) -> bool { !(*self).eq(other) }
 }
 
-fn level_to_str(lv: level) -> ~str {
+fn level_to_str(lv: level) -> &static/str {
     match lv {
-      allow => ~"allow",
-      warn => ~"warn",
-      deny => ~"deny",
-      forbid => ~"forbid"
+      allow => "allow",
+      warn => "warn",
+      deny => "deny",
+      forbid => "forbid"
     }
 }
 
@@ -126,7 +126,7 @@ impl level : cmp::Eq {
 }
 
 type lint_spec = @{lint: lint,
-                   desc: ~str,
+                   desc: &static/str,
                    default: level};
 
 type lint_dict = HashMap<~str,lint_spec>;
@@ -139,109 +139,109 @@ fn get_lint_dict() -> lint_dict {
     let v = ~[
         (~"ctypes",
          @{lint: ctypes,
-           desc: ~"proper use of core::libc types in foreign modules",
+           desc: "proper use of core::libc types in foreign modules",
            default: warn}),
 
         (~"unused_imports",
          @{lint: unused_imports,
-           desc: ~"imports that are never used",
+           desc: "imports that are never used",
            default: allow}),
 
         (~"while_true",
          @{lint: while_true,
-           desc: ~"suggest using loop { } instead of while(true) { }",
+           desc: "suggest using loop { } instead of while(true) { }",
            default: warn}),
 
         (~"path_statement",
          @{lint: path_statement,
-           desc: ~"path statements with no effect",
+           desc: "path statements with no effect",
            default: warn}),
 
         (~"unrecognized_lint",
          @{lint: unrecognized_lint,
-           desc: ~"unrecognized lint attribute",
+           desc: "unrecognized lint attribute",
            default: warn}),
 
         (~"non_implicitly_copyable_typarams",
          @{lint: non_implicitly_copyable_typarams,
-           desc: ~"passing non implicitly copyable types as copy type params",
+           desc: "passing non implicitly copyable types as copy type params",
            default: warn}),
 
         (~"vecs_implicitly_copyable",
          @{lint: vecs_implicitly_copyable,
-           desc: ~"make vecs and strs not implicitly copyable \
+           desc: "make vecs and strs not implicitly copyable \
                   (only checked at top level)",
            default: warn}),
 
         (~"implicit_copies",
          @{lint: implicit_copies,
-           desc: ~"implicit copies of non implicitly copyable data",
+           desc: "implicit copies of non implicitly copyable data",
            default: warn}),
 
         (~"deprecated_mode",
          @{lint: deprecated_mode,
-           desc: ~"warn about deprecated uses of modes",
+           desc: "warn about deprecated uses of modes",
            default: warn}),
 
         (~"deprecated_pattern",
          @{lint: deprecated_pattern,
-           desc: ~"warn about deprecated uses of pattern bindings",
+           desc: "warn about deprecated uses of pattern bindings",
            default: allow}),
 
         (~"non_camel_case_types",
          @{lint: non_camel_case_types,
-           desc: ~"types, variants and traits should have camel case names",
+           desc: "types, variants and traits should have camel case names",
            default: allow}),
 
         (~"managed_heap_memory",
          @{lint: managed_heap_memory,
-           desc: ~"use of managed (@ type) heap memory",
+           desc: "use of managed (@ type) heap memory",
            default: allow}),
 
         (~"owned_heap_memory",
          @{lint: owned_heap_memory,
-           desc: ~"use of owned (~ type) heap memory",
+           desc: "use of owned (~ type) heap memory",
            default: allow}),
 
         (~"heap_memory",
          @{lint: heap_memory,
-           desc: ~"use of any (~ type or @ type) heap memory",
+           desc: "use of any (~ type or @ type) heap memory",
            default: allow}),
 
         (~"structural_records",
          @{lint: structural_records,
-           desc: ~"use of any structural records",
+           desc: "use of any structural records",
            default: allow}),
 
         (~"legacy modes",
          @{lint: legacy_modes,
-           desc: ~"allow legacy modes",
+           desc: "allow legacy modes",
            default: forbid}),
 
         (~"type_limits",
          @{lint: type_limits,
-           desc: ~"comparisons made useless by limits of the types involved",
+           desc: "comparisons made useless by limits of the types involved",
            default: warn}),
 
         (~"default_methods",
          @{lint: default_methods,
-           desc: ~"allow default methods",
+           desc: "allow default methods",
            default: deny}),
 
         (~"deprecated_self",
          @{lint: deprecated_self,
-           desc: ~"warn about deprecated uses of `self`",
+           desc: "warn about deprecated uses of `self`",
            default: allow}),
 
         /* FIXME(#3266)--make liveness warnings lintable
         (~"unused_variable",
          @{lint: unused_variable,
-           desc: ~"detect variables which are not used in any way",
+           desc: "detect variables which are not used in any way",
            default: warn}),
 
         (~"dead_assignment",
          @{lint: dead_assignment,
-           desc: ~"detect assignments that will never be read",
+           desc: "detect assignments that will never be read",
            default: warn}),
         */
     ];

branches/dist-snap/src/librustc/middle/ty.rs

@@ -33,6 +33,7 @@ use core::dvec::DVec;
 use core::dvec;
 use core::ops;
 use core::option;
+use core::ptr::to_unsafe_ptr;
 use core::result::Result;
 use core::result;
 use core::to_bytes;
@@ -304,18 +305,22 @@ impl creader_cache_key : to_bytes::IterBytes {
     }
 }
 
-type intern_key = {sty: sty, o_def_id: Option<ast::def_id>};
+type intern_key = {sty: *sty, o_def_id: Option<ast::def_id>};
 
 impl intern_key : cmp::Eq {
     pure fn eq(&self, other: &intern_key) -> bool {
-        (*self).sty == (*other).sty && (*self).o_def_id == (*other).o_def_id
+        unsafe {
+            *self.sty == *other.sty && self.o_def_id == other.o_def_id
+        }
     }
     pure fn ne(&self, other: &intern_key) -> bool { !(*self).eq(other) }
 }
 
 impl intern_key : to_bytes::IterBytes {
     pure fn iter_bytes(&self, +lsb0: bool, f: to_bytes::Cb) {
-        to_bytes::iter_bytes_2(&self.sty, &self.o_def_id, lsb0, f);
+        unsafe {
+            to_bytes::iter_bytes_2(&*self.sty, &self.o_def_id, lsb0, f);
+        }
     }
 }
 
@@ -1008,11 +1013,12 @@ fn mk_t(cx: ctxt, +st: sty) -> t { mk_t_with_id(cx, st, None) }
 // Interns a type/name combination, stores the resulting box in cx.interner,
 // and returns the box as cast to an unsafe ptr (see comments for t above).
 fn mk_t_with_id(cx: ctxt, +st: sty, o_def_id: Option<ast::def_id>) -> t {
-    let key = {sty: st, o_def_id: o_def_id};
+    let key = {sty: to_unsafe_ptr(&st), o_def_id: o_def_id};
     match cx.interner.find(key) {
       Some(t) => unsafe { return cast::reinterpret_cast(&t); },
       _ => ()
     }
+
     let mut flags = 0u;
     fn rflags(r: Region) -> uint {
         (has_regions as uint) | {
@@ -1028,42 +1034,46 @@ fn mk_t_with_id(cx: ctxt, +st: sty, o_def_id: Option<ast::def_id>) -> t {
         substs.self_r.iter(|r| f |= rflags(*r));
         return f;
     }
-    match st {
-      ty_estr(vstore_slice(r)) => {
+    match &st {
+      &ty_estr(vstore_slice(r)) => {
         flags |= rflags(r);
       }
-      ty_evec(mt, vstore_slice(r)) => {
+      &ty_evec(ref mt, vstore_slice(r)) => {
         flags |= rflags(r);
         flags |= get(mt.ty).flags;
       }
-      ty_nil | ty_bot | ty_bool | ty_int(_) | ty_float(_) | ty_uint(_) |
-      ty_estr(_) | ty_type | ty_opaque_closure_ptr(_) |
-      ty_opaque_box | ty_err => (),
-      ty_param(_) => flags |= has_params as uint,
-      ty_infer(_) => flags |= needs_infer as uint,
-      ty_self => flags |= has_self as uint,
-      ty_enum(_, ref substs) | ty_struct(_, ref substs)
-      | ty_trait(_, ref substs, _) => {
+      &ty_nil | &ty_bot | &ty_bool | &ty_int(_) | &ty_float(_) | &ty_uint(_) |
+      &ty_estr(_) | &ty_type | &ty_opaque_closure_ptr(_) |
+      &ty_opaque_box | &ty_err => (),
+      &ty_param(_) => flags |= has_params as uint,
+      &ty_infer(_) => flags |= needs_infer as uint,
+      &ty_self => flags |= has_self as uint,
+      &ty_enum(_, ref substs) | &ty_struct(_, ref substs) |
+      &ty_trait(_, ref substs, _) => {
         flags |= sflags(substs);
       }
-      ty_box(m) | ty_uniq(m) | ty_evec(m, _) |
-      ty_ptr(m) | ty_unboxed_vec(m) => {
+      &ty_box(ref m) | &ty_uniq(ref m) | &ty_evec(ref m, _) |
+      &ty_ptr(ref m) | &ty_unboxed_vec(ref m) => {
         flags |= get(m.ty).flags;
       }
-      ty_rptr(r, m) => {
+      &ty_rptr(r, ref m) => {
         flags |= rflags(r);
         flags |= get(m.ty).flags;
       }
-      ty_rec(flds) => for flds.each |f| { flags |= get(f.mt.ty).flags; },
-      ty_tup(ts) => for ts.each |tt| { flags |= get(*tt).flags; },
-      ty_fn(ref f) => {
+      &ty_rec(ref flds) => for flds.each |f| { flags |= get(f.mt.ty).flags; },
+      &ty_tup(ref ts) => for ts.each |tt| { flags |= get(*tt).flags; },
+      &ty_fn(ref f) => {
         flags |= rflags(f.meta.region);
         for f.sig.inputs.each |a| { flags |= get(a.ty).flags; }
         flags |= get(f.sig.output).flags;
       }
     }
-    let t = @{sty: st, id: cx.next_id, flags: flags, o_def_id: o_def_id};
-    cx.interner.insert(key, t);
+
+    let t = @{sty: move st, id: cx.next_id, flags: flags, o_def_id: o_def_id};
+
+    let key = {sty: to_unsafe_ptr(&t.sty), o_def_id: o_def_id};
+    cx.interner.insert(move key, t);
+
     cx.next_id += 1u;
     unsafe { cast::reinterpret_cast(&t) }
 }

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

@@ -54,6 +54,8 @@
 // terms of error reporting, although we do not do that properly right
 // now.
 
+#[warn(vecs_implicitly_copyable)];
+
 use middle::ty;
 use middle::ty::{FnTyBase, FnMeta, FnSig};
 use middle::typeck::infer::sub::Sub;