Make object types not implement associated trait. Fixes #5087.

Author: nikomatsakis

src/libcore/io.rs

@@ -69,6 +69,26 @@ pub trait Reader {
     fn tell(&self) -> uint;
 }
 
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl Reader for @Reader {
+    fn read(&self, bytes: &mut [u8], len: uint) -> uint {
+        self.read(bytes, len)
+    }
+    fn read_byte(&self) -> int {
+        self.read_byte()
+    }
+    fn eof(&self) -> bool {
+        self.eof()
+    }
+    fn seek(&self, position: int, style: SeekStyle) {
+        self.seek(position, style)
+    }
+    fn tell(&self) -> uint {
+        self.tell()
+    }
+}
+
 /// Generic utility functions defined on readers.
 pub trait ReaderUtil {
 
@@ -631,6 +651,16 @@ pub trait Writer {
     fn get_type(&self) -> WriterType;
 }
 
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl Writer for @Writer {
+    fn write(&self, v: &[const u8]) { self.write(v) }
+    fn seek(&self, a: int, b: SeekStyle) { self.seek(a, b) }
+    fn tell(&self) -> uint { self.tell() }
+    fn flush(&self) -> int { self.flush() }
+    fn get_type(&self) -> WriterType { self.get_type() }
+}
+
 impl<W:Writer,C> Writer for Wrapper<W, C> {
     fn write(&self, bs: &[const u8]) { self.base.write(bs); }
     fn seek(&self, off: int, style: SeekStyle) { self.base.seek(off, style); }
@@ -1067,8 +1097,8 @@ pub fn buffered_file_writer(path: &Path) -> Result<Writer, ~str> {
 // FIXME (#2004) it would be great if this could be a const
 // FIXME (#2004) why are these different from the way stdin() is
 // implemented?
-pub fn stdout() -> Writer { fd_writer(libc::STDOUT_FILENO as c_int, false) }
-pub fn stderr() -> Writer { fd_writer(libc::STDERR_FILENO as c_int, false) }
+pub fn stdout() -> @Writer { fd_writer(libc::STDOUT_FILENO as c_int, false) }
+pub fn stderr() -> @Writer { fd_writer(libc::STDERR_FILENO as c_int, false) }
 
 pub fn print(s: &str) { stdout().write_str(s); }
 pub fn println(s: &str) { stdout().write_line(s); }

src/librustc/middle/astencode.rs

@@ -664,16 +664,6 @@ fn encode_vtable_origin(ecx: @e::EncodeContext,
                 }
             }
           }
-          typeck::vtable_trait(def_id, tys) => {
-            do ebml_w.emit_enum_variant(~"vtable_trait", 1u, 3u) {
-                do ebml_w.emit_enum_variant_arg(0u) {
-                    ebml_w.emit_def_id(def_id)
-                }
-                do ebml_w.emit_enum_variant_arg(1u) {
-                    ebml_w.emit_tys(ecx, /*bad*/copy tys);
-                }
-            }
-          }
         }
     }
 
@@ -720,16 +710,6 @@ impl vtable_decoder_helpers for reader::Decoder {
                         }
                     )
                   }
-                  2 => {
-                    typeck::vtable_trait(
-                        do self.read_enum_variant_arg(0u) {
-                            self.read_def_id(xcx)
-                        },
-                        do self.read_enum_variant_arg(1u) {
-                            self.read_tys(xcx)
-                        }
-                    )
-                  }
                   // hard to avoid - user input
                   _ => fail!(~"bad enum variant")
                 }

src/librustc/middle/trans/common.rs

@@ -1405,7 +1405,6 @@ pub fn resolve_vtable_in_fn_ctxt(fcx: fn_ctxt, +vt: typeck::vtable_origin)
                 }
             }
         }
-        vt => vt
     }
 }
 

src/librustc/middle/trans/meth.rs

@@ -478,14 +478,6 @@ pub fn trans_monomorphized_callee(bcx: block,
               })
           }
       }
-      typeck::vtable_trait(_, _) => {
-          trans_trait_callee(bcx,
-                             callee_id,
-                             n_method,
-                             base,
-                             ty::vstore_box,
-                             mentry.explicit_self)
-      }
       typeck::vtable_param(*) => {
           fail!(~"vtable_param left in monomorphized function's " +
               "vtable substs");
@@ -756,13 +748,7 @@ pub fn vtable_id(ccx: @CrateContext,
                 None,
                 None)
         }
-        typeck::vtable_trait(trait_id, substs) => {
-            @mono_id_ {
-                def: trait_id,
-                params: vec::map(substs, |t| mono_precise(*t, None)),
-                impl_did_opt: None
-            }
-        }
+
         // can't this be checked at the callee?
         _ => fail!(~"vtable_id")
     }

