---

yaml
---
r: 49531
b: refs/heads/master
c: a919e5e
h: refs/heads/master
i:
  49529: 66ce92e
  49527: 57d9303
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 6f4273854438e8f9b034e1342f30392f70c0eaae
+refs/heads/master: a919e5ede5465cfab27cdc7cae59f2c015735753
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: f7a2371c176663d59062ec5158f39faecba45768
 refs/heads/try: 2a8fb58d79e685d5ca07b039badcf2ae3ef077ea

trunk/configure

@@ -136,17 +136,9 @@ validate_opt () {
                 isArgValid=1
             fi
         done
-        if [ "$arg" = "--help" ]
+        if test $isArgValid -eq 0
         then
-            echo ""
-            echo "No more help available for Configure options,"
-            echo "check the Uncyclo or join our IRC channel"
-            break
-        else
-            if test $isArgValid -eq 0
-            then
-                err "Option '$arg' is not recognized"
-            fi
+            err "Option '$arg' is not recognized"
         fi
     done
 }
@@ -274,42 +266,13 @@ case $CFG_OSTYPE in
     MINGW32*)
         CFG_OSTYPE=pc-mingw32
         ;;
-# Thad's Cygwin identifers below
-
-#   Vista 32 bit
-    CYGWIN_NT-6.0)
-        CFG_OSTYPE=pc-mingw32
-        CFG_CPUTYPE=i686
-        ;;
-
-#   Vista 64 bit
-    CYGWIN_NT-6.0-WOW64)
-        CFG_OSTYPE=w64-mingw32
-        CFG_CPUTYPE=x86_64
-        ;;
-
-#   Win 7 32 bit
-    CYGWIN_NT-6.1)
-        CFG_OSTYPE=pc-mingw32
-        CFG_CPUTYPE=i686
-        ;;
 
-#   Win 7 64 bit
-    CYGWIN_NT-6.1-WOW64)
-        CFG_OSTYPE=w64-mingw32
-        CFG_CPUTYPE=x86_64
-        ;;
-
-# We do not detect other OS such as XP/2003 using 64 bit using uname.
-# If we want to in the future, we will need to use Cygwin - Chuck's csih helper in /usr/lib/csih/winProductName.exe or alternative.
     *)
         err "unknown OS type: $CFG_OSTYPE"
         ;;
 esac
 
 
-if [ -z "$CFG_CPUTYPE" ]
-then
 case $CFG_CPUTYPE in
 
     i386 | i486 | i686 | i786 | x86)
@@ -327,7 +290,6 @@ case $CFG_CPUTYPE in
     *)
         err "unknown CPU type: $CFG_CPUTYPE"
 esac
-fi
 
 # Detect 64 bit linux systems with 32 bit userland and force 32 bit compilation
 if [ $CFG_OSTYPE = unknown-linux-gnu -a $CFG_CPUTYPE = x86_64 ]

trunk/src/librustc/metadata/cstore.rs

@@ -141,24 +141,28 @@ pub fn find_extern_mod_stmt_cnum(cstore: @mut CStore,
     extern_mod_crate_map.find(&emod_id)
 }
 
