Remove old analysis framework and strip the AST->GIMPLE pass this needs

to use the new name and type resolution pass contexts.

14 files changed, 103 insertions, 6389 deletions

diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in
index 96457ed..56f308e 100644
--- a/gcc/rust/Make-lang.in
+++ b/gcc/rust/Make-lang.in
@@ -69,9 +69,6 @@ GRS_OBJS = \
     rust/rust-parse.o \
     rust/rust-ast-full-test.o \
     rust/rust-session-manager.o \
-    rust/rust-name-resolution.o \
-    rust/rust-type-resolution.o \
-    rust/rust-scan.o \
     rust/rust-compile.o \
     rust/rust-macro-expand.o \
     rust/rust-hir-full-test.o \
@@ -261,11 +258,6 @@ rust/%.o: rust/ast/%.cc
 	$(COMPILE) $(RUST_CXXFLAGS) $(RUST_INCLUDES) $<
 	$(POSTCOMPILE)
 
-# build rust/analysis files in rust folder
-rust/%.o: rust/analysis/%.cc
-	$(COMPILE) $(RUST_CXXFLAGS) $(RUST_INCLUDES) $<
-	$(POSTCOMPILE)
-
 # build rust/backend files in rust folder
 rust/%.o: rust/backend/%.cc
 	$(COMPILE) $(RUST_CXXFLAGS) $(RUST_INCLUDES) $<
