HIR Expand Type - Convert to use a generic HIR visitor

9 files changed, 512 insertions, 224 deletions

diff --git a/Makefile b/Makefile
index ebd04120..01baeb32 100644
--- a/Makefile
+++ b/Makefile
@@ -41,6 +41,7 @@ OBJ += resolve/use.o resolve/index.o resolve/absolute.o
 OBJ += hir/from_ast.o hir/from_ast_expr.o
 OBJ +=  hir/crate_ptr.o hir/type_ptr.o hir/expr_ptr.o
 OBJ +=  hir/type.o hir/path.o hir/expr.o
+OBJ +=  hir/visitor.o
 OBJ += hir_conv/expand_type.o hir_conv/constant_evaluation.o
 OBJ += dump_as_rust.o
 
diff --git a/src/hir/expr.cpp b/src/hir/expr.cpp
index efa02dfc..bb3bf0eb 100644
--- a/src/hir/expr.cpp
+++ b/src/hir/expr.cpp
@@ -9,10 +9,13 @@
 #define DEF_VISIT(nt, n, code)   void ::HIR::nt::visit(ExprVisitor& nv) { nv.visit(*this); } void ::HIR::ExprVisitorDef::visit(::HIR::nt& n) { code }
 
 DEF_VISIT(ExprNode_Block, node,
-    for(const auto& subnode : node.m_nodes)
+    for(const auto& subnode : node.m_nodes) {
+        assert(subnode);
         subnode->visit(*this);
+    }
 )
 DEF_VISIT(ExprNode_Return, node,
+    assert(node.m_value);
     node.m_value->visit(*this);
 )
 DEF_VISIT(ExprNode_Let, node,
@@ -21,15 +24,18 @@ DEF_VISIT(ExprNode_Let, node,
     }
 )
 DEF_VISIT(ExprNode_Loop, node,
+    assert(node.m_code);
     node.m_code->visit(*this);
 )
 DEF_VISIT(ExprNode_LoopControl, , )
 DEF_VISIT(ExprNode_Match, node,
+    assert(node.m_value);
     node.m_value->visit(*this);
     for(auto& arm : node.m_arms)
     {
         if( arm.m_cond )
             arm.m_cond->visit(*this);
+        assert(arm.m_code);
         arm.m_code->visit(*this);
     }
 )
