HIR - Path reporting in iteration

8 files changed, 151 insertions, 104 deletions

diff --git a/src/hir/from_ast.cpp b/src/hir/from_ast.cpp
index c0954507..7b8707a7 100644
--- a/src/hir/from_ast.cpp
+++ b/src/hir/from_ast.cpp
@@ -7,8 +7,8 @@
 #include "from_ast.hpp"
 #include "visitor.hpp"
 
-::HIR::Module LowerHIR_Module(const ::AST::Module& module, ::HIR::SimplePath path, ::std::vector< ::HIR::SimplePath> traits = {});
-::HIR::Function LowerHIR_Function(const ::AST::Function& f);
+::HIR::Module LowerHIR_Module(const ::AST::Module& module, ::HIR::ItemPath path, ::std::vector< ::HIR::SimplePath> traits = {});
+::HIR::Function LowerHIR_Function(::HIR::ItemPath path, const ::AST::Function& f);
 ::HIR::PathParams LowerHIR_PathParams(const Span& sp, const ::AST::PathParams& src_params, bool allow_assoc);
 ::HIR::TraitPath LowerHIR_TraitPath(const Span& sp, const ::AST::Path& path);
 
@@ -661,8 +661,9 @@ namespace {
     }
 }
 
-::HIR::Struct LowerHIR_Struct(const ::AST::Struct& ent)
+::HIR::Struct LowerHIR_Struct(::HIR::ItemPath path, const ::AST::Struct& ent)
 {
+    TRACE_FUNCTION_F(path);
     ::HIR::Struct::Data data;
     
     TU_MATCH(::AST::StructData, (ent.m_data), (e),
@@ -695,7 +696,7 @@ namespace {
         };
 }
 
-::HIR::Enum LowerHIR_Enum(const ::AST::Enum& f)
+::HIR::Enum LowerHIR_Enum(::HIR::ItemPath path, const ::AST::Enum& f)
 {
     ::std::vector< ::std::pair< ::std::string, ::HIR::Enum::Variant> >  variants;
     
@@ -734,6 +735,7 @@ namespace {
 }
 ::HIR::Trait LowerHIR_Trait(::HIR::SimplePath trait_path, const ::AST::Trait& f)
 {
+    TRACE_FUNCTION_F(trait_path);
     bool trait_reqires_sized = false;
     auto params = LowerHIR_GenericParams(f.params(), &trait_reqires_sized);
     
@@ -754,7 +756,7 @@ namespace {
         };
 
     {
-        auto this_trait = ::HIR::GenericPath( mv$(trait_path) );
+        auto this_trait = ::HIR::GenericPath( trait_path );
         unsigned int i = 0;
         for(const auto& arg : rv.m_params.m_types) {
             this_trait.m_params.m_types.push_back( ::HIR::TypeRef(arg.m_name, i) );
@@ -765,6 +767,9 @@ namespace {
     
     for(const auto& item : f.items())
     {
+        auto trait_ip = ::HIR::ItemPath(trait_path);
+        auto item_path = ::HIR::ItemPath( trait_ip, item.name.c_str() );
+        
         TU_MATCH_DEF(::AST::Item, (item.data), (i),
         (
             BUG(item.data.span, "Encountered unexpected item type in trait");
@@ -801,7 +806,7 @@ namespace {
                 }) );
             ),
         (Function,
-            rv.m_values.insert( ::std::make_pair(item.name, ::HIR::TraitValueItem::make_Function( LowerHIR_Function(i) )) );
+            rv.m_values.insert( ::std::make_pair(item.name, ::HIR::TraitValueItem::make_Function( LowerHIR_Function(item_path, i) )) );
             ),
         (Static,
             if( i.s_class() == ::AST::Static::CONST )
@@ -823,9 +828,9 @@ namespace {
     
     return rv;
 }
-::HIR::Function LowerHIR_Function(const ::AST::Function& f)
+::HIR::Function LowerHIR_Function(::HIR::ItemPath p, const ::AST::Function& f)
 {
-    DEBUG("");
+    DEBUG(p);
     ::std::vector< ::std::pair< ::HIR::Pattern, ::HIR::TypeRef > >    args;
     for(const auto& arg : f.args())
         args.push_back( ::std::make_pair( LowerHIR_Pattern(arg.first), LowerHIR_Type(arg.second) ) );
@@ -847,7 +852,7 @@ void _add_mod_val_item(::HIR::Module& mod, ::std::string name, bool is_pub,  ::H
     mod.m_value_items.insert( ::std::make_pair( mv$(name), ::make_unique_ptr(::HIR::VisEnt< ::HIR::ValueItem> { is_pub, mv$(ti) }) ) );
 }
 
-::HIR::Module LowerHIR_Module(const ::AST::Module& ast_mod, ::HIR::SimplePath path, ::std::vector< ::HIR::SimplePath> traits)
+::HIR::Module LowerHIR_Module(const ::AST::Module& ast_mod, ::HIR::ItemPath path, ::std::vector< ::HIR::SimplePath> traits)
 {
     TRACE_FUNCTION_F("path = " << path);
     ::HIR::Module   mod { };
@@ -868,13 +873,13 @@ void _add_mod_val_item(::HIR::Module& mod, ::std::string name, bool is_pub,  ::H
     {
         auto& submod = *ast_mod.anon_mods()[i];
         ::std::string name = FMT("#" << i);
-        auto item_path = path + name;
-        _add_mod_ns_item( mod,  mv$(name), false, ::HIR::TypeItem::make_Module( LowerHIR_Module(submod, mv$(item_path), mod.m_traits) ) );
+        auto item_path = ::HIR::ItemPath(path, name.c_str());
+        _add_mod_ns_item( mod,  mv$(name), false, ::HIR::TypeItem::make_Module( LowerHIR_Module(submod, item_path, mod.m_traits) ) );
     }
 
     for( const auto& item : ast_mod.items() )
     {
-        auto item_path = path + item.name;
+        auto item_path = ::HIR::ItemPath(path, item.name.c_str());
         TU_MATCH(::AST::Item, (item.data), (e),
         (None,
             ),
@@ -892,20 +897,20 @@ void _add_mod_val_item(::HIR::Module& mod, ::std::string name, bool is_pub,  ::H
             /// Add value reference
             TU_IFLET( ::AST::StructData, e.m_data, Struct, e2,
                 if( e2.ents.size() == 0 )
-                    _add_mod_val_item( mod,  item.name, item.is_pub, ::HIR::ValueItem::make_StructConstant({mv$(item_path)}) );
+                    _add_mod_val_item( mod,  item.name, item.is_pub, ::HIR::ValueItem::make_StructConstant({item_path.get_simple_path()}) );
                 else
-                    _add_mod_val_item( mod,  item.name, item.is_pub, ::HIR::ValueItem::make_StructConstructor({mv$(item_path)}) );
+                    _add_mod_val_item( mod,  item.name, item.is_pub, ::HIR::ValueItem::make_StructConstructor({item_path.get_simple_path()}) );
             )
-            _add_mod_ns_item( mod,  item.name, item.is_pub, LowerHIR_Struct(e) );
+            _add_mod_ns_item( mod,  item.name, item.is_pub, LowerHIR_Struct(item_path, e) );
             ),
         (Enum,
-            _add_mod_ns_item( mod,  item.name, item.is_pub, LowerHIR_Enum(e) );
+            _add_mod_ns_item( mod,  item.name, item.is_pub, LowerHIR_Enum(item_path, e) );
             ),
         (Trait,
-            _add_mod_ns_item( mod,  item.name, item.is_pub, LowerHIR_Trait(item_path, e) );
+            _add_mod_ns_item( mod,  item.name, item.is_pub, LowerHIR_Trait(item_path.get_simple_path(), e) );
             ),
         (Function,
-            _add_mod_val_item(mod, item.name, item.is_pub,  LowerHIR_Function(e));
+            _add_mod_val_item(mod, item.name, item.is_pub,  LowerHIR_Function(item_path, e));
             ),
         (Static,
             if( e.s_class() == ::AST::Static::CONST )
@@ -969,12 +974,15 @@ void LowerHIR_Module_Impls(const ::AST::Module& ast_mod,  ::HIR::Crate& hir_crat
             }
             else
             {
+                ::HIR::ItemPath    path(type, trait_name);
+                
                 ::std::map< ::std::string, ::HIR::TraitImpl::ImplEnt< ::HIR::Function> > methods;
                 ::std::map< ::std::string, ::HIR::TraitImpl::ImplEnt< ::HIR::ExprPtr> > constants;
                 ::std::map< ::std::string, ::HIR::TraitImpl::ImplEnt< ::HIR::TypeRef> > types;
                 
                 for(const auto& item : impl.items())
                 {
+                    ::HIR::ItemPath    item_path(path, item.name.c_str());
                     TU_MATCH_DEF(::AST::Item, (*item.data), (e),
                     (
                         ERROR(item.data->span, E0000, "Unexpected item type in trait impl");
@@ -984,7 +992,7 @@ void LowerHIR_Module_Impls(const ::AST::Module& ast_mod,  ::HIR::Crate& hir_crat
                         types.insert( ::std::make_pair(item.name, ::HIR::TraitImpl::ImplEnt< ::HIR::TypeRef> { item.is_specialisable, LowerHIR_Type(e.type()) }) );
                         ),
                     (Function,
-                        methods.insert( ::std::make_pair(item.name, ::HIR::TraitImpl::ImplEnt< ::HIR::Function> { item.is_specialisable, LowerHIR_Function(e) }) );
+                        methods.insert( ::std::make_pair(item.name, ::HIR::TraitImpl::ImplEnt< ::HIR::Function> { item.is_specialisable, LowerHIR_Function(item_path, e) }) );
                         )
                     )
                 }
@@ -1005,16 +1013,18 @@ void LowerHIR_Module_Impls(const ::AST::Module& ast_mod,  ::HIR::Crate& hir_crat
         else
         {
             // Inherent impls
+            ::HIR::ItemPath    path(type);
             ::std::map< ::std::string, ::HIR::TypeImpl::VisImplEnt< ::HIR::Function> > methods;
             
             for(const auto& item : impl.items())
             {
+                ::HIR::ItemPath    item_path(path, item.name.c_str());
                 TU_MATCH_DEF(::AST::Item, (*item.data), (e),
                 (
                     ERROR(item.data->span, E0000, "Unexpected item type in inherent impl");
                     ),
                 (Function,
-                    methods.insert( ::std::make_pair(item.name, ::HIR::TypeImpl::VisImplEnt< ::HIR::Function> { item.is_pub, item.is_specialisable, LowerHIR_Function(e) } ) );
+                    methods.insert( ::std::make_pair(item.name, ::HIR::TypeImpl::VisImplEnt< ::HIR::Function> { item.is_pub, item.is_specialisable, LowerHIR_Function(item_path, e) } ) );
                     )
                 )
             }
@@ -1092,7 +1102,7 @@ public:
         //}
     }
     
-    rv.m_root_module = LowerHIR_Module( crate.m_root_module, ::HIR::SimplePath("") );
+    rv.m_root_module = LowerHIR_Module( crate.m_root_module, ::HIR::ItemPath() );
     
     LowerHIR_Module_Impls(crate.m_root_module,  rv);
     
diff --git a/src/hir/hir.hpp b/src/hir/hir.hpp
index 408b6390..d7650c7e 100644
--- a/src/hir/hir.hpp
+++ b/src/hir/hir.hpp
@@ -326,4 +326,74 @@ public:
     bool find_type_impls(const ::HIR::TypeRef& type, t_cb_resolve_type ty_res, ::std::function<bool(const ::HIR::TypeImpl&)> callback) const;
 };
 
+class ItemPath
+{
+    const ItemPath* parent;
+    const ::HIR::TypeRef* ty;
+    const ::HIR::SimplePath* trait;
+    const char* name;
+    
+public:
+    ItemPath(): parent(nullptr), ty(nullptr), trait(nullptr), name(nullptr) {}
+    ItemPath(const ItemPath& p, const char* n):
+        parent(&p),
+        ty(nullptr), trait(nullptr),
+        name(n)
+    {}
+    ItemPath(const ::HIR::TypeRef& type):
+        parent(nullptr),
+        ty(&type),
+        trait(nullptr),
+        name(nullptr)
+    {}
+    ItemPath(const ::HIR::TypeRef& type, const ::HIR::SimplePath& path):
+        parent(nullptr),
+        ty(&type),
+        trait(&path),
+        name(nullptr)
+    {}
+    ItemPath(const ::HIR::SimplePath& path):
+        parent(nullptr),
+        ty(nullptr),
+        trait(&path),
+        name(nullptr)
+    {}
+    
+    ::HIR::SimplePath get_simple_path() const {
+        if( parent ) {
+            assert(name);
+            return parent->get_simple_path() + name;
+        }
+        else {
+            assert(!name);
+            return ::HIR::SimplePath();
+        }
+    }
+    
+    ItemPath operator+(const ::std::string& name) const {
+        return ItemPath(*this, name.c_str());
+    }
+    
+    friend ::std::ostream& operator<<(::std::ostream& os, const ItemPath& x) {
+        if( x.parent ) {
+            os << *x.parent;
+        }
+        if( x.name ) {
+            os << "::" << x.name;
+        }
+        else if( x.ty ) {
+            os << "<" << *x.ty;
+            if( x.trait )
+                os << " as " << *x.trait;
+            os << ">";
+        }
+        else if( x.trait ) {
+            os << "<* as " << *x.trait << ">";
+        }
+        else {
+        }
+        return os;
+    }
+};
+
 }   // namespace HIR
diff --git a/src/hir/visitor.cpp b/src/hir/visitor.cpp
index 7c2a1245..cb942123 100644
--- a/src/hir/visitor.cpp
+++ b/src/hir/visitor.cpp
@@ -8,7 +8,7 @@
 
 void ::HIR::Visitor::visit_crate(::HIR::Crate& crate)
 {
-    this->visit_module(::HIR::PathChain(""), crate.m_root_module );
+    this->visit_module(::HIR::ItemPath(), crate.m_root_module );
     
     for( auto& ty_impl : crate.m_type_impls )
     {
@@ -24,7 +24,7 @@ void ::HIR::Visitor::visit_crate(::HIR::Crate& crate)
     }
 }
 
-void ::HIR::Visitor::visit_module(::HIR::PathChain p, ::HIR::Module& mod)
+void ::HIR::Visitor::visit_module(::HIR::ItemPath p, ::HIR::Module& mod)
 {
     TRACE_FUNCTION;
     for( auto& named : mod.m_mod_items )
@@ -88,7 +88,7 @@ void ::HIR::Visitor::visit_module(::HIR::PathChain p, ::HIR::Module& mod)
 
 void ::HIR::Visitor::visit_type_impl(::HIR::TypeImpl& impl)
 {
-    ::HIR::PathChain    p { "#impl" };
+    ::HIR::ItemPath    p { impl.m_type };
     TRACE_FUNCTION_F("impl.m_type=" << impl.m_type);
     this->visit_params(impl.m_params);
     this->visit_type(impl.m_type);
@@ -100,7 +100,7 @@ void ::HIR::Visitor::visit_type_impl(::HIR::TypeImpl& impl)
 }
 void ::HIR::Visitor::visit_trait_impl(const ::HIR::SimplePath& trait_path, ::HIR::TraitImpl& impl)
 {
-    ::HIR::PathChain    p { "#impl" };
+    ::HIR::ItemPath    p( impl.m_type, trait_path );
     TRACE_FUNCTION_F("trait_path=" << trait_path);
     this->visit_params(impl.m_params);
     // - HACK: Create a generic path to visit (so that proper checks are performed)
@@ -131,14 +131,17 @@ void ::HIR::Visitor::visit_marker_impl(const ::HIR::SimplePath& trait_path, ::HI
     this->visit_type(impl.m_type);
 }
 
-void ::HIR::Visitor::visit_type_alias(::HIR::PathChain p, ::HIR::TypeAlias& item)
+void ::HIR::Visitor::visit_type_alias(::HIR::ItemPath p, ::HIR::TypeAlias& item)
 {
     this->visit_params(item.m_params);
     this->visit_type(item.m_type);
 }
-void ::HIR::Visitor::visit_trait(::HIR::PathChain p, ::HIR::Trait& item)
+void ::HIR::Visitor::visit_trait(::HIR::ItemPath p, ::HIR::Trait& item)
 {
+    ::HIR::SimplePath trait_sp = p.get_simple_path();
+    ItemPath    trait_ip(trait_sp);
     TRACE_FUNCTION;
+    
     this->visit_params(item.m_params);
     for(auto& par : item.m_parent_traits) {
         this->visit_trait_path(par);
@@ -150,24 +153,25 @@ void ::HIR::Visitor::visit_trait(::HIR::PathChain p, ::HIR::Trait& item)
         this->visit_type(i.second.m_default);
     }
     for(auto& i : item.m_values) {
+        auto item_path = ::HIR::ItemPath(trait_ip, i.first.c_str());
         TU_MATCH(::HIR::TraitValueItem, (i.second), (e),
         (None, ),
         (Constant,
             DEBUG("constant " << i.first);
-            this->visit_constant(p + i.first, e);
+            this->visit_constant(item_path, e);
             ),
         (Static,
             DEBUG("static " << i.first);
-            this->visit_static(p + i.first, e);
+            this->visit_static(item_path, e);
             ),
         (Function,
             DEBUG("method " << i.first);
-            this->visit_function(p + i.first, e);
+            this->visit_function(item_path, e);
             )
         )
     }
 }
-void ::HIR::Visitor::visit_struct(::HIR::PathChain p, ::HIR::Struct& item)
+void ::HIR::Visitor::visit_struct(::HIR::ItemPath p, ::HIR::Struct& item)
 {
     this->visit_params(item.m_params);
     TU_MATCH(::HIR::Struct::Data, (item.m_data), (e),
@@ -185,7 +189,7 @@ void ::HIR::Visitor::visit_struct(::HIR::PathChain p, ::HIR::Struct& item)
         )
     )
 }
-void ::HIR::Visitor::visit_enum(::HIR::PathChain p, ::HIR::Enum& item)
+void ::HIR::Visitor::visit_enum(::HIR::ItemPath p, ::HIR::Enum& item)
 {
     this->visit_params(item.m_params);
     for(auto& var : item.m_variants)
@@ -209,7 +213,7 @@ void ::HIR::Visitor::visit_enum(::HIR::PathChain p, ::HIR::Enum& item)
         )
     }
 }
-void ::HIR::Visitor::visit_function(::HIR::PathChain p, ::HIR::Function& item)
+void ::HIR::Visitor::visit_function(::HIR::ItemPath p, ::HIR::Function& item)
 {
     this->visit_params(item.m_params);
     for(auto& arg : item.m_args)
@@ -220,12 +224,12 @@ void ::HIR::Visitor::visit_function(::HIR::PathChain p, ::HIR::Function& item)
     this->visit_type(item.m_return);
     this->visit_expr(item.m_code);
 }
-void ::HIR::Visitor::visit_static(::HIR::PathChain p, ::HIR::Static& item)
+void ::HIR::Visitor::visit_static(::HIR::ItemPath p, ::HIR::Static& item)
 {
     this->visit_type(item.m_type);
     this->visit_expr(item.m_value);
 }
-void ::HIR::Visitor::visit_constant(::HIR::PathChain p, ::HIR::Constant& item)
+void ::HIR::Visitor::visit_constant(::HIR::ItemPath p, ::HIR::Constant& item)
 {
     this->visit_params(item.m_params);
     this->visit_type(item.m_type);
diff --git a/src/hir/visitor.hpp b/src/hir/visitor.hpp
index 844603df..baf0c4a5 100644
--- a/src/hir/visitor.hpp
+++ b/src/hir/visitor.hpp
@@ -6,47 +6,6 @@
 
 namespace HIR {
 
-class PathChain
-{
-    const PathChain*    prev;
-public:
-    const ::std::string&    name;
-
-    PathChain(const PathChain& prev, const ::std::string& name):
-        prev(&prev),
-        name(name)
-    {}
-    PathChain(const ::std::string& name):
-        prev(nullptr),
-        name(name)
-    {}
-    
-    PathChain operator+(const ::std::string& name) const {
-        return PathChain(*this, name);
-    }
-    
-    ::HIR::SimplePath to_path() const {
-        if( prev ) {
-            return prev->to_path() + name;
-        }
-        else {
-            if( name != "" ) {
-                return ::HIR::SimplePath("", {name});
-            }
-            else {
-                return ::HIR::SimplePath("", {});
-            }
-        }
-    }
-    
-    friend ::std::ostream& operator<<(::std::ostream& os, const PathChain& x) {
-        if( x.prev )
-            os << *x.prev << "::";
-        os << x.name;
-        return os;
-    }
-};
-
 class Visitor
 {
 public:
@@ -54,21 +13,21 @@ public:
     
     virtual void visit_crate(::HIR::Crate& crate);
     
-    virtual void visit_module(PathChain p, ::HIR::Module& mod);
+    virtual void visit_module(ItemPath p, ::HIR::Module& mod);
     
     virtual void visit_type_impl(::HIR::TypeImpl& impl);
     virtual void visit_trait_impl(const ::HIR::SimplePath& trait_path, ::HIR::TraitImpl& impl);
     virtual void visit_marker_impl(const ::HIR::SimplePath& trait_path, ::HIR::MarkerImpl& impl);
     
     // - Type Items
-    virtual void visit_type_alias(PathChain p, ::HIR::TypeAlias& item);
-    virtual void visit_trait(PathChain p, ::HIR::Trait& item);
-    virtual void visit_struct(PathChain p, ::HIR::Struct& item);
-    virtual void visit_enum(PathChain p, ::HIR::Enum& item);
+    virtual void visit_type_alias(ItemPath p, ::HIR::TypeAlias& item);
+    virtual void visit_trait(ItemPath p, ::HIR::Trait& item);
+    virtual void visit_struct(ItemPath p, ::HIR::Struct& item);
+    virtual void visit_enum(ItemPath p, ::HIR::Enum& item);
     // - Value Items
-    virtual void visit_function(PathChain p, ::HIR::Function& item);
-    virtual void visit_static(PathChain p, ::HIR::Static& item);
-    virtual void visit_constant(PathChain p, ::HIR::Constant& item);
+    virtual void visit_function(ItemPath p, ::HIR::Function& item);
+    virtual void visit_static(ItemPath p, ::HIR::Static& item);
+    virtual void visit_constant(ItemPath p, ::HIR::Constant& item);
     
     // - Misc
     virtual void visit_params(::HIR::GenericParams& params);
diff --git a/src/hir_conv/constant_evaluation.cpp b/src/hir_conv/constant_evaluation.cpp
index c5d9029c..af4fc18e 100644
--- a/src/hir_conv/constant_evaluation.cpp
+++ b/src/hir_conv/constant_evaluation.cpp
@@ -549,13 +549,13 @@ namespace {
                 ::HIR::Visitor::visit_type(ty);
             }
         }
-        void visit_constant(::HIR::PathChain p, ::HIR::Constant& item) override
+        void visit_constant(::HIR::ItemPath p, ::HIR::Constant& item) override
         {
             visit_type(item.m_type);
             item.m_value_res = evaluate_constant(m_crate, *item.m_value);
             DEBUG("constant: " << item.m_type <<  " = " << item.m_value_res);
         }
-        void visit_static(::HIR::PathChain p, ::HIR::Static& item) override
+        void visit_static(::HIR::ItemPath p, ::HIR::Static& item) override
         {
             visit_type(item.m_type);
             item.m_value_res = evaluate_constant(m_crate, *item.m_value);
diff --git a/src/hir_conv/resolve_ufcs.cpp b/src/hir_conv/resolve_ufcs.cpp
index c7302a0b..d6e4d64b 100644
--- a/src/hir_conv/resolve_ufcs.cpp
+++ b/src/hir_conv/resolve_ufcs.cpp
@@ -20,7 +20,7 @@ namespace {
         
         StaticTraitResolve  m_resolve;
         const ::HIR::Trait* m_current_trait;
-        const ::HIR::PathChain* m_current_trait_path;
+        const ::HIR::ItemPath* m_current_trait_path;
         
     public:
         Visitor(const ::HIR::Crate& crate):
@@ -46,25 +46,25 @@ namespace {
             }
             return rv;
         }
-        void visit_module(::HIR::PathChain p, ::HIR::Module& mod) override
+        void visit_module(::HIR::ItemPath p, ::HIR::Module& mod) override
         {
             auto _ = this->push_mod_traits( mod );
             ::HIR::Visitor::visit_module(p, mod);
         }
 
-        void visit_struct(::HIR::PathChain p, ::HIR::Struct& item) override {
+        void visit_struct(::HIR::ItemPath p, ::HIR::Struct& item) override {
             auto _ = m_resolve.set_item_generics(item.m_params);
             ::HIR::Visitor::visit_struct(p, item);
         }
-        void visit_enum(::HIR::PathChain p, ::HIR::Enum& item) override {
+        void visit_enum(::HIR::ItemPath p, ::HIR::Enum& item) override {
             auto _ = m_resolve.set_item_generics(item.m_params);
             ::HIR::Visitor::visit_enum(p, item);
         }
-        void visit_function(::HIR::PathChain p, ::HIR::Function& item) override {
+        void visit_function(::HIR::ItemPath p, ::HIR::Function& item) override {
             auto _ = m_resolve.set_item_generics(item.m_params);
             ::HIR::Visitor::visit_function(p, item);
         }
-        void visit_trait(::HIR::PathChain p, ::HIR::Trait& trait) override {
+        void visit_trait(::HIR::ItemPath p, ::HIR::Trait& trait) override {
             m_current_trait = &trait;
             m_current_trait_path = &p;
             //auto _ = m_resolve.set_item_generics(trait.m_params);
@@ -283,7 +283,7 @@ namespace {
                     // If processing a trait, and the type is 'Self', search for the type/method on the trait
                     // - TODO: This could be encoded by a `Self: Trait` bound in the generics, but that may have knock-on issues?
                     if( te.name == "Self" && m_current_trait ) {
-                        auto trait_path = ::HIR::GenericPath( m_current_trait_path->to_path() );
+                        auto trait_path = ::HIR::GenericPath( m_current_trait_path->get_simple_path() );
                         for(unsigned int i = 0; i < m_current_trait->m_params.m_types.size(); i ++ ) {
                             trait_path.m_params.m_types.push_back( ::HIR::TypeRef(m_current_trait->m_params.m_types[i].m_name, i) );
                         }
diff --git a/src/hir_typeck/expr_visit.cpp b/src/hir_typeck/expr_visit.cpp
index 0f998464..60066ef8 100644
--- a/src/hir_typeck/expr_visit.cpp
+++ b/src/hir_typeck/expr_visit.cpp
@@ -23,7 +23,7 @@ namespace {
         
     
     public:
-        void visit_module(::HIR::PathChain p, ::HIR::Module& mod) override
+        void visit_module(::HIR::ItemPath p, ::HIR::Module& mod) override
         {
             m_ms.push_traits(mod);
             ::HIR::Visitor::visit_module(p, mod);
@@ -35,7 +35,7 @@ namespace {
             TODO(Span(), "visit_expr");
         }
 
-        void visit_trait(::HIR::PathChain p, ::HIR::Trait& item) override
+        void visit_trait(::HIR::ItemPath p, ::HIR::Trait& item) override
         {
             auto _ = this->m_ms.set_impl_generics(item.m_params);
             ::HIR::Visitor::visit_trait(p, item);
@@ -91,15 +91,19 @@ namespace {
         // ------
         // Code-containing items
         // ------
-        void visit_function(::HIR::PathChain p, ::HIR::Function& item) override {
+        void visit_function(::HIR::ItemPath p, ::HIR::Function& item) override {
             auto _ = this->m_ms.set_item_generics(item.m_params);
             if( item.m_code )
             {
                 DEBUG("Function code " << p);
                 Typecheck_Code( m_ms, item.m_args, item.m_return, item.m_code );
             }
+            else
+            {
+                DEBUG("Function code " << p << " (none)");
+            }
         }
-        void visit_static(::HIR::PathChain p, ::HIR::Static& item) override {
+        void visit_static(::HIR::ItemPath p, ::HIR::Static& item) override {
             //auto _ = this->m_ms.set_item_generics(item.m_params);
             if( item.m_value )
             {
@@ -108,7 +112,7 @@ namespace {
                 Typecheck_Code(m_ms, tmp, item.m_type, item.m_value);
             }
         }
-        void visit_constant(::HIR::PathChain p, ::HIR::Constant& item) override {
+        void visit_constant(::HIR::ItemPath p, ::HIR::Constant& item) override {
             auto _ = this->m_ms.set_item_generics(item.m_params);
             if( item.m_value )
             {
@@ -117,7 +121,7 @@ namespace {
                 Typecheck_Code(m_ms, tmp, item.m_type, item.m_value);
             }
         }
-        void visit_enum(::HIR::PathChain p, ::HIR::Enum& item) override {
+        void visit_enum(::HIR::ItemPath p, ::HIR::Enum& item) override {
             auto _ = this->m_ms.set_item_generics(item.m_params);
             
             // TODO: Use a different type depding on repr()
diff --git a/src/hir_typeck/outer.cpp b/src/hir_typeck/outer.cpp
index 1ce83e57..7fb8b199 100644
--- a/src/hir_typeck/outer.cpp
+++ b/src/hir_typeck/outer.cpp
@@ -101,7 +101,7 @@ namespace {
         StaticTraitResolve  m_resolve;
         
         const ::HIR::Trait* m_current_trait;
-        const ::HIR::PathChain* m_current_trait_path;
+        const ::HIR::ItemPath* m_current_trait_path;
     
         ::std::vector< ::HIR::TypeRef* >    m_self_types;
         
@@ -424,7 +424,7 @@ namespace {
                 // If processing a trait, and the type is 'Self', search for the type/method on the trait
                 // - TODO: This could be encoded by a `Self: Trait` bound in the generics, but that may have knock-on issues?
                 if( te.name == "Self" && m_current_trait ) {
-                    auto trait_path = ::HIR::GenericPath( m_current_trait_path->to_path() );
+                    auto trait_path = ::HIR::GenericPath( m_current_trait_path->get_simple_path() );
                     for(unsigned int i = 0; i < m_current_trait->m_params.m_types.size(); i ++ ) {
                         trait_path.m_params.m_types.push_back( ::HIR::TypeRef(m_current_trait->m_params.m_types[i].m_name, i) );
                     }
@@ -556,13 +556,13 @@ namespace {
             }
         }
         
-        void visit_module(::HIR::PathChain p, ::HIR::Module& mod) override
+        void visit_module(::HIR::ItemPath p, ::HIR::Module& mod) override
         {
             auto _ = this->push_mod_traits( mod );
             ::HIR::Visitor::visit_module(p, mod);
         }
         
-        void visit_trait(::HIR::PathChain p, ::HIR::Trait& item) override
+        void visit_trait(::HIR::ItemPath p, ::HIR::Trait& item) override
         {
             m_current_trait = &item;
             m_current_trait_path = &p;
@@ -575,7 +575,7 @@ namespace {
             
             m_current_trait = nullptr;
         }
-        void visit_struct(::HIR::PathChain p, ::HIR::Struct& item) override
+        void visit_struct(::HIR::ItemPath p, ::HIR::Struct& item) override
         {
             auto _ = m_resolve.set_item_generics(item.m_params);
             ::HIR::Visitor::visit_struct(p, item);