---

yaml
---
r: 63192
b: refs/heads/snap-stage3
c: febba9f
h: refs/heads/master
v: v3

Author: yichoi

[refs]

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

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

@@ -294,6 +294,18 @@ pub enum DuplicateCheckingMode {
     OverwriteDuplicates
 }
 
+// Returns the namespace associated with the given duplicate checking mode,
+// or fails for OverwriteDuplicates. This is used for error messages.
+pub fn namespace_for_duplicate_checking_mode(mode: DuplicateCheckingMode)
+                                          -> Namespace {
+    match mode {
+        ForbidDuplicateModules | ForbidDuplicateTypes |
+        ForbidDuplicateTypesAndValues => TypeNS,
+        ForbidDuplicateValues => ValueNS,
+        OverwriteDuplicates => fail!("OverwriteDuplicates has no namespace")
+    }
+}
+
 /// One local scope.
 pub struct Rib {
     bindings: @mut HashMap<ident,def_like>,
@@ -995,43 +1007,37 @@ impl Resolver {
                 //   nothing.
 
                 let mut is_duplicate = false;
-                let ns = match duplicate_checking_mode {
+                match duplicate_checking_mode {
                     ForbidDuplicateModules => {
-                        is_duplicate = child.get_module_if_available().is_some();
-                        Some(TypeNS)
+                        is_duplicate =
+                            child.get_module_if_available().is_some();
                     }
                     ForbidDuplicateTypes => {
                         match child.def_for_namespace(TypeNS) {
                             Some(def_mod(_)) | None => {}
                             Some(_) => is_duplicate = true
                         }
-                        Some(TypeNS)
                     }
                     ForbidDuplicateValues => {
                         is_duplicate = child.defined_in_namespace(ValueNS);
-                        Some(ValueNS)
                     }
                     ForbidDuplicateTypesAndValues => {
-                        let mut n = None;
                         match child.def_for_namespace(TypeNS) {
                             Some(def_mod(_)) | None => {}
-                            Some(_) => {
-                                n = Some(TypeNS);
-                                is_duplicate = true;
-                            }
+                            Some(_) => is_duplicate = true
                         };
                         if child.defined_in_namespace(ValueNS) {
                             is_duplicate = true;
-                            n = Some(ValueNS);
                         }
-                        n
                     }
-                    OverwriteDuplicates => None
-                };
-                if is_duplicate {
+                    OverwriteDuplicates => {}
+                }
+                if duplicate_checking_mode != OverwriteDuplicates &&
+                        is_duplicate {
                     // Return an error here by looking up the namespace that
                     // had the duplicate.
-                    let ns = ns.unwrap();
+                    let ns = namespace_for_duplicate_checking_mode(
+                        duplicate_checking_mode);
                     self.session.span_err(sp,
                         fmt!("duplicate definition of %s `%s`",
                              namespace_to_str(ns),
@@ -1189,22 +1195,22 @@ impl Resolver {
 
             // These items live in both the type and value namespaces.
             item_struct(struct_def, _) => {
-                // Adding to both Type and Value namespaces or just Type?
-                let (forbid, ctor_id) = match struct_def.ctor_id {
-                    Some(ctor_id)   => (ForbidDuplicateTypesAndValues, Some(ctor_id)),
-                    None            => (ForbidDuplicateTypes, None)
-                };
-
-                let (name_bindings, new_parent) = self.add_child(ident, parent, forbid, sp);
+                let (name_bindings, new_parent) =
+                    self.add_child(ident, parent, ForbidDuplicateTypes, sp);
 
-                // Define a name in the type namespace.
-                name_bindings.define_type(privacy, def_ty(local_def(item.id)), sp);
+                name_bindings.define_type(
+                    privacy, def_ty(local_def(item.id)), sp);
 
-                // If this is a newtype or unit-like struct, define a name
-                // in the value namespace as well
-                do ctor_id.while_some |cid| {
-                    name_bindings.define_value(privacy, def_struct(local_def(cid)), sp);
-                    None
+                // If this struct is tuple-like or enum-like, define a name
+                // in the value namespace.
+                match struct_def.ctor_id {
+                    None => {}
+                    Some(ctor_id) => {
+                        name_bindings.define_value(
+                            privacy,
+                            def_struct(local_def(ctor_id)),
+                            sp);
+                    }
                 }
 
                 // Record the def ID of this struct.

branches/snap-stage3/src/rt/rust_android_dummy.cpp

@@ -76,4 +76,11 @@ extern "C" void globfree(glob_t *pglob)
 {
 }
 
+extern "C" int pthread_atfork(void (*prefork)(void),
+                              void (*postfork_parent)(void),
+                              void (*postfork_child)(void))
+{
+    return 0;
+}
+
 #endif