diff --git a/src/hir/from_ast.cpp b/src/hir/from_ast.cpp
index 46a49e75..2d5339ac 100644
--- a/src/hir/from_ast.cpp
+++ b/src/hir/from_ast.cpp
@@ -786,8 +786,8 @@ void LowerHIR_Module_Impls(const ::AST::Module& ast_mod,  ::HIR::Crate& hir_crat
             else
             {
                 ::std::map< ::std::string, ::HIR::Function> methods;
-                ::std::map< ::std::string, ::HIR::Constant> constants;
-                ::std::map< ::std::string, ::HIR::TypeAlias> types;
+                ::std::map< ::std::string, ::HIR::ExprPtr> constants;
+                ::std::map< ::std::string, ::HIR::TypeRef> types;
                 
                 for(const auto& item : impl.items())
                 {
@@ -795,8 +795,9 @@ void LowerHIR_Module_Impls(const ::AST::Module& ast_mod,  ::HIR::Crate& hir_crat
                     (
                         ERROR(Span(), E0000, "Unexpected item type in trait impl");
                         ),
+                    // TODO: Associated constants
                     (Type,
-                        types.insert( ::std::make_pair(item.name,  LowerHIR_TypeAlias(e)) );
+                        types.insert( ::std::make_pair(item.name,  LowerHIR_Type(e.type())) );
                         ),
                     (Function,
                         methods.insert( ::std::make_pair(item.name,  LowerHIR_Function(e)) );
diff --git a/src/hir/from_ast_expr.cpp b/src/hir/from_ast_expr.cpp
index ffcb82ce..d9982da9 100644
--- a/src/hir/from_ast_expr.cpp
+++ b/src/hir/from_ast_expr.cpp
@@ -28,6 +28,9 @@ struct LowerHIR_ExprNode_Visitor:
             if( n ) {
                 rv->m_nodes.push_back( LowerHIR_ExprNode_Inner( *n ) );
             }
+            else {
+                rv->m_nodes.push_back( ::HIR::ExprNodeP( new ::HIR::ExprNode_Tuple({}) ) );
+            }
         }
         
         if( v.m_local_mod )
@@ -44,7 +47,10 @@ struct LowerHIR_ExprNode_Visitor:
         switch( v.m_type )
         {
         case ::AST::ExprNode_Flow::RETURN:
-            m_rv.reset( new ::HIR::ExprNode_Return( LowerHIR_ExprNode_Inner_Opt(v.m_value.get()) ) );
+            if( v.m_value )
+                m_rv.reset( new ::HIR::ExprNode_Return( LowerHIR_ExprNode_Inner(*v.m_value) ) );
+            else
+                m_rv.reset( new ::HIR::ExprNode_Return( ::HIR::ExprNodeP(new ::HIR::ExprNode_Tuple({})) ) );
             break;
         case ::AST::ExprNode_Flow::CONTINUE:
         case ::AST::ExprNode_Flow::BREAK:
diff --git a/src/hir/hir.hpp b/src/hir/hir.hpp
index afb742cf..4236e8ac 100644
--- a/src/hir/hir.hpp
+++ b/src/hir/hir.hpp
@@ -207,8 +207,8 @@ public:
     ::HIR::TypeRef  m_type;
     
     ::std::map< ::std::string, ::HIR::Function> m_methods;
-    ::std::map< ::std::string, ::HIR::Constant> m_constants;
-    ::std::map< ::std::string, ::HIR::TypeAlias> m_types;
+    ::std::map< ::std::string, ::HIR::ExprPtr> m_constants;
+    ::std::map< ::std::string, ::HIR::TypeRef> m_types;
 };
 
 class MarkerImpl
diff --git a/src/hir/visitor.cpp b/src/hir/visitor.cpp
new file mode 100644
index 00000000..76bfda9c
--- /dev/null
+++ b/src/hir/visitor.cpp
@@ -0,0 +1,378 @@
+
+#include <hir/hir.hpp>
+#include <hir/visitor.hpp>
+
+::HIR::Visitor::~Visitor()
+{
+}
+
+void ::HIR::Visitor::visit_crate(::HIR::Crate& crate)
+{
+    this->visit_module( crate.m_root_module );
+    
+    for( auto& ty_impl : crate.m_type_impls )
+    {
+        this->visit_type_impl(ty_impl);
+    }
+    for( auto& impl : crate.m_trait_impls )
+    {
+        this->visit_trait_impl(impl.second);
+    }
+    for( auto& impl : crate.m_marker_impls )
+    {
+        this->visit_marker_impl(impl.second);
+    }
+}
+
+void ::HIR::Visitor::visit_module(::HIR::Module& mod)
+{
+    for( auto& named : mod.m_mod_items )
+    {
+        auto& item = named.second->ent;
+        TU_MATCH(::HIR::TypeItem, (item), (e),
+        (Import, ),
+        (Module,
+            this->visit_module(e);
+            ),
+        (TypeAlias,
+            this->visit_type_alias(e);
+            ),
+        (Enum,
+            this->visit_enum(e);
+            ),
+        (Struct,
+            this->visit_struct(e);
+            ),
+        (Trait,
+            this->visit_trait(e);
+            )
+        )
+    }
+    for( auto& named : mod.m_value_items )
+    {
+        auto& item = named.second->ent;
+        TU_MATCH(::HIR::ValueItem, (item), (e),
+        (Import, ),
+        (Constant,
+            this->visit_constant(e);
+            ),
+        (Static,
+            this->visit_static(e);
+            ),
+        (StructConstant,
+            // Just a path
+            ),
+        (Function,
+            this->visit_function(e);
+            ),
+        (StructConstructor,
+            // Just a path
+            )
+        )
+    }
+}
+
+
+void ::HIR::Visitor::visit_type_impl(::HIR::TypeImpl& impl)
+{
+    this->visit_params(impl.m_params);
+    this->visit_type(impl.m_type);
+    
+    for(auto& method : impl.m_methods) {
+        this->visit_function(method.second);
+    }
+}
+void ::HIR::Visitor::visit_trait_impl(::HIR::TraitImpl& impl)
+{
+    this->visit_params(impl.m_params);
+    this->visit_path_params(impl.m_trait_args);
+    this->visit_type(impl.m_type);
+    
+    for(auto& ent : impl.m_methods) {
+        this->visit_function(ent.second);
+    }
+    for(auto& ent : impl.m_constants) {
+        this->visit_expr(ent.second);
+    }
+    for(auto& ent : impl.m_types) {
+        this->visit_type(ent.second);
+    }
+}
+void ::HIR::Visitor::visit_marker_impl(::HIR::MarkerImpl& impl)
+{
+    this->visit_params(impl.m_params);
+    this->visit_path_params(impl.m_trait_args);
+    this->visit_type(impl.m_type);
+}
+
+void ::HIR::Visitor::visit_type_alias(::HIR::TypeAlias& item)
+{
+    this->visit_params(item.m_params);
+    this->visit_type(item.m_type);
+}
+void ::HIR::Visitor::visit_trait(::HIR::Trait& item)
+{
+    this->visit_params(item.m_params);
+    for(auto& par : item.m_parent_traits) {
+        this->visit_generic_path(par);
+    }
+    for(auto& i : item.m_types) {
+        this->visit_params(i.second.m_params);
+        this->visit_type(i.second.m_default);
+    }
+    for(auto& i : item.m_values) {
+        TU_MATCH(::HIR::TraitValueItem, (i.second), (e),
+        (None, ),
+        (Constant,
+            this->visit_constant(e);
+            ),
+        (Static,
+            this->visit_static(e);
+            ),
+        (Function,
+            this->visit_function(e);
+            )
+        )
+    }
+}
+void ::HIR::Visitor::visit_struct(::HIR::Struct& item)
+{
+    this->visit_params(item.m_params);
+    TU_MATCH(::HIR::Struct::Data, (item.m_data), (e),
+    (Unit,
+        ),
+    (Tuple,
+        for(auto& ty : e) {
+            this->visit_type(ty.ent);
+        }
+        ),
+    (Named,
+        for(auto& field : e) {
+            this->visit_type(field.second.ent);
+        }
+        )
+    )
+}
+void ::HIR::Visitor::visit_enum(::HIR::Enum& item)
+{
+    this->visit_params(item.m_params);
+    for(auto& var : item.m_variants)
+    {
+        TU_MATCH(::HIR::Enum::Variant, (var.second), (v),
+        (Unit,
+            ),
+        (Value,
+            this->visit_expr(v);
+            ),
+        (Tuple,
+            for(auto& ty : v) {
+                this->visit_type(ty);
+            }
+            ),
+        (Struct,
+            for(auto& field : v) {
+                this->visit_type(field.second);
+            }
+            )
+        )
+    }
+}
+void ::HIR::Visitor::visit_function(::HIR::Function& item)
+{
+    this->visit_params(item.m_params);
+    for(auto& arg : item.m_args)
+    {
+        this->visit_pattern(arg.first);
+        this->visit_type(arg.second);
+    }
+    this->visit_type(item.m_return);
+    this->visit_expr(item.m_code);
+}
+void ::HIR::Visitor::visit_static(::HIR::Static& item)
+{
+    this->visit_type(item.m_type);
+    this->visit_expr(item.m_value);
+}
+void ::HIR::Visitor::visit_constant(::HIR::Constant& item)
+{
+    this->visit_params(item.m_params);
+    this->visit_type(item.m_type);
+    this->visit_expr(item.m_value);
+}
+
+void ::HIR::Visitor::visit_params(::HIR::GenericParams& params)
+{
+    for(auto& tps : params.m_types)
+        this->visit_type( tps.m_default );
+    for(auto& bound : params.m_bounds )
+    {
+        TU_MATCH(::HIR::GenericBound, (bound), (e),
+        (Lifetime,
+            ),
+        (TypeLifetime,
+            this->visit_type(e.type);
+            ),
+        (TraitBound,
+            this->visit_type(e.type);
+            this->visit_generic_path(e.trait.m_path);
+            ),
+        (TraitUnbound,
+            this->visit_type(e.type);
+            // typeof(e.trait) == SimplePath
+            ),
+        //(NotTrait, struct {
+        //    ::HIR::TypeRef  type;
+        //    ::HIR::GenricPath    trait;
+        //    }),
+        (TypeEquality,
+            this->visit_type(e.type);
+            this->visit_type(e.other_type);
+            )
+        )
+    }
+}
+void ::HIR::Visitor::visit_type(::HIR::TypeRef& ty)
+{
+    TU_MATCH(::HIR::TypeRef::Data, (ty.m_data), (e),
+    (Infer,
+        ),
+    (Diverge,
+        ),
+    (Primitive,
+        ),
+    (Path,
+        this->visit_path(e);
+        ),
+    (Generic,
+        ),
+    (TraitObject,
+        for(auto& trait : e.m_traits) {
+            this->visit_generic_path(trait);
+        }
+        ),
+    (Array,
+        this->visit_type( *e.inner );
+        this->visit_expr( e.size );
+        ),
+    (Tuple,
+        for(auto& t : e) {
+            this->visit_type(t);
+        }
+        ),
+    (Borrow,
+        this->visit_type( *e.inner );
+        ),
+    (Pointer,
+        this->visit_type( *e.inner );
+        ),
+    (Function,
+        for(auto& t : e.m_arg_types) {
+            this->visit_type(t);
+        }
+        this->visit_type(*e.m_rettype);
+        )
+    )
+}
+void ::HIR::Visitor::visit_pattern(::HIR::Pattern& pat)
+{
+    TU_MATCH(::HIR::Pattern::Data, (pat.m_data), (e),
+    (Any,
+        ),
+    (Box,
+        this->visit_pattern( *e.sub );
+        ),
+    (Ref,
+        this->visit_pattern( *e.sub );
+        ),
+    (Tuple,
+        for(auto& sp : e.sub_patterns)
+            this->visit_pattern(sp);
+        ),
+    (StructTuple,
+        this->visit_generic_path(e.path);
+        for(auto& sp : e.sub_patterns)
+            this->visit_pattern(sp);
+        ),
+    (Struct,
+        this->visit_generic_path(e.path);
+        for(auto& sp : e.sub_patterns)
+            this->visit_pattern(sp.second);
+        ),
+    // Refutable
+    (Value,
+        this->visit_pattern_val(e.val);
+        ),
+    (Range,
+        this->visit_pattern_val(e.start);
+        this->visit_pattern_val(e.end);
+        ),
+    (EnumTuple,
+        this->visit_generic_path(e.path);
+        for(auto& sp : e.sub_patterns)
+            this->visit_pattern(sp);
+        ),
+    (EnumStruct,
+        this->visit_generic_path(e.path);
+        for(auto& sp : e.sub_patterns)
+            this->visit_pattern(sp.second);
+        ),
+    (Slice,
+        for(auto& sp : e.sub_patterns)
+            this->visit_pattern(sp);
+        ),
+    (SplitSlice,
+        for(auto& sp : e.leading)
+            this->visit_pattern(sp);
+        for(auto& sp : e.trailing)
+            this->visit_pattern(sp);
+        )
+    )
+}
+void ::HIR::Visitor::visit_pattern_val(::HIR::Pattern::Value& val)
+{
+    TU_MATCH(::HIR::Pattern::Value, (val), (e),
+    (Integer,
+        ),
+    (String,
+        ),
+    (Named,
+        this->visit_path(e);
+        )
+    )
+}
+void ::HIR::Visitor::visit_path(::HIR::Path& p)
+{
+    TU_MATCH(::HIR::Path::Data, (p.m_data), (e),
+    (Generic,
+        this->visit_generic_path(e);
+        ),
+    (UfcsInherent,
+        this->visit_type(*e.type);
+        this->visit_path_params(e.params);
+        ),
+    (UfcsKnown,
+        this->visit_type(*e.type);
+        this->visit_generic_path(e.trait);
+        this->visit_path_params(e.params);
+        ),
+    (UfcsUnknown,
+        this->visit_type(*e.type);
+        this->visit_path_params(e.params);
+        )
+    )
+}
+void ::HIR::Visitor::visit_path_params(::HIR::PathParams& p)
+{
+    for( auto& ty : p.m_types )
+    {
+        this->visit_type(ty);
+    }
+}
+void ::HIR::Visitor::visit_generic_path(::HIR::GenericPath& p)
+{
+    this->visit_path_params(p.m_params);
+}
+void ::HIR::Visitor::visit_expr(::HIR::ExprPtr& exp)
+{
+    // Do nothing, leave expression stuff for user
+}
diff --git a/src/hir/visitor.hpp b/src/hir/visitor.hpp
new file mode 100644
index 00000000..814dac67
--- /dev/null
+++ b/src/hir/visitor.hpp
@@ -0,0 +1,46 @@
+/*
+ */
+#pragma once
+
+#include <hir/hir.hpp>
+
+namespace HIR {
+
+class Visitor
+{
+public:
+    virtual ~Visitor();
+    
+    virtual void visit_crate(::HIR::Crate& crate);
+    
+    virtual void visit_module(::HIR::Module& mod);
+    
+    virtual void visit_type_impl(::HIR::TypeImpl& impl);
+    virtual void visit_trait_impl(::HIR::TraitImpl& impl);
+    virtual void visit_marker_impl(::HIR::MarkerImpl& impl);
+    
+    // - Type Items
+    virtual void visit_type_alias(::HIR::TypeAlias& item);
+    virtual void visit_trait(::HIR::Trait& item);
+    virtual void visit_struct(::HIR::Struct& item);
+    virtual void visit_enum(::HIR::Enum& item);
+    // - Value Items
+    virtual void visit_function(::HIR::Function& item);
+    virtual void visit_static(::HIR::Static& item);
+    virtual void visit_constant(::HIR::Constant& item);
+    
+    // - Misc
+    virtual void visit_params(::HIR::GenericParams& params);
+    virtual void visit_pattern(::HIR::Pattern& pat);
+    virtual void visit_pattern_val(::HIR::Pattern::Value& val);
+    virtual void visit_type(::HIR::TypeRef& tr);
+    
+    virtual void visit_path(::HIR::Path& p);
+    virtual void visit_path_params(::HIR::PathParams& p);
+    virtual void visit_generic_path(::HIR::GenericPath& p);
+
+    virtual void visit_expr(::HIR::ExprPtr& exp);
+};
+
+}   // namespace HIR
+
diff --git a/src/hir_conv/expand_type.cpp b/src/hir_conv/expand_type.cpp
index ac34f2a8..7e47b3a3 100644
--- a/src/hir_conv/expand_type.cpp
+++ b/src/hir_conv/expand_type.cpp
@@ -4,8 +4,7 @@
 #include "main_bindings.hpp"
 #include <hir/hir.hpp>
 #include <hir/expr.hpp>
-
-void ConvertHIR_ExpandAliases_Type(const ::HIR::Crate& crate, ::HIR::TypeRef& ty);
+#include <hir/visitor.hpp>
 
 ::HIR::TypeRef ConvertHIR_ExpandAliases_GetExpansion(const ::HIR::Crate& crate, const ::HIR::Path& path)
 {
@@ -58,232 +57,82 @@ void ConvertHIR_ExpandAliases_Type(const ::HIR::Crate& crate, ::HIR::TypeRef& ty
     return ::HIR::TypeRef();
 }
 
-void ConvertHIR_ExpandAliases_PathParams(const ::HIR::Crate& crate, ::HIR::PathParams& p)
+class Expander:
+    public ::HIR::Visitor
 {
-    for(auto& ty : p.m_types)
-    {
-        ConvertHIR_ExpandAliases_Type(crate, ty);
-    }
-}
-void ConvertHIR_ExpandAliases_Path(const ::HIR::Crate& crate, ::HIR::GenericPath& p)
-{
-    ConvertHIR_ExpandAliases_PathParams(crate, p.m_params);
-}
+    const ::HIR::Crate& m_crate;
 
-void ConvertHIR_ExpandAliases_Path(const ::HIR::Crate& crate, ::HIR::Path& p)
-{
-    TU_MATCH(::HIR::Path::Data, (p.m_data), (e),
-    (Generic,
-        ConvertHIR_ExpandAliases_Path(crate, e);
-        ),
-    (UfcsInherent,
-        ConvertHIR_ExpandAliases_Type(crate, *e.type);
-        ConvertHIR_ExpandAliases_PathParams(crate, e.params);
-        ),
-    (UfcsKnown,
-        ConvertHIR_ExpandAliases_Type(crate, *e.type);
-        ConvertHIR_ExpandAliases_Path(crate, e.trait);
-        ConvertHIR_ExpandAliases_PathParams(crate, e.params);
-        ),
-    (UfcsUnknown,
-        ConvertHIR_ExpandAliases_Type(crate, *e.type);
-        ConvertHIR_ExpandAliases_PathParams(crate, e.params);
-        )
-    )
-}
-
-void ConvertHIR_ExpandAliases_Type(const ::HIR::Crate& crate, ::HIR::TypeRef& ty)
-{
-    TU_MATCH(::HIR::TypeRef::Data, (ty.m_data), (e),
-    (Infer,
-        ),
-    (Diverge,
-        ),
-    (Primitive,
-        ),
-    (Path,
-        ConvertHIR_ExpandAliases_Path(crate, e);
-        
-        auto new_type = ConvertHIR_ExpandAliases_GetExpansion(crate, e);
-        if( ! new_type.m_data.is_Infer() ) {
-            DEBUG("Replacing " << ty << " with " << new_type);
-        }
-        ),
-    (Generic,
-        ),
-    (TraitObject,
-        for(auto& trait : e.m_traits) {
-            ConvertHIR_ExpandAliases_Path(crate, trait);
-        }
-        ),
-    (Array,
-        ConvertHIR_ExpandAliases_Type(crate, *e.inner);
-        // TODO: Expression?
-        ),
-    (Tuple,
-        for(auto& t : e) {
-            ConvertHIR_ExpandAliases_Type(crate, t);
-        }
-        ),
-    (Borrow,
-        ConvertHIR_ExpandAliases_Type(crate, *e.inner);
-        ),
-    (Pointer,
-        ConvertHIR_ExpandAliases_Type(crate, *e.inner);
-        ),
-    (Function,
-        for(auto& t : e.m_arg_types) {
-            ConvertHIR_ExpandAliases_Type(crate, t);
-        }
-        ConvertHIR_ExpandAliases_Type(crate, *e.m_rettype);
-        )
-    )
-}
-void ConvertHIR_ExpandAliases_Expr(const ::HIR::Crate& crate, ::HIR::ExprPtr& ep)
-{
-    struct Visitor:
-        public ::HIR::ExprVisitorDef
-    {
-        const ::HIR::Crate& crate;
-        
-        Visitor(const ::HIR::Crate& crate):
-            crate(crate)
-        {}
-        
-        void visit(::HIR::ExprNode_Let& node) override
-        {
-            ConvertHIR_ExpandAliases_Type(crate, node.m_type);
-            ::HIR::ExprVisitorDef::visit(node);
-        }
-        void visit(::HIR::ExprNode_Cast& node) override
-        {
-            ConvertHIR_ExpandAliases_Type(crate, node.m_type);
-            ::HIR::ExprVisitorDef::visit(node);
-        }
-        
-        void visit(::HIR::ExprNode_CallPath& node) override
-        {
-            ConvertHIR_ExpandAliases_Path(crate, node.m_path);
-            ::HIR::ExprVisitorDef::visit(node);
-        }
-        void visit(::HIR::ExprNode_CallMethod& node) override
-        {
-            ConvertHIR_ExpandAliases_PathParams(crate, node.m_params);
-            ::HIR::ExprVisitorDef::visit(node);
-        }
-        
-        void visit(::HIR::ExprNode_Closure& node) override
-        {
-            ConvertHIR_ExpandAliases_Type(crate, node.m_return);
-            for(auto& arg : node.m_args)
-                ConvertHIR_ExpandAliases_Type(crate, arg.second);
-            ::HIR::ExprVisitorDef::visit(node);
-        }
-    };
+public:
+    Expander(const ::HIR::Crate& crate):
+        m_crate(crate)
+    {}
     
-    if( &*ep != nullptr )
-    {
-        Visitor v { crate };
-        (*ep).visit(v);
-    }
-}
-void ConvertHIR_ExpandAliases_GenericParams(const ::HIR::Crate& crate, ::HIR::GenericParams& gp)
-{
-}
-
-void ConvertHIR_ExpandAliases_Mod(const ::HIR::Crate& crate, ::HIR::Module& mod)
-{
-    for( auto& named : mod.m_mod_items )
+    void visit_type(::HIR::TypeRef& ty) override
     {
-        auto& item = named.second->ent;
-        TU_MATCH(::HIR::TypeItem, (item), (e),
-        (Import, ),
-        (Module,
-            ConvertHIR_ExpandAliases_Mod(crate, e);
-            ),
-        (TypeAlias,
-            ConvertHIR_ExpandAliases_GenericParams(crate, e.m_params);
-            ConvertHIR_ExpandAliases_Type(crate, e.m_type);
-            ),
-        (Enum,
-            ConvertHIR_ExpandAliases_GenericParams(crate, e.m_params);
-            for(auto& var : e.m_variants)
-            {
-                TU_MATCH(::HIR::Enum::Variant, (var.second), (v),
-                (Unit,
-                    ),
-                (Value,
-                    ConvertHIR_ExpandAliases_Expr(crate, v);
-                    ),
-                (Tuple,
-                    for(auto& ty : v) {
-                        ConvertHIR_ExpandAliases_Type(crate, ty);
-                    }
-                    ),
-                (Struct,
-                    for(auto& field : v) {
-                        ConvertHIR_ExpandAliases_Type(crate, field.second);
-                    }
-                    )
-                )
+        ::HIR::Visitor::visit_type(ty);
+        
+        TU_IFLET(::HIR::TypeRef::Data, (ty.m_data), Path, (e),
+            auto new_type = ConvertHIR_ExpandAliases_GetExpansion(m_crate, e);
+            if( ! new_type.m_data.is_Infer() ) {
+                DEBUG("Replacing " << ty << " with " << new_type);
             }
-            ),
-        (Struct,
-            ConvertHIR_ExpandAliases_GenericParams(crate, e.m_params);
-            TU_MATCH(::HIR::Struct::Data, (e.m_data), (e2),
-            (Unit,
-                ),
-            (Tuple,
-                for(auto& ty : e2) {
-                    ConvertHIR_ExpandAliases_Type(crate, ty.ent);
-                }
-                ),
-            (Named,
-                for(auto& field : e2) {
-                    ConvertHIR_ExpandAliases_Type(crate, field.second.ent);
-                }
-                )
-            )
-            ),
-        (Trait,
-            ConvertHIR_ExpandAliases_GenericParams(crate, e.m_params);
-            )
         )
     }
-    for( auto& named : mod.m_value_items )
+    
+    void visit_expr(::HIR::ExprPtr& expr) override
     {
-        auto& item = named.second->ent;
-        TU_MATCH(::HIR::ValueItem, (item), (e),
-        (Import, ),
-        (Constant,
-            ConvertHIR_ExpandAliases_GenericParams(crate, e.m_params);
-            ConvertHIR_ExpandAliases_Type(crate, e.m_type);
-            ConvertHIR_ExpandAliases_Expr(crate, e.m_value);
-            ),
-        (Static,
-            ConvertHIR_ExpandAliases_Type(crate, e.m_type);
-            ConvertHIR_ExpandAliases_Expr(crate, e.m_value);
-            ),
-        (StructConstant,
-            // Just a path
-            ),
-        (Function,
-            ConvertHIR_ExpandAliases_GenericParams(crate, e.m_params);
-            for(auto& arg : e.m_args)
+        struct Visitor:
+            public ::HIR::ExprVisitorDef
+        {
+            Expander& upper_visitor;
+            
+            Visitor(Expander& uv):
+                upper_visitor(uv)
+            {}
+            
+            void visit(::HIR::ExprNode_Let& node) override
             {
-                ConvertHIR_ExpandAliases_Type(crate, arg.second);
+                upper_visitor.visit_type(node.m_type);
+                ::HIR::ExprVisitorDef::visit(node);
             }
-            ConvertHIR_ExpandAliases_Type(crate, e.m_return);
-            ConvertHIR_ExpandAliases_Expr(crate, e.m_code);
-            ),
-        (StructConstructor,
-            // Just a path
-            )
-        )
+            void visit(::HIR::ExprNode_Cast& node) override
+            {
+                upper_visitor.visit_type(node.m_type);
+                ::HIR::ExprVisitorDef::visit(node);
+            }
+            
+            void visit(::HIR::ExprNode_CallPath& node) override
+            {
+                upper_visitor.visit_path(node.m_path);
+                ::HIR::ExprVisitorDef::visit(node);
+            }
+            void visit(::HIR::ExprNode_CallMethod& node) override
+            {
+                upper_visitor.visit_path_params(node.m_params);
+                ::HIR::ExprVisitorDef::visit(node);
+            }
+            
+            void visit(::HIR::ExprNode_Closure& node) override
+            {
+                upper_visitor.visit_type(node.m_return);
+                for(auto& arg : node.m_args) {
+                    upper_visitor.visit_pattern(arg.first);
+                    upper_visitor.visit_type(arg.second);
+                }
+                ::HIR::ExprVisitorDef::visit(node);
+            }
+        };
+        
+        if( &*expr != nullptr )
+        {
+            Visitor v { *this };
+            (*expr).visit(v);
+        }
     }
-}
+};
 
 void ConvertHIR_ExpandAliases(::HIR::Crate& crate)
 {
-    ConvertHIR_ExpandAliases_Mod(crate, crate.m_root_module);
+    Expander    exp { crate };
+    exp.visit_crate( crate );
 }
diff --git a/src/main.cpp b/src/main.cpp
index a02fbac6..b519f1fb 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -25,7 +25,8 @@ int g_debug_indent_level = 0;
 bool debug_enabled()

 {

     //return g_cur_phase != "Parse";

-    return g_cur_phase != "Parse" && g_cur_phase != "Expand";

+    //return g_cur_phase != "Parse" && g_cur_phase != "Expand";

+    return g_cur_phase != "Parse" && g_cur_phase != "Expand" && g_cur_phase != "Resolve";;

 }

 ::std::ostream& debug_output(int indent, const char* function)

 {