diff --git a/gcc/rust/analysis/rust-name-resolution.cc b/gcc/rust/analysis/rust-name-resolution.cc
deleted file mode 100644
index 28a4af8..0000000
--- a/gcc/rust/analysis/rust-name-resolution.cc
+++ /dev/null
@@ -1,657 +0,0 @@
-#include "rust-name-resolution.h"
-#include "rust-diagnostics.h"
-
-/*
- * The principles of name resolution:
- * 1. If a name resolves to a binding then it should always resolve to that
- * binding, and if resolving a name produces an error, it should always produce
- * an error.
- * 2. Avoid errors due to the resolver being stuck.
- * 3. Names should be able to be used before they are declared, but the order of
- * declarations should be irrelevant.
- * 4. Macros should be hygiene and manually expandable.
- * 5. Glob imports should be manually expandable.
- */
-
-/* The algorithm of name resolution
- * 1. When encouter items which bind a name, add the name to the binding table.
- * 2. When we find an import which can't be resolved, we add it to a work list.
- * 3. When we find a glob import, we have to record a 'back link', so that when
- *    a public name is added for the supplying module, we can add it for the
- *    importing module.
- * 4. Loop over the work list and try to lookup names.
- *    a. If a name has exactly one best binding then we use it (and record the
- *       binding on a list of resolved names).
- *    b. If there are zero then we put it back on the work list.
- *    c. If there is more than one binding, then we record an ambiguity error.
- *    d. When the work list no longer changes, then we are done.
- *    e. If the work list is empty, then expansion/import resolution succeeded.
- *       Otherwise there are names not found, or ambiguous names, then failed.
- * 5. When looking up names, we record the resolutions in the binding table.
- *    a. If the name a glob import, we add bindings for every accessible name
- *       currently known.
- * 6. To expand a macro, we try to resolve the macro's name.
- *    a. If that fails, we put it on the work list.
- *       Otherwise, we expand that macro by parsing the arguments,
- *       pattern matching, and doing hygienic expansion.
- *    b. We then parse the generated code in the same way as we parsed the
- *       original program. We add new names to the binding table, and expand any
- *       new macro uses.
- * 7. If we add names for a module which has back links, we must follow them and
- *    add these names to the importing module (if they are accessible).
- */
-
-namespace Rust {
-namespace Analysis {
-
-NameResolution::NameResolution (AST::Crate &crate, TopLevelScan &toplevel)
-  : Resolution (crate, toplevel), is_work_list_changed_ (false)
-
-{}
-
-NameResolution::~NameResolution () {}
-
-bool
-NameResolution::Resolve (AST::Crate &crate, TopLevelScan &toplevel)
-{
-  NameResolution resolver (crate, toplevel);
-  return resolver.go ();
-}
-
-void
-NameResolution::process_work_list ()
-{}
-
-void
-NameResolution::expand_macros ()
-{}
-
-bool
-NameResolution::go ()
-{
-  bool ret = true;
-
-  do
-    {
-      for (auto &item : crate.items)
-	{
-	  item->accept_vis (*this);
-	}
-    }
-  while (is_work_list_changed ());
-
-  ret = work_list_.empty ();
-  for (auto &item : work_list_)
-    {
-      std::cout << "Resolution error: " << item.as_string () << std::endl;
-    }
-
-  return ret;
-}
-
-void
-NameResolution::visit (AST::Token &tok)
-{}
-
-void
-NameResolution::visit (AST::DelimTokenTree &delim_tok_tree)
-{}
-
-void
-NameResolution::visit (AST::AttrInputMetaItemContainer &input)
-{}
-
-void
-NameResolution::visit (AST::IdentifierExpr &ident_expr)
-{
-  do
-    {
-      process_work_list ();
-    }
-  while (is_work_list_changed ());
-  expand_macros ();
-}
-
-void
-NameResolution::visit (AST::Lifetime &lifetime)
-{}
-
-void
-NameResolution::visit (AST::LifetimeParam &lifetime_param)
-{}
-
-void
-NameResolution::visit (AST::MacroInvocationSemi &macro)
-{}
-
-// rust-path.h
-void
-NameResolution::visit (AST::PathInExpression &path)
-{}
-
-void
-NameResolution::visit (AST::TypePathSegment &segment)
-{}
-void
-NameResolution::visit (AST::TypePathSegmentGeneric &segment)
-{}
-
-void
-NameResolution::visit (AST::TypePathSegmentFunction &segment)
-{}
-
-void
-NameResolution::visit (AST::TypePath &path)
-{}
-
-void
-NameResolution::visit (AST::QualifiedPathInExpression &path)
-{
-  typeComparisonBuffer.push_back (path.as_string ());
-}
-
-void
-NameResolution::visit (AST::QualifiedPathInType &path)
-{}
-
-// rust-expr.h
-void
-NameResolution::visit (AST::LiteralExpr &expr)
-{}
-
-void
-NameResolution::visit (AST::AttrInputLiteral &attr_input)
-{}
-
-void
-NameResolution::visit (AST::MetaItemLitExpr &meta_item)
-{}
-
-void
-NameResolution::visit (AST::MetaItemPathLit &meta_item)
-{}
-
-void
-NameResolution::visit (AST::BorrowExpr &expr)
-{}
-void
-NameResolution::visit (AST::DereferenceExpr &expr)
-{}
-void
-NameResolution::visit (AST::ErrorPropagationExpr &expr)
-{}
-void
-NameResolution::visit (AST::NegationExpr &expr)
-{}
-
-void
-NameResolution::visit (AST::ArithmeticOrLogicalExpr &expr)
-{}
-
-void
-NameResolution::visit (AST::ComparisonExpr &expr)
-{}
-
-void
-NameResolution::visit (AST::LazyBooleanExpr &expr)
-{}
-
-void
-NameResolution::visit (AST::TypeCastExpr &expr)
-{}
-
-void
-NameResolution::visit (AST::AssignmentExpr &expr)
-{}
-
-void
-NameResolution::visit (AST::CompoundAssignmentExpr &expr)
-{}
-
-void
-NameResolution::visit (AST::GroupedExpr &expr)
-{}
-// void NameResolution::visit(ArrayElems& elems) {}
-void
-NameResolution::visit (AST::ArrayElemsValues &elems)
-{}
-void
-NameResolution::visit (AST::ArrayElemsCopied &elems)
-{}
-void
-NameResolution::visit (AST::ArrayExpr &expr)
-{}
-void
-NameResolution::visit (AST::ArrayIndexExpr &expr)
-{}
-void
-NameResolution::visit (AST::TupleExpr &expr)
-{}
-void
-NameResolution::visit (AST::TupleIndexExpr &expr)
-{}
-void
-NameResolution::visit (AST::StructExprStruct &expr)
-{}
-// void NameResolution::visit(StructExprField& field) {}
-void
-NameResolution::visit (AST::StructExprFieldIdentifier &field)
-{}
-void
-NameResolution::visit (AST::StructExprFieldIdentifierValue &field)
-{}
-void
-NameResolution::visit (AST::StructExprFieldIndexValue &field)
-{}
-void
-NameResolution::visit (AST::StructExprStructFields &expr)
-{}
-void
-NameResolution::visit (AST::StructExprStructBase &expr)
-{}
-void
-NameResolution::visit (AST::StructExprTuple &expr)
-{}
-void
-NameResolution::visit (AST::StructExprUnit &expr)
-{}
-// void NameResolution::visit(EnumExprField& field) {}
-void
-NameResolution::visit (AST::EnumExprFieldIdentifier &field)
-{}
-void
-NameResolution::visit (AST::EnumExprFieldIdentifierValue &field)
-{}
-void
-NameResolution::visit (AST::EnumExprFieldIndexValue &field)
-{}
-void
-NameResolution::visit (AST::EnumExprStruct &expr)
-{}
-void
-NameResolution::visit (AST::EnumExprTuple &expr)
-{}
-void
-NameResolution::visit (AST::EnumExprFieldless &expr)
-{}
-
-void
-NameResolution::visit (AST::CallExpr &expr)
-{}
-
-void
-NameResolution::visit (AST::MethodCallExpr &expr)
-{}
-void
-NameResolution::visit (AST::FieldAccessExpr &expr)
-{}
-void
-NameResolution::visit (AST::ClosureExprInner &expr)
-{}
-void
-NameResolution::visit (AST::BlockExpr &expr)
-{}
-void
-NameResolution::visit (AST::ClosureExprInnerTyped &expr)
-{}
-void
-NameResolution::visit (AST::ContinueExpr &expr)
-{}
-void
-NameResolution::visit (AST::BreakExpr &expr)
-{}
-void
-NameResolution::visit (AST::RangeFromToExpr &expr)
-{}
-void
-NameResolution::visit (AST::RangeFromExpr &expr)
-{}
-void
-NameResolution::visit (AST::RangeToExpr &expr)
-{}
-void
-NameResolution::visit (AST::RangeFullExpr &expr)
-{}
-void
-NameResolution::visit (AST::RangeFromToInclExpr &expr)
-{}
-void
-NameResolution::visit (AST::RangeToInclExpr &expr)
-{}
-void
-NameResolution::visit (AST::ReturnExpr &expr)
-{}
-void
-NameResolution::visit (AST::UnsafeBlockExpr &expr)
-{}
-void
-NameResolution::visit (AST::LoopExpr &expr)
-{}
-void
-NameResolution::visit (AST::WhileLoopExpr &expr)
-{}
-void
-NameResolution::visit (AST::WhileLetLoopExpr &expr)
-{}
-void
-NameResolution::visit (AST::ForLoopExpr &expr)
-{}
-void
-NameResolution::visit (AST::IfExpr &expr)
-{}
-void
-NameResolution::visit (AST::IfExprConseqElse &expr)
-{}
-void
-NameResolution::visit (AST::IfExprConseqIf &expr)
-{}
-void
-NameResolution::visit (AST::IfExprConseqIfLet &expr)
-{}
-void
-NameResolution::visit (AST::IfLetExpr &expr)
-{}
-void
-NameResolution::visit (AST::IfLetExprConseqElse &expr)
-{}
-void
-NameResolution::visit (AST::IfLetExprConseqIf &expr)
-{}
-void
-NameResolution::visit (AST::IfLetExprConseqIfLet &expr)
-{}
-// void NameResolution::visit(MatchCase& match_case) {}
-/*void
-NameResolution::visit (AST::MatchCaseBlockExpr &match_case)
-{}*/
-/*void
-NameResolution::visit (AST::MatchCaseExpr &match_case)
-{}*/
-void
-NameResolution::visit (AST::MatchExpr &expr)
-{}
-void
-NameResolution::visit (AST::AwaitExpr &expr)
-{}
-void
-NameResolution::visit (AST::AsyncBlockExpr &expr)
-{}
-
-// rust-item.h
-void
-NameResolution::visit (AST::TypeParam &param)
-{}
-// void NameResolution::visit(WhereClauseItem& item) {}
-void
-NameResolution::visit (AST::LifetimeWhereClauseItem &item)
-{}
-void
-NameResolution::visit (AST::TypeBoundWhereClauseItem &item)
-{}
-void
-NameResolution::visit (AST::Method &method)
-{}
-void
-NameResolution::visit (AST::ModuleBodied &module)
-{}
-void
-NameResolution::visit (AST::ModuleNoBody &module)
-{}
-void
-NameResolution::visit (AST::ExternCrate &crate)
-{}
-// void NameResolution::visit(UseTree& use_tree) {}
-void
-NameResolution::visit (AST::UseTreeGlob &use_tree)
-{}
-void
-NameResolution::visit (AST::UseTreeList &use_tree)
-{}
-void
-NameResolution::visit (AST::UseTreeRebind &use_tree)
-{}
-void
-NameResolution::visit (AST::UseDeclaration &use_decl)
-{}
-
-void
-NameResolution::visit (AST::Function &function)
-{}
-
-void
-NameResolution::visit (AST::TypeAlias &type_alias)
-{}
-void
-NameResolution::visit (AST::StructStruct &struct_item)
-{}
-void
-NameResolution::visit (AST::TupleStruct &tuple_struct)
-{}
-void
-NameResolution::visit (AST::EnumItem &item)
-{}
-void
-NameResolution::visit (AST::EnumItemTuple &item)
-{}
-void
-NameResolution::visit (AST::EnumItemStruct &item)
-{}
-void
-NameResolution::visit (AST::EnumItemDiscriminant &item)
-{}
-void
-NameResolution::visit (AST::Enum &enum_item)
-{}
-void
-NameResolution::visit (AST::Union &union_item)
-{}
-
-void
-NameResolution::visit (AST::ConstantItem &const_item)
-{}
-
-void
-NameResolution::visit (AST::StaticItem &static_item)
-{}
-void
-NameResolution::visit (AST::TraitItemFunc &item)
-{}
-void
-NameResolution::visit (AST::TraitItemMethod &item)
-{}
-void
-NameResolution::visit (AST::TraitItemConst &item)
-{}
-void
-NameResolution::visit (AST::TraitItemType &item)
-{}
-void
-NameResolution::visit (AST::Trait &trait)
-{}
-void
-NameResolution::visit (AST::InherentImpl &impl)
-{}
-void
-NameResolution::visit (AST::TraitImpl &impl)
-{}
-// void NameResolution::visit(ExternalItem& item) {}
-void
-NameResolution::visit (AST::ExternalStaticItem &item)
-{}
-void
-NameResolution::visit (AST::ExternalFunctionItem &item)
-{}
-void
-NameResolution::visit (AST::ExternBlock &block)
-{}
-
-// rust-macro.h
-void
-NameResolution::visit (AST::MacroMatchFragment &match)
-{}
-void
-NameResolution::visit (AST::MacroMatchRepetition &match)
-{}
-void
-NameResolution::visit (AST::MacroMatcher &matcher)
-{}
-
-void
-NameResolution::visit (AST::MacroRulesDefinition &rules_def)
-{}
-
-void
-NameResolution::visit (AST::MacroInvocation &macro_invoc)
-{}
-void
-NameResolution::visit (AST::MetaItemPath &meta_item)
-{}
-void
-NameResolution::visit (AST::MetaItemSeq &meta_item)
-{}
-void
-NameResolution::visit (AST::MetaWord &meta_item)
-{}
-void
-NameResolution::visit (AST::MetaNameValueStr &meta_item)
-{}
-void
-NameResolution::visit (AST::MetaListPaths &meta_item)
-{}
-void
-NameResolution::visit (AST::MetaListNameValueStr &meta_item)
-{}
-
-// rust-pattern.h
-void
-NameResolution::visit (AST::LiteralPattern &pattern)
-{}
-
-void
-NameResolution::visit (AST::IdentifierPattern &pattern)
-{}
-
-void
-NameResolution::visit (AST::WildcardPattern &pattern)
-{}
-// void NameResolution::visit(RangePatternBound& bound) {}
-void
-NameResolution::visit (AST::RangePatternBoundLiteral &bound)
-{}
-void
-NameResolution::visit (AST::RangePatternBoundPath &bound)
-{}
-void
-NameResolution::visit (AST::RangePatternBoundQualPath &bound)
-{}
-void
-NameResolution::visit (AST::RangePattern &pattern)
-{}
-void
-NameResolution::visit (AST::ReferencePattern &pattern)
-{}
-// void NameResolution::visit(StructPatternField& field) {}
-void
-NameResolution::visit (AST::StructPatternFieldTuplePat &field)
-{}
-void
-NameResolution::visit (AST::StructPatternFieldIdentPat &field)
-{}
-void
-NameResolution::visit (AST::StructPatternFieldIdent &field)
-{}
-void
-NameResolution::visit (AST::StructPattern &pattern)
-{}
-// void NameResolution::visit(TupleStructItems& tuple_items) {}
-void
-NameResolution::visit (AST::TupleStructItemsNoRange &tuple_items)
-{}
-void
-NameResolution::visit (AST::TupleStructItemsRange &tuple_items)
-{}
-void
-NameResolution::visit (AST::TupleStructPattern &pattern)
-{}
-// void NameResolution::visit(TuplePatternItems& tuple_items) {}
-void
-NameResolution::visit (AST::TuplePatternItemsMultiple &tuple_items)
-{}
-void
-NameResolution::visit (AST::TuplePatternItemsRanged &tuple_items)
-{}
-void
-NameResolution::visit (AST::TuplePattern &pattern)
-{}
-void
-NameResolution::visit (AST::GroupedPattern &pattern)
-{}
-void
-NameResolution::visit (AST::SlicePattern &pattern)
-{}
-
-// rust-stmt.h
-void
-NameResolution::visit (AST::EmptyStmt &stmt)
-{}
-
-void
-NameResolution::visit (AST::LetStmt &stmt)
-{}
-
-void
-NameResolution::visit (AST::ExprStmtWithoutBlock &stmt)
-{}
-
-void
-NameResolution::visit (AST::ExprStmtWithBlock &stmt)
-{}
-
-// rust-type.h
-void
-NameResolution::visit (AST::TraitBound &bound)
-{}
-
-void
-NameResolution::visit (AST::ImplTraitType &type)
-{}
-
-void
-NameResolution::visit (AST::TraitObjectType &type)
-{}
-void
-NameResolution::visit (AST::ParenthesisedType &type)
-{}
-void
-NameResolution::visit (AST::ImplTraitTypeOneBound &type)
-{}
-void
-NameResolution::visit (AST::TraitObjectTypeOneBound &type)
-{}
-void
-NameResolution::visit (AST::TupleType &type)
-{}
-void
-NameResolution::visit (AST::NeverType &type)
-{}
-void
-NameResolution::visit (AST::RawPointerType &type)
-{}
-void
-NameResolution::visit (AST::ReferenceType &type)
-{}
-void
-NameResolution::visit (AST::ArrayType &type)
-{}
-void
-NameResolution::visit (AST::SliceType &type)
-{}
-void
-NameResolution::visit (AST::InferredType &type)
-{}
-void
-NameResolution::visit (AST::BareFunctionType &type)
-{}
-
-} // namespace Analysis
-} // namespace Rust
diff --git a/gcc/rust/analysis/rust-name-resolution.h b/gcc/rust/analysis/rust-name-resolution.h
deleted file mode 100644
index b3bc780..0000000
--- a/gcc/rust/analysis/rust-name-resolution.h
+++ /dev/null
@@ -1,232 +0,0 @@
-#pragma once
-
-#include "rust-resolution.h"
-#include <list>
-
-namespace Rust {
-namespace Analysis {
-
-class NameResolution : public Resolution
-{
-public:
-  ~NameResolution ();
-  static bool Resolve (AST::Crate &crate, TopLevelScan &toplevel);
-
-  // visitor impl
-  // rust-ast.h
-  //  void visit(AttrInput& attr_input);
-  //  void visit(TokenTree& token_tree);
-  //  void visit(MacroMatch& macro_match);
-  void visit (AST::Token &tok) override;
-  void visit (AST::DelimTokenTree &delim_tok_tree) override;
-  void visit (AST::AttrInputMetaItemContainer &input) override;
-  //  void visit(MetaItem& meta_item) override;
-  //  void vsit(Stmt& stmt) override;
-  //  void visit(Expr& expr) override;
-  void visit (AST::IdentifierExpr &ident_expr) override;
-  //  void visit(Pattern& pattern) override;
-  //  void visit(Type& type) override;
-  //  void visit(TypeParamBound& type_param_bound) override;
-  void visit (AST::Lifetime &lifetime) override;
-  //  void visit(GenericParam& generic_param) override;
-  void visit (AST::LifetimeParam &lifetime_param) override;
-  //  void visit(TraitItem& trait_item) override;
-  //  void visit(InherentImplItem& inherent_impl_item) override;
-  //  void visit(TraitImplItem& trait_impl_item) override;
-  void visit (AST::MacroInvocationSemi &macro) override;
-
-  // rust-path.h
-  void visit (AST::PathInExpression &path) override;
-  void visit (AST::TypePathSegment &segment) override;
-  void visit (AST::TypePathSegmentGeneric &segment) override;
-  void visit (AST::TypePathSegmentFunction &segment) override;
-  void visit (AST::TypePath &path) override;
-  void visit (AST::QualifiedPathInExpression &path) override;
-  void visit (AST::QualifiedPathInType &path) override;
-
-  // rust-expr.h
-  void visit (AST::LiteralExpr &expr) override;
-  void visit (AST::AttrInputLiteral &attr_input) override;
-  void visit (AST::MetaItemLitExpr &meta_item) override;
-  void visit (AST::MetaItemPathLit &meta_item) override;
-  void visit (AST::BorrowExpr &expr) override;
-  void visit (AST::DereferenceExpr &expr) override;
-  void visit (AST::ErrorPropagationExpr &expr) override;
-  void visit (AST::NegationExpr &expr) override;
-  void visit (AST::ArithmeticOrLogicalExpr &expr) override;
-  void visit (AST::ComparisonExpr &expr) override;
-  void visit (AST::LazyBooleanExpr &expr) override;
-  void visit (AST::TypeCastExpr &expr) override;
-  void visit (AST::AssignmentExpr &expr) override;
-  void visit (AST::CompoundAssignmentExpr &expr) override;
-  void visit (AST::GroupedExpr &expr) override;
-  //  void visit(ArrayElems& elems) override;
-  void visit (AST::ArrayElemsValues &elems) override;
-  void visit (AST::ArrayElemsCopied &elems) override;
-  void visit (AST::ArrayExpr &expr) override;
-  void visit (AST::ArrayIndexExpr &expr) override;
-  void visit (AST::TupleExpr &expr) override;
-  void visit (AST::TupleIndexExpr &expr) override;
-  void visit (AST::StructExprStruct &expr) override;
-  //  void visit(StructExprField& field) override;
-  void visit (AST::StructExprFieldIdentifier &field) override;
-  void visit (AST::StructExprFieldIdentifierValue &field) override;
-  void visit (AST::StructExprFieldIndexValue &field) override;
-  void visit (AST::StructExprStructFields &expr) override;
-  void visit (AST::StructExprStructBase &expr) override;
-  void visit (AST::StructExprTuple &expr) override;
-  void visit (AST::StructExprUnit &expr) override;
-  //  void visit(EnumExprField& field) override;
-  void visit (AST::EnumExprFieldIdentifier &field) override;
-  void visit (AST::EnumExprFieldIdentifierValue &field) override;
-  void visit (AST::EnumExprFieldIndexValue &field) override;
-  void visit (AST::EnumExprStruct &expr) override;
-  void visit (AST::EnumExprTuple &expr) override;
-  void visit (AST::EnumExprFieldless &expr) override;
-  void visit (AST::CallExpr &expr) override;
-  void visit (AST::MethodCallExpr &expr) override;
-  void visit (AST::FieldAccessExpr &expr) override;
-  void visit (AST::ClosureExprInner &expr) override;
-  void visit (AST::BlockExpr &expr) override;
-  void visit (AST::ClosureExprInnerTyped &expr) override;
-  void visit (AST::ContinueExpr &expr) override;
-  void visit (AST::BreakExpr &expr) override;
-  void visit (AST::RangeFromToExpr &expr) override;
-  void visit (AST::RangeFromExpr &expr) override;
-  void visit (AST::RangeToExpr &expr) override;
-  void visit (AST::RangeFullExpr &expr) override;
-  void visit (AST::RangeFromToInclExpr &expr) override;
-  void visit (AST::RangeToInclExpr &expr) override;
-  void visit (AST::ReturnExpr &expr) override;
-  void visit (AST::UnsafeBlockExpr &expr) override;
-  void visit (AST::LoopExpr &expr) override;
-  void visit (AST::WhileLoopExpr &expr) override;
-  void visit (AST::WhileLetLoopExpr &expr) override;
-  void visit (AST::ForLoopExpr &expr) override;
-  void visit (AST::IfExpr &expr) override;
-  void visit (AST::IfExprConseqElse &expr) override;
-  void visit (AST::IfExprConseqIf &expr) override;
-  void visit (AST::IfExprConseqIfLet &expr) override;
-  void visit (AST::IfLetExpr &expr) override;
-  void visit (AST::IfLetExprConseqElse &expr) override;
-  void visit (AST::IfLetExprConseqIf &expr) override;
-  void visit (AST::IfLetExprConseqIfLet &expr) override;
-  //  void visit(MatchCase& match_case) override;
-  // void visit (AST::MatchCaseBlockExpr &match_case) override;
-  // void visit (AST::MatchCaseExpr &match_case) override;
-  void visit (AST::MatchExpr &expr) override;
-  void visit (AST::AwaitExpr &expr) override;
-  void visit (AST::AsyncBlockExpr &expr) override;
-
-  // rust-item.h
-  void visit (AST::TypeParam &param) override;
-  //  void visit(WhereClauseItem& item) override;
-  void visit (AST::LifetimeWhereClauseItem &item) override;
-  void visit (AST::TypeBoundWhereClauseItem &item) override;
-  void visit (AST::Method &method) override;
-  void visit (AST::ModuleBodied &module) override;
-  void visit (AST::ModuleNoBody &module) override;
-  void visit (AST::ExternCrate &crate) override;
-  //  void visit(UseTree& use_tree) override;
-  void visit (AST::UseTreeGlob &use_tree) override;
-  void visit (AST::UseTreeList &use_tree) override;
-  void visit (AST::UseTreeRebind &use_tree) override;
-  void visit (AST::UseDeclaration &use_decl) override;
-  void visit (AST::Function &function) override;
-  void visit (AST::TypeAlias &type_alias) override;
-  void visit (AST::StructStruct &struct_item) override;
-  void visit (AST::TupleStruct &tuple_struct) override;
-  void visit (AST::EnumItem &item) override;
-  void visit (AST::EnumItemTuple &item) override;
-  void visit (AST::EnumItemStruct &item) override;
-  void visit (AST::EnumItemDiscriminant &item) override;
-  void visit (AST::Enum &enum_item) override;
-  void visit (AST::Union &union_item) override;
-  void visit (AST::ConstantItem &const_item) override;
-  void visit (AST::StaticItem &static_item) override;
-  void visit (AST::TraitItemFunc &item) override;
-  void visit (AST::TraitItemMethod &item) override;
-  void visit (AST::TraitItemConst &item) override;
-  void visit (AST::TraitItemType &item) override;
-  void visit (AST::Trait &trait) override;
-  void visit (AST::InherentImpl &impl) override;
-  void visit (AST::TraitImpl &impl) override;
-  //  void visit(ExternalItem& item) override;
-  void visit (AST::ExternalStaticItem &item) override;
-  void visit (AST::ExternalFunctionItem &item) override;
-  void visit (AST::ExternBlock &block) override;
-
-  // rust-macro.h
-  void visit (AST::MacroMatchFragment &match) override;
-  void visit (AST::MacroMatchRepetition &match) override;
-  void visit (AST::MacroMatcher &matcher) override;
-  void visit (AST::MacroRulesDefinition &rules_def) override;
-  void visit (AST::MacroInvocation &macro_invoc) override;
-  void visit (AST::MetaItemPath &meta_item) override;
-  void visit (AST::MetaItemSeq &meta_item) override;
-  void visit (AST::MetaWord &meta_item) override;
-  void visit (AST::MetaNameValueStr &meta_item) override;
-  void visit (AST::MetaListPaths &meta_item) override;
-  void visit (AST::MetaListNameValueStr &meta_item) override;
-
-  // rust-pattern.h
-  void visit (AST::LiteralPattern &pattern) override;
-  void visit (AST::IdentifierPattern &pattern) override;
-  void visit (AST::WildcardPattern &pattern) override;
-  //  void visit(RangePatternBound& bound) override;
-  void visit (AST::RangePatternBoundLiteral &bound) override;
-  void visit (AST::RangePatternBoundPath &bound) override;
-  void visit (AST::RangePatternBoundQualPath &bound) override;
-  void visit (AST::RangePattern &pattern) override;
-  void visit (AST::ReferencePattern &pattern) override;
-  //  void visit(StructPatternField& field) override;
-  void visit (AST::StructPatternFieldTuplePat &field) override;
-  void visit (AST::StructPatternFieldIdentPat &field) override;
-  void visit (AST::StructPatternFieldIdent &field) override;
-  void visit (AST::StructPattern &pattern) override;
-  //  void visit(TupleStructItems& tuple_items) override;
-  void visit (AST::TupleStructItemsNoRange &tuple_items) override;
-  void visit (AST::TupleStructItemsRange &tuple_items) override;
-  void visit (AST::TupleStructPattern &pattern) override;
-  //  void visit(TuplePatternItems& tuple_items) override;
-  void visit (AST::TuplePatternItemsMultiple &tuple_items) override;
-  void visit (AST::TuplePatternItemsRanged &tuple_items) override;
-  void visit (AST::TuplePattern &pattern) override;
-  void visit (AST::GroupedPattern &pattern) override;
-  void visit (AST::SlicePattern &pattern) override;
-
-  // rust-stmt.h
-  void visit (AST::EmptyStmt &stmt) override;
-  void visit (AST::LetStmt &stmt) override;
-  void visit (AST::ExprStmtWithoutBlock &stmt) override;
-  void visit (AST::ExprStmtWithBlock &stmt) override;
-
-  // rust-type.h
-  void visit (AST::TraitBound &bound) override;
-  void visit (AST::ImplTraitType &type) override;
-  void visit (AST::TraitObjectType &type) override;
-  void visit (AST::ParenthesisedType &type) override;
-  void visit (AST::ImplTraitTypeOneBound &type) override;
-  void visit (AST::TraitObjectTypeOneBound &type) override;
-  void visit (AST::TupleType &type) override;
-  void visit (AST::NeverType &type) override;
-  void visit (AST::RawPointerType &type) override;
-  void visit (AST::ReferenceType &type) override;
-  void visit (AST::ArrayType &type) override;
-  void visit (AST::SliceType &type) override;
-  void visit (AST::InferredType &type) override;
-  void visit (AST::BareFunctionType &type) override;
-
-private:
-  NameResolution (AST::Crate &crate, TopLevelScan &toplevel);
-  bool go () override;
-  void process_names ();
-  void process_work_list ();
-  void expand_macros ();
-  bool is_work_list_changed () { return is_work_list_changed_; }
-  std::list<AST::UseDeclaration> work_list_;
-  bool is_work_list_changed_;
-};
-
-} // namespace Analysis
-} // namespace Rust
diff --git a/gcc/rust/analysis/rust-resolution.cc b/gcc/rust/analysis/rust-resolution.cc
deleted file mode 100644
index 731801a..0000000
--- a/gcc/rust/analysis/rust-resolution.cc
+++ /dev/null
@@ -1,867 +0,0 @@
-#include "rust-resolution.h"
-#include "rust-diagnostics.h"
-
-#define ADD_BUILTIN_TYPE(_X, _S)                                               \
-  do                                                                           \
-    {                                                                          \
-      AST::PathIdentSegment seg (_X);                                          \
-      auto typePath = ::std::unique_ptr<AST::TypePathSegment> (                \
-	new AST::TypePathSegment (::std::move (seg), false,                    \
-				  Linemap::unknown_location ()));              \
-      ::std::vector< ::std::unique_ptr<AST::TypePathSegment> > segs;           \
-      segs.push_back (::std::move (typePath));                                 \
-      auto bType = new AST::TypePath (::std::move (segs),                      \
-				      Linemap::unknown_location (), false);    \
-      _S.Insert (_X, bType);                                                   \
-    }                                                                          \
-  while (0)
-
-namespace Rust {
-namespace Analysis {
-
-TypeResolution::TypeResolution (AST::Crate &crate, TopLevelScan &toplevel)
-  : crate (crate), toplevel (toplevel)
-{
-  typeScope.Push ();
-  scope.Push ();
-
-  // push all builtin types - this is probably too basic for future needs
-  ADD_BUILTIN_TYPE ("u8", typeScope);
-  ADD_BUILTIN_TYPE ("u16", typeScope);
-  ADD_BUILTIN_TYPE ("u32", typeScope);
-  ADD_BUILTIN_TYPE ("u64", typeScope);
-
-  ADD_BUILTIN_TYPE ("i8", typeScope);
-  ADD_BUILTIN_TYPE ("i16", typeScope);
-  ADD_BUILTIN_TYPE ("i32", typeScope);
-  ADD_BUILTIN_TYPE ("i64", typeScope);
-
-  ADD_BUILTIN_TYPE ("f32", typeScope);
-  ADD_BUILTIN_TYPE ("f64", typeScope);
-
-  ADD_BUILTIN_TYPE ("char", typeScope);
-  ADD_BUILTIN_TYPE ("str", typeScope);
-  ADD_BUILTIN_TYPE ("bool", typeScope);
-}
-
-TypeResolution::~TypeResolution ()
-{
-  typeScope.Pop ();
-  scope.Pop ();
-}
-
-bool
-TypeResolution::ResolveNamesAndTypes (AST::Crate &crate, TopLevelScan &toplevel)
-{
-  TypeResolution resolver (crate, toplevel);
-  return resolver.go ();
-}
-
-bool
-TypeResolution::go ()
-{
-  for (auto &item : crate.items)
-    item->accept_vis (*this);
-
-  return true;
-}
-
-bool
-TypeResolution::typesAreCompatible (AST::Type *lhs, AST::Type *rhs,
-				    Location locus)
-{
-  lhs->accept_vis (*this);
-  rhs->accept_vis (*this);
-
-  auto rhsTypeStr = typeComparisonBuffer.back ();
-  typeComparisonBuffer.pop_back ();
-  auto lhsTypeStr = typeComparisonBuffer.back ();
-  typeComparisonBuffer.pop_back ();
-
-  // FIXME this needs to handle the cases of an i8 going into an i32 which is
-  // compatible
-  if (lhsTypeStr.compare (rhsTypeStr))
-    {
-      rust_error_at (locus, "E0308: expected: %s, found %s",
-		     lhsTypeStr.c_str (), rhsTypeStr.c_str ());
-      return false;
-    }
-
-  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)
-{
-  AST::Type *type = NULL;
-  bool ok = scope.Lookup (ident_expr.ident, &type);
-  if (!ok)
-    {
-      rust_error_at (ident_expr.locus, "unknown identifier");
-      return;
-    }
-
-  typeBuffer.push_back (type);
-}
-
-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)
-{
-  printf ("PathInExpression: %s\n", path.as_string ().c_str ());
-}
-
-void
-TypeResolution::visit (AST::TypePathSegment &segment)
-{}
-void
-TypeResolution::visit (AST::TypePathSegmentGeneric &segment)
-{}
-
-void
-TypeResolution::visit (AST::TypePathSegmentFunction &segment)
-{}
-
-void
-TypeResolution::visit (AST::TypePath &path)
-{
-  // this may not be robust enough for type comparisons but lets try it for now
-  typeComparisonBuffer.push_back (path.as_string ());
-}
-
-void
-TypeResolution::visit (AST::QualifiedPathInExpression &path)
-{
-  typeComparisonBuffer.push_back (path.as_string ());
-}
-
-void
-TypeResolution::visit (AST::QualifiedPathInType &path)
-{
-  typeComparisonBuffer.push_back (path.as_string ());
-}
-
-// rust-expr.h
-void
-TypeResolution::visit (AST::LiteralExpr &expr)
-{
-  std::string type;
-  switch (expr.literal.get_lit_type ())
-    {
-    case AST::Literal::CHAR:
-      type = "char";
-      break;
-
-    case AST::Literal::STRING:
-    case AST::Literal::RAW_STRING:
-      type = "str";
-      break;
-
-    case AST::Literal::BOOL:
-      type = "bool";
-      break;
-
-    case AST::Literal::BYTE:
-      type = "u8";
-      break;
-
-      // FIXME these are not always going to be the case
-      // eg: suffix on the value can change the type
-    case AST::Literal::FLOAT:
-      type = "f32";
-      break;
-
-    case AST::Literal::INT:
-      type = "i32";
-      break;
-
-    case AST::Literal::BYTE_STRING:
-    case AST::Literal::RAW_BYTE_STRING:
-      // FIXME
-      break;
-    }
-
-  if (type.empty ())
-    {
-      rust_error_at (expr.locus, "unknown literal: %s",
-		     expr.literal.as_string ().c_str ());
-      return;
-    }
-
-  AST::Type *val = NULL;
-  bool ok = typeScope.Lookup (type, &val);
-  if (ok)
-    typeBuffer.push_back (val);
-  else
-    rust_error_at (expr.locus, "unknown literal type: %s", type.c_str ());
-}
-
-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)
-{
-  size_t before;
-  before = typeBuffer.size ();
-  expr.visit_lhs (*this);
-  if (typeBuffer.size () <= before)
-    {
-      rust_error_at (expr.locus, "unable to determine lhs type");
-      return;
-    }
-
-  auto lhsType = typeBuffer.back ();
-  typeBuffer.pop_back ();
-
-  before = typeBuffer.size ();
-  expr.visit_rhs (*this);
-  if (typeBuffer.size () <= before)
-    {
-      rust_error_at (expr.locus, "unable to determine rhs type");
-      return;
-    }
-
-  auto rhsType = typeBuffer.back ();
-  // not poping because we will be checking they match and the
-  // scope will require knowledge of the type
-
-  // do the lhsType and the rhsType match
-  typesAreCompatible (lhsType, rhsType, expr.right_expr->get_locus_slow ());
-}
-
-void
-TypeResolution::visit (AST::ComparisonExpr &expr)
-{}
-
-void
-TypeResolution::visit (AST::LazyBooleanExpr &expr)
-{}
-
-void
-TypeResolution::visit (AST::TypeCastExpr &expr)
-{}
-
-void
-TypeResolution::visit (AST::AssignmentExpr &expr)
-{
-  size_t before;
-  before = typeBuffer.size ();
-  expr.visit_lhs (*this);
-  if (typeBuffer.size () <= before)
-    {
-      rust_error_at (expr.locus, "unable to determine lhs type");
-      return;
-    }
-
-  auto lhsType = typeBuffer.back ();
-  typeBuffer.pop_back ();
-
-  before = typeBuffer.size ();
-  expr.visit_rhs (*this);
-  if (typeBuffer.size () <= before)
-    {
-      rust_error_at (expr.locus, "unable to determine rhs type");
-      return;
-    }
-
-  auto rhsType = typeBuffer.back ();
-  // not poping because we will be checking they match and the
-  // scope will require knowledge of the type
-
-  // do the lhsType and the rhsType match
-  if (!typesAreCompatible (lhsType, rhsType,
-			   expr.right_expr->get_locus_slow ()))
-    return;
-
-  // is the lhs mutable?
-}
-
-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)
-{
-  printf ("CallExpr: %s\n", expr.as_string ().c_str ());
-}
-
-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)
-{
-  // always emit the function with return type in the event of nil return type
-  // its  a marker for a void function
-  scope.Insert (function.function_name, function.return_type.get ());
-
-  scope.Push ();
-  for (auto &param : function.function_params)
-    {
-      auto before = letPatternBuffer.size ();
-      param.param_name->accept_vis (*this);
-      if (letPatternBuffer.size () <= before)
-	{
-	  rust_error_at (param.locus, "failed to analyse parameter name");
-	  return;
-	}
-
-      auto paramName = letPatternBuffer.back ();
-      letPatternBuffer.pop_back ();
-      scope.Insert (paramName.variable_ident, param.type.get ());
-    }
-
-  // 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)
-{
-  printf ("ConstantItem: %s\n", const_item.as_string ().c_str ());
-}
-
-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)
-{
-  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)
-{
-  if (!stmt.has_init_expr () && !stmt.has_type ())
-    {
-      rust_error_at (stmt.locus,
-		     "E0282: type annotations or init expression needed");
-      return;
-    }
-
-  AST::Type *inferedType = NULL;
-  if (stmt.has_init_expr ())
-    {
-      stmt.init_expr->accept_vis (*this);
-
-      if (typeBuffer.empty ())
-	{
-	  rust_error_at (
-	    stmt.init_expr->get_locus_slow (),
-	    "unable to determine type for declaration from init expr");
-	  return;
-	}
-
-      inferedType = typeBuffer.back ();
-      typeBuffer.pop_back ();
-    }
-
-  if (stmt.has_type () && stmt.has_init_expr ())
-    {
-      if (!typesAreCompatible (stmt.type.get (), inferedType,
-			       stmt.init_expr->get_locus_slow ()))
-	{
-	  return;
-	}
-    }
-  else if (stmt.has_type () && !stmt.has_init_expr ())
-    {
-      inferedType = stmt.type.get ();
-    }
-
-  // TODO check we know what the type is in the scope requires the builtins to
-  // be defined at the constructor
-
-  // ensure the decl has the type set for compilation later on
-  if (!stmt.has_type ())
-    {
-      // FIXME
-      // stmt.type = inferedType;
-    }
-
-  // get all the names part of this declaration and add the types to the scope
-  stmt.variables_pattern->accept_vis (*this);
-  for (auto it = letPatternBuffer.begin (); it != letPatternBuffer.end (); it++)
-    {
-      scope.Insert (it->variable_ident, inferedType);
-    }
-  letPatternBuffer.clear ();
-}
-
-void
-TypeResolution::visit (AST::ExprStmtWithoutBlock &stmt)
-{
-  stmt.expr->accept_vis (*this);
-}
-
-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
deleted file mode 100644
index 9eb4b95..0000000
--- a/gcc/rust/analysis/rust-resolution.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#pragma once
-
-#include "rust-system.h"
-#include "rust-ast-full.h"
-#include "rust-ast-visitor.h"
-#include "rust-scan.h"
-#include "scope.h"
-
-namespace Rust {
-namespace Analysis {
-
-class Resolution : public AST::ASTVisitor
-{
-public:
-  virtual ~Resolution ()
-  {
-    scope.Pop ();
-    valueScope.Pop ();
-    macroScope.Pop ();
-    typeScope.Pop ();
-  };
-
-private:
-  virtual bool go () = 0;
-
-protected:
-  Resolution (AST::Crate &crate, TopLevelScan &toplevel)
-    : crate (crate), toplevel (toplevel)
-  {
-    scope.Push ();
-    valueScope.Push ();
-    macroScope.Push ();
-    typeScope.Push ();
-  };
-
-  Scope<AST::Type *> scope;
-  Scope<AST::Type *> valueScope;
-  Scope<AST::Type *> macroScope;
-  Scope<AST::Type *> typeScope;
-
-  AST::Crate &crate;
-  TopLevelScan &toplevel;
-
-  std::vector<AST::IdentifierPattern> letPatternBuffer;
-  std::vector<AST::Type *> typeBuffer;
-  std::vector<std::string> typeComparisonBuffer;
-  std::vector<AST::Function *> functionLookup;
-};
-
-} // namespace Analysis
-} // namespace Rust
diff --git a/gcc/rust/analysis/rust-scan.cc b/gcc/rust/analysis/rust-scan.cc
deleted file mode 100644
index 31c89e4..0000000
--- a/gcc/rust/analysis/rust-scan.cc
+++ /dev/null
@@ -1,593 +0,0 @@
-#include "rust-scan.h"
-#include "rust-diagnostics.h"
-
-namespace Rust {
-namespace Analysis {
-
-TopLevelScan::TopLevelScan (AST::Crate &crate) : crate (crate)
-{
-  for (auto &item : crate.items)
-    item->accept_vis (*this);
-}
-
-TopLevelScan::~TopLevelScan () {}
-
-AST::Function *
-TopLevelScan::lookupFunction (AST::Expr *expr)
-{
-  auto before = fnLookup.size ();
-  expr->accept_vis (*this);
-  if (fnLookup.size () > before)
-    {
-      AST::Function *fndecl = fnLookup.back ();
-      fnLookup.pop_back ();
-      return fndecl;
-    }
-  return NULL;
-}
-
-void
-TopLevelScan::visit (AST::Token &tok)
-{}
-
-void
-TopLevelScan::visit (AST::DelimTokenTree &delim_tok_tree)
-{}
-
-void
-TopLevelScan::visit (AST::AttrInputMetaItemContainer &input)
-{}
-
-void
-TopLevelScan::visit (AST::IdentifierExpr &ident_expr)
-{}
-
-void
-TopLevelScan::visit (AST::Lifetime &lifetime)
-{}
-
-void
-TopLevelScan::visit (AST::LifetimeParam &lifetime_param)
-{}
-
-void
-TopLevelScan::visit (AST::MacroInvocationSemi &macro)
-{}
-
-// rust-path.h
-void
-TopLevelScan::visit (AST::PathInExpression &path)
-{
-  auto it = functions.find (path.as_string ());
-  bool foundFndecl = it != functions.end ();
-  if (foundFndecl)
-    {
-      fnLookup.push_back (it->second);
-      return;
-    }
-}
-
-void
-TopLevelScan::visit (AST::TypePathSegment &segment)
-{}
-void
-TopLevelScan::visit (AST::TypePathSegmentGeneric &segment)
-{}
-
-void
-TopLevelScan::visit (AST::TypePathSegmentFunction &segment)
-{}
-
-void
-TopLevelScan::visit (AST::TypePath &path)
-{}
-
-void
-TopLevelScan::visit (AST::QualifiedPathInExpression &path)
-{}
-
-void
-TopLevelScan::visit (AST::QualifiedPathInType &path)
-{}
-
-// rust-expr.h
-void
-TopLevelScan::visit (AST::LiteralExpr &expr)
-{}
-
-void
-TopLevelScan::visit (AST::AttrInputLiteral &attr_input)
-{}
-
-void
-TopLevelScan::visit (AST::MetaItemLitExpr &meta_item)
-{}
-
-void
-TopLevelScan::visit (AST::MetaItemPathLit &meta_item)
-{}
-
-void
-TopLevelScan::visit (AST::BorrowExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::DereferenceExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::ErrorPropagationExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::NegationExpr &expr)
-{}
-
-void
-TopLevelScan::visit (AST::ArithmeticOrLogicalExpr &expr)
-{}
-
-void
-TopLevelScan::visit (AST::ComparisonExpr &expr)
-{}
-
-void
-TopLevelScan::visit (AST::LazyBooleanExpr &expr)
-{}
-
-void
-TopLevelScan::visit (AST::TypeCastExpr &expr)
-{}
-
-void
-TopLevelScan::visit (AST::AssignmentExpr &expr)
-{}
-
-void
-TopLevelScan::visit (AST::CompoundAssignmentExpr &expr)
-{}
-
-void
-TopLevelScan::visit (AST::GroupedExpr &expr)
-{}
-// void TopLevelScan::visit(ArrayElems& elems) {}
-void
-TopLevelScan::visit (AST::ArrayElemsValues &elems)
-{}
-void
-TopLevelScan::visit (AST::ArrayElemsCopied &elems)
-{}
-void
-TopLevelScan::visit (AST::ArrayExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::ArrayIndexExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::TupleExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::TupleIndexExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::StructExprStruct &expr)
-{}
-// void TopLevelScan::visit(StructExprField& field) {}
-void
-TopLevelScan::visit (AST::StructExprFieldIdentifier &field)
-{}
-void
-TopLevelScan::visit (AST::StructExprFieldIdentifierValue &field)
-{}
-void
-TopLevelScan::visit (AST::StructExprFieldIndexValue &field)
-{}
-void
-TopLevelScan::visit (AST::StructExprStructFields &expr)
-{}
-void
-TopLevelScan::visit (AST::StructExprStructBase &expr)
-{}
-void
-TopLevelScan::visit (AST::StructExprTuple &expr)
-{}
-void
-TopLevelScan::visit (AST::StructExprUnit &expr)
-{}
-// void TopLevelScan::visit(EnumExprField& field) {}
-void
-TopLevelScan::visit (AST::EnumExprFieldIdentifier &field)
-{}
-void
-TopLevelScan::visit (AST::EnumExprFieldIdentifierValue &field)
-{}
-void
-TopLevelScan::visit (AST::EnumExprFieldIndexValue &field)
-{}
-void
-TopLevelScan::visit (AST::EnumExprStruct &expr)
-{}
-void
-TopLevelScan::visit (AST::EnumExprTuple &expr)
-{}
-void
-TopLevelScan::visit (AST::EnumExprFieldless &expr)
-{}
-
-void
-TopLevelScan::visit (AST::CallExpr &expr)
-{}
-
-void
-TopLevelScan::visit (AST::MethodCallExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::FieldAccessExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::ClosureExprInner &expr)
-{}
-void
-TopLevelScan::visit (AST::BlockExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::ClosureExprInnerTyped &expr)
-{}
-void
-TopLevelScan::visit (AST::ContinueExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::BreakExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::RangeFromToExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::RangeFromExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::RangeToExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::RangeFullExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::RangeFromToInclExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::RangeToInclExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::ReturnExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::UnsafeBlockExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::LoopExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::WhileLoopExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::WhileLetLoopExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::ForLoopExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::IfExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::IfExprConseqElse &expr)
-{}
-void
-TopLevelScan::visit (AST::IfExprConseqIf &expr)
-{}
-void
-TopLevelScan::visit (AST::IfExprConseqIfLet &expr)
-{}
-void
-TopLevelScan::visit (AST::IfLetExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::IfLetExprConseqElse &expr)
-{}
-void
-TopLevelScan::visit (AST::IfLetExprConseqIf &expr)
-{}
-void
-TopLevelScan::visit (AST::IfLetExprConseqIfLet &expr)
-{}
-// void TopLevelScan::visit(MatchCase& match_case) {}
-/*void
-TopLevelScan::visit (AST::MatchCaseBlockExpr &match_case)
-{}*/
-/*void
-TopLevelScan::visit (AST::MatchCaseExpr &match_case)
-{}*/
-void
-TopLevelScan::visit (AST::MatchExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::AwaitExpr &expr)
-{}
-void
-TopLevelScan::visit (AST::AsyncBlockExpr &expr)
-{}
-
-// rust-item.h
-void
-TopLevelScan::visit (AST::TypeParam &param)
-{}
-// void TopLevelScan::visit(WhereClauseItem& item) {}
-void
-TopLevelScan::visit (AST::LifetimeWhereClauseItem &item)
-{}
-void
-TopLevelScan::visit (AST::TypeBoundWhereClauseItem &item)
-{}
-void
-TopLevelScan::visit (AST::Method &method)
-{}
-void
-TopLevelScan::visit (AST::ModuleBodied &module)
-{}
-void
-TopLevelScan::visit (AST::ModuleNoBody &module)
-{}
-void
-TopLevelScan::visit (AST::ExternCrate &crate)
-{}
-// void TopLevelScan::visit(UseTree& use_tree) {}
-void
-TopLevelScan::visit (AST::UseTreeGlob &use_tree)
-{}
-void
-TopLevelScan::visit (AST::UseTreeList &use_tree)
-{}
-void
-TopLevelScan::visit (AST::UseTreeRebind &use_tree)
-{}
-void
-TopLevelScan::visit (AST::UseDeclaration &use_decl)
-{}
-
-void
-TopLevelScan::visit (AST::Function &function)
-{
-  functions[function.get_function_name ()] = &function;
-}
-
-void
-TopLevelScan::visit (AST::TypeAlias &type_alias)
-{}
-void
-TopLevelScan::visit (AST::StructStruct &struct_item)
-{}
-void
-TopLevelScan::visit (AST::TupleStruct &tuple_struct)
-{}
-void
-TopLevelScan::visit (AST::EnumItem &item)
-{}
-void
-TopLevelScan::visit (AST::EnumItemTuple &item)
-{}
-void
-TopLevelScan::visit (AST::EnumItemStruct &item)
-{}
-void
-TopLevelScan::visit (AST::EnumItemDiscriminant &item)
-{}
-void
-TopLevelScan::visit (AST::Enum &enum_item)
-{}
-void
-TopLevelScan::visit (AST::Union &union_item)
-{}
-
-void
-TopLevelScan::visit (AST::ConstantItem &const_item)
-{}
-
-void
-TopLevelScan::visit (AST::StaticItem &static_item)
-{}
-void
-TopLevelScan::visit (AST::TraitItemFunc &item)
-{}
-void
-TopLevelScan::visit (AST::TraitItemMethod &item)
-{}
-void
-TopLevelScan::visit (AST::TraitItemConst &item)
-{}
-void
-TopLevelScan::visit (AST::TraitItemType &item)
-{}
-void
-TopLevelScan::visit (AST::Trait &trait)
-{}
-void
-TopLevelScan::visit (AST::InherentImpl &impl)
-{}
-void
-TopLevelScan::visit (AST::TraitImpl &impl)
-{}
-// void TopLevelScan::visit(ExternalItem& item) {}
-void
-TopLevelScan::visit (AST::ExternalStaticItem &item)
-{}
-void
-TopLevelScan::visit (AST::ExternalFunctionItem &item)
-{}
-void
-TopLevelScan::visit (AST::ExternBlock &block)
-{}
-
-// rust-macro.h
-void
-TopLevelScan::visit (AST::MacroMatchFragment &match)
-{}
-void
-TopLevelScan::visit (AST::MacroMatchRepetition &match)
-{}
-void
-TopLevelScan::visit (AST::MacroMatcher &matcher)
-{}
-void
-TopLevelScan::visit (AST::MacroRulesDefinition &rules_def)
-{}
-void
-TopLevelScan::visit (AST::MacroInvocation &macro_invoc)
-{}
-void
-TopLevelScan::visit (AST::MetaItemPath &meta_item)
-{}
-void
-TopLevelScan::visit (AST::MetaItemSeq &meta_item)
-{}
-void
-TopLevelScan::visit (AST::MetaWord &meta_item)
-{}
-void
-TopLevelScan::visit (AST::MetaNameValueStr &meta_item)
-{}
-void
-TopLevelScan::visit (AST::MetaListPaths &meta_item)
-{}
-void
-TopLevelScan::visit (AST::MetaListNameValueStr &meta_item)
-{}
-
-// rust-pattern.h
-void
-TopLevelScan::visit (AST::LiteralPattern &pattern)
-{}
-
-void
-TopLevelScan::visit (AST::IdentifierPattern &pattern)
-{}
-
-void
-TopLevelScan::visit (AST::WildcardPattern &pattern)
-{}
-// void TopLevelScan::visit(RangePatternBound& bound) {}
-void
-TopLevelScan::visit (AST::RangePatternBoundLiteral &bound)
-{}
-void
-TopLevelScan::visit (AST::RangePatternBoundPath &bound)
-{}
-void
-TopLevelScan::visit (AST::RangePatternBoundQualPath &bound)
-{}
-void
-TopLevelScan::visit (AST::RangePattern &pattern)
-{}
-void
-TopLevelScan::visit (AST::ReferencePattern &pattern)
-{}
-// void TopLevelScan::visit(StructPatternField& field) {}
-void
-TopLevelScan::visit (AST::StructPatternFieldTuplePat &field)
-{}
-void
-TopLevelScan::visit (AST::StructPatternFieldIdentPat &field)
-{}
-void
-TopLevelScan::visit (AST::StructPatternFieldIdent &field)
-{}
-void
-TopLevelScan::visit (AST::StructPattern &pattern)
-{}
-// void TopLevelScan::visit(TupleStructItems& tuple_items) {}
-void
-TopLevelScan::visit (AST::TupleStructItemsNoRange &tuple_items)
-{}
-void
-TopLevelScan::visit (AST::TupleStructItemsRange &tuple_items)
-{}
-void
-TopLevelScan::visit (AST::TupleStructPattern &pattern)
-{}
-// void TopLevelScan::visit(TuplePatternItems& tuple_items) {}
-void
-TopLevelScan::visit (AST::TuplePatternItemsMultiple &tuple_items)
-{}
-void
-TopLevelScan::visit (AST::TuplePatternItemsRanged &tuple_items)
-{}
-void
-TopLevelScan::visit (AST::TuplePattern &pattern)
-{}
-void
-TopLevelScan::visit (AST::GroupedPattern &pattern)
-{}
-void
-TopLevelScan::visit (AST::SlicePattern &pattern)
-{}
-
-// rust-stmt.h
-void
-TopLevelScan::visit (AST::EmptyStmt &stmt)
-{}
-
-void
-TopLevelScan::visit (AST::LetStmt &stmt)
-{}
-
-void
-TopLevelScan::visit (AST::ExprStmtWithoutBlock &stmt)
-{}
-
-void
-TopLevelScan::visit (AST::ExprStmtWithBlock &stmt)
-{}
-
-// rust-type.h
-void
-TopLevelScan::visit (AST::TraitBound &bound)
-{}
-
-void
-TopLevelScan::visit (AST::ImplTraitType &type)
-{}
-
-void
-TopLevelScan::visit (AST::TraitObjectType &type)
-{}
-void
-TopLevelScan::visit (AST::ParenthesisedType &type)
-{}
-void
-TopLevelScan::visit (AST::ImplTraitTypeOneBound &type)
-{}
-void
-TopLevelScan::visit (AST::TraitObjectTypeOneBound &type)
-{}
-void
-TopLevelScan::visit (AST::TupleType &type)
-{}
-void
-TopLevelScan::visit (AST::NeverType &type)
-{}
-void
-TopLevelScan::visit (AST::RawPointerType &type)
-{}
-void
-TopLevelScan::visit (AST::ReferenceType &type)
-{}
-void
-TopLevelScan::visit (AST::ArrayType &type)
-{}
-void
-TopLevelScan::visit (AST::SliceType &type)
-{}
-void
-TopLevelScan::visit (AST::InferredType &type)
-{}
-void
-TopLevelScan::visit (AST::BareFunctionType &type)
-{}
-
-} // namespace Analysis
-} // namespace Rust
diff --git a/gcc/rust/analysis/rust-scan.h b/gcc/rust/analysis/rust-scan.h
deleted file mode 100644
index 77beeca..0000000
--- a/gcc/rust/analysis/rust-scan.h
+++ /dev/null
@@ -1,233 +0,0 @@
-#pragma once
-
-#include "rust-system.h"
-#include "rust-ast-full.h"
-#include "rust-ast-visitor.h"
-#include "scope.h"
-
-namespace Rust {
-namespace Analysis {
-
-class TopLevelScan : public AST::ASTVisitor
-{
-public:
-  TopLevelScan (AST::Crate &crate);
-
-  ~TopLevelScan ();
-
-  AST::Function *lookupFunction (AST::Expr *expr);
-
-  // 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:
-  std::map<std::string, AST::Function *> functions;
-  AST::Crate &crate;
-
-  std::vector<AST::Function *> fnLookup;
-};
-
-} // namespace Analysis
-} // namespace Rust
diff --git a/gcc/rust/analysis/rust-type-resolution.cc b/gcc/rust/analysis/rust-type-resolution.cc
deleted file mode 100644
index f1edec8..0000000
--- a/gcc/rust/analysis/rust-type-resolution.cc
+++ /dev/null
@@ -1,1348 +0,0 @@
-#include "rust-type-resolution.h"
-#include "rust-diagnostics.h"
-#include "rust-type-visitor.h"
-
-#define ADD_BUILTIN_TYPE(_X, _S)                                               \
-  do                                                                           \
-    {                                                                          \
-      AST::PathIdentSegment seg (_X);                                          \
-      auto typePath = ::std::unique_ptr<AST::TypePathSegment> (                \
-	new AST::TypePathSegment (::std::move (seg), false,                    \
-				  Linemap::predeclared_location ()));          \
-      ::std::vector< ::std::unique_ptr<AST::TypePathSegment> > segs;           \
-      segs.push_back (::std::move (typePath));                                 \
-      auto bType                                                               \
-	= new AST::TypePath (::std::move (segs),                               \
-			     Linemap::predeclared_location (), false);         \
-      _S.InsertType (_X, bType);                                               \
-    }                                                                          \
-  while (0)
-
-namespace Rust {
-namespace Analysis {
-
-TypeResolution::TypeResolution (AST::Crate &crate, TopLevelScan &toplevel)
-  : Resolution (crate, toplevel)
-{
-  scope.Push ();
-
-  // push all builtin types - this is probably too basic for future needs
-  ADD_BUILTIN_TYPE ("u8", scope);
-  ADD_BUILTIN_TYPE ("u16", scope);
-  ADD_BUILTIN_TYPE ("u32", scope);
-  ADD_BUILTIN_TYPE ("u64", scope);
-
-  ADD_BUILTIN_TYPE ("i8", scope);
-  ADD_BUILTIN_TYPE ("i16", scope);
-  ADD_BUILTIN_TYPE ("i32", scope);
-  ADD_BUILTIN_TYPE ("i64", scope);
-
-  ADD_BUILTIN_TYPE ("f32", scope);
-  ADD_BUILTIN_TYPE ("f64", scope);
-
-  ADD_BUILTIN_TYPE ("char", scope);
-  ADD_BUILTIN_TYPE ("str", scope);
-  ADD_BUILTIN_TYPE ("bool", scope);
-
-  // now its the crate scope
-  scope.Push ();
-}
-
-TypeResolution::~TypeResolution ()
-{
-  scope.Pop (); // crate
-  scope.Pop (); // builtins
-}
-
-bool
-TypeResolution::Resolve (AST::Crate &crate, TopLevelScan &toplevel)
-{
-  TypeResolution resolver (crate, toplevel);
-  return resolver.go ();
-}
-
-bool
-TypeResolution::go ()
-{
-  for (auto &item : crate.items)
-    item->accept_vis (*this);
-
-  return true;
-}
-
-bool
-TypeResolution::typesAreCompatible (AST::Type *lhs, AST::Type *rhs,
-				    Location locus)
-{
-  auto before = typeComparisonBuffer.size ();
-  lhs->accept_vis (*this);
-  if (typeComparisonBuffer.size () <= before)
-    {
-      rust_error_at (locus, "failed to understand type for lhs");
-      return false;
-    }
-
-  auto lhsTypeStr = typeComparisonBuffer.back ();
-  typeComparisonBuffer.pop_back ();
-
-  rhs->accept_vis (*this);
-  if (typeComparisonBuffer.size () <= before)
-    {
-      rust_error_at (locus, "failed to understand type for rhs");
-      return false;
-    }
-
-  auto rhsTypeStr = typeComparisonBuffer.back ();
-  typeComparisonBuffer.pop_back ();
-
-  // FIXME this needs to handle the cases of an i8 going into an i32 which is
-  // compatible
-  if (lhsTypeStr.compare (rhsTypeStr))
-    {
-      rust_error_at (locus, "E0308: expected: %s, found %s",
-		     lhsTypeStr.c_str (), rhsTypeStr.c_str ());
-      return false;
-    }
-
-  AST::Type *val = NULL;
-  if (!scope.LookupType (lhsTypeStr, &val))
-    {
-      rust_error_at (locus, "Unknown type: %s", lhsTypeStr.c_str ());
-      return false;
-    }
-
-  return true;
-}
-
-bool
-TypeResolution::isTypeInScope (AST::Type *type, Location locus)
-{
-  auto before = typeComparisonBuffer.size ();
-  type->accept_vis (*this);
-  if (typeComparisonBuffer.size () <= before)
-    {
-      rust_error_at (locus, "unable to decipher type: %s",
-		     type->as_string ().c_str ());
-      return false;
-    }
-
-  auto t = typeComparisonBuffer.back ();
-  typeComparisonBuffer.pop_back ();
-
-  AST::Type *val = NULL;
-  return scope.LookupType (t, &val);
-}
-
-AST::Function *
-TypeResolution::lookupFndecl (AST::Expr *expr)
-{
-  size_t before = functionLookup.size ();
-  expr->accept_vis (*this);
-  if (functionLookup.size () > before)
-    {
-      auto fndecl = functionLookup.back ();
-      functionLookup.pop_back ();
-      return fndecl;
-    }
-
-  rust_error_at (expr->get_locus_slow (), "failed to lookup function");
-  return NULL;
-}
-
-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)
-{
-  AST::Type *type = NULL;
-  bool ok = scope.LookupType (ident_expr.get_ident (), &type);
-  if (!ok)
-    {
-      rust_error_at (ident_expr.get_locus (), "unknown identifier");
-      return;
-    }
-
-  typeBuffer.push_back (type);
-}
-
-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)
-{
-  // look up in the functionScope else lookup in the toplevel scan
-  AST::Function *fndecl = NULL;
-  if (scope.LookupFunction (path.as_string (), &fndecl))
-    {
-      functionLookup.push_back (fndecl);
-      return;
-    }
-
-  fndecl = toplevel.lookupFunction (&path);
-  if (fndecl != NULL)
-    {
-      functionLookup.push_back (fndecl);
-      return;
-    }
-}
-
-void
-TypeResolution::visit (AST::TypePathSegment &segment)
-{}
-void
-TypeResolution::visit (AST::TypePathSegmentGeneric &segment)
-{}
-
-void
-TypeResolution::visit (AST::TypePathSegmentFunction &segment)
-{}
-
-void
-TypeResolution::visit (AST::TypePath &path)
-{
-  // this may not be robust enough for type comparisons but lets try it for now
-  typeComparisonBuffer.push_back (path.as_string ());
-}
-
-void
-TypeResolution::visit (AST::QualifiedPathInExpression &path)
-{
-  typeComparisonBuffer.push_back (path.as_string ());
-}
-
-void
-TypeResolution::visit (AST::QualifiedPathInType &path)
-{
-  typeComparisonBuffer.push_back (path.as_string ());
-}
-
-// rust-expr.h
-void
-TypeResolution::visit (AST::LiteralExpr &expr)
-{
-  std::string type;
-  switch (expr.get_lit_type ())
-    {
-    case AST::Literal::CHAR:
-      type = "char";
-      break;
-
-    case AST::Literal::STRING:
-    case AST::Literal::RAW_STRING:
-      type = "str";
-      break;
-
-    case AST::Literal::BOOL:
-      type = "bool";
-      break;
-
-    case AST::Literal::BYTE:
-      type = "u8";
-      break;
-
-      // FIXME these are not always going to be the case
-      // eg: suffix on the value can change the type
-    case AST::Literal::FLOAT:
-      type = "f32";
-      break;
-
-    case AST::Literal::INT:
-      type = "i32";
-      break;
-
-    case AST::Literal::BYTE_STRING:
-    case AST::Literal::RAW_BYTE_STRING:
-      // FIXME
-      break;
-    }
-
-  if (type.empty ())
-    {
-      rust_error_at (expr.get_locus (), "unknown literal: %s",
-		     expr.get_literal ().as_string ().c_str ());
-      return;
-    }
-
-  AST::Type *val = NULL;
-  bool ok = scope.LookupType (type, &val);
-  if (ok)
-    typeBuffer.push_back (val);
-  else
-    rust_error_at (expr.get_locus (), "unknown literal type: %s", type.c_str ());
-}
-
-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)
-{
-  size_t before;
-  before = typeBuffer.size ();
-  expr.visit_lhs (*this);
-  if (typeBuffer.size () <= before)
-    {
-      rust_error_at (expr.get_locus (), "unable to determine lhs type");
-      return;
-    }
-
-  auto lhsType = typeBuffer.back ();
-  typeBuffer.pop_back ();
-
-  before = typeBuffer.size ();
-  expr.visit_rhs (*this);
-  if (typeBuffer.size () <= before)
-    {
-      rust_error_at (expr.get_locus (), "unable to determine rhs type");
-      return;
-    }
-
-  auto rhsType = typeBuffer.back ();
-  // not poping because we will be checking they match and the
-  // scope will require knowledge of the type
-
-  // do the lhsType and the rhsType match
-  typesAreCompatible (lhsType, rhsType, expr.get_right_expr ()->get_locus_slow ());
-}
-
-void
-TypeResolution::visit (AST::ComparisonExpr &expr)
-{}
-
-void
-TypeResolution::visit (AST::LazyBooleanExpr &expr)
-{}
-
-void
-TypeResolution::visit (AST::TypeCastExpr &expr)
-{}
-
-void
-TypeResolution::visit (AST::AssignmentExpr &expr)
-{
-  size_t before;
-  before = typeBuffer.size ();
-  expr.visit_lhs (*this);
-  if (typeBuffer.size () <= before)
-    {
-      rust_error_at (expr.get_locus (), "unable to determine lhs type");
-      return;
-    }
-
-  auto lhsType = typeBuffer.back ();
-  typeBuffer.pop_back ();
-
-  before = typeBuffer.size ();
-  expr.visit_rhs (*this);
-  if (typeBuffer.size () <= before)
-    {
-      rust_error_at (expr.get_locus (), "unable to determine rhs type");
-      return;
-    }
-
-  auto rhsType = typeBuffer.back ();
-  // not poping because we will be checking they match and the
-  // scope will require knowledge of the type
-
-  // do the lhsType and the rhsType match
-  if (!typesAreCompatible (lhsType, rhsType,
-			   expr.get_right_expr ()->get_locus_slow ()))
-    return;
-
-  // is the lhs mutable?
-}
-
-void
-TypeResolution::visit (AST::CompoundAssignmentExpr &expr)
-{}
-
-void
-TypeResolution::visit (AST::GroupedExpr &expr)
-{}
-
-void
-TypeResolution::visit (AST::ArrayElemsValues &elems)
-{
-  // we need to generate the AST::ArrayType for this array init_expression
-  // we can get the size via get_num_values() but we need to ensure each element
-  // are type compatible
-
-  bool failed = false;
-  AST::Type *last_inferred_type = nullptr;
-  elems.iterate ([&] (AST::Expr *expr) mutable -> bool {
-    size_t before;
-    before = typeBuffer.size ();
-    expr->accept_vis (*this);
-    if (typeBuffer.size () <= before)
-      {
-	rust_error_at (expr->get_locus_slow (),
-		       "unable to determine element type");
-	return false;
-      }
-
-    AST::Type *inferedType = typeBuffer.back ();
-    typeBuffer.pop_back ();
-
-    if (last_inferred_type == nullptr)
-      last_inferred_type = inferedType;
-    else
-      {
-	if (!typesAreCompatible (last_inferred_type, inferedType,
-				 expr->get_locus_slow ()))
-	  {
-	    failed = true;
-	    return false;
-	  }
-      }
-
-    return true;
-  });
-
-  // nothing to do when its failed
-  if (failed)
-    return;
-
-  // FIXME This will leak
-  auto capacity
-    = new AST::LiteralExpr (std::to_string (elems.get_num_values ()),
-			    AST::Literal::INT,
-			    Linemap::predeclared_location ());
-  auto arrayType = new AST::ArrayType (last_inferred_type->clone_type (),
-				       std::unique_ptr<AST::Expr> (capacity),
-				       Linemap::predeclared_location ());
-  typeBuffer.push_back (arrayType);
-}
-
-void
-TypeResolution::visit (AST::ArrayElemsCopied &elems)
-{
-  printf ("ArrayElemsCopied: %s\n", elems.as_string ().c_str ());
-}
-
-void
-TypeResolution::visit (AST::ArrayExpr &expr)
-{
-  auto& elements = expr.get_array_elems ();
-
-  auto before = typeBuffer.size ();
-  elements->accept_vis (*this);
-  if (typeBuffer.size () <= before)
-    {
-      rust_error_at (expr.get_locus_slow (),
-		     "unable to determine type for ArrayExpr");
-      return;
-    }
-
-  expr.set_inferred_type (typeBuffer.back ());
-}
-
-void
-TypeResolution::visit (AST::ArrayIndexExpr &expr)
-{
-  auto before = typeBuffer.size ();
-  expr.get_array_expr ()->accept_vis (*this);
-  if (typeBuffer.size () <= before)
-    {
-      rust_error_at (expr.get_locus_slow (),
-		     "unable to determine type for array index expression");
-      return;
-    }
-  AST::Type *array_expr_type = typeBuffer.back ();
-  typeBuffer.pop_back ();
-
-  before = typeBuffer.size ();
-  expr.get_index_expr ()->accept_vis (*this);
-  if (typeBuffer.size () <= before)
-    {
-      rust_error_at (expr.get_index_expr ()->get_locus_slow (),
-		     "unable to determine type for index expression");
-      return;
-    }
-
-  AST::Type *array_index_type = typeBuffer.back ();
-  typeBuffer.pop_back ();
-
-  // check the index_type should be an i32 which should really be
-  // more permissive
-  AST::Type *i32 = nullptr;
-  scope.LookupType ("i32", &i32);
-  rust_assert (i32 != nullptr);
-
-  if (!typesAreCompatible (array_index_type, i32,
-			   expr.get_index_expr ()->get_locus_slow ()))
-    {
-      return;
-    }
-
-  // the the element type from the array_expr_type and it _must_ be an array
-  AST::ArrayType *resolved = ArrayTypeVisitor::Resolve (array_expr_type);
-  if (resolved == nullptr)
-    {
-      rust_error_at (expr.get_locus_slow (),
-		     "unable to resolve type for array expression");
-      return;
-    }
-
-  typeBuffer.push_back (resolved->get_elem_type ().get ());
-}
-
-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)
-{
-  identifierBuffer = std::unique_ptr<std::string> (new std::string (field.get_field_name ()));
-  field.get_value ()->accept_vis (*this);
-}
-
-void
-TypeResolution::visit (AST::StructExprFieldIndexValue &field)
-{
-  tupleIndexBuffer = std::unique_ptr<int> (new int (field.get_index ()));
-  field.get_value ()->accept_vis (*this);
-}
-
-void
-TypeResolution::visit (AST::StructExprStructFields &expr)
-{
-  AST::StructStruct *decl = NULL;
-  if (!scope.LookupStruct (expr.get_struct_name ().as_string (), &decl))
-    {
-      rust_error_at (expr.get_locus_slow (), "unknown type");
-      return;
-    }
-
-  for (auto &field : expr.get_fields ())
-    {
-      identifierBuffer = NULL;
-      tupleIndexBuffer = NULL;
-
-      auto before = typeBuffer.size ();
-      field->accept_vis (*this);
-      if (typeBuffer.size () <= before)
-	{
-	  rust_error_at (expr.get_locus_slow (),
-			 "unable to determine type for field");
-	  return;
-	}
-
-      auto inferedType = typeBuffer.back ();
-      typeBuffer.pop_back ();
-
-      // do we have a name for this
-      if (identifierBuffer != NULL)
-	{
-	  AST::StructField *declField = NULL;
-	  for (auto &df : decl->get_fields ())
-	    {
-	      if (identifierBuffer->compare (df.get_field_name ()) == 0)
-		{
-		  declField = &df;
-		  break;
-		}
-	    }
-	  identifierBuffer = NULL;
-
-	  if (declField == NULL)
-	    {
-	      rust_error_at (expr.get_locus_slow (), "unknown field");
-	      return;
-	    }
-
-	  if (!typesAreCompatible (declField->get_field_type ().get (), inferedType,
-				   expr.get_locus_slow ()))
-	    return;
-	}
-      // do we have an index for this
-      else if (tupleIndexBuffer != NULL)
-	{
-	  AST::StructField *declField = NULL;
-	  if (*tupleIndexBuffer < decl->get_fields ().size ())
-	    {
-	      declField = &decl->get_fields ()[*tupleIndexBuffer];
-	    }
-	  tupleIndexBuffer = NULL;
-
-	  if (declField == NULL)
-	    {
-	      rust_error_at (expr.get_locus_slow (), "unknown field at index");
-	      return;
-	    }
-
-	  if (!typesAreCompatible (declField->get_field_type ().get (), inferedType,
-				   expr.get_locus_slow ()))
-	    return;
-	}
-      else
-	{
-	  rust_fatal_error (expr.get_locus_slow (), "unknown field initialise");
-	  return;
-	}
-    }
-
-  // need to correct the ordering with the respect to the struct definition and
-  // ensure we handle missing values and give them defaults
-  // FIXME
-
-  // setup a path in type
-  AST::PathIdentSegment seg (expr.get_struct_name ().as_string ());
-  auto typePath = ::std::unique_ptr<AST::TypePathSegment> (
-    new AST::TypePathSegment (::std::move (seg), false,
-			      expr.get_locus_slow ()));
-  ::std::vector< ::std::unique_ptr<AST::TypePathSegment> > segs;
-  segs.push_back (::std::move (typePath));
-  auto bType
-    = new AST::TypePath (::std::move (segs), expr.get_locus_slow (), false);
-  typeBuffer.push_back (bType);
-}
-
-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)
-{
-  // this look up should probably be moved to name resolution
-  auto fndecl = lookupFndecl (expr.get_function_expr ().get ());
-  if (fndecl == NULL)
-    return;
-
-  // check num args match
-  if (fndecl->get_function_params ().size () != expr.get_params ().size ())
-    {
-      rust_error_at (expr.get_locus_slow (),
-		     "differing number of arguments vs parameters to function");
-      return;
-    }
-
-  typeBuffer.push_back (fndecl->get_return_type ().get ());
-  expr.fndeclRef = fndecl;
-
-  auto before = typeBuffer.size ();
-  for (auto &item : expr.get_params ())
-    item->accept_vis (*this);
-
-  auto numInferedParams = typeBuffer.size () - before;
-  if (numInferedParams != expr.get_params ().size ())
-    {
-      rust_error_at (expr.get_locus (), "Failed to infer all parameters");
-      return;
-    }
-
-  auto offs = numInferedParams - 1;
-  for (auto it = fndecl->get_function_params ().rbegin ();
-       it != fndecl->get_function_params ().rend (); ++it)
-    {
-      AST::Type *argument = typeBuffer.back ();
-      typeBuffer.pop_back ();
-
-      if (!typesAreCompatible (it->get_type ().get (), argument,
-			       expr.get_params ()[offs]->get_locus_slow ()))
-	return;
-      offs--;
-    }
-}
-
-void
-TypeResolution::visit (AST::MethodCallExpr &expr)
-{}
-void
-TypeResolution::visit (AST::FieldAccessExpr &expr)
-{}
-void
-TypeResolution::visit (AST::ClosureExprInner &expr)
-{}
-
-void
-TypeResolution::visit (AST::BlockExpr &expr)
-{
-  scope.Push ();
-  for (auto &stmt : expr.get_statements ())
-    {
-      stmt->accept_vis (*this);
-    }
-  scope.Pop ();
-}
-
-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)
-{
-  // Ensure the type of this matches the function
-  auto before = typeBuffer.size ();
-  expr.get_returned_expr ()->accept_vis (*this);
-
-  if (typeBuffer.size () <= before)
-    {
-      rust_error_at (expr.get_returned_expr ()->get_locus_slow (),
-		     "unable to determine type for return expr");
-      return;
-    }
-
-  auto inferedType = typeBuffer.back ();
-  typeBuffer.pop_back ();
-
-  // check this is compatible with the return type
-  // this will again have issues with structs before we move to HIR
-
-  auto function = scope.CurrentFunction ();
-  if (!function->has_return_type ())
-    {
-      rust_error_at (expr.get_locus (), "return for void function %s",
-		     function->as_string ().c_str ());
-      return;
-    }
-
-  if (!typesAreCompatible (function->get_return_type ().get (), inferedType,
-			   expr.get_locus_slow ()))
-    {
-      return;
-    }
-}
-
-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)
-{
-  expr.vis_if_block (*this);
-}
-
-void
-TypeResolution::visit (AST::IfExprConseqElse &expr)
-{
-  expr.vis_if_block (*this);
-  expr.vis_else_block (*this);
-}
-
-void
-TypeResolution::visit (AST::IfExprConseqIf &expr)
-{
-  expr.vis_if_block (*this);
-  expr.vis_conseq_if_expr (*this);
-}
-
-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)
-{
-  // always emit the function with return type in the event of nil return type
-  // its  a marker for a void function
-  scope.InsertType (function.get_function_name (), function.get_return_type ().get ());
-  scope.InsertFunction (function.get_function_name (), &function);
-  scope.PushFunction (&function);
-  scope.Push ();
-
-  for (auto &param : function.get_function_params ())
-    {
-      if (!isTypeInScope (param.get_type ().get (), param.get_locus ()))
-	{
-	  scope.Pop ();
-	  scope.PopFunction ();
-	  return;
-	}
-
-      auto before = letPatternBuffer.size ();
-      param.get_pattern ()->accept_vis (*this);
-      if (letPatternBuffer.size () <= before)
-	{
-	  rust_error_at (param.get_locus (), "failed to analyse parameter name");
-
-	  scope.Pop ();
-	  scope.PopFunction ();
-	  return;
-	}
-
-      auto paramName = letPatternBuffer.back ();
-      letPatternBuffer.pop_back ();
-      scope.InsertType (paramName.get_ident (), param.get_type ().get ());
-    }
-
-  // ensure the return type is resolved
-  if (function.has_return_type ())
-    {
-      if (!isTypeInScope (function.get_return_type ().get (), function.get_locus ()))
-	{
-	  scope.Pop ();
-	  scope.PopFunction ();
-	  return;
-	}
-    }
-
-  // walk the expression body
-  for (auto &stmt : function.get_definition ()->get_statements ())
-    {
-      stmt->accept_vis (*this);
-    }
-
-  auto localMap = scope.PeekLocals ();
-  for (auto &[_, value] : localMap)
-    function.locals.push_back (value);
-
-  scope.Pop ();
-  scope.PopFunction ();
-}
-
-void
-TypeResolution::visit (AST::TypeAlias &type_alias)
-{}
-
-void
-TypeResolution::visit (AST::StructStruct &struct_item)
-{
-  for (auto &field : struct_item.get_fields ())
-    {
-      if (!isTypeInScope (field.get_field_type ().get (),
-			  Linemap::unknown_location ()))
-	{
-	  rust_fatal_error (Linemap::unknown_location (),
-			    "unknown type in struct field");
-	  return;
-	}
-    }
-
-  scope.InsertStruct (struct_item.get_struct_name (), &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)
-{
-  printf ("ConstantItem: %s\n", const_item.as_string ().c_str ());
-}
-
-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)
-{
-  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)
-{
-  scope.InsertLocal (stmt.as_string (), &stmt);
-  if (!stmt.has_init_expr () && !stmt.has_type ())
-    {
-      rust_error_at (stmt.get_locus (),
-		     "E0282: type annotations or init expression needed");
-      return;
-    }
-
-  AST::Type *inferedType = nullptr;
-  if (stmt.has_init_expr ())
-    {
-      auto before = typeBuffer.size ();
-      stmt.get_init_expr ()->accept_vis (*this);
-
-      if (typeBuffer.size () <= before)
-	{
-	  rust_error_at (
-	    stmt.get_init_expr ()->get_locus_slow (),
-	    "unable to determine type for declaration from init expr");
-	  return;
-	}
-
-      inferedType = typeBuffer.back ();
-      typeBuffer.pop_back ();
-
-      if (inferedType == NULL)
-	{
-	  rust_error_at (stmt.get_init_expr ()->get_locus_slow (),
-			 "void type found for statement initialisation");
-	  return;
-	}
-    }
-
-  if (stmt.has_type () && stmt.has_init_expr ())
-    {
-      if (!typesAreCompatible (stmt.get_type ().get (), inferedType,
-			       stmt.get_init_expr ()->get_locus_slow ()))
-	{
-	  return;
-	}
-    }
-  else if (stmt.has_type ())
-    {
-      auto before = typeComparisonBuffer.size ();
-      stmt.get_type ()->accept_vis (*this);
-      if (typeComparisonBuffer.size () <= before)
-	{
-	  rust_error_at (stmt.get_locus (), "failed to understand type for lhs");
-	  return;
-	}
-      auto typeString = typeComparisonBuffer.back ();
-      typeComparisonBuffer.pop_back ();
-
-      // AST::Type *val = NULL;
-      // if (!scope.LookupType (typeString, &val))
-      //   {
-      //     rust_error_at (stmt.locus, "LetStmt has unknown type: %s",
-      //   		 stmt.type->as_string ().c_str ());
-      //     return;
-      //   }
-    }
-  else if (inferedType != nullptr)
-    {
-      auto before = typeComparisonBuffer.size ();
-      inferedType->accept_vis (*this);
-      if (typeComparisonBuffer.size () <= before)
-	{
-	  rust_error_at (stmt.get_locus (), "failed to understand type for lhs");
-	  return;
-	}
-      auto typeString = typeComparisonBuffer.back ();
-      typeComparisonBuffer.pop_back ();
-
-      // AST::Type *val = NULL;
-      // if (!scope.LookupType (typeString, &val))
-      //   {
-      //     rust_error_at (stmt.get_locus (), "Inferred unknown type: %s",
-      //   		 inferedType->as_string ().c_str ());
-      //     return;
-      //   }
-    }
-  else
-    {
-      rust_fatal_error (stmt.get_locus (), "Failed to determine any type for LetStmt");
-      return;
-    }
-
-  // ensure the decl has the type set for compilation later on
-  if (!stmt.has_type ())
-    {
-      stmt.inferedType = inferedType;
-    }
-
-  // get all the names part of this declaration and add the types to the scope
-  stmt.get_pattern ()->accept_vis (*this);
-  for (auto &pattern : letPatternBuffer)
-    scope.InsertType (pattern.get_ident (), inferedType);
-
-  letPatternBuffer.clear ();
-}
-
-void
-TypeResolution::visit (AST::ExprStmtWithoutBlock &stmt)
-{
-  stmt.get_expr ()->accept_vis (*this);
-}
-
-void
-TypeResolution::visit (AST::ExprStmtWithBlock &stmt)
-{
-  scope.Push ();
-  stmt.get_expr ()->accept_vis (*this);
-  auto localMap = scope.PeekLocals ();
-  for (auto &[_, value] : localMap)
-    {
-      stmt.locals.push_back (value);
-    }
-  scope.Pop ();
-}
-
-// 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)
-{
-  typeComparisonBuffer.push_back (type.get_elem_type ()->as_string ());
-}
-
-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-type-resolution.h b/gcc/rust/analysis/rust-type-resolution.h
deleted file mode 100644
index 2f61a39..0000000
--- a/gcc/rust/analysis/rust-type-resolution.h
+++ /dev/null
@@ -1,334 +0,0 @@
-// Copyright (C) 2020 Free Software Foundation, Inc.
-
-// This file is part of GCC.
-
-// GCC is free software; you can redistribute it and/or modify it under
-// the terms of the GNU General Public License as published by the Free
-// Software Foundation; either version 3, or (at your option) any later
-// version.
-
-// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-// WARRANTY; without even the implied warranty of MERCHANTABILITY or
-// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-// for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with GCC; see the file COPYING3.  If not see
-// <http://www.gnu.org/licenses/>.
-#pragma once
-
-#include "rust-resolution.h"
-
-namespace Rust {
-namespace Analysis {
-
-class TypeScoping
-{
-public:
-  TypeScoping () {}
-
-  ~TypeScoping () {}
-
-  void Push ()
-  {
-    functionScope.Push ();
-    localsPerBlock.Push ();
-    structsPerBlock.Push ();
-    typeScope.Push ();
-  }
-
-  void Pop ()
-  {
-    functionScope.Pop ();
-    localsPerBlock.Pop ();
-    structsPerBlock.Pop ();
-    typeScope.Pop ();
-  }
-
-  void InsertFunction (std::string ident, AST::Function *fn)
-  {
-    functionScope.Insert (ident, fn);
-  }
-
-  bool LookupFunction (std::string ident, AST::Function **fn)
-  {
-    return functionScope.Lookup (ident, fn);
-  }
-
-  void PushFunction (AST::Function *fn) { functionStack.push_back (fn); }
-
-  void PopFunction () { functionStack.pop_back (); }
-
-  AST::Function *CurrentFunction () { return functionStack.back (); }
-
-  void InsertLocal (std::string ident, AST::LetStmt *let)
-  {
-    localsPerBlock.Insert (ident, let);
-  }
-
-  bool LookupLocal (std::string ident, AST::LetStmt **let)
-  {
-    return localsPerBlock.Lookup (ident, let);
-  }
-
-  std ::map<std::string, AST::LetStmt *> PeekLocals ()
-  {
-    return localsPerBlock.Peek ();
-  }
-
-  void InsertStruct (std::string ident, AST::StructStruct *s)
-  {
-    structsPerBlock.Insert (ident, s);
-  }
-
-  bool LookupStruct (std::string ident, AST::StructStruct **s)
-  {
-    return structsPerBlock.Lookup (ident, s);
-  }
-
-  void InsertType (std::string ident, AST::Type *s)
-  {
-    typeScope.Insert (ident, s);
-  }
-
-  bool LookupType (std::string ident, AST::Type **s)
-  {
-    return typeScope.Lookup (ident, s);
-  }
-
-private:
-  std::vector<AST::Function *> functionStack;
-
-  Scope<AST::Function *> functionScope;
-  Scope<AST::LetStmt *> localsPerBlock;
-  Scope<AST::StructStruct *> structsPerBlock;
-  Scope<AST::Type *> typeScope;
-};
-
-class TypeResolution : public Resolution
-{
-  friend class TypeScoping;
-
-public:
-  ~TypeResolution ();
-  static bool Resolve (AST::Crate &crate, TopLevelScan &toplevel);
-
-  // visitor impl
-  // rust-ast.h
-  //  void visit(AttrInput& attr_input);
-  //  void visit(TokenTree& token_tree);
-  //  void visit(MacroMatch& macro_match);
-  void visit (AST::Token &tok) override;
-  void visit (AST::DelimTokenTree &delim_tok_tree) override;
-  void visit (AST::AttrInputMetaItemContainer &input) override;
-  //  void visit(MetaItem& meta_item) override;
-  //  void vsit(Stmt& stmt) override;
-  //  void visit(Expr& expr) override;
-  void visit (AST::IdentifierExpr &ident_expr) override;
-  //  void visit(Pattern& pattern) override;
-  //  void visit(Type& type) override;
-  //  void visit(TypeParamBound& type_param_bound) override;
-  void visit (AST::Lifetime &lifetime) override;
-  //  void visit(GenericParam& generic_param) override;
-  void visit (AST::LifetimeParam &lifetime_param) override;
-  //  void visit(TraitItem& trait_item) override;
-  //  void visit(InherentImplItem& inherent_impl_item) override;
-  //  void visit(TraitImplItem& trait_impl_item) override;
-  void visit (AST::MacroInvocationSemi &macro) override;
-
-  // rust-path.h
-  void visit (AST::PathInExpression &path) override;
-  void visit (AST::TypePathSegment &segment) override;
-  void visit (AST::TypePathSegmentGeneric &segment) override;
-  void visit (AST::TypePathSegmentFunction &segment) override;
-  void visit (AST::TypePath &path) override;
-  void visit (AST::QualifiedPathInExpression &path) override;
-  void visit (AST::QualifiedPathInType &path) override;
-
-  // rust-expr.h
-  void visit (AST::LiteralExpr &expr) override;
-  void visit (AST::AttrInputLiteral &attr_input) override;
-  void visit (AST::MetaItemLitExpr &meta_item) override;
-  void visit (AST::MetaItemPathLit &meta_item) override;
-  void visit (AST::BorrowExpr &expr) override;
-  void visit (AST::DereferenceExpr &expr) override;
-  void visit (AST::ErrorPropagationExpr &expr) override;
-  void visit (AST::NegationExpr &expr) override;
-  void visit (AST::ArithmeticOrLogicalExpr &expr) override;
-  void visit (AST::ComparisonExpr &expr) override;
-  void visit (AST::LazyBooleanExpr &expr) override;
-  void visit (AST::TypeCastExpr &expr) override;
-  void visit (AST::AssignmentExpr &expr) override;
-  void visit (AST::CompoundAssignmentExpr &expr) override;
-  void visit (AST::GroupedExpr &expr) override;
-  //  void visit(ArrayElems& elems) override;
-  void visit (AST::ArrayElemsValues &elems) override;
-  void visit (AST::ArrayElemsCopied &elems) override;
-  void visit (AST::ArrayExpr &expr) override;
-  void visit (AST::ArrayIndexExpr &expr) override;
-  void visit (AST::TupleExpr &expr) override;
-  void visit (AST::TupleIndexExpr &expr) override;
-  void visit (AST::StructExprStruct &expr) override;
-  //  void visit(StructExprField& field) override;
-  void visit (AST::StructExprFieldIdentifier &field) override;
-  void visit (AST::StructExprFieldIdentifierValue &field) override;
-  void visit (AST::StructExprFieldIndexValue &field) override;
-  void visit (AST::StructExprStructFields &expr) override;
-  void visit (AST::StructExprStructBase &expr) override;
-  void visit (AST::StructExprTuple &expr) override;
-  void visit (AST::StructExprUnit &expr) override;
-  //  void visit(EnumExprField& field) override;
-  void visit (AST::EnumExprFieldIdentifier &field) override;
-  void visit (AST::EnumExprFieldIdentifierValue &field) override;
-  void visit (AST::EnumExprFieldIndexValue &field) override;
-  void visit (AST::EnumExprStruct &expr) override;
-  void visit (AST::EnumExprTuple &expr) override;
-  void visit (AST::EnumExprFieldless &expr) override;
-  void visit (AST::CallExpr &expr) override;
-  void visit (AST::MethodCallExpr &expr) override;
-  void visit (AST::FieldAccessExpr &expr) override;
-  void visit (AST::ClosureExprInner &expr) override;
-  void visit (AST::BlockExpr &expr) override;
-  void visit (AST::ClosureExprInnerTyped &expr) override;
-  void visit (AST::ContinueExpr &expr) override;
-  void visit (AST::BreakExpr &expr) override;
-  void visit (AST::RangeFromToExpr &expr) override;
-  void visit (AST::RangeFromExpr &expr) override;
-  void visit (AST::RangeToExpr &expr) override;
-  void visit (AST::RangeFullExpr &expr) override;
-  void visit (AST::RangeFromToInclExpr &expr) override;
-  void visit (AST::RangeToInclExpr &expr) override;
-  void visit (AST::ReturnExpr &expr) override;
-  void visit (AST::UnsafeBlockExpr &expr) override;
-  void visit (AST::LoopExpr &expr) override;
-  void visit (AST::WhileLoopExpr &expr) override;
-  void visit (AST::WhileLetLoopExpr &expr) override;
-  void visit (AST::ForLoopExpr &expr) override;
-  void visit (AST::IfExpr &expr) override;
-  void visit (AST::IfExprConseqElse &expr) override;
-  void visit (AST::IfExprConseqIf &expr) override;
-  void visit (AST::IfExprConseqIfLet &expr) override;
-  void visit (AST::IfLetExpr &expr) override;
-  void visit (AST::IfLetExprConseqElse &expr) override;
-  void visit (AST::IfLetExprConseqIf &expr) override;
-  void visit (AST::IfLetExprConseqIfLet &expr) override;
-  //  void visit(MatchCase& match_case) override;
-  // void visit (AST::MatchCaseBlockExpr &match_case) override;
-  // void visit (AST::MatchCaseExpr &match_case) override;
-  void visit (AST::MatchExpr &expr) override;
-  void visit (AST::AwaitExpr &expr) override;
-  void visit (AST::AsyncBlockExpr &expr) override;
-
-  // rust-item.h
-  void visit (AST::TypeParam &param) override;
-  //  void visit(WhereClauseItem& item) override;
-  void visit (AST::LifetimeWhereClauseItem &item) override;
-  void visit (AST::TypeBoundWhereClauseItem &item) override;
-  void visit (AST::Method &method) override;
-  void visit (AST::ModuleBodied &module) override;
-  void visit (AST::ModuleNoBody &module) override;
-  void visit (AST::ExternCrate &crate) override;
-  //  void visit(UseTree& use_tree) override;
-  void visit (AST::UseTreeGlob &use_tree) override;
-  void visit (AST::UseTreeList &use_tree) override;
-  void visit (AST::UseTreeRebind &use_tree) override;
-  void visit (AST::UseDeclaration &use_decl) override;
-  void visit (AST::Function &function) override;
-  void visit (AST::TypeAlias &type_alias) override;
-  void visit (AST::StructStruct &struct_item) override;
-  void visit (AST::TupleStruct &tuple_struct) override;
-  void visit (AST::EnumItem &item) override;
-  void visit (AST::EnumItemTuple &item) override;
-  void visit (AST::EnumItemStruct &item) override;
-  void visit (AST::EnumItemDiscriminant &item) override;
-  void visit (AST::Enum &enum_item) override;
-  void visit (AST::Union &union_item) override;
-  void visit (AST::ConstantItem &const_item) override;
-  void visit (AST::StaticItem &static_item) override;
-  void visit (AST::TraitItemFunc &item) override;
-  void visit (AST::TraitItemMethod &item) override;
-  void visit (AST::TraitItemConst &item) override;
-  void visit (AST::TraitItemType &item) override;
-  void visit (AST::Trait &trait) override;
-  void visit (AST::InherentImpl &impl) override;
-  void visit (AST::TraitImpl &impl) override;
-  //  void visit(ExternalItem& item) override;
-  void visit (AST::ExternalStaticItem &item) override;
-  void visit (AST::ExternalFunctionItem &item) override;
-  void visit (AST::ExternBlock &block) override;
-
-  // rust-macro.h
-  void visit (AST::MacroMatchFragment &match) override;
-  void visit (AST::MacroMatchRepetition &match) override;
-  void visit (AST::MacroMatcher &matcher) override;
-  void visit (AST::MacroRulesDefinition &rules_def) override;
-  void visit (AST::MacroInvocation &macro_invoc) override;
-  void visit (AST::MetaItemPath &meta_item) override;
-  void visit (AST::MetaItemSeq &meta_item) override;
-  void visit (AST::MetaWord &meta_item) override;
-  void visit (AST::MetaNameValueStr &meta_item) override;
-  void visit (AST::MetaListPaths &meta_item) override;
-  void visit (AST::MetaListNameValueStr &meta_item) override;
-
-  // rust-pattern.h
-  void visit (AST::LiteralPattern &pattern) override;
-  void visit (AST::IdentifierPattern &pattern) override;
-  void visit (AST::WildcardPattern &pattern) override;
-  //  void visit(RangePatternBound& bound) override;
-  void visit (AST::RangePatternBoundLiteral &bound) override;
-  void visit (AST::RangePatternBoundPath &bound) override;
-  void visit (AST::RangePatternBoundQualPath &bound) override;
-  void visit (AST::RangePattern &pattern) override;
-  void visit (AST::ReferencePattern &pattern) override;
-  //  void visit(StructPatternField& field) override;
-  void visit (AST::StructPatternFieldTuplePat &field) override;
-  void visit (AST::StructPatternFieldIdentPat &field) override;
-  void visit (AST::StructPatternFieldIdent &field) override;
-  void visit (AST::StructPattern &pattern) override;
-  //  void visit(TupleStructItems& tuple_items) override;
-  void visit (AST::TupleStructItemsNoRange &tuple_items) override;
-  void visit (AST::TupleStructItemsRange &tuple_items) override;
-  void visit (AST::TupleStructPattern &pattern) override;
-  //  void visit(TuplePatternItems& tuple_items) override;
-  void visit (AST::TuplePatternItemsMultiple &tuple_items) override;
-  void visit (AST::TuplePatternItemsRanged &tuple_items) override;
-  void visit (AST::TuplePattern &pattern) override;
-  void visit (AST::GroupedPattern &pattern) override;
-  void visit (AST::SlicePattern &pattern) override;
-
-  // rust-stmt.h
-  void visit (AST::EmptyStmt &stmt) override;
-  void visit (AST::LetStmt &stmt) override;
-  void visit (AST::ExprStmtWithoutBlock &stmt) override;
-  void visit (AST::ExprStmtWithBlock &stmt) override;
-
-  // rust-type.h
-  void visit (AST::TraitBound &bound) override;
-  void visit (AST::ImplTraitType &type) override;
-  void visit (AST::TraitObjectType &type) override;
-  void visit (AST::ParenthesisedType &type) override;
-  void visit (AST::ImplTraitTypeOneBound &type) override;
-  void visit (AST::TraitObjectTypeOneBound &type) override;
-  void visit (AST::TupleType &type) override;
-  void visit (AST::NeverType &type) override;
-  void visit (AST::RawPointerType &type) override;
-  void visit (AST::ReferenceType &type) override;
-  void visit (AST::ArrayType &type) override;
-  void visit (AST::SliceType &type) override;
-  void visit (AST::InferredType &type) override;
-  void visit (AST::BareFunctionType &type) override;
-
-private:
-  TypeResolution (AST::Crate &crate, TopLevelScan &toplevel);
-  bool go () override;
-  bool typesAreCompatible (AST::Type *lhs, AST::Type *rhs, Location locus);
-  AST::Function *lookupFndecl (AST::Expr *expr);
-  bool isTypeInScope (AST::Type *type, Location locus);
-
-  TypeScoping scope;
-  std::unique_ptr<std::string> identifierBuffer;
-  std::unique_ptr<int> tupleIndexBuffer;
-};
-
-} // namespace Analysis
-} // namespace Rust
diff --git a/gcc/rust/analysis/rust-type-visitor.h b/gcc/rust/analysis/rust-type-visitor.h
deleted file mode 100644
index 8cfe156..0000000
--- a/gcc/rust/analysis/rust-type-visitor.h
+++ /dev/null
@@ -1,261 +0,0 @@
-// rust-type-visitor.h -- Rust AST Visitor to AST::Type specific
-// Copyright (C) 2020 Free Software Foundation, Inc.
-
-// This file is part of GCC.
-
-// GCC is free software; you can redistribute it and/or modify it under
-// the terms of the GNU General Public License as published by the Free
-// Software Foundation; either version 3, or (at your option) any later
-// version.
-
-// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-// WARRANTY; without even the implied warranty of MERCHANTABILITY or
-// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-// for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with GCC; see the file COPYING3.  If not see
-// <http://www.gnu.org/licenses/>.
-
-#ifndef RUST_TYPE_VISITOR_H
-#define RUST_TYPE_VISITOR_H
-
-#include "rust-system.h"
-#include "rust-ast-full.h"
-#include "rust-ast-visitor.h"
-#include "rust-scan.h"
-
-namespace Rust {
-namespace Analysis {
-
-class BaseTypeVisitor : public AST::ASTVisitor
-{
-public:
-  // 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) override {}
-  virtual void visit (AST::DelimTokenTree &delim_tok_tree) override {}
-  virtual void visit (AST::AttrInputMetaItemContainer &input) override {}
-  //  virtual void visit(MetaItem& meta_item) override {}
-  //  void vsit(Stmt& stmt) override {}
-  //  virtual void visit(Expr& expr) override {}
-  virtual void visit (AST::IdentifierExpr &ident_expr) override {}
-  //  virtual void visit(Pattern& pattern) override {}
-  //  virtual void visit(Type& type) override {}
-  //  virtual void visit(TypeParamBound& type_param_bound) override {}
-  virtual void visit (AST::Lifetime &lifetime) override {}
-  //  virtual void visit(GenericParam& generic_param) override {}
-  virtual void visit (AST::LifetimeParam &lifetime_param) override {}
-  //  virtual void visit(TraitItem& trait_item) override {}
-  //  virtual void visit(InherentImplItem& inherent_impl_item) override {}
-  //  virtual void visit(TraitImplItem& trait_impl_item) override {}
-  virtual void visit (AST::MacroInvocationSemi &macro) override {}
-
-  // rust-path.h
-  virtual void visit (AST::PathInExpression &path) override {}
-  virtual void visit (AST::TypePathSegment &segment) override {}
-  virtual void visit (AST::TypePathSegmentGeneric &segment) override {}
-  virtual void visit (AST::TypePathSegmentFunction &segment) override {}
-  virtual void visit (AST::TypePath &path) override {}
-  virtual void visit (AST::QualifiedPathInExpression &path) override {}
-  virtual void visit (AST::QualifiedPathInType &path) override {}
-
-  // rust-expr.h
-  virtual void visit (AST::LiteralExpr &expr) override {}
-  virtual void visit (AST::AttrInputLiteral &attr_input) override {}
-  virtual void visit (AST::MetaItemLitExpr &meta_item) override {}
-  virtual void visit (AST::MetaItemPathLit &meta_item) override {}
-  virtual void visit (AST::BorrowExpr &expr) override {}
-  virtual void visit (AST::DereferenceExpr &expr) override {}
-  virtual void visit (AST::ErrorPropagationExpr &expr) override {}
-  virtual void visit (AST::NegationExpr &expr) override {}
-  virtual void visit (AST::ArithmeticOrLogicalExpr &expr) override {}
-  virtual void visit (AST::ComparisonExpr &expr) override {}
-  virtual void visit (AST::LazyBooleanExpr &expr) override {}
-  virtual void visit (AST::TypeCastExpr &expr) override {}
-  virtual void visit (AST::AssignmentExpr &expr) override {}
-  virtual void visit (AST::CompoundAssignmentExpr &expr) override {}
-  virtual void visit (AST::GroupedExpr &expr) override {}
-  //  virtual void visit(ArrayElems& elems) override {}
-  virtual void visit (AST::ArrayElemsValues &elems) override {}
-  virtual void visit (AST::ArrayElemsCopied &elems) override {}
-  virtual void visit (AST::ArrayExpr &expr) override {}
-  virtual void visit (AST::ArrayIndexExpr &expr) override {}
-  virtual void visit (AST::TupleExpr &expr) override {}
-  virtual void visit (AST::TupleIndexExpr &expr) override {}
-  virtual void visit (AST::StructExprStruct &expr) override {}
-  //  virtual void visit(StructExprField& field) override {}
-  virtual void visit (AST::StructExprFieldIdentifier &field) override {}
-  virtual void visit (AST::StructExprFieldIdentifierValue &field) override {}
-  virtual void visit (AST::StructExprFieldIndexValue &field) override {}
-  virtual void visit (AST::StructExprStructFields &expr) override {}
-  virtual void visit (AST::StructExprStructBase &expr) override {}
-  virtual void visit (AST::StructExprTuple &expr) override {}
-  virtual void visit (AST::StructExprUnit &expr) override {}
-  //  virtual void visit(EnumExprField& field) override {}
-  virtual void visit (AST::EnumExprFieldIdentifier &field) override {}
-  virtual void visit (AST::EnumExprFieldIdentifierValue &field) override {}
-  virtual void visit (AST::EnumExprFieldIndexValue &field) override {}
-  virtual void visit (AST::EnumExprStruct &expr) override {}
-  virtual void visit (AST::EnumExprTuple &expr) override {}
-  virtual void visit (AST::EnumExprFieldless &expr) override {}
-  virtual void visit (AST::CallExpr &expr) override {}
-  virtual void visit (AST::MethodCallExpr &expr) override {}
-  virtual void visit (AST::FieldAccessExpr &expr) override {}
-  virtual void visit (AST::ClosureExprInner &expr) override {}
-  virtual void visit (AST::BlockExpr &expr) override {}
-  virtual void visit (AST::ClosureExprInnerTyped &expr) override {}
-  virtual void visit (AST::ContinueExpr &expr) override {}
-  virtual void visit (AST::BreakExpr &expr) override {}
-  virtual void visit (AST::RangeFromToExpr &expr) override {}
-  virtual void visit (AST::RangeFromExpr &expr) override {}
-  virtual void visit (AST::RangeToExpr &expr) override {}
-  virtual void visit (AST::RangeFullExpr &expr) override {}
-  virtual void visit (AST::RangeFromToInclExpr &expr) override {}
-  virtual void visit (AST::RangeToInclExpr &expr) override {}
-  virtual void visit (AST::ReturnExpr &expr) override {}
-  virtual void visit (AST::UnsafeBlockExpr &expr) override {}
-  virtual void visit (AST::LoopExpr &expr) override {}
-  virtual void visit (AST::WhileLoopExpr &expr) override {}
-  virtual void visit (AST::WhileLetLoopExpr &expr) override {}
-  virtual void visit (AST::ForLoopExpr &expr) override {}
-  virtual void visit (AST::IfExpr &expr) override {}
-  virtual void visit (AST::IfExprConseqElse &expr) override {}
-  virtual void visit (AST::IfExprConseqIf &expr) override {}
-  virtual void visit (AST::IfExprConseqIfLet &expr) override {}
-  virtual void visit (AST::IfLetExpr &expr) override {}
-  virtual void visit (AST::IfLetExprConseqElse &expr) override {}
-  virtual void visit (AST::IfLetExprConseqIf &expr) override {}
-  virtual void visit (AST::IfLetExprConseqIfLet &expr) override {}
-  //  virtual void visit(MatchCase& match_case) override {}
-  // virtual void visit (AST::MatchCaseBlockExpr &match_case) override {}
-  // virtual void visit (AST::MatchCaseExpr &match_case) override {}
-  virtual void visit (AST::MatchExpr &expr) override {}
-  virtual void visit (AST::AwaitExpr &expr) override {}
-  virtual void visit (AST::AsyncBlockExpr &expr) override {}
-
-  // rust-item.h
-  virtual void visit (AST::TypeParam &param) override {}
-  //  virtual void visit(WhereClauseItem& item) override {}
-  virtual void visit (AST::LifetimeWhereClauseItem &item) override {}
-  virtual void visit (AST::TypeBoundWhereClauseItem &item) override {}
-  virtual void visit (AST::Method &method) override {}
-  virtual void visit (AST::ModuleBodied &module) override {}
-  virtual void visit (AST::ModuleNoBody &module) override {}
-  virtual void visit (AST::ExternCrate &crate) override {}
-  //  virtual void visit(UseTree& use_tree) override {}
-  virtual void visit (AST::UseTreeGlob &use_tree) override {}
-  virtual void visit (AST::UseTreeList &use_tree) override {}
-  virtual void visit (AST::UseTreeRebind &use_tree) override {}
-  virtual void visit (AST::UseDeclaration &use_decl) override {}
-  virtual void visit (AST::Function &function) override {}
-  virtual void visit (AST::TypeAlias &type_alias) override {}
-  virtual void visit (AST::StructStruct &struct_item) override {}
-  virtual void visit (AST::TupleStruct &tuple_struct) override {}
-  virtual void visit (AST::EnumItem &item) override {}
-  virtual void visit (AST::EnumItemTuple &item) override {}
-  virtual void visit (AST::EnumItemStruct &item) override {}
-  virtual void visit (AST::EnumItemDiscriminant &item) override {}
-  virtual void visit (AST::Enum &enum_item) override {}
-  virtual void visit (AST::Union &union_item) override {}
-  virtual void visit (AST::ConstantItem &const_item) override {}
-  virtual void visit (AST::StaticItem &static_item) override {}
-  virtual void visit (AST::TraitItemFunc &item) override {}
-  virtual void visit (AST::TraitItemMethod &item) override {}
-  virtual void visit (AST::TraitItemConst &item) override {}
-  virtual void visit (AST::TraitItemType &item) override {}
-  virtual void visit (AST::Trait &trait) override {}
-  virtual void visit (AST::InherentImpl &impl) override {}
-  virtual void visit (AST::TraitImpl &impl) override {}
-  //  virtual void visit(ExternalItem& item) override {}
-  virtual void visit (AST::ExternalStaticItem &item) override {}
-  virtual void visit (AST::ExternalFunctionItem &item) override {}
-  virtual void visit (AST::ExternBlock &block) override {}
-
-  // rust-macro.h
-  virtual void visit (AST::MacroMatchFragment &match) override {}
-  virtual void visit (AST::MacroMatchRepetition &match) override {}
-  virtual void visit (AST::MacroMatcher &matcher) override {}
-  virtual void visit (AST::MacroRulesDefinition &rules_def) override {}
-  virtual void visit (AST::MacroInvocation &macro_invoc) override {}
-  virtual void visit (AST::MetaItemPath &meta_item) override {}
-  virtual void visit (AST::MetaItemSeq &meta_item) override {}
-  virtual void visit (AST::MetaWord &meta_item) override {}
-  virtual void visit (AST::MetaNameValueStr &meta_item) override {}
-  virtual void visit (AST::MetaListPaths &meta_item) override {}
-  virtual void visit (AST::MetaListNameValueStr &meta_item) override {}
-
-  // rust-pattern.h
-  virtual void visit (AST::LiteralPattern &pattern) override {}
-  virtual void visit (AST::IdentifierPattern &pattern) override {}
-  virtual void visit (AST::WildcardPattern &pattern) override {}
-  //  virtual void visit(RangePatternBound& bound) override {}
-  virtual void visit (AST::RangePatternBoundLiteral &bound) override {}
-  virtual void visit (AST::RangePatternBoundPath &bound) override {}
-  virtual void visit (AST::RangePatternBoundQualPath &bound) override {}
-  virtual void visit (AST::RangePattern &pattern) override {}
-  virtual void visit (AST::ReferencePattern &pattern) override {}
-  //  virtual void visit(StructPatternField& field) override {}
-  virtual void visit (AST::StructPatternFieldTuplePat &field) override {}
-  virtual void visit (AST::StructPatternFieldIdentPat &field) override {}
-  virtual void visit (AST::StructPatternFieldIdent &field) override {}
-  virtual void visit (AST::StructPattern &pattern) override {}
-  //  virtual void visit(TupleStructItems& tuple_items) override {}
-  virtual void visit (AST::TupleStructItemsNoRange &tuple_items) override {}
-  virtual void visit (AST::TupleStructItemsRange &tuple_items) override {}
-  virtual void visit (AST::TupleStructPattern &pattern) override {}
-  //  virtual void visit(TuplePatternItems& tuple_items) override {}
-  virtual void visit (AST::TuplePatternItemsMultiple &tuple_items) override {}
-  virtual void visit (AST::TuplePatternItemsRanged &tuple_items) override {}
-  virtual void visit (AST::TuplePattern &pattern) override {}
-  virtual void visit (AST::GroupedPattern &pattern) override {}
-  virtual void visit (AST::SlicePattern &pattern) override {}
-
-  // rust-stmt.h
-  virtual void visit (AST::EmptyStmt &stmt) override {}
-  virtual void visit (AST::LetStmt &stmt) override {}
-  virtual void visit (AST::ExprStmtWithoutBlock &stmt) override {}
-  virtual void visit (AST::ExprStmtWithBlock &stmt) override {}
-
-  // rust-type.h
-  virtual void visit (AST::TraitBound &bound) override {}
-  virtual void visit (AST::ImplTraitType &type) override {}
-  virtual void visit (AST::TraitObjectType &type) override {}
-  virtual void visit (AST::ParenthesisedType &type) override {}
-  virtual void visit (AST::ImplTraitTypeOneBound &type) override {}
-  virtual void visit (AST::TraitObjectTypeOneBound &type) override {}
-  virtual void visit (AST::TupleType &type) override {}
-  virtual void visit (AST::NeverType &type) override {}
-  virtual void visit (AST::RawPointerType &type) override {}
-  virtual void visit (AST::ReferenceType &type) override {}
-  virtual void visit (AST::ArrayType &type) override {}
-  virtual void visit (AST::SliceType &type) override {}
-  virtual void visit (AST::InferredType &type) override {}
-  virtual void visit (AST::BareFunctionType &type) override {}
-};
-
-class ArrayTypeVisitor : public BaseTypeVisitor
-{
-public:
-  static AST::ArrayType *Resolve (AST::Type *type)
-  {
-    ArrayTypeVisitor vis;
-    type->accept_vis (vis);
-    return vis.resolved;
-  }
-
-  virtual void visit (AST::ArrayType &type) override { resolved = &type; };
-
-private:
-  ArrayTypeVisitor () : resolved (nullptr) {}
-
-  AST::ArrayType *resolved;
-};
-
-} // namespace Analysis
-} // namespace Rust
-
-#endif // RUST_TYPE_VISITOR_H
diff --git a/gcc/rust/backend/rust-compile.cc b/gcc/rust/backend/rust-compile.cc
index 300240f..a4b5cd4 100644
--- a/gcc/rust/backend/rust-compile.cc
+++ b/gcc/rust/backend/rust-compile.cc
@@ -1,1500 +1,31 @@
-#include "rust-compile.h"
-#include "rust-diagnostics.h"
-
-namespace Rust {
-namespace Compile {
-
-#define VISIT_POP(L, S, R, B)                                                  \
-  do                                                                           \
-    {                                                                          \
-      auto before = B.size ();                                                 \
-      S->accept_vis (*this);                                                   \
-      if (B.size () <= before)                                                 \
-	break;                                                                 \
-      R = B.back ();                                                           \
-      B.pop_back ();                                                           \
-    }                                                                          \
-  while (0)
-
-Compilation::Compilation (AST::Crate &crate, ::Backend *backend)
-  : crate (crate), backend (backend), scope (backend)
-{}
-
-Compilation::~Compilation () {}
-
-bool
-Compilation::Compile (AST::Crate &crate, ::Backend *backend)
-{
-  Compilation resolver (crate, backend);
-  return resolver.go ();
-}
-
-bool
-Compilation::go ()
-{
-  scope.Push ();
-
-  // builtin primitives
-  scope.InsertType ("bool",
-		    backend->named_type ("bool", backend->bool_type (),
-					 Linemap::predeclared_location ()));
-  scope.InsertType ("i64",
-		    backend->named_type ("i64",
-					 backend->integer_type (false, 64),
-					 Linemap::predeclared_location ()));
-  scope.InsertType ("i32",
-		    backend->named_type ("i32",
-					 backend->integer_type (false, 32),
-					 Linemap::predeclared_location ()));
-  scope.InsertType ("i16",
-		    backend->named_type ("i16",
-					 backend->integer_type (false, 16),
-					 Linemap::predeclared_location ()));
-  scope.InsertType ("i8",
-		    backend->named_type ("i8", backend->integer_type (false, 8),
-					 Linemap::predeclared_location ()));
-  scope.InsertType ("u64",
-		    backend->named_type ("u64",
-					 backend->integer_type (true, 64),
-					 Linemap::predeclared_location ()));
-  scope.InsertType ("u32",
-		    backend->named_type ("u32",
-					 backend->integer_type (true, 32),
-					 Linemap::predeclared_location ()));
-  scope.InsertType ("u16",
-		    backend->named_type ("u16",
-					 backend->integer_type (true, 16),
-					 Linemap::predeclared_location ()));
-  scope.InsertType ("u8",
-		    backend->named_type ("u8", backend->integer_type (true, 8),
-					 Linemap::predeclared_location ()));
-  scope.InsertType ("f64", backend->float_type (64));
-  scope.InsertType ("f32", backend->float_type (32));
-
-  for (auto &item : crate.items)
-    item->accept_vis (*this);
-  scope.Pop ();
-
-  // Define all globally declared values.
-  if (saw_errors ())
-    return false;
-
-  backend->write_global_definitions (type_decls, const_decls, func_decls,
-				     var_decls);
-  return true;
-}
-
-bool
-Compilation::compileVarDecl (Bfunction *fndecl, AST::LetStmt *stmt,
-			     std::vector<Bvariable *> &vars)
-{
-  AST::Type *type = stmt->has_type () ? stmt->get_type ().get () : stmt->inferedType;
-  translatedType = NULL;
-  type->accept_vis (*this);
-  if (translatedType == NULL)
-    {
-      rust_error_at (stmt->get_locus (), "failed to compile type for var decl");
-      return false;
-    }
-
-  stmt->get_pattern ()->accept_vis (*this);
-  for (auto &pattern : patternBuffer)
-    {
-      auto var = backend->local_variable (fndecl, pattern.get_ident (),
-					  translatedType, NULL /*decl_var*/,
-					  false /*address_taken*/, stmt->get_locus ());
-      vars.push_back (var);
-      scope.InsertVar (pattern.get_ident (), var);
-    }
-  patternBuffer.clear ();
-  return true;
-}
-
-Bexpression *
-Compilation::compileBooleanLiteral (std::string val)
-{
-  bool bval = val.compare ("true") == 0;
-  return backend->boolean_constant_expression (bval);
-}
-
-Bexpression *
-Compilation::compileFloatLiteral (std::string val, Location locus)
-{
-  Btype *type = NULL;
-  bool ok = scope.LookupType ("f32", &type);
-  if (!ok)
-    {
-      rust_fatal_error (locus, "unable to find type");
-      return NULL;
-    }
-  mpfr_t fval;
-  if (mpfr_init_set_str (fval, val.c_str (), 10, GMP_RNDN) != 0)
-    {
-      rust_fatal_error (locus, "bad number in literal");
-      return NULL;
-    }
-  return backend->float_constant_expression (type, fval);
-}
-
-Bexpression *
-Compilation::compileIntegerLiteral (std::string val, Location locus)
-{
-  Btype *type = NULL;
-  bool ok = scope.LookupType ("i32", &type);
-  if (!ok)
-    {
-      rust_fatal_error (locus, "unable to find type");
-      return NULL;
-    }
-  mpz_t ival;
-  if (mpz_init_set_str (ival, val.c_str (), 10) != 0)
-    {
-      rust_fatal_error (locus, "bad number in literal");
-      return NULL;
-    }
-  return backend->integer_constant_expression (type, ival);
-}
-
-void
-Compilation::visit (AST::Token &tok)
-{}
-
-void
-Compilation::visit (AST::DelimTokenTree &delim_tok_tree)
-{}
-
-void
-Compilation::visit (AST::AttrInputMetaItemContainer &input)
-{}
-
-void
-Compilation::visit (AST::IdentifierExpr &ident_expr)
-{
-  Bvariable *var = NULL;
-  if (!scope.LookupVar (ident_expr.as_string (), &var))
-    {
-      rust_fatal_error (ident_expr.get_locus (), "unknown var");
-      return;
-    }
-  exprs.push_back (backend->var_expression (var, ident_expr.get_locus ()));
-}
-
-void
-Compilation::visit (AST::Lifetime &lifetime)
-{}
-
-void
-Compilation::visit (AST::LifetimeParam &lifetime_param)
-{}
-
-void
-Compilation::visit (AST::MacroInvocationSemi &macro)
-{}
-
-// rust-path.h
-void
-Compilation::visit (AST::PathInExpression &path)
-{
-  Bfunction *fn = NULL;
-  if (scope.LookupFunction (path.as_string (), &fn))
-    {
-      auto expr
-	= backend->function_code_expression (fn, path.get_locus ());
-      exprs.push_back (expr);
-      translatedType = scope.GetFnRetType (fn);
-      return;
-    }
-}
-
-void
-Compilation::visit (AST::TypePathSegment &segment)
-{}
-void
-Compilation::visit (AST::TypePathSegmentGeneric &segment)
-{}
-void
-Compilation::visit (AST::TypePathSegmentFunction &segment)
-{}
-
-void
-Compilation::visit (AST::TypePath &path)
-{
-  if (path.get_segments ().size () > 1)
-    {
-      rust_error_at (path.get_locus (), "unable to compile multi segment types yet");
-      return;
-    }
-
-  Btype *type = NULL;
-  if (!scope.LookupType (path.as_string (), &type))
-    {
-      rust_error_at (path.get_locus (), "unknown type");
-      return;
-    }
-  translatedType = type;
-}
-
-void
-Compilation::visit (AST::QualifiedPathInExpression &path)
-{}
-void
-Compilation::visit (AST::QualifiedPathInType &path)
-{}
-
-// rust-expr.h
-void
-Compilation::visit (AST::LiteralExpr &expr)
-{
-  Bexpression *compiled;
-  switch (expr.get_lit_type ())
-    {
-    case AST::Literal::BOOL:
-      compiled = compileBooleanLiteral (expr.as_string ());
-      break;
-
-    case AST::Literal::FLOAT:
-      compiled
-	= compileFloatLiteral (expr.as_string (), expr.get_locus ());
-      break;
-
-    case AST::Literal::INT:
-      compiled
-	= compileIntegerLiteral (expr.as_string (), expr.get_locus ());
-      break;
-
-    default:
-      rust_fatal_error (expr.get_locus (), "unknown literal");
-      return;
-    }
-
-  exprs.push_back (compiled);
-}
-
-void
-Compilation::visit (AST::AttrInputLiteral &attr_input)
-{}
-void
-Compilation::visit (AST::MetaItemLitExpr &meta_item)
-{}
-void
-Compilation::visit (AST::MetaItemPathLit &meta_item)
-{}
-void
-Compilation::visit (AST::BorrowExpr &expr)
-{}
-void
-Compilation::visit (AST::DereferenceExpr &expr)
-{}
-void
-Compilation::visit (AST::ErrorPropagationExpr &expr)
-{}
-
-void
-Compilation::visit (AST::NegationExpr &expr)
-{
-  Bexpression *root = NULL;
-  VISIT_POP (expr.get_negated_expr ()->get_locus_slow (), expr.get_negated_expr ().get (), root,
-	     exprs);
-  if (root == NULL)
-    {
-      rust_error_at (expr.get_negated_expr ()->get_locus_slow (), "failed to compile");
-      return;
-    }
-
-  Operator op;
-  switch (expr.get_negation_type ())
-    {
-    case AST::NegationExpr::NEGATE:
-      op = OPERATOR_MINUS;
-      break;
-    case AST::NegationExpr::NOT:
-      op = OPERATOR_NOT;
-      break;
-    default:
-      rust_fatal_error (expr.get_locus (), "failed to compile operator");
-      return;
-    }
-
-  auto unary = backend->unary_expression (op, root, expr.get_locus ());
-  exprs.push_back (unary);
-}
-
-void
-Compilation::visit (AST::ArithmeticOrLogicalExpr &expr)
-{
-  Bexpression *lhs = NULL;
-  VISIT_POP (expr.get_left_expr ()->get_locus_slow (), expr.get_left_expr ().get (), lhs, exprs);
-  if (lhs == NULL)
-    {
-      rust_error_at (expr.get_left_expr ()->get_locus_slow (), "failed to compile");
-      return;
-    }
-
-  Bexpression *rhs = NULL;
-  VISIT_POP (expr.get_right_expr ()->get_locus_slow (), expr.get_right_expr ().get (), rhs, exprs);
-  if (rhs == NULL)
-    {
-      rust_error_at (expr.get_right_expr ()->get_locus_slow (), "failed to compile");
-      return;
-    }
-
-  Operator op;
-  switch (expr.get_expr_type ())
-    {
-    case AST::ArithmeticOrLogicalExpr::ADD:
-      op = OPERATOR_PLUS;
-      break;
-    case AST::ArithmeticOrLogicalExpr::SUBTRACT:
-      op = OPERATOR_MINUS;
-      break;
-    case AST::ArithmeticOrLogicalExpr::MULTIPLY:
-      op = OPERATOR_MULT;
-      break;
-    case AST::ArithmeticOrLogicalExpr::DIVIDE:
-      op = OPERATOR_DIV;
-      break;
-    case AST::ArithmeticOrLogicalExpr::MODULUS:
-      op = OPERATOR_MOD;
-      break;
-    case AST::ArithmeticOrLogicalExpr::BITWISE_AND:
-      op = OPERATOR_AND;
-      break;
-    case AST::ArithmeticOrLogicalExpr::BITWISE_OR:
-      op = OPERATOR_OR;
-      break;
-    case AST::ArithmeticOrLogicalExpr::BITWISE_XOR:
-      op = OPERATOR_XOR;
-      break;
-    case AST::ArithmeticOrLogicalExpr::LEFT_SHIFT:
-      op = OPERATOR_LSHIFT;
-      break;
-    case AST::ArithmeticOrLogicalExpr::RIGHT_SHIFT:
-      op = OPERATOR_RSHIFT;
-      break;
-    default:
-      rust_fatal_error (expr.get_locus (), "failed to compile operator");
-      return;
-    }
-
-  auto binExpr
-    = backend->binary_expression (op, lhs, rhs, expr.get_locus ());
-  exprs.push_back (binExpr);
-}
-
-void
-Compilation::visit (AST::ComparisonExpr &expr)
-{
-  Bexpression *lhs = NULL;
-  VISIT_POP (expr.get_left_expr ()->get_locus_slow (), expr.get_left_expr ().get (), lhs, exprs);
-  if (lhs == NULL)
-    {
-      rust_error_at (expr.get_left_expr ()->get_locus_slow (), "failed to compile");
-      return;
-    }
-
-  Bexpression *rhs = NULL;
-  VISIT_POP (expr.get_right_expr ()->get_locus_slow (), expr.get_right_expr ().get (), rhs, exprs);
-  if (rhs == NULL)
-    {
-      rust_error_at (expr.get_right_expr ()->get_locus_slow (), "failed to compile");
-      return;
-    }
-
-  Operator op;
-  switch (expr.get_expr_type ())
-    {
-    case AST::ComparisonExpr::EQUAL:
-      op = OPERATOR_EQEQ;
-      break;
-    case AST::ComparisonExpr::NOT_EQUAL:
-      op = OPERATOR_NOTEQ;
-      break;
-    case AST::ComparisonExpr::GREATER_THAN:
-      op = OPERATOR_GT;
-      break;
-    case AST::ComparisonExpr::LESS_THAN:
-      op = OPERATOR_LT;
-      break;
-    case AST::ComparisonExpr::GREATER_OR_EQUAL:
-      op = OPERATOR_GE;
-      break;
-    case AST::ComparisonExpr::LESS_OR_EQUAL:
-      op = OPERATOR_LE;
-      break;
-    default:
-      rust_fatal_error (expr.get_locus (), "failed to compile operator");
-      return;
-    }
-
-  auto compExpr
-    = backend->binary_expression (op, lhs, rhs, expr.get_locus ());
-  exprs.push_back (compExpr);
-}
-
-void
-Compilation::visit (AST::LazyBooleanExpr &expr)
-{
-  Bexpression *lhs = NULL;
-  VISIT_POP (expr.get_left_expr ()->get_locus_slow (), expr.get_left_expr ().get (), lhs, exprs);
-  if (lhs == NULL)
-    {
-      rust_error_at (expr.get_left_expr ()->get_locus_slow (), "failed to compile");
-      return;
-    }
-
-  Bexpression *rhs = NULL;
-  VISIT_POP (expr.get_right_expr ()->get_locus_slow (), expr.get_right_expr ().get (), rhs, exprs);
-  if (rhs == NULL)
-    {
-      rust_error_at (expr.get_right_expr ()->get_locus_slow (), "failed to compile");
-      return;
-    }
-
-  Operator op;
-  switch (expr.get_expr_type ())
-    {
-    case AST::LazyBooleanExpr::LOGICAL_OR:
-      op = OPERATOR_OROR;
-      break;
-    case AST::LazyBooleanExpr::LOGICAL_AND:
-      op = OPERATOR_ANDAND;
-      break;
-    default:
-      rust_fatal_error (expr.get_locus (), "failed to compile operator");
-      return;
-    }
-
-  auto compExpr
-    = backend->binary_expression (op, lhs, rhs, expr.get_locus ());
-  exprs.push_back (compExpr);
-}
-
-void
-Compilation::visit (AST::TypeCastExpr &expr)
-{}
-
-void
-Compilation::visit (AST::AssignmentExpr &expr)
-{
-  Bexpression *lhs = NULL;
-  VISIT_POP (expr.get_left_expr ()->get_locus_slow (), expr.get_left_expr ().get (), lhs, exprs);
-  if (lhs == NULL)
-    {
-      rust_error_at (expr.get_left_expr ()->get_locus_slow (), "failed to compile");
-      return;
-    }
-
-  Bexpression *rhs = NULL;
-  VISIT_POP (expr.get_right_expr ()->get_locus_slow (), expr.get_right_expr ().get (), rhs, exprs);
-  if (rhs == NULL)
-    {
-      rust_error_at (expr.get_right_expr ()->get_locus_slow (), "failed to compile");
-      return;
-    }
-
-  auto s = backend->assignment_statement (scope.GetCurrentFndecl (), lhs, rhs,
-					  expr.get_locus ());
-  scope.AddStatement (s);
-}
-
-void
-Compilation::visit (AST::CompoundAssignmentExpr &expr)
-{}
-void
-Compilation::visit (AST::GroupedExpr &expr)
-{}
-
-void
-Compilation::visit (AST::ArrayElemsValues &elems)
-{
-  std::vector< ::Bexpression *> elements;
-
-  bool failed = false;
-  elems.iterate ([&] (AST::Expr *expr) mutable -> bool {
-    Bexpression *value = nullptr;
-    VISIT_POP (expr.get_locus_slow (), expr, value, exprs);
-    if (value == nullptr)
-      {
-	rust_fatal_error (expr->get_locus_slow (),
-			  "failed to compile value to array initialiser");
-	return false;
-      }
-    elements.push_back (value);
-    return true;
-  });
-
-  // nothing to do when its failed
-  if (failed)
-    return;
-
-  arrayConsStack.push_back (elements);
-}
-
-void
-Compilation::visit (AST::ArrayElemsCopied &elems)
-{}
-
-void
-Compilation::visit (AST::ArrayExpr &expr)
-{
-  translatedType = nullptr;
-  expr.get_inferred_type ()->accept_vis (*this);
-  if (translatedType == nullptr)
-    {
-      rust_error_at (expr.get_locus_slow (),
-		     "failed to compile array type for ArrayExpr");
-      return;
-    }
-
-  ::Btype *compiledType = translatedType;
-  translatedType = nullptr;
-
-  auto before = arrayConsStack.size ();
-  expr.get_array_elems ()->accept_vis (*this);
-  if (arrayConsStack.size () <= before)
-    {
-      rust_error_at (expr.get_locus_slow (),
-		     "failed to compile the array constructor");
-      return;
-    }
-  std::vector< ::Bexpression *> initializer = arrayConsStack.back ();
-  arrayConsStack.pop_back ();
-
-  std::vector<unsigned long> indexes;
-  for (unsigned long i = 0; i < initializer.size (); ++i)
-    indexes.push_back (i);
-
-  Bexpression *cons
-    = backend->array_constructor_expression (compiledType, indexes, initializer,
-					     expr.get_locus_slow ());
-  exprs.push_back (cons);
-}
-
-void
-Compilation::visit (AST::ArrayIndexExpr &expr)
-{
-  Bexpression *arrayExpr = nullptr;
-  VISIT_POP (expr.get_array_expr ()->get_locus_slow (), expr.get_array_expr (),
-	     arrayExpr, exprs);
-  if (arrayExpr == nullptr)
-    {
-      rust_error_at (expr.get_locus_slow (),
-		     "failed to compile value to array expression reference");
-      return;
-    }
-
-  Bexpression *indexExpr = nullptr;
-  VISIT_POP (expr.get_index_expr ()->get_locus_slow (), expr.get_index_expr (),
-	     indexExpr, exprs);
-  if (indexExpr == nullptr)
-    {
-      rust_error_at (expr.get_locus_slow (),
-		     "failed to compile value to array index expression");
-      return;
-    }
-
-  Bexpression *indexExpression
-    = backend->array_index_expression (arrayExpr, indexExpr,
-				       expr.get_locus_slow ());
-  exprs.push_back (indexExpression);
-}
-
-void
-Compilation::visit (AST::TupleExpr &expr)
-{}
-void
-Compilation::visit (AST::TupleIndexExpr &expr)
-{}
-void
-Compilation::visit (AST::StructExprStruct &expr)
-{}
-// void Compilation::visit(StructExprField& field) {}
-void
-Compilation::visit (AST::StructExprFieldIdentifier &field)
-{}
-
-void
-Compilation::visit (AST::StructExprFieldIdentifierValue &field)
-{
-  Bexpression *value = NULL;
-  VISIT_POP (field.get_value ()->get_locus_slow (), field.get_value ().get (), value, exprs);
-  if (value == NULL)
-    {
-      rust_fatal_error (field.get_value ()->get_locus_slow (),
-			"failed to compile value to struct");
-      return;
-    }
-  exprs.push_back (value);
-}
-
-void
-Compilation::visit (AST::StructExprFieldIndexValue &field)
-{
-  Bexpression *value = NULL;
-  VISIT_POP (field.get_value ()->get_locus_slow (), field.get_value ().get (), value, exprs);
-  if (value == NULL)
-    {
-      rust_fatal_error (field.get_value ()->get_locus_slow (),
-			"failed to compile value to struct");
-      return;
-    }
-  exprs.push_back (value);
-}
-
-void
-Compilation::visit (AST::StructExprStructFields &expr)
-{
-  AST::StructStruct *decl = NULL;
-  if (!scope.LookupStructDecl (expr.get_struct_name ().as_string (), &decl))
-    {
-      rust_error_at (expr.get_locus (), "unknown type");
-      return;
-    }
-
-  Btype *structType = NULL;
-  if (!scope.LookupType (expr.get_struct_name ().as_string (), &structType))
-    {
-      rust_fatal_error (expr.get_locus (), "unknown type");
-      return;
-    }
-
-  structBuffer.push_back (decl);
-  std::vector<Bexpression *> constructor;
-
-  // FIXME type resolution pass should ensures these are in correct order
-  // and have defaults if required
-  for (auto &field : expr.get_fields ())
-    {
-      Bexpression *value = NULL;
-      VISIT_POP (expr.get_locus (), field, value, exprs);
-      if (value == NULL)
-	{
-	  rust_fatal_error (expr.get_locus (),
-			    "failed to compile value to struct");
-	  return;
-	}
-
-      constructor.push_back (value);
-    }
-
-  structBuffer.pop_back ();
-  auto cons = backend->constructor_expression (structType, constructor,
-					       expr.get_locus ());
-  exprs.push_back (cons);
-}
-
-void
-Compilation::visit (AST::StructExprStructBase &expr)
-{}
-void
-Compilation::visit (AST::StructExprTuple &expr)
-{}
-void
-Compilation::visit (AST::StructExprUnit &expr)
-{}
-// void Compilation::visit(EnumExprField& field) {}
-void
-Compilation::visit (AST::EnumExprFieldIdentifier &field)
-{}
-void
-Compilation::visit (AST::EnumExprFieldIdentifierValue &field)
-{}
-void
-Compilation::visit (AST::EnumExprFieldIndexValue &field)
-{}
-void
-Compilation::visit (AST::EnumExprStruct &expr)
-{}
-void
-Compilation::visit (AST::EnumExprTuple &expr)
-{}
-void
-Compilation::visit (AST::EnumExprFieldless &expr)
-{}
-
-void
-Compilation::visit (AST::CallExpr &expr)
-{
-  Bexpression *fn = NULL;
-  VISIT_POP (expr.get_function_expr ()->get_locus_slow (), expr.get_function_expr (), fn, exprs);
-  if (fn == NULL)
-    {
-      rust_error_at (expr.get_function_expr ()->get_locus_slow (), "failed to resolve");
-      return;
-    }
-
-  std::vector<Bexpression *> args;
-  for (auto &param : expr.get_params ())
-    {
-      Bexpression *arg = NULL;
-      VISIT_POP (param->get_locus_slow (), param, arg, exprs);
-      if (arg == NULL)
-	{
-	  rust_error_at (param->get_locus_slow (),
-			 "failed to compile argument");
-	  return;
-	}
-
-      args.push_back (arg);
-    }
-
-  auto call = backend->call_expression (scope.GetCurrentFndecl (), fn, args,
-					NULL, expr.get_locus ());
-  exprs.push_back (call);
-}
-
-void
-Compilation::visit (AST::MethodCallExpr &expr)
-{}
-void
-Compilation::visit (AST::FieldAccessExpr &expr)
-{}
-void
-Compilation::visit (AST::ClosureExprInner &expr)
-{}
-
-void
-Compilation::visit (AST::BlockExpr &expr)
-{
-  Bblock *enclosingScope = NULL;
-  Location start_location; /* = stmt.locus; FIXME */
-  Location end_location;   // FIXME
-
-  std::vector<Bvariable *> vars;
-  auto code_block
-    = backend->block (scope.GetCurrentFndecl (), scope.CurBlock (), vars,
-		      start_location, end_location);
-
-  scope.PushBlock (code_block);
-  for (auto &stmt : expr.get_statements ())
-    {
-      stmt->accept_vis (*this);
-    }
-  // dont pop
-}
-
-void
-Compilation::visit (AST::ClosureExprInnerTyped &expr)
-{}
-void
-Compilation::visit (AST::ContinueExpr &expr)
-{}
-void
-Compilation::visit (AST::BreakExpr &expr)
-{}
-void
-Compilation::visit (AST::RangeFromToExpr &expr)
-{}
-void
-Compilation::visit (AST::RangeFromExpr &expr)
-{}
-void
-Compilation::visit (AST::RangeToExpr &expr)
-{}
-void
-Compilation::visit (AST::RangeFullExpr &expr)
-{}
-void
-Compilation::visit (AST::RangeFromToInclExpr &expr)
-{}
-void
-Compilation::visit (AST::RangeToInclExpr &expr)
-{}
-
-void
-Compilation::visit (AST::ReturnExpr &expr)
-{
-  Bexpression *ret = NULL;
-  VISIT_POP (expr.get_returned_expr ()->get_locus_slow (), expr.get_returned_expr ().get (), ret, exprs);
-  if (ret == NULL)
-    {
-      rust_fatal_error (expr.get_returned_expr ()->get_locus_slow (),
-			"failed to compile");
-      return;
-    }
-
-  std::vector<Bexpression *> retstmts;
-  retstmts.push_back (ret);
-  auto s = backend->return_statement (scope.GetCurrentFndecl (), retstmts,
-				      expr.get_locus ());
-  scope.AddStatement (s);
-}
-
-void
-Compilation::visit (AST::UnsafeBlockExpr &expr)
-{}
-
-void
-Compilation::visit (AST::LoopExpr &expr)
-{}
-
-void
-Compilation::visit (AST::WhileLoopExpr &expr)
-{}
-
-void
-Compilation::visit (AST::WhileLetLoopExpr &expr)
-{}
-void
-Compilation::visit (AST::ForLoopExpr &expr)
-{}
-
-void
-Compilation::visit (AST::IfExpr &expr)
-{
-  Bexpression *cond = NULL;
-  VISIT_POP (expr.get_condition_expr ()->get_locus_slow (),
-	     expr.get_condition_expr ().get (), cond, exprs);
-  if (cond == NULL)
-    {
-      rust_error_at (expr.get_condition_expr ()->get_locus_slow (),
-		     "failed to compile");
-      return;
-    }
-
-  expr.vis_if_block (*this);
-  Bblock *then_block = scope.PopBlock ();
-
-  auto stmt = backend->if_statement (scope.GetCurrentFndecl (), cond,
-				     then_block, NULL, expr.get_locus ());
-  stmts.push_back (stmt);
-}
-
-void
-Compilation::visit (AST::IfExprConseqElse &expr)
-{
-  Bexpression *cond = NULL;
-  VISIT_POP (expr.get_condition_expr ()->get_locus_slow (),
-	     expr.get_condition_expr ().get (), cond, exprs);
-  if (cond == NULL)
-    {
-      rust_error_at (expr.get_condition_expr ()->get_locus_slow (),
-		     "failed to compile");
-      return;
-    }
-
-  expr.vis_if_block (*this);
-  Bblock *then_block = scope.PopBlock ();
-
-  expr.vis_else_block (*this);
-  Bblock *else_block = scope.PopBlock ();
+// Copyright (C) 2020 Free Software Foundation, Inc.
 
-  auto stmt
-    = backend->if_statement (scope.GetCurrentFndecl (), cond, then_block,
-			     else_block, expr.get_locus ());
-  stmts.push_back (stmt);
-}
+// This file is part of GCC.
 
-void
-Compilation::visit (AST::IfExprConseqIf &expr)
-{
-  Bexpression *cond = NULL;
-  VISIT_POP (expr.get_condition_expr ()->get_locus_slow (),
-	     expr.get_condition_expr ().get (), cond, exprs);
-  if (cond == NULL)
-    {
-      rust_error_at (expr.get_condition_expr ()->get_locus_slow (),
-		     "failed to compile");
-      return;
-    }
-
-  expr.vis_if_block (*this);
-  Bblock *then_block = scope.PopBlock ();
-
-  // setup else block
-  Bblock *enclosingScope = NULL;
-  Location start_location; /* = stmt.locus; FIXME */
-  Location end_location;   // FIXME
-
-  std::vector<Bvariable *> vars;
-  auto else_block
-    = backend->block (scope.GetCurrentFndecl (), scope.CurBlock (), vars,
-		      start_location, end_location);
-
-  scope.PushBlock (else_block);
-  expr.vis_conseq_if_expr (*this);
-  // get trailing if required
-  for (auto &s : stmts)
-    scope.AddStatement (s);
-  stmts.clear ();
-  scope.PopBlock ();
-
-  auto stmt
-    = backend->if_statement (scope.GetCurrentFndecl (), cond, then_block,
-			     else_block, expr.get_locus ());
-  stmts.push_back (stmt);
-}
-
-void
-Compilation::visit (AST::IfExprConseqIfLet &expr)
-{
-  printf ("IfExprConseqIfLet %s\n", expr.as_string ().c_str ());
-}
-void
-Compilation::visit (AST::IfLetExpr &expr)
-{
-  printf ("IfLetExpr %s\n", expr.as_string ().c_str ());
-}
-void
-Compilation::visit (AST::IfLetExprConseqElse &expr)
-{
-  printf ("IfLetExprConseqElse %s\n", expr.as_string ().c_str ());
-}
-
-void
-Compilation::visit (AST::IfLetExprConseqIf &expr)
-{
-  printf ("IfLetExprConseqIf %s\n", expr.as_string ().c_str ());
-}
-
-void
-Compilation::visit (AST::IfLetExprConseqIfLet &expr)
-{
-  printf ("IfLetExprConseqIfLet %s\n", expr.as_string ().c_str ());
-}
-
-// void Compilation::visit(MatchCase& match_case) {}
-/*void
-Compilation::visit (AST::MatchCaseBlockExpr &match_case)
-{}*/
-/*void
-Compilation::visit (AST::MatchCaseExpr &match_case)
-{}*/
-void
-Compilation::visit (AST::MatchExpr &expr)
-{}
-void
-Compilation::visit (AST::AwaitExpr &expr)
-{}
-void
-Compilation::visit (AST::AsyncBlockExpr &expr)
-{}
-
-// rust-item.h
-void
-Compilation::visit (AST::TypeParam &param)
-{}
-// void Compilation::visit(WhereClauseItem& item) {}
-void
-Compilation::visit (AST::LifetimeWhereClauseItem &item)
-{}
-void
-Compilation::visit (AST::TypeBoundWhereClauseItem &item)
-{}
-void
-Compilation::visit (AST::Method &method)
-{}
-void
-Compilation::visit (AST::ModuleBodied &module)
-{}
-void
-Compilation::visit (AST::ModuleNoBody &module)
-{}
-void
-Compilation::visit (AST::ExternCrate &crate)
-{}
-// void Compilation::visit(UseTree& use_tree) {}
-void
-Compilation::visit (AST::UseTreeGlob &use_tree)
-{}
-void
-Compilation::visit (AST::UseTreeList &use_tree)
-{}
-void
-Compilation::visit (AST::UseTreeRebind &use_tree)
-{}
-void
-Compilation::visit (AST::UseDeclaration &use_decl)
-{}
-
-void
-Compilation::visit (AST::Function &function)
-{
-  Backend::Btyped_identifier receiver;
-  std::vector<Backend::Btyped_identifier> parameters;
-  std::vector<Backend::Btyped_identifier> results;
-
-  for (auto &param : function.get_function_params ())
-    {
-      // translate the type
-      translatedType = NULL;
-      param.get_type ()->accept_vis (*this);
-      if (translatedType == NULL)
-	{
-	  rust_error_at (param.get_locus (), "failed to generate type for parameter");
-	  return;
-	}
-
-      auto before = patternBuffer.size ();
-      param.get_pattern ()->accept_vis (*this);
-      if (patternBuffer.size () <= before)
-	{
-	  rust_error_at (param.get_locus (), "failed to analyse parameter name");
-	  return;
-	}
-
-      auto numParamsPerType = patternBuffer.size () - before;
-      for (size_t i = 0; i < numParamsPerType; i++)
-	{
-	  auto paramName = patternBuffer.back ();
-	  patternBuffer.pop_back ();
-	  parameters.push_back (
-	    Backend::Btyped_identifier (paramName.get_ident (),
-					translatedType, param.get_locus ()));
-	}
-    }
-
-  Btype *returnType = NULL;
-  if (function.has_return_type ())
-    {
-      translatedType = NULL;
-      function.get_return_type ()->accept_vis (*this);
-      if (translatedType == NULL)
-	{
-	  rust_fatal_error (function.get_locus (),
-			    "failed to generate type for function");
-	  return;
-	}
-      returnType = translatedType;
-
-      // add into the results:
-      results.push_back (
-	Backend::Btyped_identifier ("_", translatedType, Location ()));
-    }
-
-  Btype *fntype = backend->function_type (receiver, parameters, results, NULL,
-					  function.get_locus ());
-  Bfunction *fndecl
-    = backend->function (fntype, function.get_function_name (), "" /* asm_name */,
-			 0 /* flags */, function.get_locus ());
-
-  scope.InsertFunction (function.get_function_name (), fndecl, returnType);
-  scope.Push ();
-
-  // setup the params
-  std::vector<Bvariable *> param_vars;
-  for (auto &param : parameters)
-    {
-      bool tree_addressable = false;
-      auto p = backend->parameter_variable (fndecl, param.name, param.btype,
-					    tree_addressable, param.location);
-
-      scope.InsertVar (param.name, p);
-      param_vars.push_back (p);
-    }
-
-  if (!backend->function_set_parameters (fndecl, param_vars))
-    {
-      rust_error_at (function.get_locus (), "failed to setup parameter variables");
-      return;
-    }
-
-  std::vector<Bvariable *> vars;
-  for (auto &decl : function.locals)
-    {
-      if (!compileVarDecl (fndecl, decl, vars))
-	{
-	  rust_error_at (decl->get_locus (), "failed to compile var decl");
-	  return;
-	}
-    }
-
-  // is null for top level functions - nested functions will have an enclosing
-  // scope
-  Bblock *enclosingScope = NULL;
-  Location start_location = function.get_locus ();
-  Location end_location;
-  if (function.get_definition ()->get_statements ().size () > 0)
-    {
-      end_location
-	= function.get_definition ()->get_statements ().back ()->get_locus_slow ();
-    }
-
-  auto code_block = backend->block (fndecl, enclosingScope, vars,
-				    start_location, end_location);
-
-  scope.PushBlock (code_block);
-
-  Bvariable *retDecl = NULL;
-  if (function.has_return_type ())
-    {
-      bool address_is_taken = false;
-      Bstatement *ret_var_stmt = NULL;
-      retDecl = backend->temporary_variable (fndecl, code_block, returnType,
-					     NULL, address_is_taken,
-					     function.get_locus (), &ret_var_stmt);
-      scope.AddStatement (ret_var_stmt);
-    }
-  scope.PushCurrentFunction (function.get_function_name (), fndecl, returnType,
-			     retDecl);
-
-  for (auto &stmt : function.get_definition ()->get_statements ())
-    stmt->accept_vis (*this);
-
-  scope.PopBlock ();
-
-  auto body = backend->block_statement (code_block);
-  if (!backend->function_set_body (fndecl, body))
-    {
-      rust_error_at (function.get_locus (), "failed to set body to function");
-      return;
-    }
-
-  scope.Pop ();
-  scope.PopCurrentFunction ();
-
-  func_decls.push_back (fndecl);
-}
-
-void
-Compilation::visit (AST::TypeAlias &type_alias)
-{}
-
-void
-Compilation::visit (AST::StructStruct &struct_item)
-{
-  std::vector<Backend::Btyped_identifier> fields;
-  for (auto &field : struct_item.get_fields ())
-    {
-      translatedType = NULL;
-      field.get_field_type ()->accept_vis (*this);
-      if (translatedType == NULL)
-	{
-	  rust_fatal_error (
-	    struct_item.get_locus () /* StructField is mi sing locus */,
-	    "failed to compile struct field");
-	  return;
-	}
-
-      fields.push_back (Backend::Btyped_identifier (
-	field.get_field_name (), translatedType,
-	struct_item.get_locus () /* StructField is mi sing locus */));
-    }
-
-  auto compiledStruct
-    = backend->placeholder_struct_type (struct_item.get_struct_name (),
-					struct_item.get_locus ());
-  bool ok = backend->set_placeholder_struct_type (compiledStruct, fields);
-  if (!ok)
-    {
-      rust_fatal_error (struct_item.get_locus (), "failed to compile struct");
-      return;
-    }
-
-  type_decls.push_back (compiledStruct);
-  scope.InsertType (struct_item.get_struct_name (), compiledStruct);
-  scope.InsertStructDecl (struct_item.get_struct_name (), &struct_item);
-}
-
-void
-Compilation::visit (AST::TupleStruct &tuple_struct)
-{}
-void
-Compilation::visit (AST::EnumItem &item)
-{}
-void
-Compilation::visit (AST::EnumItemTuple &item)
-{}
-void
-Compilation::visit (AST::EnumItemStruct &item)
-{}
-void
-Compilation::visit (AST::EnumItemDiscriminant &item)
-{}
-void
-Compilation::visit (AST::Enum &enum_item)
-{}
-void
-Compilation::visit (AST::Union &union_item)
-{}
-void
-Compilation::visit (AST::ConstantItem &const_item)
-{}
-void
-Compilation::visit (AST::StaticItem &static_item)
-{}
-void
-Compilation::visit (AST::TraitItemFunc &item)
-{}
-void
-Compilation::visit (AST::TraitItemMethod &item)
-{}
-void
-Compilation::visit (AST::TraitItemConst &item)
-{}
-void
-Compilation::visit (AST::TraitItemType &item)
-{}
-void
-Compilation::visit (AST::Trait &trait)
-{}
-void
-Compilation::visit (AST::InherentImpl &impl)
-{}
-void
-Compilation::visit (AST::TraitImpl &impl)
-{}
-// void Compilation::visit(ExternalItem& item) {}
-void
-Compilation::visit (AST::ExternalStaticItem &item)
-{}
-void
-Compilation::visit (AST::ExternalFunctionItem &item)
-{}
-void
-Compilation::visit (AST::ExternBlock &block)
-{}
-
-// rust-macro.h
-void
-Compilation::visit (AST::MacroMatchFragment &match)
-{}
-void
-Compilation::visit (AST::MacroMatchRepetition &match)
-{}
-void
-Compilation::visit (AST::MacroMatcher &matcher)
-{}
-void
-Compilation::visit (AST::MacroRulesDefinition &rules_def)
-{}
-void
-Compilation::visit (AST::MacroInvocation &macro_invoc)
-{}
-void
-Compilation::visit (AST::MetaItemPath &meta_item)
-{}
-void
-Compilation::visit (AST::MetaItemSeq &meta_item)
-{}
-void
-Compilation::visit (AST::MetaWord &meta_item)
-{}
-void
-Compilation::visit (AST::MetaNameValueStr &meta_item)
-{}
-void
-Compilation::visit (AST::MetaListPaths &meta_item)
-{}
-void
-Compilation::visit (AST::MetaListNameValueStr &meta_item)
-{}
-
-// rust-pattern.h
-void
-Compilation::visit (AST::LiteralPattern &pattern)
-{
-  printf ("LiteralPattern: %s\n", pattern.as_string ().c_str ());
-}
-
-void
-Compilation::visit (AST::IdentifierPattern &pattern)
-{
-  patternBuffer.push_back (pattern);
-}
-
-void
-Compilation::visit (AST::WildcardPattern &pattern)
-{}
-// void Compilation::visit(RangePatternBound& bound) {}
-void
-Compilation::visit (AST::RangePatternBoundLiteral &bound)
-{}
-void
-Compilation::visit (AST::RangePatternBoundPath &bound)
-{}
-void
-Compilation::visit (AST::RangePatternBoundQualPath &bound)
-{}
-void
-Compilation::visit (AST::RangePattern &pattern)
-{}
-void
-Compilation::visit (AST::ReferencePattern &pattern)
-{}
-// void Compilation::visit(StructPatternField& field) {}
-void
-Compilation::visit (AST::StructPatternFieldTuplePat &field)
-{}
-void
-Compilation::visit (AST::StructPatternFieldIdentPat &field)
-{}
-void
-Compilation::visit (AST::StructPatternFieldIdent &field)
-{}
-void
-Compilation::visit (AST::StructPattern &pattern)
-{}
-// void Compilation::visit(TupleStructItems& tuple_items) {}
-void
-Compilation::visit (AST::TupleStructItemsNoRange &tuple_items)
-{}
-void
-Compilation::visit (AST::TupleStructItemsRange &tuple_items)
-{}
-void
-Compilation::visit (AST::TupleStructPattern &pattern)
-{}
-// void Compilation::visit(TuplePatternItems& tuple_items) {}
-void
-Compilation::visit (AST::TuplePatternItemsMultiple &tuple_items)
-{}
-void
-Compilation::visit (AST::TuplePatternItemsRanged &tuple_items)
-{}
-void
-Compilation::visit (AST::TuplePattern &pattern)
-{}
-void
-Compilation::visit (AST::GroupedPattern &pattern)
-{}
-void
-Compilation::visit (AST::SlicePattern &pattern)
-{}
-
-// rust-stmt.h
-void
-Compilation::visit (AST::EmptyStmt &stmt)
-{}
-void
-
-Compilation::visit (AST::LetStmt &stmt)
-{
-  if (!stmt.has_init_expr ())
-    return;
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
 
-  stmt.get_pattern ()->accept_vis (*this);
-  for (auto &pattern : patternBuffer)
-    {
-      Bvariable *var = NULL;
-      if (!scope.LookupVar (pattern.get_ident (), &var))
-	{
-	  rust_error_at (stmt.get_locus (), "failed to find var decl for %s",
-			 pattern.get_ident ().c_str ());
-	  return;
-	}
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
 
-      varBuffer.push_back (var);
-
-      Bexpression *init = NULL;
-      VISIT_POP (stmt.get_init_expr ()->get_locus_slow (), stmt.get_init_expr (), init,
-		 exprs);
-      if (init == NULL)
-	{
-	  rust_error_at (stmt.get_init_expr ()->get_locus_slow (),
-			 "failed to compile init statement");
-	  return;
-	}
-
-      auto s = backend->init_statement (scope.GetCurrentFndecl (), var, init);
-      scope.AddStatement (s);
-
-      varBuffer.pop_back ();
-    }
-  patternBuffer.clear ();
-}
-
-void
-Compilation::visit (AST::ExprStmtWithoutBlock &stmt)
-{
-  stmt.get_expr ()->accept_vis (*this);
-}
-
-void
-Compilation::visit (AST::ExprStmtWithBlock &stmt)
-{
-  Bblock *enclosingScope = NULL;
-  Location start_location; /* = stmt.locus; FIXME */
-  Location end_location;   // FIXME
-
-  std::vector<Bvariable *> vars;
-  auto code_block
-    = backend->block (scope.GetCurrentFndecl (), scope.CurBlock (), vars,
-		      start_location, end_location);
-
-  scope.PushBlock (code_block);
-  stmt.get_expr ()->accept_vis (*this);
-
-  // get trailing if required
-  for (auto &s : stmts)
-    {
-      scope.AddStatement (s);
-    }
-  stmts.clear ();
-
-  scope.PopBlock ();
-
-  auto body = backend->block_statement (code_block);
-  scope.AddStatement (body);
-}
-
-// rust-type.h
-void
-Compilation::visit (AST::TraitBound &bound)
-{}
-void
-Compilation::visit (AST::ImplTraitType &type)
-{}
-void
-Compilation::visit (AST::TraitObjectType &type)
-{}
-void
-Compilation::visit (AST::ParenthesisedType &type)
-{}
-void
-Compilation::visit (AST::ImplTraitTypeOneBound &type)
-{}
-void
-Compilation::visit (AST::TraitObjectTypeOneBound &type)
-{}
-void
-Compilation::visit (AST::TupleType &type)
-{}
-void
-Compilation::visit (AST::NeverType &type)
-{}
-void
-Compilation::visit (AST::RawPointerType &type)
-{}
-void
-Compilation::visit (AST::ReferenceType &type)
-{}
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
 
-void
-Compilation::visit (AST::ArrayType &type)
-{
-  Btype *elementType;
-  translatedType = nullptr;
-  type.get_elem_type ()->accept_vis (*this);
-  if (translatedType == nullptr)
-    {
-      rust_error_at (type.get_locus (),
-		     "Failed to compile element type for array");
-      return;
-    }
-  elementType = translatedType;
+#include "rust-compile.h"
+#include "rust-diagnostics.h"
 
-  Bexpression *length = nullptr;
-  VISIT_POP (type.get_size_expr ()->get_locus_slow (), type.get_size_expr (),
-	     length, exprs);
-  if (length == nullptr)
-    {
-      rust_error_at (type.get_size_expr ()->get_locus_slow (),
-		     "failed to size for array type");
-      return;
-    }
+namespace Rust {
+namespace Compile {
 
-  translatedType = backend->array_type (elementType, length);
-}
+CompileCrate::~CompileCrate () {}
 
 void
-Compilation::visit (AST::SliceType &type)
-{}
-void
-Compilation::visit (AST::InferredType &type)
-{}
-void
-Compilation::visit (AST::BareFunctionType &type)
+CompileCrate::Compile (HIR::Crate &crate, Context *ctx)
 {}
 
 } // namespace Compile
diff --git a/gcc/rust/backend/rust-compile.h b/gcc/rust/backend/rust-compile.h
index 88c8318..5ee1122 100644
--- a/gcc/rust/backend/rust-compile.h
+++ b/gcc/rust/backend/rust-compile.h
@@ -1,257 +1,89 @@
-#pragma once
+// Copyright (C) 2020 Free Software Foundation, Inc.
+
+// This file is part of GCC.
+
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
+
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#ifndef RUST_COMPILE_H
+#define RUST_COMPILE_H
 
 #include "rust-system.h"
-#include "rust-ast-full.h"
-#include "rust-ast-visitor.h"
+#include "rust-hir-map.h"
+#include "rust-name-resolver.h"
+#include "rust-hir-type-check.h"
+#include "rust-linemap.h"
 #include "rust-backend.h"
-#include "cscope.h"
 
 namespace Rust {
 namespace Compile {
 
-class Compilation : public AST::ASTVisitor
+class Context
 {
 public:
-  static bool Compile (AST::Crate &crate, ::Backend *backend);
-
-  ~Compilation ();
-
-  // 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);
+  Context (::Backend *backend)
+    : backend (backend), resolver (Resolver::Resolver::get ()),
+      tyctx (Resolver::TypeCheckContext::get ()),
+      mappings (Analysis::Mappings::get ())
+  {}
+
+  ~Context () {}
+
+  ::Backend *get_backend () { return backend; }
+  Resolver::Resolver *get_resolver () { return resolver; }
+  Resolver::TypeCheckContext *get_tyctx () { return tyctx; }
+  Analysis::Mappings *get_mappings () { return mappings; }
+
+  void push_type (::Btype *t) { type_decls.push_back (t); }
+  void push_var (::Bvariable *v) { var_decls.push_back (v); }
+  void push_const (::Bexpression *c) { const_decls.push_back (c); }
+  void push_function (::Bfunction *f) { func_decls.push_back (f); }
+
+  void write_to_backend ()
+  {
+    backend->write_global_definitions (type_decls, const_decls, func_decls,
+				       var_decls);
+  }
 
 private:
-  Compilation (AST::Crate &crate, Backend *backend);
-  bool go ();
+  ::Backend *backend;
+  Resolver::Resolver *resolver;
+  Resolver::TypeCheckContext *tyctx;
+  Analysis::Mappings *mappings;
 
-  AST::Crate &crate;
-  Backend *backend;
-
-  // utils
-  bool compileVarDecl (Bfunction *fndecl, AST::LetStmt *stmt,
-		       std::vector<Bvariable *> &vars);
-
-  Bexpression *compileBooleanLiteral (std::string val);
-  Bexpression *compileFloatLiteral (std::string val, Location locus);
-  Bexpression *compileIntegerLiteral (std::string val, Location locus);
-
-  // state
-  Scope scope;
-  ::Btype *translatedType;
-  std::vector<AST::IdentifierPattern> patternBuffer;
-  std::vector< ::Bexpression *> exprs;
-  std::vector< ::Bstatement *> stmts;
-  std::vector< ::Bvariable *> varBuffer;
-  std::vector<AST::StructStruct *> structBuffer;
-  std::vector<std::vector< ::Bexpression *> > arrayConsStack;
-
-  // careful these are the vectors we pass into the GCC middle-end
+  // To GCC middle-end
   std::vector< ::Btype *> type_decls;
   std::vector< ::Bvariable *> var_decls;
   std::vector< ::Bexpression *> const_decls;
   std::vector< ::Bfunction *> func_decls;
 };
 
+class CompileCrate
+{
+public:
+  static void Compile (HIR::Crate &crate, Context *ctx);
+
+  ~CompileCrate ();
+
+private:
+  CompileCrate (HIR::Crate &crate, Context *ctx);
+
+  HIR::Crate &crate;
+  Context *ctx;
+};
+
 } // namespace Compile
 } // namespace Rust
+
+#endif // RUST_COMPILE_H
diff --git a/gcc/rust/rust-session-manager.cc b/gcc/rust/rust-session-manager.cc
index fc64994..17ff24a 100644
--- a/gcc/rust/rust-session-manager.cc
+++ b/gcc/rust/rust-session-manager.cc
@@ -30,11 +30,11 @@
 
 #include "rust-lex.h"
 #include "rust-parse.h"
-#include "rust-scan.h"
 #include "rust-macro-expand.h"
 #include "rust-ast-resolve.h"
 #include "rust-ast-lower.h"
 #include "rust-hir-type-check.h"
+#include "rust-compile.h"
 
 extern Linemap *
 rust_get_linemap ();
@@ -529,6 +529,9 @@ Session::parse_file (const char *filename)
       // TODO: what do I dump here? resolved names? AST with resolved names?
     }
 
+  if (saw_errors ())
+    return;
+
   // lower AST to HIR
   HIR::Crate hir = lower_ast (parsed_crate);
   if (options.dump_option == CompileOptions::HIR_DUMP)
@@ -537,6 +540,9 @@ Session::parse_file (const char *filename)
       return;
     }
 
+  if (saw_errors ())
+    return;
+
   // type resolve
   type_resolution (hir);
 
@@ -544,7 +550,14 @@ Session::parse_file (const char *filename)
     return;
 
   // do compile
-  // Compile::Compilation::Compile (parsed_crate, backend);
+  Compile::Context ctx (backend);
+  Compile::CompileCrate::Compile (hir, &ctx);
+
+  if (saw_errors ())
+    return;
+
+  // pass to GCC
+  ctx.write_to_backend ();
 }
 
 // TODO: actually implement method
