HIR - Add more complete privacy handling (allowing for autoderef to skip private fields)

19 files changed, 189 insertions, 75 deletions

diff --git a/src/hir/deserialise.cpp b/src/hir/deserialise.cpp
index cc376474..9933255f 100644
--- a/src/hir/deserialise.cpp
+++ b/src/hir/deserialise.cpp
@@ -101,10 +101,14 @@
                 rv.push_back( cb() );
             return rv;
         }
+        ::HIR::Publicity deserialise_pub()
+        {
+            return (m_in.read_bool() ? ::HIR::Publicity::new_global() : ::HIR::Publicity::new_none());
+        }
         template<typename T>
         ::HIR::VisEnt<T> deserialise_visent()
         {
-            return ::HIR::VisEnt<T> { m_in.read_bool(), D<T>::des(*this) };
+            return ::HIR::VisEnt<T> { deserialise_pub(), D<T>::des(*this) };
         }
 
         template<typename T>
@@ -153,7 +157,7 @@
             {
                 auto name = m_in.read_string();
                 rv.m_methods.insert( ::std::make_pair( mv$(name), ::HIR::TypeImpl::VisImplEnt< ::HIR::Function> {
-                    m_in.read_bool(), m_in.read_bool(), deserialise_function()
+                    deserialise_pub(), m_in.read_bool(), deserialise_function()
                     } ) );
             }
             size_t const_count = m_in.read_count();
@@ -161,7 +165,7 @@
             {
                 auto name = m_in.read_string();
                 rv.m_constants.insert( ::std::make_pair( mv$(name), ::HIR::TypeImpl::VisImplEnt< ::HIR::Constant> {
-                    m_in.read_bool(), m_in.read_bool(), deserialise_constant()
+                    deserialise_pub(), m_in.read_bool(), deserialise_constant()
                     } ) );
             }
             // m_src_module doesn't matter after typeck
