---

yaml
---
r: 32149
b: refs/heads/dist-snap
c: bdbedb9
h: refs/heads/master
i:
  32147: e958bb5
v: v3

Author: Vincent-Belliard

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: 6277046fa0a5c119885ba33bcb6ac2f4fba0228f
+refs/heads/dist-snap: bdbedb9d35903be0e3f587c603db49c014ef7d9f
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/src/rustc/middle/resolve3.rs

@@ -4069,6 +4069,47 @@ struct Resolver {
         }
     }
 
+    fn name_exists_in_scope_class(name: &str) -> bool {
+        let mut i = self.type_ribs.len();
+        while i != 0 {
+          i -= 1;
+          let rib = self.type_ribs.get_elt(i);
+          match rib.kind {
+            MethodRibKind(node_id, _) =>
+              for vec::each(self.crate.node.module.items) |item| {
+                if item.id == node_id {
+                  match item.node {
+                    item_class(class_def, _) => {
+                      for vec::each(class_def.fields) |field| {
+                        match field.node.kind {
+                          syntax::ast::unnamed_field
+                            => {},
+                          syntax::ast::named_field(ident, _, _)
+                            => {
+                              if str::eq_slice(self.session.str_of(ident),
+                                               name) {
+                                return true
+                              }
+                            }
+                        }
+                      }
+                      for vec::each(class_def.methods) |method| {
+                        if str::eq_slice(self.session.str_of(method.ident),
+                                         name) {
+                          return true
+                        }
+                      }
+                    }
+                    _ => {}
+                  }
+                }
+            },
+          _ => {}
+        }
+      }
+      return false;
+    }
+
     fn resolve_expr(expr: @expr, visitor: ResolveVisitor) {
         // First, record candidate traits for this expression if it could
         // result in the invocation of a method call.
@@ -4093,12 +4134,21 @@ struct Resolver {
                         self.record_def(expr.id, def);
                     }
                     none => {
-                        self.session.span_err(
-                            expr.span,
-                            fmt!("unresolved name: %s",
-                                 connect(path.idents.map(
-                                     |x| self.session.str_of(x)),
-                                         ~"::")));
+                        let wrong_name =
+                            connect(path.idents.map(
+                                |x| self.session.str_of(x)), ~"::") ;
+                        if self.name_exists_in_scope_class(wrong_name) {
+                            self.session.span_err(expr.span,
+                                        fmt!("unresolved name: %s. \
+                                            Did you mean: self.%s",
+                                        wrong_name,
+                                        wrong_name));
+                        }
+                        else {
+                            self.session.span_err(expr.span,
+                                                fmt!("unresolved name: %s",
+                                                wrong_name));
+                        }
                     }
                 }