This setups an initial frame work for our resolution step for the pipeline

More work is required but it takes advantage of the vistior pattern
from the AST so we can do this without RTTI and dynamic_casts.

More passes on the AST AKA our HIR should follow this pattern.

Addresses: #12

3 files changed, 895 insertions, 0 deletions

diff --git a/gcc/rust/analysis/rust-resolution.cc b/gcc/rust/analysis/rust-resolution.cc
new file mode 100644
index 0000000..65fed90
--- /dev/null
+++ b/gcc/rust/analysis/rust-resolution.cc
@@ -0,0 +1,605 @@
+#include "rust-resolution.h"
+
+namespace Rust {
+namespace Analysis {
+
+TypeResolution::TypeResolution (AST::Crate &crate) : scope (), crate (crate) {}
+
+TypeResolution::~TypeResolution () {}
+
+bool
+TypeResolution::ResolveNamesAndTypes (AST::Crate &crate)
+{
+  TypeResolution resolver (crate);
+  return resolver.go ();
+}
+
+bool
+TypeResolution::go ()
+{
+  scope.Push ();
+  for (auto &item : crate.items)
+    {
+      item->accept_vis (*this);
+    }
+  scope.Pop ();
+  return true;
+}
+
+void
+TypeResolution::visit (AST::Token &tok)
+{}
+
+void
+TypeResolution::visit (AST::DelimTokenTree &delim_tok_tree)
+{}
+
+void
+TypeResolution::visit (AST::AttrInputMetaItemContainer &input)
+{}
+
+void
+TypeResolution::visit (AST::IdentifierExpr &ident_expr)
+{}
+
+void
+TypeResolution::visit (AST::Lifetime &lifetime)
+{}
+
+void
+TypeResolution::visit (AST::LifetimeParam &lifetime_param)
+{}
+
+void
+TypeResolution::visit (AST::MacroInvocationSemi &macro)
+{}
+
+// rust-path.h
+void
+TypeResolution::visit (AST::PathInExpression &path)
+{}
+void
+TypeResolution::visit (AST::TypePathSegment &segment)
+{}
+void
+TypeResolution::visit (AST::TypePathSegmentGeneric &segment)
+{}
+void
+TypeResolution::visit (AST::TypePathSegmentFunction &segment)
+{}
+void
+TypeResolution::visit (AST::TypePath &path)
+{}
+void
+TypeResolution::visit (AST::QualifiedPathInExpression &path)
+{}
+void
+TypeResolution::visit (AST::QualifiedPathInType &path)
+{}
+
+// rust-expr.h
+void
+TypeResolution::visit (AST::LiteralExpr &expr)
+{}
+void
+TypeResolution::visit (AST::AttrInputLiteral &attr_input)
+{}
+void
+TypeResolution::visit (AST::MetaItemLitExpr &meta_item)
+{}
+void
+TypeResolution::visit (AST::MetaItemPathLit &meta_item)
+{}
+void
+TypeResolution::visit (AST::BorrowExpr &expr)
+{}
+void
+TypeResolution::visit (AST::DereferenceExpr &expr)
+{}
+void
+TypeResolution::visit (AST::ErrorPropagationExpr &expr)
+{}
+void
+TypeResolution::visit (AST::NegationExpr &expr)
+{}
+void
+TypeResolution::visit (AST::ArithmeticOrLogicalExpr &expr)
+{}
+void
+TypeResolution::visit (AST::ComparisonExpr &expr)
+{}
+void
+TypeResolution::visit (AST::LazyBooleanExpr &expr)
+{}
+void
+TypeResolution::visit (AST::TypeCastExpr &expr)
+{}
+void
+TypeResolution::visit (AST::AssignmentExpr &expr)
+{}
+void
+TypeResolution::visit (AST::CompoundAssignmentExpr &expr)
+{}
+void
+TypeResolution::visit (AST::GroupedExpr &expr)
+{}
+// void TypeResolution::visit(ArrayElems& elems) {}
+void
+TypeResolution::visit (AST::ArrayElemsValues &elems)
+{}
+void
+TypeResolution::visit (AST::ArrayElemsCopied &elems)
+{}
+void
+TypeResolution::visit (AST::ArrayExpr &expr)
+{}
+void
+TypeResolution::visit (AST::ArrayIndexExpr &expr)
+{}
+void
+TypeResolution::visit (AST::TupleExpr &expr)
+{}
+void
+TypeResolution::visit (AST::TupleIndexExpr &expr)
+{}
+void
+TypeResolution::visit (AST::StructExprStruct &expr)
+{}
+// void TypeResolution::visit(StructExprField& field) {}
+void
+TypeResolution::visit (AST::StructExprFieldIdentifier &field)
+{}
+void
+TypeResolution::visit (AST::StructExprFieldIdentifierValue &field)
+{}
+void
+TypeResolution::visit (AST::StructExprFieldIndexValue &field)
+{}
+void
+TypeResolution::visit (AST::StructExprStructFields &expr)
+{}
+void
+TypeResolution::visit (AST::StructExprStructBase &expr)
+{}
+void
+TypeResolution::visit (AST::StructExprTuple &expr)
+{}
+void
+TypeResolution::visit (AST::StructExprUnit &expr)
+{}
+// void TypeResolution::visit(EnumExprField& field) {}
+void
+TypeResolution::visit (AST::EnumExprFieldIdentifier &field)
+{}
+void
+TypeResolution::visit (AST::EnumExprFieldIdentifierValue &field)
+{}
+void
+TypeResolution::visit (AST::EnumExprFieldIndexValue &field)
+{}
+void
+TypeResolution::visit (AST::EnumExprStruct &expr)
+{}
+void
+TypeResolution::visit (AST::EnumExprTuple &expr)
+{}
+void
+TypeResolution::visit (AST::EnumExprFieldless &expr)
+{}
+void
+TypeResolution::visit (AST::CallExpr &expr)
+{}
+void
+TypeResolution::visit (AST::MethodCallExpr &expr)
+{}
+void
+TypeResolution::visit (AST::FieldAccessExpr &expr)
+{}
+void
+TypeResolution::visit (AST::ClosureExprInner &expr)
+{}
+void
+TypeResolution::visit (AST::BlockExpr &expr)
+{}
+void
+TypeResolution::visit (AST::ClosureExprInnerTyped &expr)
+{}
+void
+TypeResolution::visit (AST::ContinueExpr &expr)
+{}
+void
+TypeResolution::visit (AST::BreakExpr &expr)
+{}
+void
+TypeResolution::visit (AST::RangeFromToExpr &expr)
+{}
+void
+TypeResolution::visit (AST::RangeFromExpr &expr)
+{}
+void
+TypeResolution::visit (AST::RangeToExpr &expr)
+{}
+void
+TypeResolution::visit (AST::RangeFullExpr &expr)
+{}
+void
+TypeResolution::visit (AST::RangeFromToInclExpr &expr)
+{}
+void
+TypeResolution::visit (AST::RangeToInclExpr &expr)
+{}
+void
+TypeResolution::visit (AST::ReturnExpr &expr)
+{}
+void
+TypeResolution::visit (AST::UnsafeBlockExpr &expr)
+{}
+void
+TypeResolution::visit (AST::LoopExpr &expr)
+{}
+void
+TypeResolution::visit (AST::WhileLoopExpr &expr)
+{}
+void
+TypeResolution::visit (AST::WhileLetLoopExpr &expr)
+{}
+void
+TypeResolution::visit (AST::ForLoopExpr &expr)
+{}
+void
+TypeResolution::visit (AST::IfExpr &expr)
+{}
+void
+TypeResolution::visit (AST::IfExprConseqElse &expr)
+{}
+void
+TypeResolution::visit (AST::IfExprConseqIf &expr)
+{}
+void
+TypeResolution::visit (AST::IfExprConseqIfLet &expr)
+{}
+void
+TypeResolution::visit (AST::IfLetExpr &expr)
+{}
+void
+TypeResolution::visit (AST::IfLetExprConseqElse &expr)
+{}
+void
+TypeResolution::visit (AST::IfLetExprConseqIf &expr)
+{}
+void
+TypeResolution::visit (AST::IfLetExprConseqIfLet &expr)
+{}
+// void TypeResolution::visit(MatchCase& match_case) {}
+void
+TypeResolution::visit (AST::MatchCaseBlockExpr &match_case)
+{}
+void
+TypeResolution::visit (AST::MatchCaseExpr &match_case)
+{}
+void
+TypeResolution::visit (AST::MatchExpr &expr)
+{}
+void
+TypeResolution::visit (AST::AwaitExpr &expr)
+{}
+void
+TypeResolution::visit (AST::AsyncBlockExpr &expr)
+{}
+
+// rust-item.h
+void
+TypeResolution::visit (AST::TypeParam &param)
+{}
+// void TypeResolution::visit(WhereClauseItem& item) {}
+void
+TypeResolution::visit (AST::LifetimeWhereClauseItem &item)
+{}
+void
+TypeResolution::visit (AST::TypeBoundWhereClauseItem &item)
+{}
+void
+TypeResolution::visit (AST::Method &method)
+{}
+void
+TypeResolution::visit (AST::ModuleBodied &module)
+{}
+void
+TypeResolution::visit (AST::ModuleNoBody &module)
+{}
+void
+TypeResolution::visit (AST::ExternCrate &crate)
+{}
+// void TypeResolution::visit(UseTree& use_tree) {}
+void
+TypeResolution::visit (AST::UseTreeGlob &use_tree)
+{}
+void
+TypeResolution::visit (AST::UseTreeList &use_tree)
+{}
+void
+TypeResolution::visit (AST::UseTreeRebind &use_tree)
+{}
+void
+TypeResolution::visit (AST::UseDeclaration &use_decl)
+{}
+
+void
+TypeResolution::visit (AST::Function &function)
+{
+  scope.Insert (function.function_name, function.return_type.get ());
+
+  scope.Push ();
+  printf ("INSIDE FUNCTION: %s\n", function.function_name.c_str ());
+
+  for (auto &param : function.function_params)
+    {
+      printf ("FUNC PARAM: %s\n", param.as_string ().c_str ());
+    }
+
+  // ensure return types
+  // TODO
+
+  // walk the expression body
+  for (auto &stmt : function.function_body->statements)
+    {
+      stmt->accept_vis (*this);
+    }
+
+  scope.Pop ();
+}
+
+void
+TypeResolution::visit (AST::TypeAlias &type_alias)
+{}
+void
+TypeResolution::visit (AST::StructStruct &struct_item)
+{}
+void
+TypeResolution::visit (AST::TupleStruct &tuple_struct)
+{}
+void
+TypeResolution::visit (AST::EnumItem &item)
+{}
+void
+TypeResolution::visit (AST::EnumItemTuple &item)
+{}
+void
+TypeResolution::visit (AST::EnumItemStruct &item)
+{}
+void
+TypeResolution::visit (AST::EnumItemDiscriminant &item)
+{}
+void
+TypeResolution::visit (AST::Enum &enum_item)
+{}
+void
+TypeResolution::visit (AST::Union &union_item)
+{}
+void
+TypeResolution::visit (AST::ConstantItem &const_item)
+{}
+void
+TypeResolution::visit (AST::StaticItem &static_item)
+{}
+void
+TypeResolution::visit (AST::TraitItemFunc &item)
+{}
+void
+TypeResolution::visit (AST::TraitItemMethod &item)
+{}
+void
+TypeResolution::visit (AST::TraitItemConst &item)
+{}
+void
+TypeResolution::visit (AST::TraitItemType &item)
+{}
+void
+TypeResolution::visit (AST::Trait &trait)
+{}
+void
+TypeResolution::visit (AST::InherentImpl &impl)
+{}
+void
+TypeResolution::visit (AST::TraitImpl &impl)
+{}
+// void TypeResolution::visit(ExternalItem& item) {}
+void
+TypeResolution::visit (AST::ExternalStaticItem &item)
+{}
+void
+TypeResolution::visit (AST::ExternalFunctionItem &item)
+{}
+void
+TypeResolution::visit (AST::ExternBlock &block)
+{}
+
+// rust-macro.h
+void
+TypeResolution::visit (AST::MacroMatchFragment &match)
+{}
+void
+TypeResolution::visit (AST::MacroMatchRepetition &match)
+{}
+void
+TypeResolution::visit (AST::MacroMatcher &matcher)
+{}
+void
+TypeResolution::visit (AST::MacroRulesDefinition &rules_def)
+{}
+void
+TypeResolution::visit (AST::MacroInvocation &macro_invoc)
+{}
+void
+TypeResolution::visit (AST::MetaItemPath &meta_item)
+{}
+void
+TypeResolution::visit (AST::MetaItemSeq &meta_item)
+{}
+void
+TypeResolution::visit (AST::MetaWord &meta_item)
+{}
+void
+TypeResolution::visit (AST::MetaNameValueStr &meta_item)
+{}
+void
+TypeResolution::visit (AST::MetaListPaths &meta_item)
+{}
+void
+TypeResolution::visit (AST::MetaListNameValueStr &meta_item)
+{}
+
+// rust-pattern.h
+void
+TypeResolution::visit (AST::LiteralPattern &pattern)
+{
+  printf ("LiteralPattern: %s\n", pattern.as_string ().c_str ());
+}
+
+void
+TypeResolution::visit (AST::IdentifierPattern &pattern)
+{
+  printf ("IdentifierPattern: %s\n", pattern.as_string ().c_str ());
+  letPatternBuffer.push_back (pattern);
+}
+
+void
+TypeResolution::visit (AST::WildcardPattern &pattern)
+{}
+// void TypeResolution::visit(RangePatternBound& bound) {}
+void
+TypeResolution::visit (AST::RangePatternBoundLiteral &bound)
+{}
+void
+TypeResolution::visit (AST::RangePatternBoundPath &bound)
+{}
+void
+TypeResolution::visit (AST::RangePatternBoundQualPath &bound)
+{}
+void
+TypeResolution::visit (AST::RangePattern &pattern)
+{}
+void
+TypeResolution::visit (AST::ReferencePattern &pattern)
+{}
+// void TypeResolution::visit(StructPatternField& field) {}
+void
+TypeResolution::visit (AST::StructPatternFieldTuplePat &field)
+{}
+void
+TypeResolution::visit (AST::StructPatternFieldIdentPat &field)
+{}
+void
+TypeResolution::visit (AST::StructPatternFieldIdent &field)
+{}
+void
+TypeResolution::visit (AST::StructPattern &pattern)
+{}
+// void TypeResolution::visit(TupleStructItems& tuple_items) {}
+void
+TypeResolution::visit (AST::TupleStructItemsNoRange &tuple_items)
+{}
+void
+TypeResolution::visit (AST::TupleStructItemsRange &tuple_items)
+{}
+void
+TypeResolution::visit (AST::TupleStructPattern &pattern)
+{}
+// void TypeResolution::visit(TuplePatternItems& tuple_items) {}
+void
+TypeResolution::visit (AST::TuplePatternItemsMultiple &tuple_items)
+{}
+void
+TypeResolution::visit (AST::TuplePatternItemsRanged &tuple_items)
+{}
+void
+TypeResolution::visit (AST::TuplePattern &pattern)
+{}
+void
+TypeResolution::visit (AST::GroupedPattern &pattern)
+{}
+void
+TypeResolution::visit (AST::SlicePattern &pattern)
+{}
+
+// rust-stmt.h
+void
+TypeResolution::visit (AST::EmptyStmt &stmt)
+{}
+void
+
+TypeResolution::visit (AST::LetStmt &stmt)
+{
+  printf ("Within LetStmt: %s\n", stmt.as_string ().c_str ());
+
+  if (!stmt.has_type ())
+    {
+      // infer the type
+      printf ("XXX UNKNOWN TYPE PLEASE INFER ME\n");
+    }
+
+  // TODO check we know what the type is
+
+  stmt.variables_pattern->accept_vis (*this);
+
+  for (auto it = letPatternBuffer.begin (); it != letPatternBuffer.end (); it++)
+    {
+      scope.Insert (it->variable_ident, stmt.type.get ());
+    }
+
+  letPatternBuffer.clear ();
+}
+
+void
+TypeResolution::visit (AST::ExprStmtWithoutBlock &stmt)
+{}
+void
+TypeResolution::visit (AST::ExprStmtWithBlock &stmt)
+{}
+
+// rust-type.h
+void
+TypeResolution::visit (AST::TraitBound &bound)
+{}
+void
+TypeResolution::visit (AST::ImplTraitType &type)
+{}
+void
+TypeResolution::visit (AST::TraitObjectType &type)
+{}
+void
+TypeResolution::visit (AST::ParenthesisedType &type)
+{}
+void
+TypeResolution::visit (AST::ImplTraitTypeOneBound &type)
+{}
+void
+TypeResolution::visit (AST::TraitObjectTypeOneBound &type)
+{}
+void
+TypeResolution::visit (AST::TupleType &type)
+{}
+void
+TypeResolution::visit (AST::NeverType &type)
+{}
+void
+TypeResolution::visit (AST::RawPointerType &type)
+{}
+void
+TypeResolution::visit (AST::ReferenceType &type)
+{}
+void
+TypeResolution::visit (AST::ArrayType &type)
+{}
+void
+TypeResolution::visit (AST::SliceType &type)
+{}
+void
+TypeResolution::visit (AST::InferredType &type)
+{}
+void
+TypeResolution::visit (AST::BareFunctionType &type)
+{}
+
+} // namespace Analysis
+} // namespace Rust
diff --git a/gcc/rust/analysis/rust-resolution.h b/gcc/rust/analysis/rust-resolution.h
new file mode 100644
index 0000000..940557e
--- /dev/null
+++ b/gcc/rust/analysis/rust-resolution.h
@@ -0,0 +1,235 @@
+#pragma once
+
+#include "rust-system.h"
+#include "rust-ast-full.h"
+#include "rust-ast-visitor.h"
+#include "scope.h"
+
+namespace Rust {
+namespace Analysis {
+
+class TypeResolution : public AST::ASTVisitor
+{
+public:
+  static bool ResolveNamesAndTypes (AST::Crate &crate);
+
+  ~TypeResolution ();
+
+  // 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);
+  // virtual 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);
+
+private:
+  TypeResolution (AST::Crate &crate);
+
+  bool go ();
+
+  Scope scope;
+  AST::Crate &crate;
+
+  std::vector<AST::IdentifierPattern> letPatternBuffer;
+};
+
+} // namespace Analysis
+} // namespace Rust
diff --git a/gcc/rust/analysis/scope.h b/gcc/rust/analysis/scope.h
new file mode 100644
index 0000000..0374251
--- /dev/null
+++ b/gcc/rust/analysis/scope.h
@@ -0,0 +1,55 @@
+#pragma once
+
+#include "rust-system.h"
+#include "rust-ast-full.h"
+
+namespace Rust {
+namespace Analysis {
+
+class Scope
+{
+public:
+  Scope () : scopeStack () {}
+
+  ~Scope () {}
+
+  bool Insert (std::string key, AST::Type *val)
+  {
+    if (scopeStack.back ().find (key) != scopeStack.back ().end ())
+      {
+	return false;
+      }
+
+    scopeStack.back ().insert (std::make_pair (key, std::move (val)));
+    return true;
+  }
+
+  bool Lookup (std::string key, AST::Type **result)
+  {
+    for (auto it = scopeStack.rbegin (); it != scopeStack.rend (); ++it)
+      {
+	auto lookup = it->find (key);
+	if (lookup != it->end ())
+	  {
+	    *result = lookup->second;
+	    return true;
+	  }
+      }
+    return false;
+  }
+
+  void Push () { scopeStack.push_back ({}); }
+
+  std ::map<std::string, AST::Type *> Pop ()
+  {
+    auto toplevel = scopeStack.back ();
+    scopeStack.pop_back ();
+    return toplevel;
+  }
+
+private:
+  std::vector<std::map<std::string, AST::Type *> > scopeStack;
+};
+
+} // namespace Analysis
+} // namespace Rust