diff --git a/src/hir/dump.cpp b/src/hir/dump.cpp
index a60ec643..3b981e26 100644
--- a/src/hir/dump.cpp
+++ b/src/hir/dump.cpp
@@ -152,7 +152,7 @@ namespace {
                 m_os << "(";
                 for(const auto& fld : flds)
                 {
-                    m_os << (fld.is_public ? "pub " : "") << fld.ent << ", ";
+                    m_os << fld.publicity << " " << fld.ent << ", ";
                 }
                 if( item.m_params.m_bounds.empty() )
                 {
@@ -175,7 +175,7 @@ namespace {
                 inc_indent();
                 for(const auto& fld : flds)
                 {
-                    m_os << indent() << (fld.second.is_public ? "pub " : "") << fld.first << ": " << fld.second.ent << ",\n";
+                    m_os << indent() << fld.second.publicity << " " << fld.first << ": " << fld.second.ent << ",\n";
                 }
                 dec_indent();
                 m_os << indent() << "}\n";
diff --git a/src/hir/expr_ptr.cpp b/src/hir/expr_ptr.cpp
index 7b3a6811..0c219e0f 100644
--- a/src/hir/expr_ptr.cpp
+++ b/src/hir/expr_ptr.cpp
@@ -90,6 +90,12 @@ void HIR::ExprPtr::set_mir(::MIR::FunctionPointer mir)
 {
     assert( !this->m_mir );
     m_mir = ::std::move(mir);
+    // Reset the HIR tree to be a placeholder node (thus freeing the backing memory)
+    //if( node )
+    //{
+    //    auto sp = node->span();
+    //    node = ExprPtrInner(::std::unique_ptr<HIR::ExprNode>(new ::HIR::ExprNode_Tuple(sp, {})));
+    //}
 }
 
 
diff --git a/src/hir/expr_state.hpp b/src/hir/expr_state.hpp
index 5491b4d3..11fffe67 100644
--- a/src/hir/expr_state.hpp
+++ b/src/hir/expr_state.hpp
@@ -10,8 +10,9 @@
 
 namespace HIR {
 
-struct ExprState
+class ExprState
 {
+public:
     ::HIR::SimplePath   m_mod_path;
     const ::HIR::Module&    m_module;
 
diff --git a/src/hir/from_ast.cpp b/src/hir/from_ast.cpp
index 014b744c..af6bc9cb 100644
--- a/src/hir/from_ast.cpp
+++ b/src/hir/from_ast.cpp
@@ -868,9 +868,20 @@ const ::AST::Crate* g_ast_crate_ptr;
 
 namespace {
     template<typename T>
-    ::HIR::VisEnt<T> new_visent(bool pub, T v) {
+    ::HIR::VisEnt<T> new_visent(HIR::Publicity pub, T v) {
         return ::HIR::VisEnt<T> { pub, mv$(v) };
     }
+
+    ::HIR::SimplePath get_parent_module(const ::HIR::ItemPath& p) {
+        const ::HIR::ItemPath*  parent_ip = p.parent;
+        assert(parent_ip);
+        while(parent_ip->name && parent_ip->name[0] == '#')
+        {
+            parent_ip = parent_ip->parent;
+            assert(parent_ip);
+        }
+        return parent_ip->get_simple_path();
+    }
 }
 
 ::HIR::Struct LowerHIR_Struct(::HIR::ItemPath path, const ::AST::Struct& ent, const ::AST::AttributeList& attrs)
@@ -878,6 +889,9 @@ namespace {
     TRACE_FUNCTION_F(path);
     ::HIR::Struct::Data data;
 
+    auto priv_path = ::HIR::Publicity::new_priv( get_parent_module(path) );
+    auto get_pub = [&](bool is_pub){ return is_pub ? ::HIR::Publicity::new_global() : priv_path; };
+
     TU_MATCH(::AST::StructData, (ent.m_data), (e),
     (Unit,
         data = ::HIR::Struct::Data::make_Unit({});
@@ -886,14 +900,14 @@ namespace {
         ::HIR::Struct::Data::Data_Tuple fields;
 
         for(const auto& field : e.ents)
-            fields.push_back( { field.m_is_public, LowerHIR_Type(field.m_type) } );
+            fields.push_back( { get_pub(field.m_is_public), LowerHIR_Type(field.m_type) } );
 
         data = ::HIR::Struct::Data::make_Tuple( mv$(fields) );
         ),
     (Struct,
         ::HIR::Struct::Data::Data_Named fields;
         for(const auto& field : e.ents)
-            fields.push_back( ::std::make_pair( field.m_name, new_visent(field.m_is_public, LowerHIR_Type(field.m_type)) ) );
+            fields.push_back( ::std::make_pair( field.m_name, new_visent( get_pub(field.m_is_public), LowerHIR_Type(field.m_type)) ) );
         data = ::HIR::Struct::Data::make_Named( mv$(fields) );
         )
     )
@@ -956,7 +970,6 @@ namespace {
 
 ::HIR::Enum LowerHIR_Enum(::HIR::ItemPath path, const ::AST::Enum& ent, const ::AST::AttributeList& attrs, ::std::function<void(::std::string, ::HIR::Struct)> push_struct)
 {
-
     // 1. Figure out what sort of enum this is (value or data)
     bool has_value = false;
     bool has_data = false;
@@ -1053,14 +1066,14 @@ namespace {
                 {
                     ::HIR::Struct::Data::Data_Tuple fields;
                     for(const auto& field : ve->m_sub_types)
-                        fields.push_back( new_visent(true, LowerHIR_Type(field)) );
+                        fields.push_back( new_visent(::HIR::Publicity::new_global(), LowerHIR_Type(field)) );
                     data = ::HIR::Struct::Data::make_Tuple( mv$(fields) );
                 }
                 else if( const auto* ve = var.m_data.opt_Struct() )
                 {
                     ::HIR::Struct::Data::Data_Named fields;
                     for(const auto& field : ve->m_fields)
-                        fields.push_back( ::std::make_pair( field.m_name, new_visent(true, LowerHIR_Type(field.m_type)) ) );
+                        fields.push_back( ::std::make_pair( field.m_name, new_visent(::HIR::Publicity::new_global(), LowerHIR_Type(field.m_type)) ) );
                     data = ::HIR::Struct::Data::make_Named( mv$(fields) );
                 }
                 else
@@ -1106,6 +1119,9 @@ namespace {
 }
 ::HIR::Union LowerHIR_Union(::HIR::ItemPath path, const ::AST::Union& f, const ::AST::AttributeList& attrs)
 {
+    auto priv_path = ::HIR::Publicity::new_priv( get_parent_module(path) );
+    auto get_pub = [&](bool is_pub){ return is_pub ? ::HIR::Publicity::new_global() : priv_path; };
+
     auto repr = ::HIR::Union::Repr::Rust;
 
     if( const auto* attr_repr = attrs.get("repr") )
@@ -1124,7 +1140,7 @@ namespace {
 
     ::HIR::Struct::Data::Data_Named variants;
     for(const auto& field : f.m_variants)
-        variants.push_back( ::std::make_pair( field.m_name, new_visent(field.m_is_public, LowerHIR_Type(field.m_type)) ) );
+        variants.push_back( ::std::make_pair( field.m_name, new_visent(get_pub(field.m_is_public), LowerHIR_Type(field.m_type)) ) );
 
     return ::HIR::Union {
         LowerHIR_GenericParams(f.m_params, nullptr),
@@ -1369,10 +1385,10 @@ namespace {
         };
 }
 
-void _add_mod_ns_item(::HIR::Module& mod, ::std::string name, bool is_pub,  ::HIR::TypeItem ti) {
+void _add_mod_ns_item(::HIR::Module& mod, ::std::string name, ::HIR::Publicity is_pub,  ::HIR::TypeItem ti) {
     mod.m_mod_items.insert( ::std::make_pair( mv$(name), ::make_unique_ptr(::HIR::VisEnt< ::HIR::TypeItem> { is_pub, mv$(ti) }) ) );
 }
-void _add_mod_val_item(::HIR::Module& mod, ::std::string name, bool is_pub,  ::HIR::ValueItem ti) {
+void _add_mod_val_item(::HIR::Module& mod, ::std::string name, ::HIR::Publicity is_pub,  ::HIR::ValueItem ti) {
     mod.m_value_items.insert( ::std::make_pair( mv$(name), ::make_unique_ptr(::HIR::VisEnt< ::HIR::ValueItem> { is_pub, mv$(ti) }) ) );
 }
 
@@ -1383,6 +1399,9 @@ void _add_mod_val_item(::HIR::Module& mod, ::std::string name, bool is_pub,  ::H
 
     mod.m_traits = mv$(traits);
 
+    auto priv_path = ::HIR::Publicity::new_priv( path.get_simple_path() );
+    auto get_pub = [&](bool is_pub)->::HIR::Publicity{ return (is_pub ? ::HIR::Publicity::new_global() : priv_path); };
+
     // Populate trait list
     for(const auto& item : ast_mod.m_type_items)
     {
@@ -1402,7 +1421,7 @@ void _add_mod_val_item(::HIR::Module& mod, ::std::string name, bool is_pub,  ::H
             ::std::string name = FMT("#" << i);
             auto item_path = ::HIR::ItemPath(path, name.c_str());
             auto ti = ::HIR::TypeItem::make_Module( LowerHIR_Module(submod, item_path, mod.m_traits) );
-            _add_mod_ns_item( mod,  mv$(name), false, mv$(ti) );
+            _add_mod_ns_item( mod,  mv$(name), get_pub(false), mv$(ti) );
         }
     }
 
@@ -1456,12 +1475,12 @@ void _add_mod_val_item(::HIR::Module& mod, ::std::string name, bool is_pub,  ::H
             // Ignore - The index is used to add `Import`s
             ),
         (Module,
-            _add_mod_ns_item( mod,  item.name, item.is_pub, LowerHIR_Module(e, mv$(item_path)) );
+            _add_mod_ns_item( mod,  item.name, get_pub(item.is_pub), LowerHIR_Module(e, mv$(item_path)) );
             ),
         (Crate,
             // All 'extern crate' items should be normalised into a list in the crate root
             // - If public, add a namespace import here referring to the root of the imported crate
-            _add_mod_ns_item( mod, item.name, item.is_pub, ::HIR::TypeItem::make_Import({ ::HIR::SimplePath(e.name, {}), false, 0} ) );
+            _add_mod_ns_item( mod, item.name, get_pub(item.is_pub), ::HIR::TypeItem::make_Import({ ::HIR::SimplePath(e.name, {}), false, 0} ) );
             ),
         (Type,
             if( e.type().m_data.is_Any() )
@@ -1470,39 +1489,39 @@ void _add_mod_val_item(::HIR::Module& mod, ::std::string name, bool is_pub,  ::H
                 {
                     ERROR(item.data.span, E0000, "Generics on extern type");
                 }
-                _add_mod_ns_item(mod, item.name, item.is_pub, ::HIR::ExternType {});
+                _add_mod_ns_item(mod, item.name, get_pub(item.is_pub), ::HIR::ExternType {});
                 break;
             }
-            _add_mod_ns_item( mod,  item.name, item.is_pub, ::HIR::TypeItem::make_TypeAlias( LowerHIR_TypeAlias(e) ) );
+            _add_mod_ns_item( mod,  item.name, get_pub(item.is_pub), ::HIR::TypeItem::make_TypeAlias( LowerHIR_TypeAlias(e) ) );
             ),
         (Struct,
             /// Add value reference
             if( e.m_data.is_Unit() ) {
-                _add_mod_val_item( mod,  item.name, item.is_pub, ::HIR::ValueItem::make_StructConstant({item_path.get_simple_path()}) );
+                _add_mod_val_item( mod,  item.name, get_pub(item.is_pub), ::HIR::ValueItem::make_StructConstant({item_path.get_simple_path()}) );
             }
             else if( e.m_data.is_Tuple() ) {
-                _add_mod_val_item( mod,  item.name, item.is_pub, ::HIR::ValueItem::make_StructConstructor({item_path.get_simple_path()}) );
+                _add_mod_val_item( mod,  item.name, get_pub(item.is_pub), ::HIR::ValueItem::make_StructConstructor({item_path.get_simple_path()}) );
             }
             else {
             }
-            _add_mod_ns_item( mod,  item.name, item.is_pub, LowerHIR_Struct(item_path, e, item.data.attrs) );
+            _add_mod_ns_item( mod,  item.name, get_pub(item.is_pub), LowerHIR_Struct(item_path, e, item.data.attrs) );
             ),
         (Enum,
-            auto enm = LowerHIR_Enum(item_path, e, item.data.attrs, [&](auto name, auto str){ _add_mod_ns_item(mod, name, item.is_pub, mv$(str)); });
-            _add_mod_ns_item( mod,  item.name, item.is_pub, mv$(enm) );
+            auto enm = LowerHIR_Enum(item_path, e, item.data.attrs, [&](auto name, auto str){ _add_mod_ns_item(mod, name, get_pub(item.is_pub), mv$(str)); });
+            _add_mod_ns_item( mod,  item.name, get_pub(item.is_pub), mv$(enm) );
             ),
         (Union,
-            _add_mod_ns_item( mod,  item.name, item.is_pub, LowerHIR_Union(item_path, e, item.data.attrs) );
+            _add_mod_ns_item( mod,  item.name, get_pub(item.is_pub), LowerHIR_Union(item_path, e, item.data.attrs) );
             ),
         (Trait,
-            _add_mod_ns_item( mod,  item.name, item.is_pub, LowerHIR_Trait(item_path.get_simple_path(), e) );
+            _add_mod_ns_item( mod,  item.name, get_pub(item.is_pub), LowerHIR_Trait(item_path.get_simple_path(), e) );
             ),
         (Function,
-            _add_mod_val_item(mod, item.name, item.is_pub,  LowerHIR_Function(item_path, item.data.attrs, e, ::HIR::TypeRef{}));
+            _add_mod_val_item(mod, item.name, get_pub(item.is_pub),  LowerHIR_Function(item_path, item.data.attrs, e, ::HIR::TypeRef{}));
             ),
         (Static,
             if( e.s_class() == ::AST::Static::CONST )
-                _add_mod_val_item(mod, item.name, item.is_pub,  ::HIR::ValueItem::make_Constant(::HIR::Constant {
+                _add_mod_val_item(mod, item.name, get_pub(item.is_pub),  ::HIR::ValueItem::make_Constant(::HIR::Constant {
                     ::HIR::GenericParams {},
                     LowerHIR_Type( e.type() ),
                     LowerHIR_Expr( e.value() )
@@ -1516,7 +1535,7 @@ void _add_mod_val_item(::HIR::Module& mod, ::std::string name, bool is_pub,  ::H
                     linkage.name = item.name;
                 }
 
-                _add_mod_val_item(mod, item.name, item.is_pub,  ::HIR::ValueItem::make_Static(::HIR::Static {
+                _add_mod_val_item(mod, item.name, get_pub(item.is_pub),  ::HIR::ValueItem::make_Static(::HIR::Static {
                     mv$(linkage),
                     (e.s_class() == ::AST::Static::MUT),
                     LowerHIR_Type( e.type() ),
@@ -1542,7 +1561,7 @@ void _add_mod_val_item(::HIR::Module& mod, ::std::string name, bool is_pub,  ::H
                 DEBUG("Import NS " << ie.first << " = " << hir_path);
                 ti = ::HIR::TypeItem::make_Import({ mv$(hir_path), false, 0 });
             }
-            _add_mod_ns_item(mod, ie.first, ie.second.is_pub, mv$(ti));
+            _add_mod_ns_item(mod, ie.first, get_pub(ie.second.is_pub), mv$(ti));
         }
     }
     for( const auto& ie : ast_mod.m_value_items )
@@ -1561,7 +1580,7 @@ void _add_mod_val_item(::HIR::Module& mod, ::std::string name, bool is_pub,  ::H
                 vi = ::HIR::ValueItem::make_Import({ mv$(hir_path), true, pb.idx });
                 }
             }
-            _add_mod_val_item(mod, ie.first, ie.second.is_pub, mv$(vi));
+            _add_mod_val_item(mod, ie.first, get_pub(ie.second.is_pub), mv$(vi));
         }
     }
 
@@ -1687,6 +1706,9 @@ void LowerHIR_Module_Impls(const ::AST::Module& ast_mod,  ::HIR::Crate& hir_crat
             auto type = LowerHIR_Type(impl.def().type());
             ::HIR::ItemPath    path(type);
 
+            auto priv_path = ::HIR::Publicity::new_priv( LowerHIR_SimplePath(Span(), ast_mod.path()) ); // TODO: Does this need to consume anon modules?
+            auto get_pub = [&](bool is_pub){ return is_pub ? ::HIR::Publicity::new_global() : priv_path; };
+
             ::std::map< ::std::string, ::HIR::TypeImpl::VisImplEnt< ::HIR::Function> > methods;
             ::std::map< ::std::string, ::HIR::TypeImpl::VisImplEnt< ::HIR::Constant> > constants;
 
@@ -1703,7 +1725,7 @@ void LowerHIR_Module_Impls(const ::AST::Module& ast_mod,  ::HIR::Crate& hir_crat
                     ),
                 (Static,
                     if( e.s_class() == ::AST::Static::CONST ) {
-                        constants.insert( ::std::make_pair(item.name, ::HIR::TypeImpl::VisImplEnt< ::HIR::Constant> { item.is_pub, item.is_specialisable, ::HIR::Constant {
+                        constants.insert( ::std::make_pair(item.name, ::HIR::TypeImpl::VisImplEnt< ::HIR::Constant> { get_pub(item.is_pub), item.is_specialisable, ::HIR::Constant {
                             ::HIR::GenericParams {},
                             LowerHIR_Type( e.type() ),
                             LowerHIR_Expr( e.value() )
@@ -1715,7 +1737,7 @@ void LowerHIR_Module_Impls(const ::AST::Module& ast_mod,  ::HIR::Crate& hir_crat
                     ),
                 (Function,
                     methods.insert( ::std::make_pair(item.name, ::HIR::TypeImpl::VisImplEnt< ::HIR::Function> {
-                        item.is_pub, item.is_specialisable, LowerHIR_Function(item_path, item.data->attrs, e, type)
+                        get_pub(item.is_pub), item.is_specialisable, LowerHIR_Function(item_path, item.data->attrs, e, type)
                         } ) );
                     )
                 )
diff --git a/src/hir/hir.hpp b/src/hir/hir.hpp
index 48787583..f0844580 100644
--- a/src/hir/hir.hpp
+++ b/src/hir/hir.hpp
@@ -41,10 +41,70 @@ class TypeItem;
 
 class ItemPath;
 
+class Publicity
+{
+    ::std::shared_ptr<::HIR::SimplePath>    vis_path;
+
+    Publicity(::std::shared_ptr<::HIR::SimplePath> p)
+        :vis_path(p)
+    {
+    }
+public:
+
+    static Publicity new_global() {
+        return Publicity({});
+    }
+    static Publicity new_none() {
+        static ::std::shared_ptr<::HIR::SimplePath> none_path = ::std::make_shared<HIR::SimplePath>();
+        return Publicity(none_path);
+    }
+    static Publicity new_priv(::HIR::SimplePath p) {
+        return Publicity(::std::make_shared<HIR::SimplePath>(::std::move(p)));
+    }
+
+    bool is_global() const {
+        return !vis_path;
+    }
+    bool is_visible(const ::HIR::SimplePath& p) const {
+        // No path = global public
+        if( !vis_path )
+            return true;
+        // Empty simple path = full private
+        if( *vis_path == ::HIR::SimplePath() ) {
+            return false;
+        }
+        // Crate names must match
+        if(p.m_crate_name != vis_path->m_crate_name)
+            return false;
+        // `p` must be a child of vis_path
+        if(p.m_components.size() < vis_path->m_components.size())
+            return false;
+        for(size_t i = 0; i < vis_path->m_components.size(); i ++)
+        {
+            if(p.m_components[i] != vis_path->m_components[i])
+                return false;
+        }
+        return true;
+    }
+
+    friend ::std::ostream& operator<<(::std::ostream& os, const Publicity& x) {
+        if( !x.vis_path ) {
+            os << "pub";
+        }
+        else if( *x.vis_path == ::HIR::SimplePath() ) {
+            os << "priv";
+        }
+        else {
+            os << "pub(" << *x.vis_path << ")";
+        }
+        return os;
+    }
+};
+
 template<typename Ent>
 struct VisEnt
 {
-    bool is_public;
+    Publicity   publicity;
     Ent ent;
 };
 
@@ -396,7 +456,7 @@ class TypeImpl
 public:
     template<typename T>
     struct VisImplEnt {
-        bool is_pub;
+        Publicity   publicity;
         bool is_specialisable;
         T   data;
     };
diff --git a/src/hir/hir_ops.cpp b/src/hir/hir_ops.cpp
index b09dbdf7..89e48c80 100644
--- a/src/hir/hir_ops.cpp
+++ b/src/hir/hir_ops.cpp
@@ -1036,6 +1036,7 @@ const ::MIR::Function* HIR::Crate::get_or_gen_mir(const ::HIR::ItemPath& ip, con
                 ms.m_impl_generics = ep.m_state->m_impl_generics;
                 ms.m_item_generics = ep.m_state->m_item_generics;
                 ms.m_traits = ep.m_state->m_traits;
+                ms.m_mod_paths.push_back(ep.m_state->m_mod_path);
                 Typecheck_Code(ms, const_cast<::HIR::Function::args_t&>(args), ret_ty, ep_mut);
                 //Debug_SetStagePre("Expand HIR Annotate");
                 HIR_Expand_AnnotateUsage_Expr(*this, ep_mut);
diff --git a/src/hir/serialise.cpp b/src/hir/serialise.cpp
index 0d01ed25..dd81596f 100644
--- a/src/hir/serialise.cpp
+++ b/src/hir/serialise.cpp
@@ -60,7 +60,7 @@
         template<typename T>
         void serialise(const ::HIR::VisEnt<T>& e)
         {
-            m_out.write_bool(e.is_public);
+            m_out.write_bool(e.publicity.is_global());  // At this stage, we only care if the item is visible outside the crate or not
             serialise(e.ent);
         }
         template<typename T>
@@ -322,14 +322,14 @@
             m_out.write_count(impl.m_methods.size());
             for(const auto& v : impl.m_methods) {
                 m_out.write_string(v.first);
-                m_out.write_bool(v.second.is_pub);
+                m_out.write_bool(v.second.publicity.is_global());
                 m_out.write_bool(v.second.is_specialisable);
                 serialise(v.second.data);
             }
             m_out.write_count(impl.m_constants.size());
             for(const auto& v : impl.m_constants) {
                 m_out.write_string(v.first);
-                m_out.write_bool(v.second.is_pub);
+                m_out.write_bool(v.second.publicity.is_global());
                 m_out.write_bool(v.second.is_specialisable);
                 serialise(v.second.data);
             }
diff --git a/src/hir_conv/bind.cpp b/src/hir_conv/bind.cpp
index c26ae03f..a3b0041b 100644
--- a/src/hir_conv/bind.cpp
+++ b/src/hir_conv/bind.cpp
@@ -120,7 +120,7 @@ namespace {
             m_cur_module.ptr = &mod;
             m_cur_module.path = &p;
 
-            m_ms.push_traits(mod);
+            m_ms.push_traits(p, mod);
             ::HIR::Visitor::visit_module(p, mod);
             m_ms.pop_traits(mod);
 
@@ -512,12 +512,16 @@ namespace {
 
         void visit_type_impl(::HIR::TypeImpl& impl) override
         {
-            TRACE_FUNCTION_F("impl " << impl.m_type);
+            TRACE_FUNCTION_F("impl " << impl.m_type << " - from " << impl.m_src_module);
             auto _ = this->m_ms.set_impl_generics(impl.m_params);
 
+            auto mod_ip = ::HIR::ItemPath(impl.m_src_module);
             const auto* mod = (impl.m_src_module != ::HIR::SimplePath() ? &this->m_ms.m_crate.get_mod_by_path(Span(), impl.m_src_module) : nullptr);
-            if(mod)
-                m_ms.push_traits(*mod);
+            if(mod) {
+                m_ms.push_traits(impl.m_src_module, *mod);
+                m_cur_module.ptr = mod;
+                m_cur_module.path = &mod_ip;
+            }
             ::HIR::Visitor::visit_type_impl(impl);
             if(mod)
                 m_ms.pop_traits(*mod);
@@ -527,9 +531,13 @@ namespace {
             TRACE_FUNCTION_F("impl " << trait_path << " for " << impl.m_type);
             auto _ = this->m_ms.set_impl_generics(impl.m_params);
 
+            auto mod_ip = ::HIR::ItemPath(impl.m_src_module);
             const auto* mod = (impl.m_src_module != ::HIR::SimplePath() ? &this->m_ms.m_crate.get_mod_by_path(Span(), impl.m_src_module) : nullptr);
-            if(mod)
-                m_ms.push_traits(*mod);
+            if(mod) {
+                m_ms.push_traits(impl.m_src_module, *mod);
+                m_cur_module.ptr = mod;
+                m_cur_module.path = &mod_ip;
+            }
             m_ms.m_traits.push_back( ::std::make_pair( &trait_path, &this->m_ms.m_crate.get_trait_by_path(Span(), trait_path) ) );
             ::HIR::Visitor::visit_trait_impl(trait_path, impl);
             m_ms.m_traits.pop_back( );
@@ -541,9 +549,13 @@ namespace {
             TRACE_FUNCTION_F("impl " << trait_path << " for " << impl.m_type << " { }");
             auto _ = this->m_ms.set_impl_generics(impl.m_params);
 
+            auto mod_ip = ::HIR::ItemPath(impl.m_src_module);
             const auto* mod = (impl.m_src_module != ::HIR::SimplePath() ? &this->m_ms.m_crate.get_mod_by_path(Span(), impl.m_src_module) : nullptr);
-            if(mod)
-                m_ms.push_traits(*mod);
+            if(mod) {
+                m_ms.push_traits(impl.m_src_module, *mod);
+                m_cur_module.ptr = mod;
+                m_cur_module.path = &mod_ip;
+            }
             ::HIR::Visitor::visit_marker_impl(trait_path, impl);
             if(mod)
                 m_ms.pop_traits(*mod);
diff --git a/src/hir_conv/constant_evaluation.cpp b/src/hir_conv/constant_evaluation.cpp
index 3d1bf4a5..6049056c 100644
--- a/src/hir_conv/constant_evaluation.cpp
+++ b/src/hir_conv/constant_evaluation.cpp
@@ -1035,6 +1035,7 @@ namespace {
                         tp.pp_impl = ms.pp_impl->clone();
                         ep.m_mir = Trans_Monomorphise(resolve, mv$(tp), template_const.m_value.m_mir);
                         ep.m_state = ::HIR::ExprStatePtr( ::HIR::ExprState(*m_mod, m_mod_path->get_simple_path()) );
+                        DEBUG("TMP TMP " << trait_path << " - " << ep.m_state->m_mod_path);
                         ep.m_state->stage = ::HIR::ExprState::Stage::Mir;
                         impl.m_constants.insert(::std::make_pair(
                             vi.first,
@@ -1211,7 +1212,7 @@ namespace {
                 {
                     // ::std::unique_ptr<VisEnt<ValueItem>>
                     ::std::unique_ptr<::HIR::VisEnt<::HIR::ValueItem>>  iv;
-                    iv.reset( new ::HIR::VisEnt<::HIR::ValueItem> { false, ::HIR::ValueItem::make_Static(mv$(v.second)) } );
+                    iv.reset( new ::HIR::VisEnt<::HIR::ValueItem> { ::HIR::Publicity::new_none(), ::HIR::ValueItem::make_Static(mv$(v.second)) } );
                     mod.m_value_items.insert(::std::make_pair( v.first, mv$(iv) ));
                 }
                 mod.m_inline_statics.clear();
diff --git a/src/hir_expand/closures.cpp b/src/hir_expand/closures.cpp
index ee0cff08..d7d476e5 100644
--- a/src/hir_expand/closures.cpp
+++ b/src/hir_expand/closures.cpp
@@ -720,7 +720,7 @@ namespace {
                 // - Fix type to replace closure types with known paths
                 ExprVisitor_Fixup   fixup { m_resolve.m_crate, &params, monomorph_cb };
                 fixup.visit_type(ty_mono);
-                capture_types.push_back( ::HIR::VisEnt< ::HIR::TypeRef> { false, mv$(ty_mono) } );
+                capture_types.push_back( ::HIR::VisEnt< ::HIR::TypeRef> { ::HIR::Publicity::new_none(), mv$(ty_mono) } );
             }
             auto closure_struct_path = m_new_type(
                 ::HIR::Struct {
@@ -1182,7 +1182,7 @@ namespace {
             m_new_type = [&](auto s)->auto {
                 auto name = FMT("closure#I_" << closure_count);
                 closure_count += 1;
-                auto boxed = box$(( ::HIR::VisEnt< ::HIR::TypeItem> { false, ::HIR::TypeItem( mv$(s) ) } ));
+                auto boxed = box$(( ::HIR::VisEnt< ::HIR::TypeItem> { ::HIR::Publicity::new_none(), ::HIR::TypeItem( mv$(s) ) } ));
                 crate.m_root_module.m_mod_items.insert( ::std::make_pair(name, mv$(boxed)) );
                 return ::HIR::SimplePath(crate.m_crate_name, {}) + name;
                 };
@@ -1209,7 +1209,7 @@ namespace {
                     crate.m_type_impls.push_back( ::HIR::TypeImpl {
                         mv$(impl.second.m_params),
                         mv$(impl.second.m_type),
-                        make_map1(impl.second.m_methods.begin()->first, ::HIR::TypeImpl::VisImplEnt< ::HIR::Function> { true, false,  mv$(impl.second.m_methods.begin()->second.data) }),
+                        make_map1(impl.second.m_methods.begin()->first, ::HIR::TypeImpl::VisImplEnt< ::HIR::Function> { ::HIR::Publicity::new_global(), false,  mv$(impl.second.m_methods.begin()->second.data) }),
                         {},
                         mv$(impl.second.m_src_module)
                         } );
@@ -1233,7 +1233,7 @@ namespace {
             m_new_type = [&](auto s)->auto {
                 auto name = FMT("closure#" << closure_count);
                 closure_count += 1;
-                auto boxed = box$( (::HIR::VisEnt< ::HIR::TypeItem> { false, ::HIR::TypeItem( mv$(s) ) }) );
+                auto boxed = box$( (::HIR::VisEnt< ::HIR::TypeItem> { ::HIR::Publicity::new_none(), ::HIR::TypeItem( mv$(s) ) }) );
                 mod.m_mod_items.insert( ::std::make_pair(name, mv$(boxed)) );
                 return (p + name).get_simple_path();
                 };
diff --git a/src/hir_expand/vtable.cpp b/src/hir_expand/vtable.cpp
index 79e163ac..2b3dcfb4 100644
--- a/src/hir_expand/vtable.cpp
+++ b/src/hir_expand/vtable.cpp
@@ -32,7 +32,7 @@ namespace {
 
             ::std::vector< decltype(mod.m_mod_items)::value_type> new_types;
             m_new_type = [&](bool pub, auto name, auto s)->auto {
-                auto boxed = box$( (::HIR::VisEnt< ::HIR::TypeItem> { pub, ::HIR::TypeItem( mv$(s) ) }) );
+                auto boxed = box$( (::HIR::VisEnt< ::HIR::TypeItem> { (pub ? ::HIR::Publicity::new_global() : ::HIR::Publicity::new_none()), ::HIR::TypeItem( mv$(s) ) }) );
                 auto ret = (p + name).get_simple_path();
                 new_types.push_back( ::std::make_pair( mv$(name), mv$(boxed)) );
                 return ret;
@@ -173,7 +173,7 @@ namespace {
                             DEBUG("- '" << vi.first << "' is @" << fields.size());
                             fields.push_back( ::std::make_pair(
                                 vi.first,
-                                ::HIR::VisEnt< ::HIR::TypeRef> { true, mv$(fcn_type) }
+                                ::HIR::VisEnt< ::HIR::TypeRef> { ::HIR::Publicity::new_global(), mv$(fcn_type) }
                                 ) );
                             ),
                         (Static,
@@ -204,11 +204,11 @@ namespace {
             ft.m_abi = ABI_RUST;
             ft.m_rettype.reset( new ::HIR::TypeRef(::HIR::TypeRef::new_unit()) );
             ft.m_arg_types.push_back( ::HIR::TypeRef::new_pointer(::HIR::BorrowType::Owned, ::HIR::TypeRef::new_unit()) );
-            vtc.fields.push_back(::std::make_pair( "#drop_glue", ::HIR::VisEnt<::HIR::TypeRef> { false, ::HIR::TypeRef(mv$(ft)) } ));
+            vtc.fields.push_back(::std::make_pair( "#drop_glue", ::HIR::VisEnt<::HIR::TypeRef> { ::HIR::Publicity::new_none(), ::HIR::TypeRef(mv$(ft)) } ));
             // - Size of data
-            vtc.fields.push_back(::std::make_pair( "#size", ::HIR::VisEnt<::HIR::TypeRef> { false, ::HIR::CoreType::Usize } ));
+            vtc.fields.push_back(::std::make_pair( "#size", ::HIR::VisEnt<::HIR::TypeRef> { ::HIR::Publicity::new_none(), ::HIR::CoreType::Usize } ));
             // - Alignment of data
-            vtc.fields.push_back(::std::make_pair( "#align", ::HIR::VisEnt<::HIR::TypeRef> { false, ::HIR::CoreType::Usize } ));
+            vtc.fields.push_back(::std::make_pair( "#align", ::HIR::VisEnt<::HIR::TypeRef> { ::HIR::Publicity::new_none(), ::HIR::CoreType::Usize } ));
             // - Add methods
             if( ! vtc.add_ents_from_trait(tr, trait_path) )
             {
diff --git a/src/hir_typeck/expr_cs.cpp b/src/hir_typeck/expr_cs.cpp
index 762adf5a..1fd44698 100644
--- a/src/hir_typeck/expr_cs.cpp
+++ b/src/hir_typeck/expr_cs.cpp
@@ -156,9 +156,9 @@ struct Context
 
     const ::HIR::SimplePath m_lang_Box;
 
-    Context(const ::HIR::Crate& crate, const ::HIR::GenericParams* impl_params, const ::HIR::GenericParams* item_params):
+    Context(const ::HIR::Crate& crate, const ::HIR::GenericParams* impl_params, const ::HIR::GenericParams* item_params, const ::HIR::SimplePath& mod_path):
         m_crate(crate),
-        m_resolve(m_ivars, crate, impl_params, item_params)
+        m_resolve(m_ivars, crate, impl_params, item_params, mod_path)
         ,next_rule_idx( 0 )
         ,m_lang_Box( crate.get_lang_item_path_opt("owned_box") )
     {
@@ -8062,7 +8062,8 @@ void Typecheck_Code_CS(const typeck::ModuleState& ms, t_args& args, const ::HIR:
     TRACE_FUNCTION;
 
     auto root_ptr = expr.into_unique();
-    Context context { ms.m_crate, ms.m_impl_generics, ms.m_item_generics };
+    assert(!ms.m_mod_paths.empty());
+    Context context { ms.m_crate, ms.m_impl_generics, ms.m_item_generics, ms.m_mod_paths.back() };
 
     for( auto& arg : args ) {
         context.handle_pattern( Span(), arg.first, arg.second );
diff --git a/src/hir_typeck/expr_visit.cpp b/src/hir_typeck/expr_visit.cpp
index 1a153aaf..d713c135 100644
--- a/src/hir_typeck/expr_visit.cpp
+++ b/src/hir_typeck/expr_visit.cpp
@@ -36,7 +36,7 @@ namespace {
     public:
         void visit_module(::HIR::ItemPath p, ::HIR::Module& mod) override
         {
-            m_ms.push_traits(mod);
+            m_ms.push_traits(p, mod);
             ::HIR::Visitor::visit_module(p, mod);
             m_ms.pop_traits(mod);
         }
@@ -58,7 +58,7 @@ namespace {
             auto _ = this->m_ms.set_impl_generics(impl.m_params);
 
             const auto& mod = this->m_ms.m_crate.get_mod_by_path(Span(), impl.m_src_module);
-            m_ms.push_traits(mod);
+            m_ms.push_traits(impl.m_src_module, mod);
             ::HIR::Visitor::visit_type_impl(impl);
             m_ms.pop_traits(mod);
         }
@@ -68,7 +68,7 @@ namespace {
             auto _ = this->m_ms.set_impl_generics(impl.m_params);
 
             const auto& mod = this->m_ms.m_crate.get_mod_by_path(Span(), impl.m_src_module);
-            m_ms.push_traits(mod);
+            m_ms.push_traits(impl.m_src_module, mod);
             m_ms.m_traits.push_back( ::std::make_pair( &trait_path, &this->m_ms.m_crate.get_trait_by_path(Span(), trait_path) ) );
             ::HIR::Visitor::visit_trait_impl(trait_path, impl);
             m_ms.m_traits.pop_back( );
@@ -80,7 +80,7 @@ namespace {
             auto _ = this->m_ms.set_impl_generics(impl.m_params);
 
             const auto& mod = this->m_ms.m_crate.get_mod_by_path(Span(), impl.m_src_module);
-            m_ms.push_traits(mod);
+            m_ms.push_traits(impl.m_src_module, mod);
             ::HIR::Visitor::visit_marker_impl(trait_path, impl);
             m_ms.pop_traits(mod);
         }
diff --git a/src/hir_typeck/expr_visit.hpp b/src/hir_typeck/expr_visit.hpp
index 21a775dc..9388b1dd 100644
--- a/src/hir_typeck/expr_visit.hpp
+++ b/src/hir_typeck/expr_visit.hpp
@@ -5,6 +5,7 @@
  * hir_typeck/expr_visit.hpp
  * - Helpers for the HIR typecheck expression visiting
  */
+#include <hir/item_path.hpp>
 
 namespace typeck {
     struct ModuleState
@@ -15,6 +16,7 @@ namespace typeck {
         ::HIR::GenericParams*   m_item_generics;
 
         ::std::vector< ::std::pair< const ::HIR::SimplePath*, const ::HIR::Trait* > >   m_traits;
+        ::std::vector<HIR::SimplePath>  m_mod_paths;
 
         ModuleState(const ::HIR::Crate& crate):
             m_crate(crate),
@@ -44,8 +46,9 @@ namespace typeck {
             return NullOnDrop< ::HIR::GenericParams>(m_item_generics);
         }
 
-        void push_traits(const ::HIR::Module& mod) {
+        void push_traits(::HIR::ItemPath p, const ::HIR::Module& mod) {
             auto sp = Span();
+            m_mod_paths.push_back( p.get_simple_path() );
             DEBUG("Module has " << mod.m_traits.size() << " in-scope traits");
             // - Push a NULL entry to prevent parent module import lists being searched
             m_traits.push_back( ::std::make_pair(nullptr, nullptr) );
@@ -59,6 +62,7 @@ namespace typeck {
             for(unsigned int i = 0; i < mod.m_traits.size(); i ++ )
                 m_traits.pop_back();
             m_traits.pop_back();
+            m_mod_paths.pop_back();
         }
     };
 }
diff --git a/src/hir_typeck/helpers.cpp b/src/hir_typeck/helpers.cpp
index f94cdf26..0ebb9c07 100644
--- a/src/hir_typeck/helpers.cpp
+++ b/src/hir_typeck/helpers.cpp
@@ -4334,8 +4334,8 @@ bool TraitResolution::find_field(const Span& sp, const ::HIR::TypeRef& ty, const
             (Tuple,
                 for( unsigned int i = 0; i < se.size(); i ++ )
                 {
-                    // TODO: Privacy
-                    if( FMT(i) == name ) {
+                    DEBUG(i << ": " << se[i].publicity);
+                    if( se[i].publicity.is_visible(this->m_vis_path) && FMT(i) == name ) {
                         field_ty = monomorphise_type_with(sp, se[i].ent, monomorph);
                         return true;
                     }
@@ -4344,8 +4344,8 @@ bool TraitResolution::find_field(const Span& sp, const ::HIR::TypeRef& ty, const
             (Named,
                 for( const auto& fld : se )
                 {
-                    // TODO: Privacy
-                    if( fld.first == name ) {
+                    DEBUG(fld.first << ": " << fld.second.publicity << ", " << this->m_vis_path);
+                    if( fld.second.publicity.is_visible(this->m_vis_path) && fld.first == name ) {
                         field_ty = monomorphise_type_with(sp, fld.second.ent, monomorph);
                         return true;
                     }
@@ -4379,7 +4379,7 @@ bool TraitResolution::find_field(const Span& sp, const ::HIR::TypeRef& ty, const
             for( const auto& fld : unm.m_variants )
             {
                 // TODO: Privacy
-                if( fld.first == name ) {
+                if( fld.second.publicity.is_visible(this->m_vis_path) && fld.first == name ) {
                     field_ty = monomorphise_type_with(sp, fld.second.ent, monomorph);
                     return true;
                 }
diff --git a/src/hir_typeck/helpers.hpp b/src/hir_typeck/helpers.hpp
index 651a36c8..dd9a1581 100644
--- a/src/hir_typeck/helpers.hpp
+++ b/src/hir_typeck/helpers.hpp
@@ -150,17 +150,19 @@ class TraitResolution
     const ::HIR::Crate& m_crate;
     const ::HIR::GenericParams* m_impl_params;
     const ::HIR::GenericParams* m_item_params;
+    const ::HIR::SimplePath&    m_vis_path;
 
     ::std::map< ::HIR::TypeRef, ::HIR::TypeRef> m_type_equalities;
 
     ::HIR::SimplePath   m_lang_Box;
     mutable ::std::vector< ::HIR::TypeRef>  m_eat_active_stack;
 public:
-    TraitResolution(const HMTypeInferrence& ivars, const ::HIR::Crate& crate, const ::HIR::GenericParams* impl_params, const ::HIR::GenericParams* item_params):
+    TraitResolution(const HMTypeInferrence& ivars, const ::HIR::Crate& crate, const ::HIR::GenericParams* impl_params, const ::HIR::GenericParams* item_params, const ::HIR::SimplePath& vis_path):
         m_ivars(ivars),
         m_crate(crate),
         m_impl_params( impl_params ),
         m_item_params( item_params )
+        ,m_vis_path(vis_path)
     {
         prep_indexes();
         m_lang_Box = crate.get_lang_item_path_opt("owned_box");
diff --git a/src/resolve/index.cpp b/src/resolve/index.cpp
index f010b420..f38219ef 100644
--- a/src/resolve/index.cpp
+++ b/src/resolve/index.cpp
@@ -286,7 +286,7 @@ void Resolve_Index_Module_Wildcard__glob_in_hir_mod(const Span& sp, const AST::C
 {
     for(const auto& it : hmod.m_mod_items) {
         const auto& ve = *it.second;
-        if( ve.is_public ) {
+        if( ve.publicity.is_global() ) {
             const auto* vep = &ve.ent;
             AST::Path   p;
             if( vep->is_Import() ) {
@@ -346,7 +346,7 @@ void Resolve_Index_Module_Wildcard__glob_in_hir_mod(const Span& sp, const AST::C
     }
     for(const auto& it : hmod.m_value_items) {
         const auto& ve = *it.second;
-        if( ve.is_public ) {
+        if( ve.publicity.is_global() ) {
             AST::Path   p;
             const auto* vep = &ve.ent;
             if( ve.ent.is_Import() ) {
diff --git a/src/trans/enumerate.cpp b/src/trans/enumerate.cpp
index e1e2bbd5..afdbd626 100644
--- a/src/trans/enumerate.cpp
+++ b/src/trans/enumerate.cpp
@@ -152,14 +152,14 @@ namespace {
         const bool EMIT_ALL = true;
         for(auto& vi : mod.m_value_items)
         {
-            Trans_Enumerate_ValItem(state, vi.second->ent, EMIT_ALL || (is_visible && vi.second->is_public), [&](){ return mod_path + vi.first; });
+            Trans_Enumerate_ValItem(state, vi.second->ent, EMIT_ALL || (is_visible && vi.second->publicity.is_global()), [&](){ return mod_path + vi.first; });
         }
 
         for(auto& ti : mod.m_mod_items)
         {
             if(auto* e = ti.second->ent.opt_Module() )
             {
-                Trans_Enumerate_Public_Mod(state, *e, mod_path + ti.first, ti.second->is_public);
+                Trans_Enumerate_Public_Mod(state, *e, mod_path + ti.first, ti.second->publicity.is_global());
             }
         }
     }