src/librustc/middle/typeck/check/method.rs

@@ -30,7 +30,7 @@ itself (note that inherent impls can only be defined in the same
 module as the type itself).
 
 Inherent candidates are not always derived from impls.  If you have a
-trait instance, such as a value of type `ToStr`, then the trait
+trait instance, such as a value of type `@ToStr`, then the trait
 methods (`to_str()`, in this case) are inherently associated with it.
 Another case is type parameters, in which case the methods of their
 bounds are inherent.
@@ -1221,7 +1221,7 @@ pub impl LookupContext {
             }
             method_trait(trait_did, _, _) | method_self(trait_did, _)
                 | method_super(trait_did, _) => {
-                self.report_param_candidate(idx, trait_did)
+                self.report_trait_candidate(idx, trait_did)
             }
         }
     }

src/librustc/middle/typeck/check/vtable.rs

@@ -18,7 +18,7 @@ use middle::typeck::infer::{fixup_err_to_str, InferCtxt};
 use middle::typeck::infer::{resolve_and_force_all_but_regions, resolve_type};
 use middle::typeck::infer;
 use middle::typeck::{CrateCtxt, vtable_origin, vtable_param, vtable_res};
-use middle::typeck::{vtable_static, vtable_trait};
+use middle::typeck::{vtable_static};
 use util::common::indenter;
 use util::ppaux::tys_to_str;
 use util::ppaux;