-// returns hashes of crates directly used by this crate. Hashes are
-// sorted by crate name.
+// returns hashes of crates directly used by this crate. Hashes are sorted by
+// (crate name, crate version, crate hash) in lexicographic order (not semver)
 pub fn get_dep_hashes(cstore: @mut CStore) -> ~[~str] {
-    struct crate_hash { name: @~str, hash: @~str }
+    struct crate_hash { name: @~str, vers: @~str, hash: @~str }
     let mut result = ~[];
 
     let extern_mod_crate_map = cstore.extern_mod_crate_map;
     for extern_mod_crate_map.each_value |&cnum| {
         let cdata = cstore::get_crate_data(cstore, cnum);
         let hash = decoder::get_crate_hash(cdata.data);
-        debug!("Add hash[%s]: %s", *cdata.name, *hash);
+        let vers = decoder::get_crate_vers(cdata.data);
+        debug!("Add hash[%s]: %s %s", *cdata.name, *vers, *hash);
         result.push(crate_hash {
             name: cdata.name,
+            vers: vers,
             hash: hash
         });
     }
 
-    let sorted = std::sort::merge_sort(result, |a, b| a.name <= b.name);
+    let sorted = do std::sort::merge_sort(result) |a, b| {
+        (a.name, a.vers, a.hash) <= (b.name, b.vers, b.hash)
+    };
 
     debug!("sorted:");
     for sorted.each |x| {

trunk/src/librustc/middle/resolve.rs

@@ -4741,8 +4741,8 @@ pub impl Resolver {
         let mut j = this.value_ribs.len();
         while j != 0 {
             j -= 1;
-            for this.value_ribs[j].bindings.each_entry |e| {
-                vec::push(&mut maybes, copy *this.session.str_of(e.key));
+            for this.value_ribs[j].bindings.each_key |&k| {
+                vec::push(&mut maybes, copy *this.session.str_of(k));
                 vec::push(&mut values, uint::max_value);
             }
         }

trunk/src/librustc/middle/typeck/coherence.rs

@@ -104,32 +104,6 @@ pub fn get_base_type(inference_context: @mut InferCtxt,
     }
 }
 
-pub fn type_is_defined_in_local_crate(original_type: t) -> bool {
-    /*!
-     *
-     * For coherence, when we have `impl Trait for Type`, we need to
-     * guarantee that `Type` is "local" to the
-     * crate.  For our purposes, this means that it must contain
-     * some nominal type defined in this crate.
-     */
-
-    let mut found_nominal = false;
-    do ty::walk_ty(original_type) |t| {
-        match get(t).sty {
-            ty_enum(def_id, _) |
-            ty_trait(def_id, _, _) |
-            ty_struct(def_id, _) => {
-                if def_id.crate == ast::local_crate {
-                    found_nominal = true;
-                }
-            }
-
-            _ => { }
-        }
-    }
-    return found_nominal;
-}
-
 // Returns the def ID of the base type, if there is one.
 pub fn get_base_type_def_id(inference_context: @mut InferCtxt,
                             span: span,
@@ -187,7 +161,8 @@ pub fn CoherenceChecker(crate_context: @mut CrateCtxt) -> CoherenceChecker {
         crate_context: crate_context,
         inference_context: new_infer_ctxt(crate_context.tcx),
 
-        base_type_def_ids: HashMap()
+        base_type_def_ids: HashMap(),
+        privileged_implementations: HashMap()
     }
 }
 
@@ -199,6 +174,11 @@ pub struct CoherenceChecker {
     // definition ID.
 
     base_type_def_ids: HashMap<def_id,def_id>,
+
+    // A set of implementations in privileged scopes; i.e. those
+    // implementations that are defined in the same scope as their base types.
+
+    privileged_implementations: HashMap<node_id,()>,
 }
 
 pub impl CoherenceChecker {
@@ -635,11 +615,27 @@ pub impl CoherenceChecker {
                         visit_mod(module_, item.span, item.id, (), visitor);
                     }
                     item_impl(_, opt_trait, _, _) => {
-                        // `for_ty` is `Type` in `impl Trait for Type`
-                        let for_ty =
-                            ty::node_id_to_type(self.crate_context.tcx,
-                                                item.id);
-                        if !type_is_defined_in_local_crate(for_ty) {
+                        let mut ok = false;
+                        match self.base_type_def_ids.find(
+                            &local_def(item.id)) {
+
+                            None => {
+                                // Nothing to do.
+                            }
+                            Some(base_type_def_id) => {
+                                // Check to see whether the implementation is
+                                // in the same crate as its base type.
+
+                                if base_type_def_id.crate == local_crate {
+                                    // Record that this implementation is OK.
+                                    self.privileged_implementations.insert
+                                        (item.id, ());
+                                    ok = true;
+                                }
+                            }
+                        }
+
+                        if !ok {
                             // This implementation is not in scope of its base
                             // type. This still might be OK if the trait is
                             // defined in the same crate.
@@ -659,24 +655,25 @@ pub impl CoherenceChecker {
                                                       implement a trait or \
                                                       new type instead");
                                 }
+                                _ => ()
+                          }
 
-                                Some(trait_ref) => {
-                                    // This is OK if and only if the trait was
-                                    // defined in this crate.
-
-                                    let trait_def_id =
-                                        self.trait_ref_to_trait_def_id(
-                                            trait_ref);
-
-                                    if trait_def_id.crate != local_crate {
-                                        let session = self.crate_context.tcx.sess;
-                                        session.span_err(item.span,
-                                                         ~"cannot provide an \
-                                                           extension \
-                                                           implementation for a \
-                                                           trait not defined in \
-                                                           this crate");
-                                    }
+                          for opt_trait.each |trait_ref| {
+                                // This is OK if and only if the trait was
+                                // defined in this crate.
+
+                                let trait_def_id =
+                                    self.trait_ref_to_trait_def_id(
+                                        *trait_ref);
+
+                                if trait_def_id.crate != local_crate {
+                                    let session = self.crate_context.tcx.sess;
+                                    session.span_err(item.span,
+                                                     ~"cannot provide an \
+                                                       extension \
+                                                       implementation for a \
+                                                       trait not defined in \
+                                                       this crate");
                                 }
                             }
                         }