---

yaml
---
r: 143098
b: refs/heads/try2
c: a74d92e
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 40a48e62c1c72090dc00fa50dc7c6d3da8c9ab88
+refs/heads/try2: a74d92e8ab61863876d2b5b6256b403efbb55492
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/target.mk

@@ -17,7 +17,8 @@ export CFG_COMPILER_TRIPLE
 # code, make sure that these common warnings are denied by default. These can
 # be overridden during development temporarily. For stage0, we allow all these
 # to suppress warnings which may be bugs in stage0 (should be fixed in stage1+)
-WFLAGS_ST0 = -A warnings
+# NOTE: add "-A warnings" after snapshot to WFLAGS_ST0
+WFLAGS_ST0 = -A unrecognized-lint
 WFLAGS_ST1 = -D warnings
 WFLAGS_ST2 = -D warnings
 

branches/try2/src/etc/extract-tests.py

@@ -60,6 +60,9 @@
             if not re.search(r"\bextern mod extra\b", block):
                 block = "extern mod extra;\n" + block
             block = """#[ forbid(ctypes) ];
+#[ forbid(deprecated_pattern) ];
+#[ forbid(implicit_copies) ];
+#[ forbid(non_implicitly_copyable_typarams) ];
 #[ forbid(path_statement) ];
 #[ forbid(type_limits) ];
 #[ forbid(unrecognized_lint) ];

branches/try2/src/etc/zsh/_rust

@@ -33,9 +33,12 @@ _rustc_opts_switches=(
 )
 _rustc_opts_lint=(
     'path-statement[path statements with no effect]'
+    'deprecated-pattern[warn about deprecated uses of pattern bindings]'
+    'non-implicitly-copyable-typarams[passing non implicitly copyable types as copy type params]'
     'missing-trait-doc[detects missing documentation for traits]'
     'missing-struct-doc[detects missing documentation for structs]'
     'ctypes[proper use of core::libc types in foreign modules]'
+    'implicit-copies[implicit copies of non implicitly copyable data]'
     "unused-mut[detect mut variables which don't need to be mutable]"
     'unused-imports[imports that are never used]'
     'heap-memory[use of any (~ type or @ type) heap memory]'

branches/try2/src/libextra/arc.rs

@@ -305,6 +305,7 @@ struct RWARCInner<T> { priv lock: RWlock, priv failed: bool, priv data: T }
  *
  * Unlike mutex_arcs, rw_arcs are safe, because they cannot be nested.
  */
+#[mutable] // XXX remove after snap
 #[no_freeze]
 struct RWARC<T> {
     priv x: UnsafeAtomicRcBox<RWARCInner<T>>,

branches/try2/src/libextra/arena.rs

@@ -46,7 +46,15 @@ use std::sys;
 use std::uint;
 use std::vec;
 use std::unstable::intrinsics;
-use std::unstable::intrinsics::{TyDesc, get_tydesc};
+use std::unstable::intrinsics::{TyDesc};
+
+#[cfg(not(stage0))]
+use std::unstable::intrinsics::{get_tydesc};
+
+#[cfg(stage0)]
+unsafe fn get_tydesc<T>() -> *TyDesc {
+    intrinsics::get_tydesc::<T>() as *TyDesc
+}
 
 // The way arena uses arrays is really deeply awful. The arrays are
 // allocated, and have capacities reserved, but the fill for the array
@@ -57,6 +65,7 @@ struct Chunk {
     is_pod: bool,
 }
 
+#[mutable] // XXX remove after snap
 #[no_freeze]
 pub struct Arena {
     // The head is separated out from the list as a unbenchmarked
@@ -108,6 +117,19 @@ fn round_up_to(base: uint, align: uint) -> uint {
     (base + (align - 1)) & !(align - 1)
 }
 
+#[inline]
+#[cfg(not(stage0))]
+unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) {
+    // This function should be inlined when stage0 is gone
+    ((*tydesc).drop_glue)(data);
+}
+
+#[inline]
+#[cfg(stage0)]
+unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) {
+    ((*tydesc).drop_glue)(0 as **TyDesc, data);
+}
+
 // Walk down a chunk, running the destructors for any objects stored
 // in it.
 unsafe fn destroy_chunk(chunk: &Chunk) {
@@ -127,7 +149,7 @@ unsafe fn destroy_chunk(chunk: &Chunk) {
         //debug!("freeing object: idx = %u, size = %u, align = %u, done = %b",
         //       start, size, align, is_done);
         if is_done {
-            ((*tydesc).drop_glue)(ptr::offset(buf, start) as *i8);
+            call_drop_glue(tydesc, ptr::offset(buf, start) as *i8);
         }
 
         // Find where the next tydesc lives

branches/try2/src/libextra/dbg.rs

@@ -13,9 +13,15 @@
 #[allow(missing_doc)];
 
 use std::cast::transmute;
+#[cfg(stage0)]
+use intrinsic::{get_tydesc};
+#[cfg(not(stage0))]
 use std::unstable::intrinsics::{get_tydesc};
 
 pub mod rustrt {
+    #[cfg(stage0)]
+    use intrinsic::{TyDesc};
+    #[cfg(not(stage0))]
     use std::unstable::intrinsics::{TyDesc};
 
     #[abi = "cdecl"]

branches/try2/src/libextra/rc.rs

@@ -166,7 +166,9 @@ struct RcMutBox<T> {
 }
 
 /// Mutable reference counted pointer type
+#[non_owned]
 #[no_send]
+#[mutable] // XXX remove after snap
 #[no_freeze]
 #[unsafe_no_drop_flag]
 pub struct RcMut<T> {

branches/try2/src/libextra/rl.rs

@@ -68,7 +68,10 @@ pub unsafe fn read(prompt: &str) -> Option<~str> {
 
 pub type CompletionCb = @fn(~str, @fn(~str));
 
+#[cfg(not(stage0))]
 static complete_key: local_data::Key<@CompletionCb> = &local_data::Key;
+#[cfg(stage0)]
+fn complete_key(_: @CompletionCb) {}
 
 /// Bind to the main completion callback
 pub unsafe fn complete(cb: CompletionCb) {

branches/try2/src/librustc/back/link.rs

@@ -106,6 +106,7 @@ pub mod jit {
     use metadata::cstore;
 
     use std::cast;
+    #[cfg(not(stage0))]
     use std::local_data;
     use std::unstable::intrinsics;
 
@@ -203,15 +204,22 @@ pub mod jit {
 
     // The stage1 compiler won't work, but that doesn't really matter. TLS
     // changed only very recently to allow storage of owned values.
+    #[cfg(not(stage0))]
     static engine_key: local_data::Key<~Engine> = &local_data::Key;
 
+    #[cfg(not(stage0))]
     fn set_engine(engine: ~Engine) {
         local_data::set(engine_key, engine)
     }
+    #[cfg(stage0)]
+    fn set_engine(_: ~Engine) {}
 
+    #[cfg(not(stage0))]
     pub fn consume_engine() -> Option<~Engine> {
         local_data::pop(engine_key)
     }
+    #[cfg(stage0)]
+    pub fn consume_engine() -> Option<~Engine> { None }
 }
 
 pub mod write {

branches/try2/src/librustc/middle/lint.rs

@@ -75,7 +75,9 @@ pub enum lint {
     unnecessary_qualification,
     while_true,
     path_statement,
+    implicit_copies,
     unrecognized_lint,
+    deprecated_pattern,
     non_camel_case_types,
     non_uppercase_statics,
     type_limits,
@@ -180,6 +182,20 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         default: warn
      }),
 
+    ("implicit_copies",
+     LintSpec {
+        lint: implicit_copies,
+        desc: "implicit copies of non implicitly copyable data",
+        default: warn
+     }),
+
+    ("deprecated_pattern",
+     LintSpec {
+        lint: deprecated_pattern,
+        desc: "warn about deprecated uses of pattern bindings",
+        default: allow
+     }),
+
     ("non_camel_case_types",
      LintSpec {
         lint: non_camel_case_types,

branches/try2/src/librustc/middle/trans/base.rs

@@ -90,7 +90,10 @@ use syntax::abi::{X86, X86_64, Arm, Mips};
 
 pub use middle::trans::context::task_llcx;
 
+#[cfg(not(stage0))]
 static task_local_insn_key: local_data::Key<@~[&'static str]> = &local_data::Key;
+#[cfg(stage0)]
+fn task_local_insn_key(_: @~[&'static str]) {}
 
 pub fn with_insn_ctxt(blk: &fn(&[&'static str])) {
     let opt = local_data::get(task_local_insn_key, |k| k.map(|&k| *k));

branches/try2/src/librustc/middle/trans/context.rs

@@ -236,6 +236,9 @@ impl Drop for CrateContext {
     }
 }
 
+#[cfg(stage0)]
+fn task_local_llcx_key(_v: @ContextRef) {}
+#[cfg(not(stage0))]
 static task_local_llcx_key: local_data::Key<@ContextRef> = &local_data::Key;
 
 pub fn task_llcx() -> ContextRef {

branches/try2/src/librustc/middle/trans/debuginfo.rs

@@ -607,6 +607,9 @@ fn tuple_metadata(cx: &mut CrateContext,
         span);
 }
 
+// The stage0 snapshot does not yet support the fixes from PR #7557, so there are two versions of
+// following function for now
+#[cfg(not(stage0))]
 fn enum_metadata(cx: &mut CrateContext,
                  enum_type: ty::t,
                  enum_def_id: ast::def_id,
@@ -769,6 +772,142 @@ fn enum_metadata(cx: &mut CrateContext,
     }
 }
 
+#[cfg(stage0)]
+fn enum_metadata(cx: &mut CrateContext,
+                 enum_type: ty::t,
+                 enum_def_id: ast::def_id,
+                 substs: &ty::substs,
+                 span: span)
+              -> DIType {
+
+    let enum_name = ty_to_str(cx.tcx, enum_type);
+
+    // For empty enums there is an early exit. Just describe it as an empty struct with the
+    // appropriate type name
+    if ty::type_is_empty(cx.tcx, enum_type) {
+        return composite_type_metadata(cx, Type::nil(), enum_name, &[], &[], &[], span);
+    }
+
+    // Prepare some data (llvm type, size, align, ...) about the discriminant. This data will be
+    // needed in all of the following cases.
+    let discriminant_llvm_type = Type::enum_discrim(cx);
+    let (discriminant_size, discriminant_align) = size_and_align_of(cx, discriminant_llvm_type);
+
+    assert!(Type::enum_discrim(cx) == cx.int_type);
+    let discriminant_type_metadata = type_metadata(cx, ty::mk_int(), span);
+
+    let variants: &[@ty::VariantInfo] = *ty::enum_variants(cx.tcx, enum_def_id);
+
+    let enumerators_metadata: ~[DIDescriptor] = variants
+        .iter()
+        .transform(|v| {
+            let name: &str = cx.sess.str_of(v.name);
+            let discriminant_value = v.disr_val as c_ulonglong;
+
+            do name.as_c_str |name| {
+                unsafe {
+                    llvm::LLVMDIBuilderCreateEnumerator(
+                        DIB(cx),
+                        name,
+                        discriminant_value)
+                }
+            }
+        })
+        .collect();
+
+    let loc = span_start(cx, span);
+    let file_metadata = file_metadata(cx, loc.file.name);
+
+    let discriminant_type_metadata = do enum_name.as_c_str |enum_name| {
+        unsafe {
+            llvm::LLVMDIBuilderCreateEnumerationType(
+                DIB(cx),
+                file_metadata,
+                enum_name,
+                file_metadata,
+                loc.line as c_uint,
+                bytes_to_bits(discriminant_size),
+                bytes_to_bits(discriminant_align),
+                create_DIArray(DIB(cx), enumerators_metadata),
+                discriminant_type_metadata)
+        }
+    };
+
+    if ty::type_is_c_like_enum(cx.tcx, enum_type) {
+        return discriminant_type_metadata;
+    }
+
+    let is_univariant = variants.len() == 1;
+
+    let variants_metadata = do variants.map |&vi| {
+
+        let raw_types: &[ty::t] = vi.args;
+        let arg_types = do raw_types.map |&raw_type| { ty::subst(cx.tcx, substs, raw_type) };
+
+        let mut arg_llvm_types = do arg_types.map |&ty| { type_of::type_of(cx, ty) };
+        let mut arg_names = match vi.arg_names {
+            Some(ref names) => do names.map |ident| { cx.sess.str_of(*ident).to_owned() },
+            None => do arg_types.map |_| { ~"" }
+        };
+
+        let mut arg_metadata = do arg_types.map |&ty| { type_metadata(cx, ty, span) };
+
+        if !is_univariant {
+            arg_llvm_types.insert(0, discriminant_llvm_type);
+            arg_names.insert(0, ~"");
+            arg_metadata.insert(0, discriminant_type_metadata);
+        }
+
+        let variant_llvm_type = Type::struct_(arg_llvm_types, false);
+        let (variant_type_size, variant_type_align) = size_and_align_of(cx, variant_llvm_type);
+
+        let variant_type_metadata = composite_type_metadata(
+            cx,
+            variant_llvm_type,
+            &"",
+            arg_llvm_types,
+            arg_names,
+            arg_metadata,
+            span);
+
+        do "".as_c_str |name| {
+            unsafe {
+                llvm::LLVMDIBuilderCreateMemberType(
+                    DIB(cx),
+                    file_metadata,
+                    name,
+                    file_metadata,
+                    loc.line as c_uint,
+                    bytes_to_bits(variant_type_size),
+                    bytes_to_bits(variant_type_align),
+                    bytes_to_bits(0),
+                    0,
+                    variant_type_metadata)
+            }
+        }
+    };
+
+    let enum_llvm_type = type_of::type_of(cx, enum_type);
+    let (enum_type_size, enum_type_align) = size_and_align_of(cx, enum_llvm_type);
+
+    return do enum_name.as_c_str |enum_name| {
+        unsafe {
+            llvm::LLVMDIBuilderCreateUnionType(
+                DIB(cx),
+                file_metadata,
+                enum_name,
+                file_metadata,
+                loc.line as c_uint,
+                bytes_to_bits(enum_type_size),
+                bytes_to_bits(enum_type_align),
+                0, // Flags
+                create_DIArray(DIB(cx), variants_metadata),
+                0) // RuntimeLang
+        }
+    };
+}
+
+
 /// Creates debug information for a composite type, that is, anything that results in a LLVM struct.
 ///
 /// Examples of Rust types to use this are: structs, tuples, boxes, vecs, and enums.

branches/try2/src/librustc/rustc.rs

@@ -17,6 +17,8 @@
 #[license = "MIT/ASL2"];
 #[crate_type = "lib"];
 
+#[deny(deprecated_pattern)];
+
 extern mod extra;
 extern mod syntax;