this.with_current_self_type(self_type, |this| {
for method in methods.iter() {
+ // If this is a trait impl, ensure the method exists in trait
+ this.check_trait_method(&**method);
+
// We also need a new scope for the method-specific type parameters.
this.resolve_method(MethodRibKind(id, Provided(method.id)),
&**method);
});
}
+ fn check_trait_method(&self, method: &Method) {
+ // If there is a TraitRef in scope for an impl, then the method must be in the trait.
+ for &(did, ref trait_ref) in self.current_trait_ref.iter() {
+ let method_name = method.ident.name;
+
+ if self.method_map.borrow().find(&(method_name, did)).is_none() {
+ let path_str = self.path_idents_to_str(&trait_ref.path);
+ self.resolve_error(method.span,
+ format!("method `{}` is not a member of trait `{}`",
+ token::get_name(method_name),
+ path_str).as_slice());
+ }
+ }
+ }
+
fn resolve_module(&mut self, module: &Mod, _span: Span,
_name: Ident, id: NodeId) {
// Write the implementations in scope into the module metadata.
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// ignore-test
-
-use std::io;
-
struct Point {
x: f64,
y: f64,
}
-impl ToStr for Point { //~ ERROR implements a method not defined in the trait
+trait NewTrait {
+ fn a(&self) -> String;
+}
+
+impl NewTrait for Point {
fn new(x: f64, y: f64) -> Point {
+ //~^ ERROR method `new` is not a member of trait `NewTrait`
Point { x: x, y: y }
}
- fn to_str(&self) -> String {
+ fn a(&self) -> String {
format!("({}, {})", self.x, self.y)
}
}
fn main() {
let p = Point::new(0.0, 0.0);
- println!("{}", p.to_str());
+ //~^ ERROR unresolved name `Point::new`
+ //~^^ ERROR unresolved name
+ //~^^^ ERROR use of undeclared module `Point`
+ println!("{}", p.a());
}