auto merge of #7725 : msullivan/rust/default-methods, r=pcwalton

r?

Author: bors

src/librustc/metadata/encoder.rs

@@ -791,7 +791,7 @@ fn encode_info_for_method(ecx: &EncodeContext,
     if len > 0u || should_inline {
         (ecx.encode_inlined_item)(
            ecx, ebml_w, impl_path,
-           ii_method(local_def(parent_id), m));
+           ii_method(local_def(parent_id), false, m));
     } else {
         encode_symbol(ecx, ebml_w, m.id);
     }
@@ -1123,21 +1123,16 @@ fn encode_info_for_item(ecx: &EncodeContext,
                 }
 
                 provided(m) => {
-                    // This is obviously a bogus assert but I don't think this
-                    // ever worked before anyhow...near as I can tell, before
-                    // we would emit two items.
-                    if method_ty.explicit_self == sty_static {
-                        tcx.sess.span_unimpl(
-                            item.span,
-                            fmt!("Method %s is both provided and static",
-                                 token::ident_to_str(&method_ty.ident)));
+                    // If this is a static method, we've already encoded
+                    // this.
+                    if method_ty.explicit_self != sty_static {
+                        encode_type_param_bounds(ebml_w, ecx,
+                                                 &m.generics.ty_params);
                     }
-                    encode_type_param_bounds(ebml_w, ecx,
-                                             &m.generics.ty_params);
                     encode_method_sort(ebml_w, 'p');
                     (ecx.encode_inlined_item)(
                         ecx, ebml_w, path,
-                        ii_method(local_def(item.id), m));
+                        ii_method(local_def(item.id), true, m));
                 }
             }
 

src/librustc/middle/astencode.rs

@@ -319,7 +319,8 @@ fn simplify_ast(ii: &ast::inlined_item) -> ast::inlined_item {
     match *ii {
         //hack: we're not dropping items
         ast::ii_item(i) => ast::ii_item(fld.fold_item(i).get()),
-        ast::ii_method(d, m) => ast::ii_method(d, fld.fold_method(m)),
+        ast::ii_method(d, is_provided, m) =>
+          ast::ii_method(d, is_provided, fld.fold_method(m)),
         ast::ii_foreign(i) => ast::ii_foreign(fld.fold_foreign_item(i))
     }
 }
@@ -340,7 +341,8 @@ fn renumber_ast(xcx: @ExtendedDecodeContext, ii: ast::inlined_item)
 
     match ii {
         ast::ii_item(i) => ast::ii_item(fld.fold_item(i).get()),
-        ast::ii_method(d, m) => ast::ii_method(xcx.tr_def_id(d), fld.fold_method(m)),
+        ast::ii_method(d, is_provided, m) =>
+          ast::ii_method(xcx.tr_def_id(d), is_provided, fld.fold_method(m)),
         ast::ii_foreign(i) => ast::ii_foreign(fld.fold_foreign_item(i)),
     }
 }

src/librustc/middle/lint.rs

@@ -244,7 +244,7 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
      LintSpec {
         lint: default_methods,
         desc: "allow default methods",
-        default: deny
+        default: allow
      }),
 
     ("unused_unsafe",

src/librustc/middle/mem_categorization.rs

@@ -1185,7 +1185,7 @@ impl cmt_ {
     }
 }
 