@@ -81,7 +81,6 @@ pub fn lookup_vtables(vcx: &VtableContext,
                       location_info: &LocationInfo,
                       bounds: @~[ty::param_bounds],
                       substs: &ty::substs,
-                      allow_unsafe: bool,
                       is_early: bool) -> vtable_res {
     debug!("lookup_vtables(location_info=%?,
             # bounds=%?, \
@@ -110,8 +109,7 @@ pub fn lookup_vtables(vcx: &VtableContext,
             debug!("after subst: %?",
                    ppaux::ty_to_str(tcx, trait_ty));
 
-            match lookup_vtable(vcx, location_info, *ty, trait_ty,
-                                allow_unsafe, is_early) {
+            match lookup_vtable(vcx, location_info, *ty, trait_ty, is_early) {
                 Some(vtable) => result.push(vtable),
                 None => {
                     vcx.tcx().sess.span_fatal(
@@ -162,7 +160,6 @@ pub fn lookup_vtable(vcx: &VtableContext,
                      location_info: &LocationInfo,
                      ty: ty::t,
                      trait_ty: ty::t,
-                     allow_unsafe: bool,
                      is_early: bool)
                   -> Option<vtable_origin> {
     debug!("lookup_vtable(ty=%s, trait_ty=%s)",
@@ -224,30 +221,6 @@ pub fn lookup_vtable(vcx: &VtableContext,
             }
         }
 
-        ty::ty_trait(did, ref substs, _) if trait_id == did => {
-            debug!("(checking vtable) @1 relating ty to trait ty with did %?",
-                   did);
-
-            relate_trait_tys(vcx, location_info, trait_ty, ty);
-            if !allow_unsafe && !is_early {
-                for vec::each(*ty::trait_methods(tcx, did)) |m| {
-                    if ty::type_has_self(ty::mk_bare_fn(tcx, copy m.fty)) {
-                        tcx.sess.span_err(
-                            location_info.span,
-                            ~"a boxed trait with self types may not be \
-                              passed as a bounded type");
-                    } else if (*m.tps).len() > 0u {
-                        tcx.sess.span_err(
-                            location_info.span,
-                            ~"a boxed trait with generic methods may not \
-                              be passed as a bounded type");
-
-                    }
-                }
-            }
-            return Some(vtable_trait(did, /*bad*/copy (*substs).tps));
-        }
-
         _ => {
             let mut found = ~[];
 
@@ -411,7 +384,7 @@ pub fn lookup_vtable(vcx: &VtableContext,
                                               trait_vstore);
                             let subres = lookup_vtables(
                                 vcx, location_info, im_bs, &substs_f,
-                                false, is_early);
+                                is_early);
 
                             // Finally, we register that we found a
                             // matching impl, and record the def ID of
@@ -542,8 +515,7 @@ pub fn early_resolve_expr(ex: @ast::expr,
                 }
                 let vcx = VtableContext { ccx: fcx.ccx, infcx: fcx.infcx() };
                 let vtbls = lookup_vtables(&vcx, &location_info_for_expr(ex),
-                                           item_ty.bounds, substs, false,
-                                           is_early);
+                                           item_ty.bounds, substs, is_early);
                 if !is_early {
                     let vtable_map = cx.vtable_map;
                     vtable_map.insert(ex.id, vtbls);
@@ -573,7 +545,7 @@ pub fn early_resolve_expr(ex: @ast::expr,
                 let substs = fcx.node_ty_substs(callee_id);
                 let vcx = VtableContext { ccx: fcx.ccx, infcx: fcx.infcx() };
                 let vtbls = lookup_vtables(&vcx, &location_info_for_expr(ex),
-                                           bounds, &substs, false, is_early);
+                                           bounds, &substs, is_early);
                 if !is_early {
                     insert_vtables(cx, callee_id, vtbls);
                 }
@@ -607,7 +579,6 @@ pub fn early_resolve_expr(ex: @ast::expr,
                                             location_info,
                                             mt.ty,
                                             target_ty,
-                                            true,
                                             is_early);
                           match vtable_opt {
                               Some(vtable) => {

src/librustc/middle/typeck/check/writeback.rs

@@ -22,7 +22,7 @@ use middle::typeck::infer::{force_all, resolve_all, resolve_region};
 use middle::typeck::infer::{resolve_type};
 use middle::typeck::infer;
 use middle::typeck::method_map_entry;
-use middle::typeck::{vtable_param, vtable_trait, write_substs_to_tcx};
+use middle::typeck::{vtable_param, write_substs_to_tcx};
 use middle::typeck::{write_ty_to_tcx};
 use util::ppaux;
 

src/librustc/middle/typeck/mod.rs

@@ -150,12 +150,7 @@ pub enum vtable_origin {
       The first uint is the param number (identifying T in the example),
       and the second is the bound number (identifying baz)
      */
-    vtable_param(uint, uint),
-    /*
-      Dynamic vtable, comes from something known to have a trait
-      type. def_id refers to the trait item, tys are the substs
-     */
-    vtable_trait(ast::def_id, ~[ty::t]),
+    vtable_param(uint, uint)
 }
 
 pub impl vtable_origin {
@@ -171,12 +166,6 @@ pub impl vtable_origin {
             vtable_param(x, y) => {
                 fmt!("vtable_param(%?, %?)", x, y)
             }
-
-            vtable_trait(def_id, ref tys) => {
-                fmt!("vtable_trait(%?:%s, %?)",
-                     def_id, ty::item_path_str(tcx, def_id),
-                     tys.map(|t| ppaux::ty_to_str(tcx, *t)))
-            }
         }
     }
 }

src/test/run-pass/autoderef-method-on-trait-monomorphized.rs renamed to src/test/compile-fail/object-does-not-impl-trait.rs

@@ -8,19 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-trait double {
-    fn double() -> uint;
-}
+// Test that an object type `@Foo` is not considered to implement the
+// trait `Foo`. Issue #5087.
 
-impl double for uint {
-    fn double() -> uint { self * 2u }
-}
-
-fn is_equal<D:double>(x: @D, exp: uint) {
-    assert x.double() == exp;
-}
-
-pub fn main() {
-    let x = @(@3u as @double);
-    is_equal(x, 6);
-}
+trait Foo {}
+fn take_foo<F:Foo>(f: F) {}
+fn take_object(f: @Foo) { take_foo(f); } //~ ERROR failed to find an implementation of trait
+fn main() {}

src/test/compile-fail/regions-trait-3.rs

@@ -16,8 +16,16 @@ fn make_gc1(gc: get_ctxt/&a) -> get_ctxt/&b  {
     return gc; //~ ERROR mismatched types: expected `@get_ctxt/&b` but found `@get_ctxt/&a`
 }
 
-fn make_gc2(gc: get_ctxt/&a) -> get_ctxt/&b  {
-    return @gc as get_ctxt; //~ ERROR cannot infer an appropriate lifetime
+struct Foo {
+    r: &'self uint
+}
+
+impl get_ctxt/&self for Foo/&self {
+    fn get_ctxt() -> &self/uint { self.r }
+}
+
+fn make_gc2(foo: Foo/&a) -> get_ctxt/&b  {
+    return @foo as get_ctxt; //~ ERROR cannot infer an appropriate lifetime
 }
 
 fn main() {

src/test/compile-fail/selftype-astparam.rs

@@ -14,7 +14,7 @@ extern mod cci_class_cast;
 use core::to_str::ToStr;
 use cci_class_cast::kitty::*;
 
-fn print_out<T:ToStr>(thing: T, expected: ~str) {
+fn print_out(thing: @ToStr, expected: ~str) {
   let actual = thing.to_str();
   debug!("%s", actual);
   assert(actual == expected);

src/test/compile-fail/trait-cast.rs

@@ -79,7 +79,7 @@ fn cat(in_x : uint, in_y : int, in_name: ~str) -> cat {
 }
 
 
-fn annoy_neighbors<T:noisy>(critter: T) {
+fn annoy_neighbors(critter: @noisy) {
   for uint::range(0u, 10u) |i| { critter.speak(); }
 }