---

yaml
---
r: 23086
b: refs/heads/master
c: d67314d
h: refs/heads/master
v: v3

Author: alexrp

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: edf1d0c245e7ba4eed4be89101073d8515a0f129
+refs/heads/master: d67314d5fcfeb75da8281794f8e6af3583705c2f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/doc/rust.md

@@ -1927,13 +1927,15 @@ x <- copy y;
 
 The former is just more terse and familiar.
 
-#### Operator-assignment expressions
+#### Compound assignment expressions
 
 The `+`, `-`, `*`, `/`, `%`, `&`, `|`, `^`, `<<`, `>>`, and `>>>`
 operators may be composed with the `=` operator. The expression `lval
 OP= val` is equivalent to `lval = lval OP val`. For example, `x = x +
 1` may be written as `x += 1`.
 
+Any such expression always has the [`nil`](#primitive-types) type.
+
 #### Operator precedence
 
 The precedence of Rust binary operators is ordered as follows, going

trunk/src/rustc/middle/typeck.rs

@@ -79,7 +79,6 @@ export vtable_res;
 export vtable_origin;
 export method_static, method_param, method_trait;
 export vtable_static, vtable_param, vtable_trait;
-export provided_methods_map;
 
 #[auto_serialize]
 enum method_origin {
@@ -152,23 +151,15 @@ enum vtable_origin {
 
 type vtable_map = hashmap<ast::node_id, vtable_res>;
 
-// Stores information about provided methods, aka "default methods" in traits.
-// Maps from a trait's def_id to a MethodInfo about
-// that method in that trait.
-type provided_methods_map = hashmap<ast::node_id,
-                                    ~[@resolve3::MethodInfo]>;
-
 type ty_param_substs_and_ty = {substs: ty::substs, ty: ty::t};
 
-type crate_ctxt_ = {impl_map: resolve3::ImplMap,
+type ty_table = hashmap<ast::def_id, ty::t>;
 
-                    // A mapping from method call sites to traits that have
-                    // that method.
+type crate_ctxt_ = {impl_map: resolve3::ImplMap,
                     trait_map: resolve3::TraitMap,
                     method_map: method_map,
                     vtable_map: vtable_map,
                     coherence_info: @coherence::CoherenceInfo,
-                    provided_methods_map: provided_methods_map,
                     tcx: ty::ctxt};
 
 enum crate_ctxt {
@@ -311,7 +302,6 @@ fn check_crate(tcx: ty::ctxt,
                             method_map: std::map::int_hash(),
                             vtable_map: std::map::int_hash(),
                             coherence_info: @coherence::CoherenceInfo(),
-                            provided_methods_map: std::map::int_hash(),
                             tcx: tcx});
     collect::collect_item_types(ccx, crate);
     coherence::check_coherence(ccx, crate);

trunk/src/rustc/middle/typeck/check/method.rs

@@ -366,10 +366,10 @@ class lookup {
     }
 
     fn add_candidates_from_scope(use_assignability: bool) {
-
         // If we're using coherence and this is one of the method invocation
         // forms it supports, don't use this method; it'll result in lots of
         // multiple-methods-in-scope errors.
+
         if self.fcx.ccx.trait_map.contains_key(self.expr.id) {
             return;
         }

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

@@ -7,7 +7,7 @@
 import metadata::csearch::{each_path, get_impl_traits, get_impls_for_mod};
 import metadata::cstore::{cstore, iter_crate_data};
 import metadata::decoder::{dl_def, dl_field, dl_impl};
-import middle::resolve3::{Impl, MethodInfo};
+import middle::resolve3::Impl;
 import middle::ty::{get, lookup_item_type, subst, t, ty_box};
 import middle::ty::{ty_uniq, ty_ptr, ty_rptr, ty_enum};
 import middle::ty::{ty_class, ty_nil, ty_bot, ty_bool, ty_int, ty_uint};
@@ -108,16 +108,6 @@ fn get_base_type_def_id(inference_context: infer_ctxt,
     }
 }
 
-
-fn method_to_MethodInfo(ast_method: @method) -> @MethodInfo {
-    @{
-        did: local_def(ast_method.id),
-        n_tps: ast_method.tps.len(),
-        ident: ast_method.ident,
-        self_type: ast_method.self_ty.node
-    }
-}
-
 class CoherenceInfo {
     // Contains implementations of methods that are inherent to a type.
     // Methods in these implementations don't need to be exported.
@@ -161,70 +151,10 @@ class CoherenceChecker {
         self.privileged_types = new_def_hash();
     }
 
-    // Create a mapping containing a MethodInfo for every provided
-    // method in every trait.
-    fn build_provided_methods_map(crate: @crate) {
-
-        let pmm = self.crate_context.provided_methods_map;
-
-        visit_crate(*crate, (), mk_simple_visitor(@{
-            visit_item: |item| {
-                match item.node {
-                  item_trait(_, _, trait_methods) => {
-                    for trait_methods.each |trait_method| {
-                        debug!{"(building provided methods map) checking \
-                                trait `%s` with id %d", *item.ident, item.id};
-
-                        match trait_method {
-                            required(_) => { /* fall through */}
-                            provided(m) => {
-                                // For every provided method in the
-                                // trait, store a MethodInfo.
-                                let mi = method_to_MethodInfo(m);
-
-                                match pmm.find(item.id) {
-                                    some(mis) => {
-                                      // If the trait already has an
-                                      // entry in the
-                                      // provided_methods_map, we just
-                                      // need to add this method to
-                                      // that entry.
-                                      debug!{"(building provided \
-                                              methods map) adding \
-                                              method `%s` to entry for \
-                                              existing trait",
-                                              *mi.ident};
-                                      let mut method_infos = mis;
-                                      push(method_infos, mi);
-                                      pmm.insert(item.id, method_infos);
-                                    }
-                                    none => {
-                                      // If the trait doesn't have an
-                                      // entry yet, create one.
-                                      debug!{"(building provided \
-                                              methods map) creating new \
-                                              entry for method `%s`",
-                                              *mi.ident};
-                                      pmm.insert(item.id, ~[mi]);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                  }
-                  _ => {
-                    // Nothing to do.
-                  }
-                };
-            }
-            with *default_simple_visitor()
-        }));
-    }
-
     fn check_coherence(crate: @crate) {
-
         // Check implementations. This populates the tables containing the
         // inherent methods and extension methods.
+
         visit_crate(*crate, (), mk_simple_visitor(@{
             visit_item: |item| {
                 debug!{"(checking coherence) item '%s'", *item.ident};
@@ -257,6 +187,7 @@ class CoherenceChecker {
         // Bring in external crates. It's fine for this to happen after the
         // coherence checks, because we ensure by construction that no errors
         // can happen at link time.
+
         self.add_external_crates();
     }
 
@@ -272,8 +203,8 @@ class CoherenceChecker {
                    *item.ident};
 
             match get_base_type_def_id(self.inference_context,
-                                       item.span,
-                                       self_type.ty) {
+                                     item.span,
+                                     self_type.ty) {
                 none => {
                     let session = self.crate_context.tcx.sess;
                     session.span_err(item.span,
@@ -420,6 +351,7 @@ class CoherenceChecker {
     }
 
     // Privileged scope checking
+
     fn check_privileged_scopes(crate: @crate) {
         // Gather up all privileged types.
         let privileged_types =
@@ -498,13 +430,15 @@ class CoherenceChecker {
                                         // 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;
+                                        let def_map = self.crate_context.tcx
+                                            .def_map;
+                                        let trait_def = def_map.get
+                                            (trait_ref.ref_id);
+                                        let trait_id =
+                                            def_id_of_def(trait_def);
+                                        if trait_id.crate != local_crate {
+                                            let session = self.crate_context
+                                                .tcx.sess;
                                             session.span_err(item.span,
                                                              ~"cannot \
                                                                provide an \
@@ -532,13 +466,6 @@ class CoherenceChecker {
         }));
     }
 
-    fn trait_ref_to_trait_def_id(trait_ref: @trait_ref) -> def_id {
-        let def_map = self.crate_context.tcx.def_map;
-        let trait_def = def_map.get(trait_ref.ref_id);
-        let trait_id = def_id_of_def(trait_def);
-        return trait_id;
-    }
-
     fn gather_privileged_types(items: ~[@item]) -> @dvec<def_id> {
         let results = @dvec();
         for items.each |item| {
@@ -560,70 +487,16 @@ class CoherenceChecker {
 
     // Converts an implementation in the AST to an Impl structure.
     fn create_impl_from_item(item: @item) -> @Impl {
-
-        fn add_provided_methods(inherent_methods: ~[@MethodInfo],
-                                all_provided_methods: ~[@MethodInfo])
-            -> ~[@MethodInfo] {
-
-            let mut methods = inherent_methods;
-
-            // If there's no inherent method with the same name as a
-            // provided method, add that provided method to `methods`.
-            for all_provided_methods.each |provided_method| {
-                let mut method_inherent_to_impl = false;
-                for inherent_methods.each |inherent_method| {
-                    if provided_method.ident == inherent_method.ident {
-                        method_inherent_to_impl = true;
-                    }
-                }
-
-                if !method_inherent_to_impl {
-                    debug!{"(creating impl) adding provided method `%s` to \
-                            impl", *provided_method.ident};
-                    push(methods, provided_method);
-                }
-            }
-
-            return methods;
-        }
-
         match item.node {
-            item_impl(ty_params, trait_refs, _, ast_methods) => {
+            item_impl(ty_params, _, _, ast_methods) => {
                 let mut methods = ~[];
-
                 for ast_methods.each |ast_method| {
-                    push(methods,
-                         method_to_MethodInfo(ast_method));
-                }
-
-                // For each trait that the impl implements, see what
-                // methods are provided.  For each of those methods,
-                // if a method of that name is not inherent to the
-                // impl, use the provided definition in the trait.
-                for trait_refs.each |trait_ref| {
-
-                    let trait_did = self.trait_ref_to_trait_def_id(trait_ref);
-
-                    match self.crate_context.provided_methods_map
-                        .find(trait_did.node) {
-                        none => {
-                            debug!{"(creating impl) trait with node_id `%d` \
-                                    has no provided methods", trait_did.node};
-                            /* fall through */
-                        }
-                        some(all_provided)
-                                    => {
-                            debug!{"(creating impl) trait with node_id `%d` \
-                                    has provided methods", trait_did.node};
-                            // Selectively add only those provided
-                            // methods that aren't inherent to the
-                            // trait.
-
-                            // XXX: could probably be doing this with filter.
-                            methods = add_provided_methods(methods,
-                                                           all_provided);
-                        }
-                    }
+                    push(methods, @{
+                        did: local_def(ast_method.id),
+                        n_tps: ast_method.tps.len(),
+                        ident: ast_method.ident,
+                        self_type: ast_method.self_ty.node
+                    });
                 }
 
                 return @{
@@ -715,8 +588,8 @@ class CoherenceChecker {
 
             if associated_traits.len() == 0 {
                 match get_base_type_def_id(self.inference_context,
-                                           dummy_sp(),
-                                           self_type.ty) {
+                                         dummy_sp(),
+                                         self_type.ty) {
                     none => {
                         let session = self.crate_context.tcx.sess;
                         session.bug(fmt!{"no base type for external impl \
@@ -796,8 +669,6 @@ class CoherenceChecker {
 }
 
 fn check_coherence(crate_context: @crate_ctxt, crate: @crate) {
-    let coherence_checker = @CoherenceChecker(crate_context);
-    (*coherence_checker).build_provided_methods_map(crate);
-    (*coherence_checker).check_coherence(crate);
+    CoherenceChecker(crate_context).check_coherence(crate);
 }
 

trunk/src/rustc/middle/typeck/collect.rs

@@ -197,7 +197,7 @@ fn ensure_trait_methods(ccx: @crate_ctxt, id: ast::node_id) {
 
     let tcx = ccx.tcx;
     let rp = tcx.region_paramd_items.contains_key(id);
-    match tcx.items.get(id) {
+    match check tcx.items.get(id) {
       ast_map::node_item(@{node: ast::item_trait(params, _, ms), _}, _) => {
         store_methods::<ast::trait_method>(ccx, id, ms, |m| {
             let trait_bounds = ty_param_bounds(ccx, params);
@@ -218,7 +218,6 @@ fn ensure_trait_methods(ccx: @crate_ctxt, id: ast::node_id) {
             ty_of_method(ccx, m, rp)
         });
       }
-      _ => { /* Ignore things that aren't traits or classes */ }
     }
 }