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

to use the new name and type resolution pass contexts.

9 files changed, 0 insertions, 4576 deletions

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