diff --git a/gcc/rust/util/scope.h b/gcc/rust/util/scope.h
deleted file mode 100644
index 6e853c3..0000000
--- a/gcc/rust/util/scope.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright (C) 2020 Free Software Foundation, Inc.
-
-// This file is part of GCC.
-
-// GCC is free software; you can redistribute it and/or modify it under
-// the terms of the GNU General Public License as published by the Free
-// Software Foundation; either version 3, or (at your option) any later
-// version.
-
-// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-// WARRANTY; without even the implied warranty of MERCHANTABILITY or
-// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-// for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with GCC; see the file COPYING3.  If not see
-// <http://www.gnu.org/licenses/>.
-
-#ifndef RUST_SCOPE_H
-#define RUST_SCOPE_H
-
-#include "rust-system.h"
-#include "rust-ast-full.h"
-
-namespace Rust {
-namespace Analysis {
-
-template <class T> class Scope
-{
-public:
-  Scope () : scopeStack () {}
-
-  ~Scope () {}
-
-  bool Insert (std::string key, T 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, T *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, T> Pop ()
-  {
-    auto toplevel = scopeStack.back ();
-    scopeStack.pop_back ();
-    return toplevel;
-  }
-
-  std ::map<std::string, T> Peek () { return scopeStack.back (); }
-
-private:
-  std::vector<std::map<std::string, T> > scopeStack;
-};
-
-} // namespace Analysis
-} // namespace Rust
-
-#endif // RUST_SCOPE_H