All - Switch to using interned (de-duplicated) RcString-s instead of std::string for paths/identifiers

16 files changed, 121 insertions, 130 deletions

diff --git a/src/ast/ast.cpp b/src/ast/ast.cpp
index 03257fc6..f1a68680 100644
--- a/src/ast/ast.cpp
+++ b/src/ast/ast.cpp
@@ -107,16 +107,16 @@ Function Function::clone() const
     return rv;
 }
 
-void Trait::add_type(::std::string name, AttributeList attrs, TypeRef type) {
+void Trait::add_type(RcString name, AttributeList attrs, TypeRef type) {
     m_items.push_back( Named<Item>(mv$(name), Item::make_Type({TypeAlias(GenericParams(), mv$(type))}), true) );
     m_items.back().data.attrs = mv$(attrs);
 }
-void Trait::add_function(::std::string name, AttributeList attrs, Function fcn) {
+void Trait::add_function(RcString name, AttributeList attrs, Function fcn) {
     DEBUG("trait fn " << name);
     m_items.push_back( Named<Item>(mv$(name), Item::make_Function({mv$(fcn)}), true) );
     m_items.back().data.attrs = mv$(attrs);
 }
-void Trait::add_static(::std::string name, AttributeList attrs, Static v) {
+void Trait::add_static(RcString name, AttributeList attrs, Static v) {
     m_items.push_back( Named<Item>(mv$(name), Item::make_Static({mv$(v)}), true) );
     m_items.back().data.attrs = mv$(attrs);
 }
@@ -126,7 +126,7 @@ void Trait::set_is_marker() {
 bool Trait::is_marker() const {
     return m_is_marker;
 }
-bool Trait::has_named_item(const ::std::string& name, bool& out_is_fcn) const
+bool Trait::has_named_item(const RcString& name, bool& out_is_fcn) const
 {
     for( const auto& i : m_items )
     {
@@ -208,16 +208,16 @@ Union Union::clone() const
     return os << "impl<" << impl.m_params << "> " << impl.m_trait.ent << " for " << impl.m_type << "";
 }
 
-void Impl::add_function(bool is_public, bool is_specialisable, ::std::string name, Function fcn)
+void Impl::add_function(bool is_public, bool is_specialisable, RcString name, Function fcn)
 {
     DEBUG("impl fn " << name);
     m_items.push_back( ImplItem { is_public, is_specialisable, mv$(name), box$( Item::make_Function(mv$(fcn)) ) } );
 }
-void Impl::add_type(bool is_public, bool is_specialisable, ::std::string name, TypeRef type)
+void Impl::add_type(bool is_public, bool is_specialisable, RcString name, TypeRef type)
 {
     m_items.push_back( ImplItem { is_public, is_specialisable, mv$(name), box$( Item::make_Type(TypeAlias(GenericParams(), mv$(type))) ) } );
 }
-void Impl::add_static(bool is_public, bool is_specialisable, ::std::string name, Static v)
+void Impl::add_static(bool is_public, bool is_specialisable, RcString name, Static v)
 {
     m_items.push_back( ImplItem { is_public, is_specialisable, mv$(name), box$( Item::make_Static(mv$(v)) ) } );
 }
@@ -225,7 +225,7 @@ void Impl::add_macro_invocation(MacroInvocation item) {
     m_items.push_back( ImplItem { false, false, "", box$( Item::make_MacroInv(mv$(item)) ) } );
 }
 
-bool Impl::has_named_item(const ::std::string& name) const
+bool Impl::has_named_item(const RcString& name) const
 {
     for( const auto& it : this->items() )
     {
@@ -271,7 +271,7 @@ ExternBlock ExternBlock::clone() const
 }
 
 ::std::shared_ptr<AST::Module> Module::add_anon() {
-    auto rv = ::std::shared_ptr<AST::Module>( new Module(m_my_path + FMT("#" << m_anon_modules.size())) );
+    auto rv = ::std::shared_ptr<AST::Module>( new Module(m_my_path + RcString::new_interned(FMT("#" << m_anon_modules.size()))) );
     DEBUG("New anon " << rv->m_my_path);
     rv->m_file_info = m_file_info;
 
@@ -289,20 +289,20 @@ void Module::add_item( Named<Item> named_item ) {
         DEBUG(m_my_path << "::" << i.name << " = " << i.data.tag_str() << ", attrs = " << i.data.attrs);
     }
 }
-void Module::add_item(bool is_pub, ::std::string name, Item it, AttributeList attrs) {
+void Module::add_item(bool is_pub, RcString name, Item it, AttributeList attrs) {
     it.attrs = mv$(attrs);
     add_item( Named<Item>( mv$(name), mv$(it), is_pub ) );
 }
-void Module::add_ext_crate(bool is_public, ::std::string ext_name, ::std::string imp_name, AttributeList attrs) {
+void Module::add_ext_crate(bool is_public, RcString ext_name, RcString imp_name, AttributeList attrs) {
     this->add_item( is_public, imp_name, Item::make_Crate({mv$(ext_name)}), mv$(attrs) );
 }
 void Module::add_macro_invocation(MacroInvocation item) {
     this->add_item( false, "", Item( mv$(item) ), ::AST::AttributeList {} );
 }
-void Module::add_macro(bool is_exported, ::std::string name, MacroRulesPtr macro) {
+void Module::add_macro(bool is_exported, RcString name, MacroRulesPtr macro) {
     m_macros.push_back( Named<MacroRulesPtr>( mv$(name), mv$(macro), is_exported ) );
 }
-void Module::add_macro_import(::std::string name, const MacroRules& mr) {
+void Module::add_macro_import(RcString name, const MacroRules& mr) {
     m_macro_import_res.push_back( Named<const MacroRules*>( mv$(name), &mr, false ) );
 }
 
diff --git a/src/ast/ast.hpp b/src/ast/ast.hpp
index f6f97fce..bfef9cff 100644
--- a/src/ast/ast.hpp
+++ b/src/ast/ast.hpp
@@ -58,12 +58,12 @@ struct StructItem
 {
     ::AST::AttributeList   m_attrs;
     bool    m_is_public;
-    ::std::string   m_name;
+    RcString   m_name;
     TypeRef m_type;
 
     //StructItem() {}
 
-    StructItem(::AST::AttributeList attrs, bool is_pub, ::std::string name, TypeRef ty):
+    StructItem(::AST::AttributeList attrs, bool is_pub, RcString name, TypeRef ty):
         m_attrs( mv$(attrs) ),
         m_is_public(is_pub),
         m_name( mv$(name) ),
@@ -222,16 +222,16 @@ public:
     const NamedList<Item>& items() const { return m_items; }
           NamedList<Item>& items()       { return m_items; }
 
-    void add_type(::std::string name, AttributeList attrs, TypeRef type);
-    void add_function(::std::string name, AttributeList attrs, Function fcn);
-    void add_static(::std::string name, AttributeList attrs, Static v);
+    void add_type(RcString name, AttributeList attrs, TypeRef type);
+    void add_function(RcString name, AttributeList attrs, Function fcn);
+    void add_static(RcString name, AttributeList attrs, Static v);
 
     void set_is_marker();
     bool is_marker() const;
     void set_is_unsafe() { m_is_unsafe = true; }
     bool is_unsafe() const { return m_is_unsafe; }
 
-    bool has_named_item(const ::std::string& name, bool& out_is_fcn) const;
+    bool has_named_item(const RcString& name, bool& out_is_fcn) const;
 
     Trait clone() const;
 };
@@ -257,28 +257,28 @@ TAGGED_UNION_EX(EnumVariantData, (), Value,
 struct EnumVariant
 {
     AttributeList   m_attrs;
-    ::std::string   m_name;
+    RcString   m_name;
     EnumVariantData m_data;
 
     EnumVariant()
     {
     }
 
-    EnumVariant(AttributeList attrs, ::std::string name, Expr&& value):
+    EnumVariant(AttributeList attrs, RcString name, Expr&& value):
         m_attrs( mv$(attrs) ),
         m_name( mv$(name) ),
         m_data( EnumVariantData::make_Value({mv$(value)}) )
     {
     }
 
-    EnumVariant(AttributeList attrs, ::std::string name, ::std::vector<TypeRef> sub_types):
+    EnumVariant(AttributeList attrs, RcString name, ::std::vector<TypeRef> sub_types):
         m_attrs( mv$(attrs) ),
         m_name( ::std::move(name) ),
         m_data( EnumVariantData::make_Tuple( {mv$(sub_types)} ) )
     {
     }
 
-    EnumVariant(AttributeList attrs, ::std::string name, ::std::vector<StructItem> fields):
+    EnumVariant(AttributeList attrs, RcString name, ::std::vector<StructItem> fields):
         m_attrs( mv$(attrs) ),
         m_name( ::std::move(name) ),
         m_data( EnumVariantData::make_Struct( {mv$(fields)} ) )
@@ -425,7 +425,7 @@ public:
     struct ImplItem {
         bool    is_pub; // Ignored for trait impls
         bool    is_specialisable;
-        ::std::string   name;
+        RcString   name;
 
         ::std::unique_ptr<Item> data;
     };
@@ -445,9 +445,9 @@ public:
     {}
     Impl& operator=(Impl&&) = default;
 
-    void add_function(bool is_public, bool is_specialisable, ::std::string name, Function fcn);
-    void add_type(bool is_public, bool is_specialisable, ::std::string name, TypeRef type);
-    void add_static(bool is_public, bool is_specialisable, ::std::string name, Static v);
+    void add_function(bool is_public, bool is_specialisable, RcString name, Function fcn);
+    void add_type(bool is_public, bool is_specialisable, RcString name, TypeRef type);
+    void add_static(bool is_public, bool is_specialisable, RcString name, Static v);
     void add_macro_invocation( MacroInvocation inv );
 
     const ImplDef& def() const { return m_def; }
@@ -455,7 +455,7 @@ public:
     const ::std::vector<ImplItem>& items() const { return m_items; }
           ::std::vector<ImplItem>& items()       { return m_items; }
 
-    bool has_named_item(const ::std::string& name) const;
+    bool has_named_item(const RcString& name) const;
 
     friend ::std::ostream& operator<<(::std::ostream& os, const Impl& impl);
 
@@ -468,7 +468,7 @@ struct UseItem
     struct Ent {
         Span    sp; // Span covering just the path (final component)
         ::AST::Path path;
-        ::std::string   name;   // If "", this is a glob/wildcard use
+        RcString   name;   // If "", this is a glob/wildcard use
     };
     ::std::vector<Ent>  entries;
 
@@ -533,23 +533,23 @@ public:
     };
 
     // TODO: Document difference between namespace and Type
-    ::std::unordered_map< ::std::string, IndexEnt >    m_namespace_items;
-    ::std::unordered_map< ::std::string, IndexEnt >    m_type_items;
-    ::std::unordered_map< ::std::string, IndexEnt >    m_value_items;
+    ::std::unordered_map< RcString, IndexEnt >    m_namespace_items;
+    ::std::unordered_map< RcString, IndexEnt >    m_type_items;
+    ::std::unordered_map< RcString, IndexEnt >    m_value_items;
 
     // List of macros imported from other modules (via #[macro_use], includes proc macros)
     // - First value is an absolute path to the macro (including crate name)
     struct MacroImport {
         bool    is_pub;
-        ::std::string   name;   // Can be different, if `use foo as bar` is used
-        ::std::vector<::std::string>    path;   // includes the crate name
+        RcString   name;   // Can be different, if `use foo as bar` is used
+        ::std::vector<RcString>    path;   // includes the crate name
         const MacroRules*   macro_ptr;
     };
     ::std::vector<MacroImport>  m_macro_imports;
 
     struct Import {
         bool    is_pub;
-        ::std::string   name;
+        RcString   name;
         ::AST::Path path;   // If `name` is "", then this is a module/enum to glob
     };
     ::std::vector<Import>   m_item_imports;
@@ -562,19 +562,19 @@ public:
     }
 
     bool is_anon() const {
-        return m_my_path.nodes().size() > 0 && m_my_path.nodes().back().name()[0] == '#';
+        return m_my_path.nodes().size() > 0 && m_my_path.nodes().back().name().c_str()[0] == '#';
     }
 
     /// Create an anon module (for use inside expressions)
     ::std::shared_ptr<AST::Module> add_anon();
 
     void add_item(Named<Item> item);
-    void add_item(bool is_pub, ::std::string name, Item it, AttributeList attrs);
-    void add_ext_crate(bool is_public, ::std::string ext_name, ::std::string imp_name, AttributeList attrs);
+    void add_item(bool is_pub, RcString name, Item it, AttributeList attrs);
+    void add_ext_crate(bool is_public, RcString ext_name, RcString imp_name, AttributeList attrs);
     void add_macro_invocation(MacroInvocation item);
 
-    void add_macro(bool is_exported, ::std::string name, MacroRulesPtr macro);
-    void add_macro_import(::std::string name, const MacroRules& mr);
+    void add_macro(bool is_exported, RcString name, MacroRulesPtr macro);
+    void add_macro_import(RcString name, const MacroRules& mr);
 
 
 
@@ -590,9 +590,6 @@ public:
           NamedList<MacroRulesPtr>&    macros()        { return m_macros; }
     const NamedList<MacroRulesPtr>&    macros()  const { return m_macros; }
     const ::std::vector<Named<const MacroRules*> >  macro_imports_res() const { return m_macro_import_res; }
-
-private:
-    void resolve_macro_import(const Crate& crate, const ::std::string& modname, const ::std::string& macro_name);
 };
 
 TAGGED_UNION_EX(Item, (), None,
@@ -610,7 +607,7 @@ TAGGED_UNION_EX(Item, (), None,
     (Macro, MacroRulesPtr),
     (Module, Module),
     (Crate, struct {
-        ::std::string   name;
+        RcString   name;
         }),
 
     (Type, TypeAlias),
diff --git a/src/ast/attrs.hpp b/src/ast/attrs.hpp
index a15b4175..04328130 100644
--- a/src/ast/attrs.hpp
+++ b/src/ast/attrs.hpp
@@ -74,24 +74,24 @@ TAGGED_UNION(AttributeData, None,
 class Attribute
 {
     Span    m_span;
-    ::std::string   m_name;
+    RcString   m_name;
     AttributeData   m_data;
     mutable bool    m_is_used;
     // TODO: Parse as a TT then expand?
 public:
-    Attribute(Span sp, ::std::string name):
+    Attribute(Span sp, RcString name):
         m_span(::std::move(sp)),
         m_name(name),
         m_data( AttributeData::make_None({}) )
     {
     }
-    Attribute(Span sp, ::std::string name, ::std::string str_val):
+    Attribute(Span sp, RcString name, ::std::string str_val):
         m_span(::std::move(sp)),
         m_name(name),
         m_data( AttributeData::make_String({mv$(str_val)}) )
     {
     }
-    Attribute(Span sp, ::std::string name, ::std::vector<Attribute> items):
+    Attribute(Span sp, RcString name, ::std::vector<Attribute> items):
         m_span(::std::move(sp)),
         m_name(name),
         m_data( AttributeData::make_List({mv$(items)}) )
@@ -123,7 +123,7 @@ public:
     bool is_used() const { return m_is_used; }
 
     const Span& span() const { return m_span; }
-    const ::std::string& name() const { return m_name; }
+    const RcString& name() const { return m_name; }
     const AttributeData& data() const { return m_data; }
 
     // Legacy accessors/checkers
diff --git a/src/ast/crate.cpp b/src/ast/crate.cpp
index 5717cbdb..c9856781 100644
--- a/src/ast/crate.cpp
+++ b/src/ast/crate.cpp
@@ -64,7 +64,7 @@ void Crate::load_externs()
             TU_IFLET(AST::Item, it.data, Crate, c,
                 if( check_item_cfg(it.data.attrs) )
                 {
-                    c.name = load_extern_crate( it.data.span, c.name );
+                    c.name = load_extern_crate( it.data.span, c.name.c_str() );
                 }
             )
         }
@@ -109,12 +109,12 @@ void Crate::load_externs()
 }
 // TODO: Handle disambiguating crates with the same name (e.g. libc in std and crates.io libc)
 // - Crates recorded in rlibs should specify a hash/tag that's passed in to this function.
-::std::string Crate::load_extern_crate(Span sp, const ::std::string& name, const ::std::string& basename/*=""*/)
+RcString Crate::load_extern_crate(Span sp, const RcString& name, const ::std::string& basename/*=""*/)
 {
     DEBUG("Loading crate '" << name << "'");
 
     ::std::string   path;
-    auto it = g_crate_overrides.find(name);
+    auto it = g_crate_overrides.find(name.c_str());
     if(basename == "" && it != g_crate_overrides.end())
     {
         path = it->second;
@@ -140,18 +140,19 @@ void Crate::load_externs()
     else
     {
         ::std::vector<::std::string>    paths;
-        auto name_prefix = "lib"+name+"-";
+        auto direct_filename = FMT("lib" << name.c_str() << ".hir");
+        auto name_prefix = FMT("lib" << name.c_str() << "-");
         // Search a list of load paths for the crate
         for(const auto& p : g_crate_load_dirs)
         {
 
-            path = p + "/lib" + name + ".hir";
-            // TODO: Search for `p+"/lib"+name+"-*.hir" (which would match e.g. libnum-0.11.hir)
+            path = p + "/" + direct_filename;
             if( ::std::ifstream(path).good() ) {
                 paths.push_back(path);
             }
             path = "";
 
+            // Search for `p+"/lib"+name+"-*.hir" (which would match e.g. libnum-0.11.hir)
             auto dp = opendir(p.c_str());
             if( !dp ) {
                 continue ;
@@ -187,7 +188,7 @@ void Crate::load_externs()
     // NOTE: Creating `ExternCrate` loads the crate from the specified path
     auto ec = ExternCrate { name, path };
     auto real_name = ec.m_hir->m_crate_name;
-    assert(!real_name.empty());
+    assert(real_name != "");
     auto res = m_extern_crates.insert(::std::make_pair( real_name, mv$(ec) ));
     if( !res.second ) {
         // Crate already loaded?
@@ -214,26 +215,26 @@ void Crate::load_externs()
     return real_name;
 }
 
-ExternCrate::ExternCrate(const ::std::string& name, const ::std::string& path):
+ExternCrate::ExternCrate(const RcString& name, const ::std::string& path):
     m_name(name),
     m_short_name(name),
     m_filename(path)
 {
     TRACE_FUNCTION_F("name=" << name << ", path='" << path << "'");
-    m_hir = HIR_Deserialise(path, name);
+    m_hir = HIR_Deserialise(path);
 
     m_hir->post_load_update(name);
     m_name = m_hir->m_crate_name;
 }
 
-void ExternCrate::with_all_macros(::std::function<void(const ::std::string& , const MacroRules&)> cb) const
+void ExternCrate::with_all_macros(::std::function<void(const RcString& , const MacroRules&)> cb) const
 {
     for(const auto& m : m_hir->m_exported_macros)
     {
         cb(m.first, *m.second);
     }
 }
-const MacroRules* ExternCrate::find_macro_rules(const ::std::string& name) const
+const MacroRules* ExternCrate::find_macro_rules(const RcString& name) const
 {
     auto i = m_hir->m_exported_macros.find(name);
     if(i != m_hir->m_exported_macros.end())
diff --git a/src/ast/crate.hpp b/src/ast/crate.hpp
index 79cb9cd7..c4e1d5df 100644
--- a/src/ast/crate.hpp
+++ b/src/ast/crate.hpp
@@ -36,7 +36,7 @@ public:
 class ProcMacroDef
 {
 public:
-    ::std::string   name;
+    RcString    name;
     ::AST::Path path;
     ::std::vector<::std::string>    attributes;
 };
@@ -49,9 +49,9 @@ public:
     ::std::map< ::std::string, ::AST::Path> m_lang_items;
 public:
     Module  m_root_module;
-    ::std::map< ::std::string, ExternCrate> m_extern_crates;
+    ::std::map< RcString, ExternCrate> m_extern_crates;
     // Mapping filled by searching for (?visible) macros with is_pub=true
-    ::std::map< ::std::string, const MacroRules*> m_exported_macros;
+    ::std::map< RcString, const MacroRules*> m_exported_macros;
 
     // List of tests (populated in expand if --test is passed)
     bool    m_test_harness = false;
@@ -91,27 +91,27 @@ public:
 
     /// Load the named crate and returns the crate's unique name
     /// If the parameter `file` is non-empty, only that particular filename will be loaded (from any of the search paths)
-    ::std::string load_extern_crate(Span sp, const ::std::string& name, const ::std::string& file="");
+    RcString load_extern_crate(Span sp, const RcString& name, const ::std::string& file="");
 };
 
 /// Representation of an imported crate
 class ExternCrate
 {
 public:
-    ::std::string   m_name;
-    ::std::string   m_short_name;
+    RcString    m_name;
+    RcString    m_short_name;
     ::std::string   m_filename;
     ::HIR::CratePtr m_hir;
 
-    ExternCrate(const ::std::string& name, const ::std::string& path);
+    ExternCrate(const RcString& name, const ::std::string& path);
 
     ExternCrate(ExternCrate&&) = default;
     ExternCrate& operator=(ExternCrate&&) = default;
     ExternCrate(const ExternCrate&) = delete;
     ExternCrate& operator=(const ExternCrate& ) = delete;
 
-    void with_all_macros(::std::function<void(const ::std::string& , const MacroRules&)> cb) const;
-    const MacroRules* find_macro_rules(const ::std::string& name) const;
+    void with_all_macros(::std::function<void(const RcString& , const MacroRules&)> cb) const;
+    const MacroRules* find_macro_rules(const RcString& name) const;
 };
 
 extern ::std::vector<::std::string>    g_crate_load_dirs;
diff --git a/src/ast/dump.cpp b/src/ast/dump.cpp
index 00848fb5..9fb34099 100644
--- a/src/ast/dump.cpp
+++ b/src/ast/dump.cpp
@@ -36,7 +36,7 @@ public:
     void handle_enum(const AST::Enum& s);
     void handle_trait(const AST::Trait& s);
 
-    void handle_function(bool is_pub, const ::std::string& name, const AST::Function& f);
+    void handle_function(bool is_pub, const RcString& name, const AST::Function& f);
 
     virtual bool is_const() const override { return true; }
     virtual void visit(AST::ExprNode_Block& n) override {
@@ -1133,7 +1133,7 @@ void RustPrinter::handle_trait(const AST::Trait& s)
     m_os << "\n";
 }
 
-void RustPrinter::handle_function(bool is_pub, const ::std::string& name, const AST::Function& f)
+void RustPrinter::handle_function(bool is_pub, const RcString& name, const AST::Function& f)
 {
     m_os << indent();
     m_os << (is_pub ? "pub " : "");
diff --git a/src/ast/expr.hpp b/src/ast/expr.hpp
index 7675b29a..a9c82efa 100644
--- a/src/ast/expr.hpp
+++ b/src/ast/expr.hpp
@@ -90,11 +90,11 @@ struct ExprNode_Try:
 struct ExprNode_Macro:
     public ExprNode
 {
-    ::std::string   m_name;
-    ::std::string   m_ident;
+    RcString   m_name;
+    RcString   m_ident;
     ::TokenTree m_tokens;
 
-    ExprNode_Macro(::std::string name, ::std::string ident, ::TokenTree&& tokens):
+    ExprNode_Macro(RcString name, RcString ident, ::TokenTree&& tokens):
         m_name(name),
         m_ident(ident),
         m_tokens( move(tokens) )
@@ -140,10 +140,10 @@ struct ExprNode_Flow:
         CONTINUE,
         BREAK,
     } m_type;
-    ::std::string   m_target;
+    RcString   m_target;
     unique_ptr<ExprNode>    m_value;
 
-    ExprNode_Flow(Type type, ::std::string target, unique_ptr<ExprNode>&& value):
+    ExprNode_Flow(Type type, RcString target, unique_ptr<ExprNode>&& value):
         m_type(type),
         m_target( move(target) ),
         m_value( move(value) )
@@ -245,24 +245,24 @@ struct ExprNode_Loop:
         WHILELET,
         FOR,
     } m_type;
-    ::std::string   m_label;
+    RcString   m_label;
     AST::Pattern    m_pattern;
     unique_ptr<ExprNode>    m_cond; // if NULL, loop is a 'loop'
     unique_ptr<ExprNode>    m_code;
 
     ExprNode_Loop(): m_type(LOOP) {}
-    ExprNode_Loop(::std::string label, unique_ptr<ExprNode> code):
+    ExprNode_Loop(RcString label, unique_ptr<ExprNode> code):
         m_type(LOOP),
         m_label( ::std::move(label) ),
         m_code( ::std::move(code) )
     {}
-    ExprNode_Loop(::std::string label, unique_ptr<ExprNode> cond, unique_ptr<ExprNode> code):
+    ExprNode_Loop(RcString label, unique_ptr<ExprNode> cond, unique_ptr<ExprNode> code):
         m_type(WHILE),
         m_label( ::std::move(label) ),
         m_cond( ::std::move(cond) ),
         m_code( ::std::move(code) )
     {}
-    ExprNode_Loop(::std::string label, Type type, AST::Pattern pattern, unique_ptr<ExprNode> val, unique_ptr<ExprNode> code):
+    ExprNode_Loop(RcString label, Type type, AST::Pattern pattern, unique_ptr<ExprNode> val, unique_ptr<ExprNode> code):
         m_type(type),
         m_label( ::std::move(label) ),
         m_pattern( ::std::move(pattern) ),
@@ -430,7 +430,7 @@ struct ExprNode_StructLiteral:
 {
     struct Ent {
         AttributeList   attrs;
-        ::std::string   name;
+        RcString   name;
         unique_ptr<ExprNode>    value;
     };
     typedef ::std::vector<Ent> t_values;
@@ -493,9 +493,9 @@ struct ExprNode_Field:
     public ExprNode
 {
     ::std::unique_ptr<ExprNode> m_obj;
-    ::std::string   m_name;
+    RcString   m_name;
 
-    ExprNode_Field(::std::unique_ptr<ExprNode>&& obj, ::std::string name):
+    ExprNode_Field(::std::unique_ptr<ExprNode>&& obj, RcString name):
         m_obj( ::std::move(obj) ),
         m_name( ::std::move(name) )
     {
diff --git a/src/ast/generics.hpp b/src/ast/generics.hpp
index c222044c..bfc7080b 100644
--- a/src/ast/generics.hpp
+++ b/src/ast/generics.hpp
@@ -17,7 +17,7 @@ class TypeParam
     ::AST::AttributeList    m_attrs;
     Span    m_span;
     // TODO: use an Ident?
-    ::std::string   m_name;
+    RcString   m_name;
     ::TypeRef m_default;
 public:
     TypeParam(TypeParam&& x) = default;
@@ -30,7 +30,7 @@ public:
     {
     }
 
-    TypeParam(Span sp, ::AST::AttributeList attrs, ::std::string name):
+    TypeParam(Span sp, ::AST::AttributeList attrs, RcString name):
         m_attrs( ::std::move(attrs) ),
         m_span( ::std::move(sp) ),
         m_name( ::std::move(name) ),
@@ -44,7 +44,7 @@ public:
 
     const ::AST::AttributeList& attrs() const { return m_attrs; }
     const Span& span() const { return m_span; }
-    const ::std::string& name() const { return m_name; }
+    const RcString& name() const { return m_name; }
 
     const TypeRef& get_default() const { return m_default; }
           TypeRef& get_default()       { return m_default; }
diff --git a/src/ast/item.hpp b/src/ast/item.hpp
index 0074ce9a..ee83a8db 100644
--- a/src/ast/item.hpp
+++ b/src/ast/item.hpp
@@ -15,7 +15,7 @@ namespace AST {
 template <typename T>
 struct Named
 {
-    ::std::string   name;
+    RcString   name;
     T   data;
     bool    is_pub;
 
@@ -25,7 +25,7 @@ struct Named
     Named(Named&&) = default;
     Named(const Named&) = default;
     Named& operator=(Named&&) = default;
-    Named(::std::string name, T data, bool is_pub):
+    Named(RcString name, T data, bool is_pub):
         name( ::std::move(name) ),
         data( ::std::move(data) ),
         is_pub( is_pub )
diff --git a/src/ast/macro.hpp b/src/ast/macro.hpp
index 5b2223ce..e94de8f1 100644
--- a/src/ast/macro.hpp
+++ b/src/ast/macro.hpp
@@ -18,8 +18,8 @@ class MacroInvocation
 {
     Span    m_span;
 
-    ::std::string   m_macro_name;
-    ::std::string   m_ident;
+    RcString   m_macro_name;
+    RcString   m_ident;
     TokenTree   m_input;
 public:
     MacroInvocation(MacroInvocation&&) = default;
@@ -31,7 +31,7 @@ public:
     {
     }
 
-    MacroInvocation(Span span, ::std::string macro, ::std::string ident, TokenTree input):
+    MacroInvocation(Span span, RcString macro, RcString ident, TokenTree input):
         m_span( mv$(span) ),
         m_macro_name( mv$(macro) ),
         m_ident( mv$(ident) ),
@@ -48,9 +48,9 @@ public:
     }
 
     const Span& span() const { return m_span; }
-    const ::std::string& name() const { return m_macro_name; }
+    const RcString& name() const { return m_macro_name; }
 
-    const ::std::string& input_ident() const { return m_ident; }
+    const RcString& input_ident() const { return m_ident; }
     const TokenTree& input_tt() const { return m_input; }
           TokenTree& input_tt()       { return m_input; }
 
diff --git a/src/ast/path.cpp b/src/ast/path.cpp
index d156f465..830e7372 100644
--- a/src/ast/path.cpp
+++ b/src/ast/path.cpp
@@ -148,7 +148,7 @@ Ordering PathParams::ord(const PathParams& x) const
 }
 
 // --- AST::PathNode
-PathNode::PathNode(::std::string name, PathParams args):
+PathNode::PathNode(RcString name, PathParams args):
     m_name( mv$(name) ),
     m_params( mv$(args) )
 {
@@ -256,7 +256,7 @@ void Path::bind_variable(unsigned int slot)
 {
     m_bindings.value = PathBinding_Value::make_Variable({slot});
 }
-void Path::bind_enum_var(const Enum& ent, const ::std::string& name)
+void Path::bind_enum_var(const Enum& ent, const RcString& name)
 {
     auto it = ::std::find_if(ent.variants().begin(), ent.variants().end(), [&](const auto& x) { return x.m_name == name; });
     if( it == ent.variants().end() )
diff --git a/src/ast/path.hpp b/src/ast/path.hpp
index faa1ffe6..c611c819 100644
--- a/src/ast/path.hpp
+++ b/src/ast/path.hpp
@@ -127,15 +127,15 @@ TAGGED_UNION_EX(PathBinding_Macro, (), Unbound, (
         }),
     (ProcMacroDerive, struct {
         const ExternCrate* crate_;
-        ::std::string   mac_name;
+        RcString mac_name;
         }),
     (ProcMacroAttribute, struct {
         const ExternCrate* crate_;
-        ::std::string   mac_name;
+        RcString mac_name;
         }),
     (ProcMacro, struct {
         const ExternCrate* crate_;
-        ::std::string   mac_name;
+        RcString mac_name;
         }),
     (MacroRules, struct {
         const ExternCrate* crate_;  // Can be NULL
@@ -157,12 +157,12 @@ struct PathParams
 {
     ::std::vector< LifetimeRef >  m_lifetimes;
     ::std::vector< TypeRef >    m_types;
-    ::std::vector< ::std::pair< ::std::string, TypeRef> >   m_assoc;
+    ::std::vector< ::std::pair< RcString, TypeRef> >   m_assoc;
 
     PathParams(PathParams&& x) = default;
     PathParams(const PathParams& x);
     PathParams() {}
-    PathParams(::std::vector<LifetimeRef> lfts, ::std::vector<TypeRef> tys, ::std::vector<::std::pair<::std::string,TypeRef>> a):
+    PathParams(::std::vector<LifetimeRef> lfts, ::std::vector<TypeRef> tys, ::std::vector<::std::pair<RcString,TypeRef>> a):
         m_lifetimes(mv$(lfts)),
         m_types(mv$(tys)),
         m_assoc(mv$(a))
@@ -182,12 +182,12 @@ struct PathParams
 
 class PathNode
 {
-    ::std::string   m_name;
+    RcString    m_name;
     PathParams  m_params;
 public:
     PathNode() {}
-    PathNode(::std::string name, PathParams args = {});
-    const ::std::string& name() const { return m_name; }
+    PathNode(RcString name, PathParams args = {});
+    const RcString& name() const { return m_name; }
 
     const ::AST::PathParams& args() const { return m_params; }
           ::AST::PathParams& args()       { return m_params; }
@@ -205,7 +205,7 @@ public:
     TAGGED_UNION(Class, Invalid,
         (Invalid, struct {}),
         (Local, struct {   // Variable / Type param (resolved)
-            ::std::string name;
+            RcString name;
             } ),
         (Relative, struct {    // General relative
             Ident::Hygiene hygiene;
@@ -219,7 +219,7 @@ public:
             ::std::vector<PathNode> nodes;
             } ),
         (Absolute, struct {    // Absolute
-            ::std::string   crate;
+            RcString    crate;
             ::std::vector<PathNode> nodes;
             } ),
         (UFCS, struct {    // Type-relative
@@ -267,7 +267,7 @@ public:
     Path& operator=(const AST::Path&) = delete;
 
     // ABSOLUTE
-    Path(::std::string crate, ::std::vector<PathNode> nodes):
+    Path(RcString crate, ::std::vector<PathNode> nodes):
         m_class( Class::make_Absolute({ mv$(crate), mv$(nodes)}) )
     {}
 
@@ -278,10 +278,10 @@ public:
 
     // VARIABLE
     struct TagLocal {};
-    Path(TagLocal, ::std::string name):
+    Path(TagLocal, RcString name):
         m_class( Class::make_Local({ mv$(name) }) )
     {}
-    Path(::std::string name):
+    Path(RcString name):
         m_class( Class::make_Local({ mv$(name) }) )
     {}
 
@@ -301,14 +301,6 @@ public:
         m_class( Class::make_Super({ count, mv$(nodes) }) )
     {}
 
-    //void set_crate(::std::string crate) {
-    //    if( m_crate == "" ) {
-    //        m_crate = crate;
-    //        DEBUG("crate set to " << m_crate);
-    //    }
-    //}
-
-
     Class::Tag class_tag() const {
         return m_class.tag();
     }
@@ -318,7 +310,7 @@ public:
         tmp.nodes().push_back( mv$(pn) );
         return tmp;
     }
-    Path operator+(const ::std::string& s) const {
+    Path operator+(const RcString& s) const {
         Path tmp = Path(*this);
         tmp.append(PathNode(s, {}));
         return tmp;
@@ -370,7 +362,6 @@ public:
         )
         throw ::std::runtime_error("Path::nodes() fell off");
     }
-    //const ::std::string& crate() const { return m_crate; }
 
     bool is_parent_of(const Path& x) const;
 
@@ -407,7 +398,7 @@ private:
 
     void check_param_counts(const GenericParams& params, bool expect_params, PathNode& node);
 public:
-    void bind_enum_var(const Enum& ent, const ::std::string& name);
+    void bind_enum_var(const Enum& ent, const RcString& name);
     void bind_function(const Function& ent) {
         m_bindings.value = PathBinding_Value::make_Function({&ent});
     }
diff --git a/src/ast/pattern.cpp b/src/ast/pattern.cpp
index 72087d95..e13662fe 100644
--- a/src/ast/pattern.cpp
+++ b/src/ast/pattern.cpp
@@ -223,7 +223,7 @@ AST::Pattern AST::Pattern::clone() const
         rv.m_data = Data::make_StructTuple({ ::AST::Path(e.path), H::clone_tup(e.tup_pat) });
         ),
     (Struct,
-        ::std::vector< ::std::pair< ::std::string, Pattern> >   sps;
+        ::std::vector< ::std::pair< RcString, Pattern> >   sps;
         for(const auto& sp : e.sub_patterns)
             sps.push_back( ::std::make_pair(sp.first, sp.second.clone()) );
         rv.m_data = Data::make_Struct({ ::AST::Path(e.path), mv$(sps) });
diff --git a/src/ast/pattern.hpp b/src/ast/pattern.hpp
index 40cfa927..81c1126a 100644
--- a/src/ast/pattern.hpp
+++ b/src/ast/pattern.hpp
@@ -88,7 +88,7 @@ public:
         (Value,     struct { Value start; Value end; } ),
         (Tuple,     TuplePat ),
         (StructTuple, struct { Path path; TuplePat tup_pat; } ),
-        (Struct,    struct { Path path; ::std::vector< ::std::pair< ::std::string, Pattern> > sub_patterns; bool is_exhaustive; } ),
+        (Struct,    struct { Path path; ::std::vector< ::std::pair< RcString, Pattern> > sub_patterns; bool is_exhaustive; } ),
         (Slice,     struct { ::std::vector<Pattern> sub_pats; }),
         (SplitSlice, struct { ::std::vector<Pattern> leading; PatternBinding extra_bind; ::std::vector<Pattern> trailing; } )
         );
@@ -171,7 +171,7 @@ public:
     {}
 
     struct TagStruct {};
-    Pattern(TagStruct, Span sp, Path path, ::std::vector< ::std::pair< ::std::string,Pattern> > sub_patterns, bool is_exhaustive):
+    Pattern(TagStruct, Span sp, Path path, ::std::vector< ::std::pair< RcString,Pattern> > sub_patterns, bool is_exhaustive):
         m_span( mv$(sp) ),
         m_data( Data::make_Struct( { ::std::move(path), ::std::move(sub_patterns), is_exhaustive } ) )
     {}
diff --git a/src/ast/types.cpp b/src/ast/types.cpp
index f9103b37..496cf694 100644
--- a/src/ast/types.cpp
+++ b/src/ast/types.cpp
@@ -40,13 +40,14 @@ static const struct {
     {"usize", CORETYPE_UINT},
 };
 
-enum eCoreType coretype_fromstring(const ::std::string& name)
+enum eCoreType coretype_fromstring(const char* name)
 {
     for(unsigned int i = 0; i < sizeof(CORETYPES)/sizeof(CORETYPES[0]); i ++)
     {
-        if( name < CORETYPES[i].name )
+        int cmp = strcmp(name, CORETYPES[i].name);
+        if( cmp < 0 )
             break;
-        if( name == CORETYPES[i].name )
+        if( cmp == 0 )
             return CORETYPES[i].type;
     }
     return CORETYPE_INVAL;
diff --git a/src/ast/types.hpp b/src/ast/types.hpp
index 0b0f205e..15cb1383 100644
--- a/src/ast/types.hpp
+++ b/src/ast/types.hpp
@@ -73,6 +73,7 @@ namespace AST {
         bool is_infer() const { return m_binding == BINDING_INFER; }
 
         const Ident& name() const { return m_name; }
+        uint16_t binding() const { return m_binding; }
         Ordering ord(const LifetimeRef& x) const { return ::ord(m_name.name, x.m_name.name); }
         bool operator==(const LifetimeRef& x) const { return ord(x) == OrdEqual; }
         bool operator!=(const LifetimeRef& x) const { return ord(x) != OrdEqual; }
@@ -97,7 +98,7 @@ public:
 
 struct TypeArgRef
 {
-    ::std::string   name;
+    RcString   name;
     unsigned int    level;
     const AST::GenericParams*  params;
 };
@@ -165,7 +166,7 @@ TAGGED_UNION(TypeData, None,
         ::std::shared_ptr<AST::ExprNode> size;
         }),
     (Generic, struct {
-        ::std::string name;
+        RcString name;
         unsigned int index;
         }),
     (Path, struct {
@@ -276,11 +277,11 @@ public:
     {}
 
     struct TagArg {};
-    TypeRef(TagArg, Span sp, ::std::string name, unsigned int binding = ~0u):
+    TypeRef(TagArg, Span sp, RcString name, unsigned int binding = ~0u):
         m_span( mv$(sp) ),
         m_data(TypeData::make_Generic({ name, binding }))
     {}
-    TypeRef(Span sp, ::std::string name, unsigned int binding = ~0u):
+    TypeRef(Span sp, RcString name, unsigned int binding = ~0u):
         TypeRef(TagArg(), mv$(sp), mv$(name), binding)
     {}
 
@@ -314,7 +315,7 @@ public:
     AST::Path& path() { return m_data.as_Path().path; }
 
     bool is_type_param() const { return m_data.is_Generic(); }
-    const ::std::string& type_param() const { return m_data.as_Generic().name; }
+    const RcString& type_param() const { return m_data.as_Generic().name; }
 
     bool is_reference() const { return m_data.is_Borrow(); }
     bool is_pointer() const { return m_data.is_Pointer(); }