-impl Repr for cmt {
+impl Repr for cmt_ {
     fn repr(&self, tcx: ty::ctxt) -> ~str {
         fmt!("{%s id:%d m:%? ty:%s}",
              self.cat.repr(tcx),

src/librustc/middle/trans/base.rs

@@ -520,7 +520,7 @@ pub fn get_res_dtor(ccx: @mut CrateContext,
     let _icx = push_ctxt("trans_res_dtor");
     if !substs.is_empty() {
         let did = if did.crate != ast::local_crate {
-            inline::maybe_instantiate_inline(ccx, did, true)
+            inline::maybe_instantiate_inline(ccx, did)
         } else {
             did
         };

src/librustc/middle/trans/callee.rs

@@ -250,7 +250,7 @@ pub fn trans_fn_ref_with_vtables(
         def_id: ast::def_id,   // def id of fn
         ref_id: ast::node_id,  // node id of use of fn; may be zero if N/A
         type_params: &[ty::t], // values for fn's ty params
-        vtables: Option<typeck::vtable_res>)
+        vtables: Option<typeck::vtable_res>) // vtables for the call
      -> FnData {
     //!
     //
@@ -361,8 +361,7 @@ pub fn trans_fn_ref_with_vtables(
     // def_id to the local id of the inlined copy.
     let def_id = {
         if def_id.crate != ast::local_crate {
-            let may_translate = opt_impl_did.is_none();
-            inline::maybe_instantiate_inline(ccx, def_id, may_translate)
+            inline::maybe_instantiate_inline(ccx, def_id)
         } else {
             def_id
         }

src/librustc/middle/trans/common.rs

@@ -154,12 +154,6 @@ impl Repr for param_substs {
     }
 }
 
-impl Repr for @param_substs {
-    fn repr(&self, tcx: ty::ctxt) -> ~str {
-        param_substs_to_str(*self, tcx)
-    }
-}
-
 // Function context.  Every LLVM function we create will have one of
 // these.
 pub struct fn_ctxt_ {

src/librustc/middle/trans/consts.rs

@@ -159,7 +159,7 @@ pub fn get_const_val(cx: @mut CrateContext, mut def_id: ast::def_id) -> ValueRef
     let contains_key = cx.const_values.contains_key(&def_id.node);
     if !ast_util::is_local(def_id) || !contains_key {
         if !ast_util::is_local(def_id) {
-            def_id = inline::maybe_instantiate_inline(cx, def_id, true);
+            def_id = inline::maybe_instantiate_inline(cx, def_id);
         }
         match cx.tcx.items.get_copy(&def_id.node) {
             ast_map::node_item(@ast::item {

src/librustc/middle/trans/expr.rs

@@ -956,7 +956,7 @@ fn trans_lvalue_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock {
                 fn get_did(ccx: @mut CrateContext, did: ast::def_id)
                     -> ast::def_id {
                     if did.crate != ast::local_crate {
-                        inline::maybe_instantiate_inline(ccx, did, true)
+                        inline::maybe_instantiate_inline(ccx, did)
                     } else {
                         did
                     }

src/librustc/middle/trans/inline.rs

@@ -22,11 +22,7 @@ use syntax::ast;
 use syntax::ast_map::path_name;
 use syntax::ast_util::local_def;
 
-// `translate` will be true if this function is allowed to translate the
-// item and false otherwise. Currently, this parameter is set to false when
-// translating default methods.
-pub fn maybe_instantiate_inline(ccx: @mut CrateContext, fn_id: ast::def_id,
-                                translate: bool)
+pub fn maybe_instantiate_inline(ccx: @mut CrateContext, fn_id: ast::def_id)
     -> ast::def_id {
     let _icx = push_ctxt("maybe_instantiate_inline");
     match ccx.external.find(&fn_id) {
@@ -59,7 +55,7 @@ pub fn maybe_instantiate_inline(ccx: @mut CrateContext, fn_id: ast::def_id,
         csearch::found(ast::ii_item(item)) => {
             ccx.external.insert(fn_id, Some(item.id));
             ccx.stats.n_inlines += 1;
-            if translate { trans_item(ccx, item); }
+            trans_item(ccx, item);
             local_def(item.id)
         }
         csearch::found(ast::ii_foreign(item)) => {
@@ -81,19 +77,19 @@ pub fn maybe_instantiate_inline(ccx: @mut CrateContext, fn_id: ast::def_id,
             _ => ccx.sess.bug("maybe_instantiate_inline: item has a \
                                non-enum parent")
           }
-          if translate { trans_item(ccx, item); }
+          trans_item(ccx, item);
           local_def(my_id)
         }
         csearch::found_parent(_, _) => {
             ccx.sess.bug("maybe_get_item_ast returned a found_parent \
              with a non-item parent");
         }
-        csearch::found(ast::ii_method(impl_did, mth)) => {
+        csearch::found(ast::ii_method(impl_did, is_provided, mth)) => {
           ccx.stats.n_inlines += 1;
           ccx.external.insert(fn_id, Some(mth.id));
           // If this is a default method, we can't look up the
           // impl type. But we aren't going to translate anyways, so don't.
-          if !translate { return local_def(mth.id); }
+          if is_provided { return local_def(mth.id); }
 
             let impl_tpt = ty::lookup_item_type(ccx.tcx, impl_did);
             let num_type_params =