9 files changed, 367 insertions, 247 deletions

diff --git a/gcc/rust/resolve/rust-ast-resolve-base.h b/gcc/rust/resolve/rust-ast-resolve-base.h
index cc60055..16334bd 100644
--- a/gcc/rust/resolve/rust-ast-resolve-base.h
+++ b/gcc/rust/resolve/rust-ast-resolve-base.h
@@ -21,7 +21,6 @@
 
 #include "rust-ast-visitor.h"
 #include "rust-name-resolver.h"
-
 #include "rust-diagnostics.h"
 #include "rust-location.h"
 
@@ -33,210 +32,181 @@ class ResolverBase : public AST::ASTVisitor
 public:
   virtual ~ResolverBase () {}
 
-  // visitor impl
-  // rust-ast.h
-  //  virtual void visit(AttrInput& attr_input);
-  //  virtual void visit(TokenTree& token_tree);
-  //  virtual void visit(MacroMatch& macro_match);
-  virtual void visit (AST::Token &tok) {}
-  virtual void visit (AST::DelimTokenTree &delim_tok_tree) {}
-  virtual void visit (AST::AttrInputMetaItemContainer &input) {}
-  //  virtual void visit(MetaItem& meta_item) {}
-  //  void vsit(Stmt& stmt) {}
-  //  virtual void visit(Expr& expr) {}
-  virtual void visit (AST::IdentifierExpr &ident_expr) {}
-  //  virtual void visit(Pattern& pattern) {}
-  //  virtual void visit(Type& type) {}
-  //  virtual void visit(TypeParamBound& type_param_bound) {}
-  virtual void visit (AST::Lifetime &lifetime) {}
-  //  virtual void visit(GenericParam& generic_param) {}
-  virtual void visit (AST::LifetimeParam &lifetime_param) {}
-  //  virtual void visit(TraitItem& trait_item) {}
-  //  virtual void visit(InherentImplItem& inherent_impl_item) {}
-  //  virtual void visit(TraitImplItem& trait_impl_item) {}
-  virtual void visit (AST::MacroInvocationSemi &macro) {}
-
-  // rust-path.h
-  virtual void visit (AST::PathInExpression &path) {}
-  virtual void visit (AST::TypePathSegment &segment) {}
-  virtual void visit (AST::TypePathSegmentGeneric &segment) {}
-  virtual void visit (AST::TypePathSegmentFunction &segment) {}
-  virtual void visit (AST::TypePath &path) {}
-  virtual void visit (AST::QualifiedPathInExpression &path) {}
-  virtual void visit (AST::QualifiedPathInType &path) {}
-
-  // rust-expr.h
-  virtual void visit (AST::LiteralExpr &expr) {}
-  virtual void visit (AST::AttrInputLiteral &attr_input) {}
-  virtual void visit (AST::MetaItemLitExpr &meta_item) {}
-  virtual void visit (AST::MetaItemPathLit &meta_item) {}
-  virtual void visit (AST::BorrowExpr &expr) {}
-  virtual void visit (AST::DereferenceExpr &expr) {}
-  virtual void visit (AST::ErrorPropagationExpr &expr) {}
-  virtual void visit (AST::NegationExpr &expr) {}
-  virtual void visit (AST::ArithmeticOrLogicalExpr &expr) {}
-  virtual void visit (AST::ComparisonExpr &expr) {}
-  virtual void visit (AST::LazyBooleanExpr &expr) {}
-  virtual void visit (AST::TypeCastExpr &expr) {}
-  virtual void visit (AST::AssignmentExpr &expr) {}
-  virtual void visit (AST::CompoundAssignmentExpr &expr) {}
-  virtual void visit (AST::GroupedExpr &expr) {}
-  //  virtual void visit(ArrayElems& elems) {}
-  virtual void visit (AST::ArrayElemsValues &elems) {}
-  virtual void visit (AST::ArrayElemsCopied &elems) {}
-  virtual void visit (AST::ArrayExpr &expr) {}
-  virtual void visit (AST::ArrayIndexExpr &expr) {}
-  virtual void visit (AST::TupleExpr &expr) {}
-  virtual void visit (AST::TupleIndexExpr &expr) {}
-  virtual void visit (AST::StructExprStruct &expr) {}
-  //  virtual void visit(StructExprField& field) {}
-  virtual void visit (AST::StructExprFieldIdentifier &field) {}
-  virtual void visit (AST::StructExprFieldIdentifierValue &field) {}
-  virtual void visit (AST::StructExprFieldIndexValue &field) {}
-  virtual void visit (AST::StructExprStructFields &expr) {}
-  virtual void visit (AST::StructExprStructBase &expr) {}
-  virtual void visit (AST::StructExprTuple &expr) {}
-  virtual void visit (AST::StructExprUnit &expr) {}
-  //  virtual void visit(EnumExprField& field) {}
-  virtual void visit (AST::EnumExprFieldIdentifier &field) {}
-  virtual void visit (AST::EnumExprFieldIdentifierValue &field) {}
-  virtual void visit (AST::EnumExprFieldIndexValue &field) {}
-  virtual void visit (AST::EnumExprStruct &expr) {}
-  virtual void visit (AST::EnumExprTuple &expr) {}
-  virtual void visit (AST::EnumExprFieldless &expr) {}
-  virtual void visit (AST::CallExpr &expr) {}
-  virtual void visit (AST::MethodCallExpr &expr) {}
-  virtual void visit (AST::FieldAccessExpr &expr) {}
-  virtual void visit (AST::ClosureExprInner &expr) {}
-  virtual void visit (AST::BlockExpr &expr) {}
-  virtual void visit (AST::ClosureExprInnerTyped &expr) {}
-  virtual void visit (AST::ContinueExpr &expr) {}
-  virtual void visit (AST::BreakExpr &expr) {}
-  virtual void visit (AST::RangeFromToExpr &expr) {}
-  virtual void visit (AST::RangeFromExpr &expr) {}
-  virtual void visit (AST::RangeToExpr &expr) {}
-  virtual void visit (AST::RangeFullExpr &expr) {}
-  virtual void visit (AST::RangeFromToInclExpr &expr) {}
-  virtual void visit (AST::RangeToInclExpr &expr) {}
-  virtual void visit (AST::ReturnExpr &expr) {}
-  virtual void visit (AST::UnsafeBlockExpr &expr) {}
-  virtual void visit (AST::LoopExpr &expr) {}
-  virtual void visit (AST::WhileLoopExpr &expr) {}
-  virtual void visit (AST::WhileLetLoopExpr &expr) {}
-  virtual void visit (AST::ForLoopExpr &expr) {}
-  virtual void visit (AST::IfExpr &expr) {}
-  virtual void visit (AST::IfExprConseqElse &expr) {}
-  virtual void visit (AST::IfExprConseqIf &expr) {}
-  virtual void visit (AST::IfExprConseqIfLet &expr) {}
-  virtual void visit (AST::IfLetExpr &expr) {}
-  virtual void visit (AST::IfLetExprConseqElse &expr) {}
-  virtual void visit (AST::IfLetExprConseqIf &expr) {}
-  virtual void visit (AST::IfLetExprConseqIfLet &expr) {}
-  //  virtual void visit(MatchCase& match_case) {}
-  // virtual void visit (AST::MatchCaseBlockExpr &match_case) {}
-  // virtual void visit (AST::MatchCaseExpr &match_case) {}
-  virtual void visit (AST::MatchExpr &expr) {}
-  virtual void visit (AST::AwaitExpr &expr) {}
-  virtual void visit (AST::AsyncBlockExpr &expr) {}
-
-  // rust-item.h
-  virtual void visit (AST::TypeParam &param) {}
-  //  virtual void visit(WhereClauseItem& item) {}
-  virtual void visit (AST::LifetimeWhereClauseItem &item) {}
-  virtual void visit (AST::TypeBoundWhereClauseItem &item) {}
-  virtual void visit (AST::Method &method) {}
-  virtual void visit (AST::ModuleBodied &module) {}
-  virtual void visit (AST::ModuleNoBody &module) {}
-  virtual void visit (AST::ExternCrate &crate) {}
-  //  virtual void visit(UseTree& use_tree) {}
-  virtual void visit (AST::UseTreeGlob &use_tree) {}
-  virtual void visit (AST::UseTreeList &use_tree) {}
-  virtual void visit (AST::UseTreeRebind &use_tree) {}
-  virtual void visit (AST::UseDeclaration &use_decl) {}
-  virtual void visit (AST::Function &function) {}
-  virtual void visit (AST::TypeAlias &type_alias) {}
-  virtual void visit (AST::StructStruct &struct_item) {}
-  virtual void visit (AST::TupleStruct &tuple_struct) {}
-  virtual void visit (AST::EnumItem &item) {}
-  virtual void visit (AST::EnumItemTuple &item) {}
-  virtual void visit (AST::EnumItemStruct &item) {}
-  virtual void visit (AST::EnumItemDiscriminant &item) {}
-  virtual void visit (AST::Enum &enum_item) {}
-  virtual void visit (AST::Union &union_item) {}
-  virtual void visit (AST::ConstantItem &const_item) {}
-  virtual void visit (AST::StaticItem &static_item) {}
-  virtual void visit (AST::TraitItemFunc &item) {}
-  virtual void visit (AST::TraitItemMethod &item) {}
-  virtual void visit (AST::TraitItemConst &item) {}
-  virtual void visit (AST::TraitItemType &item) {}
-  virtual void visit (AST::Trait &trait) {}
-  virtual void visit (AST::InherentImpl &impl) {}
-  virtual void visit (AST::TraitImpl &impl) {}
-  //  virtual void visit(ExternalItem& item) {}
-  virtual void visit (AST::ExternalStaticItem &item) {}
-  virtual void visit (AST::ExternalFunctionItem &item) {}
-  virtual void visit (AST::ExternBlock &block) {}
-
-  // rust-macro.h
-  virtual void visit (AST::MacroMatchFragment &match) {}
-  virtual void visit (AST::MacroMatchRepetition &match) {}
-  virtual void visit (AST::MacroMatcher &matcher) {}
-  virtual void visit (AST::MacroRulesDefinition &rules_def) {}
-  virtual void visit (AST::MacroInvocation &macro_invoc) {}
-  virtual void visit (AST::MetaItemPath &meta_item) {}
-  virtual void visit (AST::MetaItemSeq &meta_item) {}
-  virtual void visit (AST::MetaWord &meta_item) {}
-  virtual void visit (AST::MetaNameValueStr &meta_item) {}
-  virtual void visit (AST::MetaListPaths &meta_item) {}
-  virtual void visit (AST::MetaListNameValueStr &meta_item) {}
-
-  // rust-pattern.h
-  virtual void visit (AST::LiteralPattern &pattern) {}
-  virtual void visit (AST::IdentifierPattern &pattern) {}
-  virtual void visit (AST::WildcardPattern &pattern) {}
-  //  virtual void visit(RangePatternBound& bound) {}
-  virtual void visit (AST::RangePatternBoundLiteral &bound) {}
-  virtual void visit (AST::RangePatternBoundPath &bound) {}
-  virtual void visit (AST::RangePatternBoundQualPath &bound) {}
-  virtual void visit (AST::RangePattern &pattern) {}
-  virtual void visit (AST::ReferencePattern &pattern) {}
-  //  virtual void visit(StructPatternField& field) {}
-  virtual void visit (AST::StructPatternFieldTuplePat &field) {}
-  virtual void visit (AST::StructPatternFieldIdentPat &field) {}
-  virtual void visit (AST::StructPatternFieldIdent &field) {}
-  virtual void visit (AST::StructPattern &pattern) {}
-  //  virtual void visit(TupleStructItems& tuple_items) {}
-  virtual void visit (AST::TupleStructItemsNoRange &tuple_items) {}
-  virtual void visit (AST::TupleStructItemsRange &tuple_items) {}
-  virtual void visit (AST::TupleStructPattern &pattern) {}
-  //  virtual void visit(TuplePatternItems& tuple_items) {}
-  virtual void visit (AST::TuplePatternItemsMultiple &tuple_items) {}
-  virtual void visit (AST::TuplePatternItemsRanged &tuple_items) {}
-  virtual void visit (AST::TuplePattern &pattern) {}
-  virtual void visit (AST::GroupedPattern &pattern) {}
-  virtual void visit (AST::SlicePattern &pattern) {}
-
-  // rust-stmt.h
-  virtual void visit (AST::EmptyStmt &stmt) {}
-  virtual void visit (AST::LetStmt &stmt) {}
-  virtual void visit (AST::ExprStmtWithoutBlock &stmt) {}
-  virtual void visit (AST::ExprStmtWithBlock &stmt) {}
-
-  // rust-type.h
-  virtual void visit (AST::TraitBound &bound) {}
-  virtual void visit (AST::ImplTraitType &type) {}
-  virtual void visit (AST::TraitObjectType &type) {}
-  virtual void visit (AST::ParenthesisedType &type) {}
-  virtual void visit (AST::ImplTraitTypeOneBound &type) {}
-  virtual void visit (AST::TraitObjectTypeOneBound &type) {}
-  virtual void visit (AST::TupleType &type) {}
-  virtual void visit (AST::NeverType &type) {}
-  virtual void visit (AST::RawPointerType &type) {}
-  virtual void visit (AST::ReferenceType &type) {}
-  virtual void visit (AST::ArrayType &type) {}
-  virtual void visit (AST::SliceType &type) {}
-  virtual void visit (AST::InferredType &type) {}
-  virtual void visit (AST::BareFunctionType &type) {}
+  void visit (AST::Token &) {}
+  void visit (AST::DelimTokenTree &) {}
+  void visit (AST::AttrInputMetaItemContainer &) {}
+  void visit (AST::IdentifierExpr &) {}
+  void visit (AST::Lifetime &) {}
+  void visit (AST::LifetimeParam &) {}
+  void visit (AST::MacroInvocationSemi &) {}
+  void visit (AST::PathInExpression &) {}
+  void visit (AST::TypePathSegment &) {}
+  void visit (AST::TypePathSegmentGeneric &) {}
+  void visit (AST::TypePathSegmentFunction &) {}
+  void visit (AST::TypePath &) {}
+  void visit (AST::QualifiedPathInExpression &) {}
+  void visit (AST::QualifiedPathInType &) {}
+  void visit (AST::LiteralExpr &) {}
+  void visit (AST::AttrInputLiteral &) {}
+  void visit (AST::MetaItemLitExpr &) {}
+  void visit (AST::MetaItemPathLit &) {}
+  void visit (AST::BorrowExpr &) {}
+  void visit (AST::DereferenceExpr &) {}
+  void visit (AST::ErrorPropagationExpr &) {}
+  void visit (AST::NegationExpr &) {}
+  void visit (AST::ArithmeticOrLogicalExpr &) {}
+  void visit (AST::ComparisonExpr &) {}
+  void visit (AST::LazyBooleanExpr &) {}
+  void visit (AST::TypeCastExpr &) {}
+  void visit (AST::AssignmentExpr &) {}
+  void visit (AST::CompoundAssignmentExpr &) {}
+  void visit (AST::GroupedExpr &) {}
+  void visit (AST::ArrayElemsValues &) {}
+  void visit (AST::ArrayElemsCopied &) {}
+  void visit (AST::ArrayExpr &) {}
+  void visit (AST::ArrayIndexExpr &) {}
+  void visit (AST::TupleExpr &) {}
+  void visit (AST::TupleIndexExpr &) {}
+  void visit (AST::StructExprStruct &) {}
+  void visit (AST::StructExprFieldIdentifier &) {}
+  void visit (AST::StructExprFieldIdentifierValue &) {}
+  void visit (AST::StructExprFieldIndexValue &) {}
+  void visit (AST::StructExprStructFields &) {}
+  void visit (AST::StructExprStructBase &) {}
+  void visit (AST::StructExprTuple &) {}
+  void visit (AST::StructExprUnit &) {}
+  void visit (AST::EnumExprFieldIdentifier &) {}
+  void visit (AST::EnumExprFieldIdentifierValue &) {}
+  void visit (AST::EnumExprFieldIndexValue &) {}
+  void visit (AST::EnumExprStruct &) {}
+  void visit (AST::EnumExprTuple &) {}
+  void visit (AST::EnumExprFieldless &) {}
+  void visit (AST::CallExpr &) {}
+  void visit (AST::MethodCallExpr &) {}
+  void visit (AST::FieldAccessExpr &) {}
+  void visit (AST::ClosureExprInner &) {}
+  void visit (AST::BlockExpr &) {}
+  void visit (AST::ClosureExprInnerTyped &) {}
+  void visit (AST::ContinueExpr &) {}
+  void visit (AST::BreakExpr &) {}
+  void visit (AST::RangeFromToExpr &) {}
+  void visit (AST::RangeFromExpr &) {}
+  void visit (AST::RangeToExpr &) {}
+  void visit (AST::RangeFullExpr &) {}
+  void visit (AST::RangeFromToInclExpr &) {}
+  void visit (AST::RangeToInclExpr &) {}
+  void visit (AST::ReturnExpr &) {}
+  void visit (AST::UnsafeBlockExpr &) {}
+  void visit (AST::LoopExpr &) {}
+  void visit (AST::WhileLoopExpr &) {}
+  void visit (AST::WhileLetLoopExpr &) {}
+  void visit (AST::ForLoopExpr &) {}
+  void visit (AST::IfExpr &) {}
+  void visit (AST::IfExprConseqElse &) {}
+  void visit (AST::IfExprConseqIf &) {}
+  void visit (AST::IfExprConseqIfLet &) {}
+  void visit (AST::IfLetExpr &) {}
+  void visit (AST::IfLetExprConseqElse &) {}
+  void visit (AST::IfLetExprConseqIf &) {}
+  void visit (AST::IfLetExprConseqIfLet &) {}
+
+  void visit (AST::MatchExpr &) {}
+  void visit (AST::AwaitExpr &) {}
+  void visit (AST::AsyncBlockExpr &) {}
+
+  void visit (AST::TypeParam &) {}
+
+  void visit (AST::LifetimeWhereClauseItem &) {}
+  void visit (AST::TypeBoundWhereClauseItem &) {}
+  void visit (AST::Method &) {}
+  void visit (AST::ModuleBodied &) {}
+  void visit (AST::ModuleNoBody &) {}
+  void visit (AST::ExternCrate &) {}
+
+  void visit (AST::UseTreeGlob &) {}
+  void visit (AST::UseTreeList &) {}
+  void visit (AST::UseTreeRebind &) {}
+  void visit (AST::UseDeclaration &) {}
+  void visit (AST::Function &) {}
+  void visit (AST::TypeAlias &) {}
+  void visit (AST::StructStruct &) {}
+  void visit (AST::TupleStruct &) {}
+  void visit (AST::EnumItem &) {}
+  void visit (AST::EnumItemTuple &) {}
+  void visit (AST::EnumItemStruct &) {}
+  void visit (AST::EnumItemDiscriminant &) {}
+  void visit (AST::Enum &) {}
+  void visit (AST::Union &) {}
+  void visit (AST::ConstantItem &) {}
+  void visit (AST::StaticItem &) {}
+  void visit (AST::TraitItemFunc &) {}
+  void visit (AST::TraitItemMethod &) {}
+  void visit (AST::TraitItemConst &) {}
+  void visit (AST::TraitItemType &) {}
+  void visit (AST::Trait &) {}
+  void visit (AST::InherentImpl &) {}
+  void visit (AST::TraitImpl &) {}
+
+  void visit (AST::ExternalStaticItem &) {}
+  void visit (AST::ExternalFunctionItem &) {}
+  void visit (AST::ExternBlock &) {}
+
+  void visit (AST::MacroMatchFragment &) {}
+  void visit (AST::MacroMatchRepetition &) {}
+  void visit (AST::MacroMatcher &) {}
+  void visit (AST::MacroRulesDefinition &) {}
+  void visit (AST::MacroInvocation &) {}
+  void visit (AST::MetaItemPath &) {}
+  void visit (AST::MetaItemSeq &) {}
+  void visit (AST::MetaWord &) {}
+  void visit (AST::MetaNameValueStr &) {}
+  void visit (AST::MetaListPaths &) {}
+  void visit (AST::MetaListNameValueStr &) {}
+
+  void visit (AST::LiteralPattern &) {}
+  void visit (AST::IdentifierPattern &) {}
+  void visit (AST::WildcardPattern &) {}
+
+  void visit (AST::RangePatternBoundLiteral &) {}
+  void visit (AST::RangePatternBoundPath &) {}
+  void visit (AST::RangePatternBoundQualPath &) {}
+  void visit (AST::RangePattern &) {}
+  void visit (AST::ReferencePattern &) {}
+
+  void visit (AST::StructPatternFieldTuplePat &) {}
+  void visit (AST::StructPatternFieldIdentPat &) {}
+  void visit (AST::StructPatternFieldIdent &) {}
+  void visit (AST::StructPattern &) {}
+
+  void visit (AST::TupleStructItemsNoRange &) {}
+  void visit (AST::TupleStructItemsRange &) {}
+  void visit (AST::TupleStructPattern &) {}
+
+  void visit (AST::TuplePatternItemsMultiple &) {}
+  void visit (AST::TuplePatternItemsRanged &) {}
+  void visit (AST::TuplePattern &) {}
+  void visit (AST::GroupedPattern &) {}
+  void visit (AST::SlicePattern &) {}
+
+  void visit (AST::EmptyStmt &) {}
+  void visit (AST::LetStmt &) {}
+  void visit (AST::ExprStmtWithoutBlock &) {}
+  void visit (AST::ExprStmtWithBlock &) {}
+
+  void visit (AST::TraitBound &) {}
+  void visit (AST::ImplTraitType &) {}
+  void visit (AST::TraitObjectType &) {}
+  void visit (AST::ParenthesisedType &) {}
+  void visit (AST::ImplTraitTypeOneBound &) {}
+  void visit (AST::TraitObjectTypeOneBound &) {}
+  void visit (AST::TupleType &) {}
+  void visit (AST::NeverType &) {}
+  void visit (AST::RawPointerType &) {}
+  void visit (AST::ReferenceType &) {}
+  void visit (AST::ArrayType &) {}
+  void visit (AST::SliceType &) {}
+  void visit (AST::InferredType &) {}
+  void visit (AST::BareFunctionType &) {}
 
 protected:
   ResolverBase (NodeId parent)
