---

yaml
---
r: 63663
b: refs/heads/snap-stage3
c: 5e26808
h: refs/heads/master
i:
  63661: 166b9cf
  63659: c52460e
  63655: 10cce62
  63647: 7814297
v: v3

Author: msullivan

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 92424f0670723e417a96a96310a6ad871994c6b7
+refs/heads/snap-stage3: 5e26808141592354a4c9ab28a7e2190e9acf8942
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/Makefile.in

@@ -239,29 +239,29 @@ $(foreach target,$(CFG_TARGET_TRIPLES),\
 # Standard library variables
 ######################################################################
 
-STDLIB_CRATE := $(S)src/libstd/std.rs
+STDLIB_CRATE := $(S)src/libstd/core.rc
 STDLIB_INPUTS := $(wildcard $(addprefix $(S)src/libstd/,        \
-                                           *.rs */*.rs */*/*rs */*/*/*rs))
+                                           core.rc *.rs */*.rs */*/*rs */*/*/*rs))
 
 ######################################################################
 # Extra library variables
 ######################################################################
 
-EXTRALIB_CRATE := $(S)src/libextra/extra.rs
+EXTRALIB_CRATE := $(S)src/libextra/std.rc
 EXTRALIB_INPUTS := $(wildcard $(addprefix $(S)src/libextra/,          \
-                                          *.rs */*.rs))
+                                          std.rc *.rs */*.rs))
 
 ######################################################################
 # rustc crate variables
 ######################################################################
 
-COMPILER_CRATE := $(S)src/librustc/rustc.rs
+COMPILER_CRATE := $(S)src/librustc/rustc.rc
 COMPILER_INPUTS := $(wildcard $(addprefix $(S)src/librustc/,      \
-                           *.rs */*.rs */*/*.rs */*/*/*.rs))
+                           rustc.rc *.rs */*.rs */*/*.rs */*/*/*.rs))
 
-LIBSYNTAX_CRATE := $(S)src/libsyntax/syntax.rs
+LIBSYNTAX_CRATE := $(S)src/libsyntax/syntax.rc
 LIBSYNTAX_INPUTS := $(wildcard $(addprefix $(S)src/libsyntax/, \
-                           *.rs */*.rs */*/*.rs))
+                            syntax.rc *.rs */*.rs */*/*.rs))
 
 DRIVER_CRATE := $(S)src/driver/driver.rs
 

branches/snap-stage3/mk/tools.mk

@@ -12,23 +12,23 @@
 # and host architectures
 
 # The test runner that runs the cfail/rfail/rpass and bxench tests
-COMPILETEST_CRATE := $(S)src/compiletest/compiletest.rs
-COMPILETEST_INPUTS := $(wildcard $(S)src/compiletest/*.rs)
+COMPILETEST_CRATE := $(S)src/compiletest/compiletest.rc
+COMPILETEST_INPUTS := $(wildcard $(S)src/compiletest/*rs)
 
 # Rustpkg, the package manager and build system
-RUSTPKG_LIB := $(S)src/librustpkg/rustpkg.rs
-RUSTPKG_INPUTS := $(wildcard $(S)src/librustpkg/*.rs)
+RUSTPKG_LIB := $(S)src/librustpkg/rustpkg.rc
+RUSTPKG_INPUTS := $(wildcard $(S)src/librustpkg/*rs)
 
 # Rustdoc, the documentation tool
-RUSTDOC_LIB := $(S)src/librustdoc/rustdoc.rs
+RUSTDOC_LIB := $(S)src/librustdoc/rustdoc.rc
 RUSTDOC_INPUTS := $(wildcard $(S)src/librustdoc/*.rs)
 
 # Rusti, the JIT REPL
-RUSTI_LIB := $(S)src/librusti/rusti.rs
+RUSTI_LIB := $(S)src/librusti/rusti.rc
 RUSTI_INPUTS := $(wildcard $(S)src/librusti/*.rs)
 
 # Rust, the convenience tool
-RUST_LIB := $(S)src/librust/rust.rs
+RUST_LIB := $(S)src/librust/rust.rc
 RUST_INPUTS := $(wildcard $(S)src/librust/*.rs)
 
 # FIXME: These are only built for the host arch. Eventually we'll

branches/snap-stage3/src/compiletest/compiletest.rs renamed to branches/snap-stage3/src/compiletest/compiletest.rc

@@ -70,10 +70,12 @@ impl<T> Rc<T> {
 impl<T> Drop for Rc<T> {
     fn finalize(&self) {
         unsafe {
-            (*self.ptr).count -= 1;
-            if (*self.ptr).count == 0 {
-                ptr::replace_ptr(self.ptr, intrinsics::uninit());
-                free(self.ptr as *c_void)
+            if self.ptr.is_not_null() {
+                (*self.ptr).count -= 1;
+                if (*self.ptr).count == 0 {
+                    ptr::replace_ptr(self.ptr, intrinsics::uninit());
+                    free(self.ptr as *c_void)
+                }
             }
         }
     }
@@ -220,10 +222,12 @@ impl<T> RcMut<T> {
 impl<T> Drop for RcMut<T> {
     fn finalize(&self) {
         unsafe {
-            (*self.ptr).count -= 1;
-            if (*self.ptr).count == 0 {
-                ptr::replace_ptr(self.ptr, uninit());
-                free(self.ptr as *c_void)
+            if self.ptr.is_not_null() {
+                (*self.ptr).count -= 1;
+                if (*self.ptr).count == 0 {
+                    ptr::replace_ptr(self.ptr, uninit());
+                    free(self.ptr as *c_void)
+                }
             }
         }
     }

branches/snap-stage3/src/libextra/rc.rs

@@ -24,11 +24,6 @@ use syntax::ast;
 use syntax::ast_map;
 use syntax::diagnostic::expect;
 
-pub struct ProvidedTraitMethodInfo {
-    ty: ty::Method,
-    def_id: ast::def_id
-}
-
 pub struct StaticMethodInfo {
     ident: ast::ident,
     def_id: ast::def_id,
@@ -134,7 +129,7 @@ pub fn get_trait_method_def_ids(cstore: @mut cstore::CStore,
 
 pub fn get_provided_trait_methods(tcx: ty::ctxt,
                                   def: ast::def_id)
-                               -> ~[ProvidedTraitMethodInfo] {
+                               -> ~[@ty::Method] {
     let cstore = tcx.cstore;
     let cdata = cstore::get_crate_data(cstore, def.crate);
     decoder::get_provided_trait_methods(cstore.intr, cdata, def.node, tcx)

branches/snap-stage3/src/libextra/extra.rs renamed to branches/snap-stage3/src/libextra/std.rc

@@ -14,7 +14,7 @@ use core::prelude::*;
 
 use metadata::cstore::crate_metadata;
 use metadata::common::*;
-use metadata::csearch::{ProvidedTraitMethodInfo, StaticMethodInfo};
+use metadata::csearch::StaticMethodInfo;
 use metadata::csearch;
 use metadata::cstore;
 use metadata::decoder;
@@ -752,7 +752,7 @@ pub fn get_trait_method_def_ids(cdata: cmd,
 
 pub fn get_provided_trait_methods(intr: @ident_interner, cdata: cmd,
                                   id: ast::node_id, tcx: ty::ctxt) ->
-        ~[ProvidedTraitMethodInfo] {
+        ~[@ty::Method] {
     let data = cdata.data;
     let item = lookup_item(id, data);
     let mut result = ~[];
@@ -763,13 +763,8 @@ pub fn get_provided_trait_methods(intr: @ident_interner, cdata: cmd,
 
         if item_method_sort(mth) != 'p' { loop; }
 
-        let ty_method = get_method(intr, cdata, did.node, tcx);
-        let provided_trait_method_info = ProvidedTraitMethodInfo {
-            ty: ty_method,
-            def_id: did
-        };
-
-        vec::push(&mut result, provided_trait_method_info);
+        vec::push(&mut result,
+                  @get_method(intr, cdata, did.node, tcx));
     }
 
     return result;

branches/snap-stage3/src/librust/rust.rs renamed to branches/snap-stage3/src/librust/rust.rc

@@ -96,8 +96,6 @@ pub enum lint {
 
     missing_doc,
     unreachable_code,
-
-    warnings,
 }
 
 pub fn level_to_str(lv: level) -> &'static str {
@@ -282,13 +280,6 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         desc: "detects unreachable code",
         default: warn
     }),
-
-    ("warnings",
-     LintSpec {
-        lint: warnings,
-        desc: "mass-change the level for lints which produce warnings",
-        default: warn
-    }),
 ];
 
 /*
@@ -371,11 +362,10 @@ impl Context {
 
     fn span_lint(&self, lint: lint, span: span, msg: &str) {
         let (level, src) = match self.curr.find(&(lint as uint)) {
-            None => { return }
-            Some(&(warn, src)) => (self.get_level(warnings), src),
             Some(&pair) => pair,
+            None => { return; }
         };
-        if level == allow { return }
+        if level == allow { return; }
 
         let mut note = None;
         let msg = match src {

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

@@ -135,7 +135,7 @@ fn represent_type_uncached(cx: &mut CrateContext, t: ty::t) -> Repr {
                 ty::lookup_field_type(cx.tcx, def_id, field.id, substs)
             };
             let packed = ty::lookup_packed(cx.tcx, def_id);
-            let dtor = ty::ty_dtor(cx.tcx, def_id).is_present();
+            let dtor = ty::ty_dtor(cx.tcx, def_id).has_drop_flag();
             let ftys =
                 if dtor { ftys + [ty::mk_bool()] } else { ftys };
             return Univariant(mk_struct(cx, ftys, packed), dtor)

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

@@ -404,13 +404,8 @@ pub fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) {
     build_return(bcx);
 }
 
-pub fn trans_struct_drop(bcx: block,
-                         t: ty::t,
-                         v0: ValueRef,
-                         dtor_did: ast::def_id,
-                         class_did: ast::def_id,
-                         substs: &ty::substs)
-                      -> block {
+pub fn trans_struct_drop_flag(bcx: block, t: ty::t, v0: ValueRef, dtor_did: ast::def_id,
+                              class_did: ast::def_id, substs: &ty::substs) -> block {
     let repr = adt::represent_type(bcx.ccx(), t);
     let drop_flag = adt::trans_drop_flag_ptr(bcx, repr, v0);
     do with_cond(bcx, IsNotNull(bcx, Load(bcx, drop_flag))) |cx| {
@@ -452,6 +447,43 @@ pub fn trans_struct_drop(bcx: block,
     }
 }
 
+pub fn trans_struct_drop(mut bcx: block, t: ty::t, v0: ValueRef, dtor_did: ast::def_id,
+                         class_did: ast::def_id, substs: &ty::substs) -> block {
+    let repr = adt::represent_type(bcx.ccx(), t);
+
+    // Find and call the actual destructor
+    let dtor_addr = get_res_dtor(bcx.ccx(), dtor_did,
+                                 class_did, /*bad*/copy substs.tps);
+
+    // The second argument is the "self" argument for drop
+    let params = unsafe {
+        let ty = Type::from_ref(llvm::LLVMTypeOf(dtor_addr));
+        ty.element_type().func_params()
+    };
+
+    // Class dtors have no explicit args, so the params should
+    // just consist of the environment (self)
+    assert_eq!(params.len(), 1);
+
+    // Take a reference to the class (because it's using the Drop trait),
+    // do so now.
+    let llval = alloca(bcx, val_ty(v0));
+    Store(bcx, v0, llval);
+
+    let self_arg = PointerCast(bcx, llval, params[0]);
+    let args = ~[self_arg];
+
+    Call(bcx, dtor_addr, args);
+
+    // Drop the fields
+    let field_tys = ty::struct_fields(bcx.tcx(), class_did, substs);
+    for field_tys.iter().enumerate().advance |(i, fld)| {
+        let llfld_a = adt::trans_field_ptr(bcx, repr, v0, 0, i);
+        bcx = drop_ty(bcx, llfld_a, fld.mt.ty);
+    }
+
+    bcx
+}
 
 pub fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) {
     // NB: v0 is an *alias* of type t here, not a direct value.
@@ -472,7 +504,10 @@ pub fn make_drop_glue(bcx: block, v0: ValueRef, t: ty::t) {
       ty::ty_struct(did, ref substs) => {
         let tcx = bcx.tcx();
         match ty::ty_dtor(tcx, did) {
-          ty::TraitDtor(dtor) => {
+          ty::TraitDtor(dtor, true) => {
+            trans_struct_drop_flag(bcx, t, v0, dtor, did, substs)
+          }
+          ty::TraitDtor(dtor, false) => {
             trans_struct_drop(bcx, t, v0, dtor, did, substs)
           }
           ty::NoDtor => {
@@ -592,6 +627,23 @@ pub fn make_take_glue(bcx: block, v: ValueRef, t: ty::t) {
       ty::ty_opaque_closure_ptr(ck) => {
         closure::make_opaque_cbox_take_glue(bcx, ck, v)
       }
+      ty::ty_struct(did, ref substs) => {
+        let tcx = bcx.tcx();
+        let bcx = iter_structural_ty(bcx, v, t, take_ty);
+
+        match ty::ty_dtor(tcx, did) {
+          ty::TraitDtor(dtor, false) => {
+            // Zero out the struct
+            unsafe {
+                let ty = Type::from_ref(llvm::LLVMTypeOf(v));
+                memzero(bcx, v, ty);
+            }
+
+          }
+          _ => { }
+        }
+        bcx
+      }
       _ if ty::type_is_structural(t) => {
         iter_structural_ty(bcx, v, t, take_ty)
       }

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

@@ -3649,21 +3649,21 @@ pub fn def_has_ty_params(def: ast::def) -> bool {
     }
 }
 
-pub fn provided_trait_methods(cx: ctxt, id: ast::def_id) -> ~[ast::ident] {
+pub fn provided_trait_methods(cx: ctxt, id: ast::def_id) -> ~[@Method] {
     if is_local(id) {
         match cx.items.find(&id.node) {
             Some(&ast_map::node_item(@ast::item {
                         node: item_trait(_, _, ref ms),
                         _
                     }, _)) =>
                 match ast_util::split_trait_methods(*ms) {
-                   (_, p) => p.map(|method| method.ident)
+                   (_, p) => p.map(|m| method(cx, ast_util::local_def(m.id)))
                 },
             _ => cx.sess.bug(fmt!("provided_trait_methods: %? is not a trait",
                                   id))
         }
     } else {
-        csearch::get_provided_trait_methods(cx, id).map(|ifo| ifo.ty.ident)
+        csearch::get_provided_trait_methods(cx, id)
     }
 }
 
@@ -3852,7 +3852,7 @@ pub fn item_path_str(cx: ctxt, id: ast::def_id) -> ~str {
 
 pub enum DtorKind {
     NoDtor,
-    TraitDtor(def_id)
+    TraitDtor(def_id, bool)
 }
 
 impl DtorKind {
@@ -3866,13 +3866,24 @@ impl DtorKind {
     pub fn is_present(&const self) -> bool {
         !self.is_not_present()
     }
+
+    pub fn has_drop_flag(&self) -> bool {
+        match self {
+            &NoDtor => false,
+            &TraitDtor(_, flag) => flag
+        }
+    }
 }
 
 /* If struct_id names a struct with a dtor, return Some(the dtor's id).
    Otherwise return none. */
 pub fn ty_dtor(cx: ctxt, struct_id: def_id) -> DtorKind {
     match cx.destructor_for_type.find(&struct_id) {
-        Some(&method_def_id) => TraitDtor(method_def_id),
+        Some(&method_def_id) => {
+            let flag = !has_attr(cx, struct_id, "no_drop_flag");
+
+            TraitDtor(method_def_id, flag)
+        }
         None => NoDtor,
     }
 }