---

yaml
---
r: 30234
b: refs/heads/incoming
c: 5b4d5ce
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: 3b554c1e0c46efcf0e55994fcd8fbc0c17b9c119
+refs/heads/incoming: 5b4d5cee03bdc297361f52b34e6e09b7b64161ea
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/rustc/middle/typeck/coherence.rs

@@ -147,18 +147,12 @@ struct CoherenceChecker {
 
     let privileged_implementations: hashmap<node_id,()>;
 
-    // The set of types that we are currently in the privileged scope of. This
-    // is used while we traverse the AST while checking privileged scopes.
-
-    let privileged_types: hashmap<def_id,()>;
-
     new(crate_context: @crate_ctxt) {
         self.crate_context = crate_context;
         self.inference_context = new_infer_ctxt(crate_context.tcx);
 
         self.base_type_def_ids = new_def_hash();
         self.privileged_implementations = int_hash();
-        self.privileged_types = new_def_hash();
     }
 
     // Create a mapping containing a MethodInfo for every provided
@@ -427,36 +421,12 @@ struct CoherenceChecker {
 
     // Privileged scope checking
     fn check_privileged_scopes(crate: @crate) {
-        // Gather up all privileged types.
-        let privileged_types =
-            self.gather_privileged_types(crate.node.module.items);
-        for privileged_types.each |privileged_type| {
-            self.privileged_types.insert(privileged_type, ());
-        }
-
         visit_crate(*crate, (), mk_vt(@{
             visit_item: |item, _context, visitor| {
                 match item.node {
                     item_mod(module_) => {
-                        // First, gather up all privileged types.
-                        let privileged_types =
-                            self.gather_privileged_types(module_.items);
-                        for privileged_types.each |privileged_type| {
-                            debug!("(checking privileged scopes) entering \
-                                    privileged scope of %d:%d",
-                                   privileged_type.crate,
-                                   privileged_type.node);
-
-                            self.privileged_types.insert(privileged_type, ());
-                        }
-
                         // Then visit the module items.
                         visit_mod(module_, item.span, item.id, (), visitor);
-
-                        // Finally, remove privileged types from the map.
-                        for privileged_types.each |privileged_type| {
-                            self.privileged_types.remove(privileged_type);
-                        }
                     }
                     item_impl(_, associated_traits, _, _) => {
                         match self.base_type_def_ids.find(
@@ -467,12 +437,9 @@ struct CoherenceChecker {
                             }
                             Some(base_type_def_id) => {
                                 // Check to see whether the implementation is
-                                // in the scope of its base type.
-
-                                let privileged_types = &self.privileged_types;
-                                if privileged_types.
-                                        contains_key(base_type_def_id) {
+                                // 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, ());
@@ -492,7 +459,7 @@ struct CoherenceChecker {
                                                          ~"cannot implement \
                                                           inherent methods \
                                                           for a type outside \
-                                                          the scope the type \
+                                                          the crate the type \
                                                           was defined in; \
                                                           define and \
                                                           implement a trait \
@@ -546,25 +513,6 @@ struct CoherenceChecker {
         return trait_id;
     }
 
-    fn gather_privileged_types(items: ~[@item]) -> @DVec<def_id> {
-        let results = @DVec();
-        for items.each |item| {
-            match item.node {
-                item_class(*) | item_enum(*) | item_trait(*) => {
-                    results.push(local_def(item.id));
-                }
-
-                item_const(*) | item_fn(*) | item_mod(*) |
-                item_foreign_mod(*) | item_ty(*) | item_impl(*) |
-                item_mac(*) => {
-                    // Nothing to do.
-                }
-            }
-        }
-
-        return results;
-    }
-
     // Converts an implementation in the AST to an Impl structure.
     fn create_impl_from_item(item: @item) -> @Impl {
 

branches/incoming/src/test/run-pass/coherence-impl-in-fn.rs

@@ -0,0 +1,6 @@
+fn main() {
+    enum x { foo }
+    impl x : core::cmp::Eq {
+        pure fn eq(&&other: x) -> bool { self as int == other as int }
+    }
+}