diff --git a/gcc/rust/resolve/rust-ast-resolve-expr.h b/gcc/rust/resolve/rust-ast-resolve-expr.h
index f62f17c..d563f93 100644
--- a/gcc/rust/resolve/rust-ast-resolve-expr.h
+++ b/gcc/rust/resolve/rust-ast-resolve-expr.h
@@ -91,6 +91,15 @@ public:
     });
   }
 
+  void visit (AST::MethodCallExpr &expr)
+  {
+    ResolveExpr::go (expr.get_receiver_expr ().get (), expr.get_node_id ());
+    expr.iterate_params ([&] (AST::Expr *p) mutable -> bool {
+      ResolveExpr::go (p, expr.get_node_id ());
+      return true;
+    });
+  }
+
   void visit (AST::AssignmentExpr &expr)
   {
     ResolveExpr::go (expr.get_left_expr ().get (), expr.get_node_id ());
diff --git a/gcc/rust/resolve/rust-ast-resolve-implitem.h b/gcc/rust/resolve/rust-ast-resolve-implitem.h
index 74f2cdc..9cbef53 100644
--- a/gcc/rust/resolve/rust-ast-resolve-implitem.h
+++ b/gcc/rust/resolve/rust-ast-resolve-implitem.h
@@ -39,8 +39,12 @@ public:
   {
     std::string identifier
       = base->as_string () + "::" + constant.get_identifier ();
-    resolver->get_name_scope ().insert (identifier, constant.get_node_id (),
-					constant.get_locus ());
+    resolver->get_name_scope ().insert (
+      identifier, constant.get_node_id (), constant.get_locus (), false,
+      [&] (std::string, NodeId, Location locus) -> void {
+	rust_error_at (constant.get_locus (), "redefined multiple times");
+	rust_error_at (locus, "was defined here");
+      });
     resolver->insert_new_definition (constant.get_node_id (),
 				     Definition{constant.get_node_id (),
 						constant.get_node_id ()});
@@ -50,8 +54,12 @@ public:
   {
     std::string identifier
       = base->as_string () + "::" + function.get_function_name ();
-    resolver->get_name_scope ().insert (identifier, function.get_node_id (),
-					function.get_locus ());
+    resolver->get_name_scope ().insert (
+      identifier, function.get_node_id (), function.get_locus (), false,
+      [&] (std::string, NodeId, Location locus) -> void {
+	rust_error_at (function.get_locus (), "redefined multiple times");
+	rust_error_at (locus, "was defined here");
+      });
     resolver->insert_new_definition (function.get_node_id (),
 				     Definition{function.get_node_id (),
 						function.get_node_id ()});
@@ -61,8 +69,12 @@ public:
   {
     std::string identifier
       = base->as_string () + "::" + method.get_method_name ();
-    resolver->get_name_scope ().insert (identifier, method.get_node_id (),
-					method.get_locus ());
+    resolver->get_name_scope ().insert (
+      identifier, method.get_node_id (), method.get_locus (), false,
+      [&] (std::string, NodeId, Location locus) -> void {
+	rust_error_at (method.get_locus (), "redefined multiple times");
+	rust_error_at (locus, "was defined here");
+      });
     resolver->insert_new_definition (method.get_node_id (),
 				     Definition{method.get_node_id (),
 						method.get_node_id ()});
diff --git a/gcc/rust/resolve/rust-ast-resolve-item.h b/gcc/rust/resolve/rust-ast-resolve-item.h
index 74b5f8d..8b6227e 100644
--- a/gcc/rust/resolve/rust-ast-resolve-item.h
+++ b/gcc/rust/resolve/rust-ast-resolve-item.h
@@ -24,7 +24,6 @@
 #include "rust-ast-resolve-type.h"
 #include "rust-ast-resolve-pattern.h"
 #include "rust-ast-resolve-stmt.h"
-#include "rust-ast-resolve-unused.h"
 
 namespace Rust {
 namespace Resolver {
@@ -110,17 +109,76 @@ public:
     ResolveExpr::go (function.get_definition ().get (),
 		     function.get_node_id ());
 
-    ScanUnused::Scan (resolver->get_name_scope ().peek ());
-    ScanUnused::Scan (resolver->get_type_scope ().peek ());
-
     resolver->get_name_scope ().pop ();
     resolver->get_type_scope ().pop ();
   }
 
   void visit (AST::InherentImpl &impl_block)
   {
+    NodeId resolved_node = ResolveType::go (impl_block.get_type ().get (),
+					    impl_block.get_node_id ());
+    if (resolved_node == UNKNOWN_NODEID)
+      return;
+
+    resolver->get_type_scope ().insert (
+      "Self", resolved_node, impl_block.get_type ()->get_locus_slow ());
+
     for (auto &impl_item : impl_block.get_impl_items ())
       impl_item->accept_vis (*this);
+
+    resolver->get_type_scope ().peek ()->clear_name ("Self", resolved_node);
+  }
+
+  void visit (AST::Method &method)
+  {
+    if (method.has_return_type ())
+      ResolveType::go (method.get_return_type ().get (), method.get_node_id ());
+
+    NodeId scope_node_id = method.get_node_id ();
+    resolver->get_name_scope ().push (scope_node_id);
+    resolver->get_type_scope ().push (scope_node_id);
+    resolver->push_new_name_rib (resolver->get_name_scope ().peek ());
+    resolver->push_new_type_rib (resolver->get_type_scope ().peek ());
+
+    // self turns into self: Self as a function param
+    AST::SelfParam &self_param = method.get_self_param ();
+    AST::IdentifierPattern self_pattern (
+      self_param.get_node_id (), "self", self_param.get_locus (),
+      self_param.get_has_ref (), self_param.get_is_mut (),
+      std::unique_ptr<AST::Pattern> (nullptr));
+
+    std::vector<std::unique_ptr<AST::TypePathSegment> > segments;
+    segments.push_back (std::unique_ptr<AST::TypePathSegment> (
+      new AST::TypePathSegment ("Self", false, self_param.get_locus ())));
+
+    AST::TypePath self_type_path (std::move (segments),
+				  self_param.get_locus ());
+
+    ResolveType::go (&self_type_path, self_param.get_node_id ());
+    PatternDeclaration::go (&self_pattern, self_param.get_node_id ());
+
+    resolver->mark_assignment_to_decl (self_pattern.get_node_id (),
+				       self_pattern.get_node_id ());
+
+    // we make a new scope so the names of parameters are resolved and shadowed
+    // correctly
+    for (auto &param : method.get_function_params ())
+      {
+	ResolveType::go (param.get_type ().get (), param.get_node_id ());
+	PatternDeclaration::go (param.get_pattern ().get (),
+				param.get_node_id ());
+
+	// the mutability checker needs to verify for immutable decls the number
+	// of assignments are <1. This marks an implicit assignment
+	resolver->mark_assignment_to_decl (param.get_pattern ()->get_node_id (),
+					   param.get_node_id ());
+      }
+
+    // resolve the function body
+    ResolveExpr::go (method.get_definition ().get (), method.get_node_id ());
+
+    resolver->get_name_scope ().pop ();
+    resolver->get_type_scope ().pop ();
   }
 
 private:
diff --git a/gcc/rust/resolve/rust-ast-resolve-toplevel.h b/gcc/rust/resolve/rust-ast-resolve-toplevel.h
index 7ca8275..2e4e8e7 100644
--- a/gcc/rust/resolve/rust-ast-resolve-toplevel.h
+++ b/gcc/rust/resolve/rust-ast-resolve-toplevel.h
@@ -38,22 +38,34 @@ public:
 
   void visit (AST::TupleStruct &struct_decl)
   {
-    resolver->get_type_scope ().insert (struct_decl.get_identifier (),
-					struct_decl.get_node_id (),
-					struct_decl.get_locus ());
+    resolver->get_type_scope ().insert (
+      struct_decl.get_identifier (), struct_decl.get_node_id (),
+      struct_decl.get_locus (), false,
+      [&] (std::string, NodeId, Location locus) -> void {
+	rust_error_at (struct_decl.get_locus (), "redefined multiple times");
+	rust_error_at (locus, "was defined here");
+      });
   }
 
   void visit (AST::StructStruct &struct_decl)
   {
-    resolver->get_type_scope ().insert (struct_decl.get_identifier (),
-					struct_decl.get_node_id (),
-					struct_decl.get_locus ());
+    resolver->get_type_scope ().insert (
+      struct_decl.get_identifier (), struct_decl.get_node_id (),
+      struct_decl.get_locus (), false,
+      [&] (std::string, NodeId, Location locus) -> void {
+	rust_error_at (struct_decl.get_locus (), "redefined multiple times");
+	rust_error_at (locus, "was defined here");
+      });
   }
 
   void visit (AST::StaticItem &var)
   {
-    resolver->get_name_scope ().insert (var.get_identifier (),
-					var.get_node_id (), var.get_locus ());
+    resolver->get_name_scope ().insert (
+      var.get_identifier (), var.get_node_id (), var.get_locus (), false,
+      [&] (std::string, NodeId, Location locus) -> void {
+	rust_error_at (var.get_locus (), "redefined multiple times");
+	rust_error_at (locus, "was defined here");
+      });
     resolver->insert_new_definition (var.get_node_id (),
 				     Definition{var.get_node_id (),
 						var.get_node_id ()});
@@ -62,9 +74,13 @@ public:
 
   void visit (AST::ConstantItem &constant)
   {
-    resolver->get_name_scope ().insert (constant.get_identifier (),
-					constant.get_node_id (),
-					constant.get_locus ());
+    resolver->get_name_scope ().insert (
+      constant.get_identifier (), constant.get_node_id (),
+      constant.get_locus (), false,
+      [&] (std::string, NodeId, Location locus) -> void {
+	rust_error_at (constant.get_locus (), "redefined multiple times");
+	rust_error_at (locus, "was defined here");
+      });
     resolver->insert_new_definition (constant.get_node_id (),
 				     Definition{constant.get_node_id (),
 						constant.get_node_id ()});
@@ -72,9 +88,13 @@ public:
 
   void visit (AST::Function &function)
   {
-    resolver->get_name_scope ().insert (function.get_function_name (),
-					function.get_node_id (),
-					function.get_locus ());
+    resolver->get_name_scope ().insert (
+      function.get_function_name (), function.get_node_id (),
+      function.get_locus (), false,
+      [&] (std::string, NodeId, Location locus) -> void {
+	rust_error_at (function.get_locus (), "redefined multiple times");
+	rust_error_at (locus, "was defined here");
+      });
     resolver->insert_new_definition (function.get_node_id (),
 				     Definition{function.get_node_id (),
 						function.get_node_id ()});
@@ -90,10 +110,6 @@ public:
 
   void visit (AST::InherentImpl &impl_block)
   {
-    if (!ResolveType::go (impl_block.get_type ().get (),
-			  impl_block.get_node_id ()))
-      return;
-
     for (auto &impl_item : impl_block.get_impl_items ())
       ResolveToplevelImplItem::go (impl_item.get (),
 				   impl_block.get_type ().get ());
diff --git a/gcc/rust/resolve/rust-ast-resolve-type.h b/gcc/rust/resolve/rust-ast-resolve-type.h
index 258524b..ec8ee87 100644
--- a/gcc/rust/resolve/rust-ast-resolve-type.h
+++ b/gcc/rust/resolve/rust-ast-resolve-type.h
@@ -28,14 +28,14 @@ namespace Resolver {
 class ResolveType : public ResolverBase
 {
 public:
-  static bool go (AST::Type *type, NodeId parent)
+  static NodeId go (AST::Type *type, NodeId parent)
   {
     ResolveType resolver (parent);
     type->accept_vis (resolver);
     if (!resolver.ok)
       rust_error_at (type->get_locus_slow (), "unresolved type");
 
-    return resolver.ok;
+    return resolver.resolved_node;
   };
 
   void visit (AST::BareFunctionType &fntype)
diff --git a/gcc/rust/resolve/rust-ast-resolve-unused.h b/gcc/rust/resolve/rust-ast-resolve-unused.h
index 08b2db1..928cf11 100644
--- a/gcc/rust/resolve/rust-ast-resolve-unused.h
+++ b/gcc/rust/resolve/rust-ast-resolve-unused.h
@@ -24,10 +24,10 @@
 namespace Rust {
 namespace Resolver {
 
-class ScanUnused : public ResolverBase
+class ScanUnused
 {
 public:
-  static void Scan (Rib *r)
+  static void ScanRib (Rib *r)
   {
     r->iterate_decls ([&] (NodeId decl_node_id, Location locus) -> bool {
       if (!r->have_references_for_node (decl_node_id))
@@ -37,6 +37,13 @@ public:
       return true;
     });
   }
+
+  static void Scan ()
+  {
+    auto resolver = Resolver::get ();
+    resolver->iterate_name_ribs ([&] (Rib *r) -> void { ScanRib (r); });
+    resolver->iterate_type_ribs ([&] (Rib *r) -> void { ScanRib (r); });
+  }
 };
 
 } // namespace Resolver
diff --git a/gcc/rust/resolve/rust-ast-resolve.cc b/gcc/rust/resolve/rust-ast-resolve.cc
index 6731f13..d514132 100644
--- a/gcc/rust/resolve/rust-ast-resolve.cc
+++ b/gcc/rust/resolve/rust-ast-resolve.cc
@@ -22,7 +22,6 @@
 #include "rust-ast-resolve-toplevel.h"
 #include "rust-ast-resolve-item.h"
 #include "rust-ast-resolve-expr.h"
-#include "rust-ast-resolve-unused.h"
 
 #define MKBUILTIN_TYPE(_X, _R, _TY)                                            \
   do                                                                           \
@@ -110,7 +109,8 @@ Resolver::insert_builtin_types (Rib *r)
   auto builtins = get_builtin_types ();
   for (auto &builtin : builtins)
     r->insert_name (builtin->as_string (), builtin->get_node_id (),
-		    Linemap::predeclared_location ());
+		    Linemap::predeclared_location (), false,
+		    [] (std::string, NodeId, Location) -> void {});
 }
 
 std::vector<AST::Type *> &
@@ -283,9 +283,6 @@ NameResolution::go (AST::Crate &crate)
   // next we can drill down into the items and their scopes
   for (auto it = crate.items.begin (); it != crate.items.end (); it++)
     ResolveItem::go (it->get ());
-
-  ScanUnused::Scan (resolver->get_name_scope ().peek ());
-  ScanUnused::Scan (resolver->get_type_scope ().peek ());
 }
 
 // rust-ast-resolve-expr.h
@@ -307,9 +304,6 @@ ResolveExpr::visit (AST::BlockExpr &expr)
   if (expr.has_tail_expr ())
     ResolveExpr::go (expr.get_tail_expr ().get (), expr.get_node_id ());
 
-  ScanUnused::Scan (resolver->get_name_scope ().peek ());
-  ScanUnused::Scan (resolver->get_type_scope ().peek ());
-
   resolver->get_name_scope ().pop ();
   resolver->get_type_scope ().pop ();
 }
diff --git a/gcc/rust/resolve/rust-name-resolver.h b/gcc/rust/resolve/rust-name-resolver.h
index 5bc6aba..ea0e4f5 100644
--- a/gcc/rust/resolve/rust-name-resolver.h
+++ b/gcc/rust/resolve/rust-name-resolver.h
@@ -37,8 +37,25 @@ public:
 
   ~Rib () {}
 
-  void insert_name (std::string ident, NodeId id, Location locus)
+  void insert_name (std::string ident, NodeId id, Location locus, bool shadow,
+		    std::function<void (std::string, NodeId, Location)> dup_cb)
   {
+    auto it = mappings.find (ident);
+    bool already_exists = it != mappings.end ();
+    if (already_exists && !shadow)
+      {
+	for (auto &decl : decls_within_rib)
+	  {
+	    if (decl.first == it->second)
+	      {
+		dup_cb (ident, it->second, decl.second);
+		return;
+	      }
+	  }
+	dup_cb (ident, it->second, locus);
+	return;
+      }
+
     mappings[ident] = id;
     decls_within_rib.insert (std::pair<NodeId, Location> (id, locus));
     references[id] = {};
@@ -54,6 +71,19 @@ public:
     return true;
   }
 
+  void clear_name (std::string ident, NodeId id)
+  {
+    mappings.erase (ident);
+    for (auto &it : decls_within_rib)
+      {
+	if (it.first == id)
+	  {
+	    decls_within_rib.erase (it);
+	    break;
+	  }
+      }
+  }
+
   CrateNum get_crate_num () const { return crate_num; }
   NodeId get_node_id () const { return node_id; }
 
@@ -117,9 +147,16 @@ public:
   Scope (CrateNum crate_num) : crate_num (crate_num) {}
   ~Scope () {}
 
+  void insert (std::string ident, NodeId id, Location locus, bool shadow,
+	       std::function<void (std::string, NodeId, Location)> dup_cb)
+  {
+    peek ()->insert_name (ident, id, locus, shadow, dup_cb);
+  }
+
   void insert (std::string ident, NodeId id, Location locus)
   {
-    peek ()->insert_name (ident, id, locus);
+    peek ()->insert_name (ident, id, locus, true,
+			  [] (std::string, NodeId, Location) -> void {});
   }
 
   bool lookup (std::string ident, NodeId *id)
@@ -266,6 +303,23 @@ public:
     return it->second.size ();
   }
 
+  void iterate_name_ribs (std::function<void (Rib *)> cb)
+  {
+    for (auto it = name_ribs.begin (); it != name_ribs.end (); it++)
+      cb (it->second);
+  }
+
+  void iterate_type_ribs (std::function<void (Rib *)> cb)
+  {
+    for (auto it = type_ribs.begin (); it != type_ribs.end (); it++)
+      {
+	if (it->first == global_type_node_id)
+	  continue;
+
+	cb (it->second);
+      }
+  }
+
 private:
   Resolver ();