All - Cleaning up some memory leaks

11 files changed, 90 insertions, 89 deletions

diff --git a/src/include/rc_string.hpp b/src/include/rc_string.hpp
index eec47d80..914228c6 100644
--- a/src/include/rc_string.hpp
+++ b/src/include/rc_string.hpp
@@ -29,12 +29,7 @@ public:
     {
     }
 
-    RcString(const RcString& x):
-        m_ptr(x.m_ptr),
-        m_len(x.m_len)
-    {
-        if( m_ptr ) *m_ptr += 1;
-    }
+    RcString(const RcString& x);
     RcString(RcString&& x):
         m_ptr(x.m_ptr),
         m_len(x.m_len)
@@ -47,36 +42,28 @@ public:
 
     RcString& operator=(const RcString& x)
     {
-        if( &x != this )
-        {
-            this->~RcString();
-            m_ptr = x.m_ptr;
-            m_len = x.m_len;
-            if( m_ptr ) *m_ptr += 1;
-        }
+        if( !(&x != this) ) throw "";
+
+        this->~RcString();
+        new (this) RcString(x);
+
         return *this;
     }
     RcString& operator=(RcString&& x)
     {
-        if( &x != this )
-        {
-            this->~RcString();
-            m_ptr = x.m_ptr;
-            m_len = x.m_len;
-            x.m_ptr = nullptr;
-            x.m_len = 0;
-        }
+        if( !(&x != this) ) throw "";
+
+        this->~RcString();
+        new (this) RcString( ::std::move(x) );
         return *this;
     }
 
 
     const char* c_str() const {
-        if( m_len > 0 )
-        {
+        if( m_len > 0 ) {
             return reinterpret_cast<const char*>(m_ptr + 1);
         }
-        else
-        {
+        else {
             return "";
         }
     }
diff --git a/src/include/span.hpp b/src/include/span.hpp
index 68d6bfdf..d41fa81e 100644
--- a/src/include/span.hpp
+++ b/src/include/span.hpp
@@ -46,10 +46,14 @@ struct Span
         end_line(end_line),
         end_ofs(end_ofs)
     {}
-    Span(const Span& x);
+    Span(const Span& x) = default;
+    Span(Span&& x) = default;
     Span(const Position& position);
     Span();
 
+    Span& operator=(const Span& x) = default;
+    Span& operator=(Span&& x) = default;
+
     void bug(::std::function<void(::std::ostream&)> msg) const;
     void error(ErrorType tag, ::std::function<void(::std::ostream&)> msg) const;
     void warning(WarningType tag, ::std::function<void(::std::ostream&)> msg) const;
diff --git a/src/macro_rules/macro_rules_ptr.hpp b/src/macro_rules/macro_rules_ptr.hpp
index fdb01fbe..5dbfd032 100644
--- a/src/macro_rules/macro_rules_ptr.hpp
+++ b/src/macro_rules/macro_rules_ptr.hpp
@@ -14,7 +14,7 @@ class MacroRulesPtr
     MacroRules* m_ptr;
 public:
     MacroRulesPtr(): m_ptr(nullptr) {}
-    MacroRulesPtr(MacroRules* p): m_ptr(p) {}
+    MacroRulesPtr(MacroRules* p);
     MacroRulesPtr(MacroRulesPtr&& x):
         m_ptr(x.m_ptr)
     {
diff --git a/src/macro_rules/mod.cpp b/src/macro_rules/mod.cpp
index 6410d334..f9754286 100644
--- a/src/macro_rules/mod.cpp
+++ b/src/macro_rules/mod.cpp
@@ -157,10 +157,16 @@ bool is_token_item(eTokenType tt) {
     }
 }
 
+MacroRulesPtr::MacroRulesPtr(MacroRules* p):
+    m_ptr(p)
+{
+    //::std::cout << "MRP new " << m_ptr << ::std::endl;
+}
 MacroRulesPtr::~MacroRulesPtr()
 {
     if(m_ptr)
     {
+        //::std::cout << "MRP delete " << m_ptr << ::std::endl;
         delete m_ptr;
         m_ptr = nullptr;
     }
diff --git a/src/parse/pattern.cpp b/src/parse/pattern.cpp
index f6d61728..e2949a63 100644
--- a/src/parse/pattern.cpp
+++ b/src/parse/pattern.cpp
@@ -92,7 +92,7 @@ AST::Pattern Parse_Pattern(TokenStream& lex, bool is_refutable)
         if( GET_TOK(tok, lex) != TOK_AT )
         {
             PUTBACK(tok, lex);
-            return AST::Pattern(AST::Pattern::TagBind(), lex.end_span(ps), mv$(bind_name), bind_type, is_mut);
+            return AST::Pattern(AST::Pattern::TagBind(), lex.end_span(mv$(ps)), mv$(bind_name), bind_type, is_mut);
         }
         binding = AST::PatternBinding( mv$(bind_name), bind_type, is_mut );
 
@@ -126,11 +126,11 @@ AST::Pattern Parse_Pattern(TokenStream& lex, bool is_refutable)
             if( is_refutable ) {
                 assert(bind_type == ::AST::PatternBinding::Type::MOVE);
                 assert(is_mut == false);
-                return AST::Pattern(AST::Pattern::TagMaybeBind(), lex.end_span(ps), mv$(name));
+                return AST::Pattern(AST::Pattern::TagMaybeBind(), lex.end_span(mv$(ps)), mv$(name));
             }
             // Otherwise, it IS a binding
             else {
-                return AST::Pattern(AST::Pattern::TagBind(), lex.end_span(ps), mv$(name), bind_type, is_mut);
+                return AST::Pattern(AST::Pattern::TagBind(), lex.end_span(mv$(ps)), mv$(name), bind_type, is_mut);
             }
             break;}
         }
@@ -188,11 +188,11 @@ AST::Pattern Parse_PatternReal1(TokenStream& lex, bool is_refutable)
     switch( GET_TOK(tok, lex) )
     {
     case TOK_UNDERSCORE:
-        return AST::Pattern( lex.end_span(ps), AST::Pattern::Data() );
+        return AST::Pattern( lex.end_span(mv$(ps)), AST::Pattern::Data() );
     //case TOK_DOUBLE_DOT:
     //    return AST::Pattern( AST::Pattern::TagWildcard() );
     case TOK_RWORD_BOX:
-        return AST::Pattern( AST::Pattern::TagBox(), lex.end_span(ps), Parse_Pattern(lex, is_refutable) );
+        return AST::Pattern( AST::Pattern::TagBox(), lex.end_span(mv$(ps)), Parse_Pattern(lex, is_refutable) );
     case TOK_DOUBLE_AMP:
         lex.putback(TOK_AMP);
     case TOK_AMP: {
@@ -203,7 +203,7 @@ AST::Pattern Parse_PatternReal1(TokenStream& lex, bool is_refutable)
             is_mut = true;
         else
             PUTBACK(tok, lex);
-        return AST::Pattern( AST::Pattern::TagReference(), lex.end_span(ps), is_mut, Parse_Pattern(lex, is_refutable) );
+        return AST::Pattern( AST::Pattern::TagReference(), lex.end_span(mv$(ps)), is_mut, Parse_Pattern(lex, is_refutable) );
         }
     case TOK_RWORD_SELF:
     case TOK_RWORD_SUPER:
@@ -221,44 +221,44 @@ AST::Pattern Parse_PatternReal1(TokenStream& lex, bool is_refutable)
         {
             auto dt = tok.datatype();
             // TODO: Ensure that the type is ANY or a signed integer
-            return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_Integer({dt, -tok.intval()}) );
+            return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(mv$(ps)), AST::Pattern::Value::make_Integer({dt, -tok.intval()}) );
         }
         else if( tok.type() == TOK_FLOAT )
         {
-            return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_Float({tok.datatype(), -tok.floatval()}) );
+            return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(mv$(ps)), AST::Pattern::Value::make_Float({tok.datatype(), -tok.floatval()}) );
         }
         else
         {
             throw ParseError::Unexpected(lex, tok, {TOK_INTEGER, TOK_FLOAT});
         }
     case TOK_FLOAT:
-        return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_Float({tok.datatype(), tok.floatval()}) );
+        return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(mv$(ps)), AST::Pattern::Value::make_Float({tok.datatype(), tok.floatval()}) );
     case TOK_INTEGER:
-        return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_Integer({tok.datatype(), tok.intval()}) );
+        return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(mv$(ps)), AST::Pattern::Value::make_Integer({tok.datatype(), tok.intval()}) );
     case TOK_RWORD_TRUE:
-        return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_Integer({CORETYPE_BOOL, 1}) );
+        return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(mv$(ps)), AST::Pattern::Value::make_Integer({CORETYPE_BOOL, 1}) );
     case TOK_RWORD_FALSE:
-        return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_Integer({CORETYPE_BOOL, 0}) );
+        return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(mv$(ps)), AST::Pattern::Value::make_Integer({CORETYPE_BOOL, 0}) );
     case TOK_STRING:
-        return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_String( mv$(tok.str()) ) );
+        return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(mv$(ps)), AST::Pattern::Value::make_String( mv$(tok.str()) ) );
     case TOK_BYTESTRING:
-        return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_ByteString({ mv$(tok.str()) }) );
+        return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(mv$(ps)), AST::Pattern::Value::make_ByteString({ mv$(tok.str()) }) );
     case TOK_INTERPOLATED_EXPR: {
         auto e = tok.take_frag_node();
         if( auto* n = dynamic_cast<AST::ExprNode_String*>(e.get()) ) {
-            return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_String( mv$(n->m_value) ) );
+            return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(mv$(ps)), AST::Pattern::Value::make_String( mv$(n->m_value) ) );
         }
         //else if( auto* n = dynamic_cast<AST::ExprNode_ByteString*>(e.get()) ) {
-        //    return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_ByteString( mv$(n->m_value) ) );
+        //    return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(mv$(ps)), AST::Pattern::Value::make_ByteString( mv$(n->m_value) ) );
         //}
         else if( auto* n = dynamic_cast<AST::ExprNode_Bool*>(e.get()) ) {
-            return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_Integer({CORETYPE_BOOL, n->m_value}) );
+            return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(mv$(ps)), AST::Pattern::Value::make_Integer({CORETYPE_BOOL, n->m_value}) );
         }
         else if( auto* n = dynamic_cast<AST::ExprNode_Integer*>(e.get()) ) {
-            return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_Integer({n->m_datatype, n->m_value}) );
+            return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(mv$(ps)), AST::Pattern::Value::make_Integer({n->m_datatype, n->m_value}) );
         }
         else if( auto* n = dynamic_cast<AST::ExprNode_Float*>(e.get()) ) {
-            return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_Float({n->m_datatype, n->m_value}) );
+            return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(mv$(ps)), AST::Pattern::Value::make_Float({n->m_datatype, n->m_value}) );
         }
         else {
             TODO(lex.point_span(), "Convert :expr into a pattern value - " << *e);
@@ -266,7 +266,7 @@ AST::Pattern Parse_PatternReal1(TokenStream& lex, bool is_refutable)
         } break;
 
     case TOK_PAREN_OPEN:
-        return AST::Pattern( AST::Pattern::TagTuple(), lex.end_span(ps), Parse_PatternTuple(lex, is_refutable) );
+        return AST::Pattern( AST::Pattern::TagTuple(), lex.end_span(mv$(ps)), Parse_PatternTuple(lex, is_refutable) );
     case TOK_SQUARE_OPEN:
         return Parse_PatternReal_Slice(lex, is_refutable);
     default:
@@ -280,12 +280,12 @@ AST::Pattern Parse_PatternReal_Path(TokenStream& lex, ProtoSpan ps, AST::Path pa
     switch( GET_TOK(tok, lex) )
     {
     case TOK_PAREN_OPEN:
-        return AST::Pattern( AST::Pattern::TagNamedTuple(), lex.end_span(ps), mv$(path), Parse_PatternTuple(lex, is_refutable) );
+        return AST::Pattern( AST::Pattern::TagNamedTuple(), lex.end_span(mv$(ps)), mv$(path), Parse_PatternTuple(lex, is_refutable) );
     case TOK_BRACE_OPEN:
         return Parse_PatternStruct(lex, ps, mv$(path), is_refutable);
     default:
         PUTBACK(tok, lex);
-        return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(ps), AST::Pattern::Value::make_Named(mv$(path)) );
+        return AST::Pattern( AST::Pattern::TagValue(), lex.end_span(mv$(ps)), AST::Pattern::Value::make_Named(mv$(path)) );
     }
 }
 
@@ -323,7 +323,7 @@ AST::Pattern Parse_PatternReal_Slice(TokenStream& lex, bool is_refutable)
 
         if( has_binding ) {
             if(is_split)
-                ERROR(lex.end_span(ps), E0000, "Multiple instances of .. in a slice pattern");
+                ERROR(lex.end_span(mv$(ps)), E0000, "Multiple instances of .. in a slice pattern");
 
             inner_binding = mv$(binding);
             is_split = true;
@@ -346,13 +346,13 @@ AST::Pattern Parse_PatternReal_Slice(TokenStream& lex, bool is_refutable)
 
     if( is_split )
     {
-        return ::AST::Pattern( lex.end_span(ps), ::AST::Pattern::Data::make_SplitSlice({ mv$(leading), mv$(inner_binding), mv$(trailing) }) );
+        return ::AST::Pattern( lex.end_span(mv$(ps)), ::AST::Pattern::Data::make_SplitSlice({ mv$(leading), mv$(inner_binding), mv$(trailing) }) );
     }
     else
     {
         assert( !inner_binding.is_valid() );
         assert( trailing.empty() );
-        return ::AST::Pattern( lex.end_span(ps), ::AST::Pattern::Data::make_Slice({ mv$(leading) }) );
+        return ::AST::Pattern( lex.end_span(mv$(ps)), ::AST::Pattern::Data::make_Slice({ mv$(leading) }) );
     }
 }
 
@@ -452,7 +452,7 @@ AST::Pattern Parse_PatternStruct(TokenStream& lex, ProtoSpan ps, AST::Path path,
             i ++;
         }
 
-        return AST::Pattern(AST::Pattern::TagNamedTuple(), lex.end_span(ps), mv$(path),  AST::Pattern::TuplePat { mv$(leading), has_split, mv$(trailing) });
+        return AST::Pattern(AST::Pattern::TagNamedTuple(), lex.end_span(mv$(ps)), mv$(path),  AST::Pattern::TuplePat { mv$(leading), has_split, mv$(trailing) });
     }
 
     bool is_exhaustive = true;
@@ -521,6 +521,6 @@ AST::Pattern Parse_PatternStruct(TokenStream& lex, ProtoSpan ps, AST::Path path,
     } while( GET_TOK(tok, lex) == TOK_COMMA );
     CHECK_TOK(tok, TOK_BRACE_CLOSE);
 
-    return AST::Pattern(AST::Pattern::TagStruct(), lex.end_span(ps), ::std::move(path), ::std::move(subpats), is_exhaustive);
+    return AST::Pattern(AST::Pattern::TagStruct(), lex.end_span(mv$(ps)), ::std::move(path), ::std::move(subpats), is_exhaustive);
 }
 
diff --git a/src/parse/root.cpp b/src/parse/root.cpp
index 68ad570b..bc001c99 100644
--- a/src/parse/root.cpp
+++ b/src/parse/root.cpp
@@ -25,7 +25,7 @@ Spanned<T> get_spanned(TokenStream& lex, ::std::function<T()> f) {
     auto ps = lex.start_span();
     auto v = f();
     return Spanned<T> {
-        lex.end_span(ps),
+        lex.end_span( mv$(ps) ),
         mv$(v)
         };
 }
@@ -499,7 +499,7 @@ AST::Function Parse_FunctionDef(TokenStream& lex, ::std::string abi, bool allow_
         PUTBACK(tok, lex);
     }
 
-    return AST::Function(lex.end_span(ps), mv$(params), mv$(abi), is_unsafe, is_const, is_variadic, mv$(ret_type), mv$(args));
+    return AST::Function(lex.end_span( mv$(ps) ), mv$(params), mv$(abi), is_unsafe, is_const, is_variadic, mv$(ret_type), mv$(args));
 }
 
 AST::Function Parse_FunctionDefWithCode(TokenStream& lex, ::std::string abi, bool allow_self, bool is_unsafe, bool is_const)
@@ -1003,12 +1003,12 @@ AST::Attribute Parse_MetaItem(TokenStream& lex)
         switch(GET_TOK(tok, lex))
         {
         case TOK_STRING:
-            return AST::Attribute(lex.end_span(ps), name, tok.str());
+            return AST::Attribute(lex.end_span(mv$(ps)), name, tok.str());
         case TOK_INTERPOLATED_EXPR: {
             auto n = tok.take_frag_node();
             if( auto* v = dynamic_cast<::AST::ExprNode_String*>(&*n) )
             {
-                return AST::Attribute(lex.end_span(ps), name, mv$(v->m_value));
+                return AST::Attribute(lex.end_span(mv$(ps)), name, mv$(v->m_value));
             }
             else
             {
@@ -1031,10 +1031,10 @@ AST::Attribute Parse_MetaItem(TokenStream& lex)
             items.push_back(Parse_MetaItem(lex));
         } while(GET_TOK(tok, lex) == TOK_COMMA);
         CHECK_TOK(tok, TOK_PAREN_CLOSE);
-        return AST::Attribute(lex.end_span(ps), name, mv$(items)); }
+        return AST::Attribute(lex.end_span(mv$(ps)), name, mv$(items)); }
     default:
         PUTBACK(tok, lex);
-        return AST::Attribute(lex.end_span(ps), name);
+        return AST::Attribute(lex.end_span(mv$(ps)), name);
     }
 }
 
@@ -1229,7 +1229,7 @@ void Parse_Impl_Item(TokenStream& lex, AST::Impl& impl)
         throw ParseError::Unexpected(lex, tok);
     }
 
-    impl.items().back().data->span = lex.end_span(ps);
+    impl.items().back().data->span = lex.end_span(mv$(ps));
     impl.items().back().data->attrs = mv$(item_attrs);    // Empty for functions
 }
 
@@ -1262,7 +1262,7 @@ AST::ExternBlock Parse_ExternBlock(TokenStream& lex, ::std::string abi, ::AST::A
             GET_CHECK_TOK(tok, lex, TOK_SEMICOLON);
 
             i.attrs = mv$(meta_items);
-            i.span = lex.end_span(ps);
+            i.span = lex.end_span(mv$(ps));
 
             rv.add_item( AST::Named<AST::Item> { mv$(name), mv$(i), is_public } );
             break; }
@@ -1280,7 +1280,7 @@ AST::ExternBlock Parse_ExternBlock(TokenStream& lex, ::std::string abi, ::AST::A
 
             auto i = ::AST::Item(::AST::Static( (is_mut ? ::AST::Static::MUT : ::AST::Static::STATIC),  mv$(type), ::AST::Expr() ));
             i.attrs = mv$(meta_items);
-            i.span = lex.end_span(ps);
+            i.span = lex.end_span(mv$(ps));
             rv.add_item( AST::Named<AST::Item> { mv$(name), mv$(i), is_public } );
             break; }
         default:
@@ -1504,7 +1504,7 @@ bool Parse_MacroInvocation_Opt(TokenStream& lex,  AST::MacroInvocation& out_inv)
         {
             item_data = ::AST::Item( mv$(inv) );
             item_data.attrs = mv$(meta_items);
-            item_data.span = lex.end_span(ps);
+            item_data.span = lex.end_span(mv$(ps));
 
             return ::AST::Named< ::AST::Item> { "", mv$(item_data), false };
         }
@@ -1875,7 +1875,7 @@ bool Parse_MacroInvocation_Opt(TokenStream& lex,  AST::MacroInvocation& out_inv)
     }
 
     item_data.attrs = mv$(meta_items);
-    item_data.span = lex.end_span(ps);
+    item_data.span = lex.end_span(mv$(ps));
 
     return ::AST::Named< ::AST::Item> { mv$(item_name), mv$(item_data), is_public };
 }
diff --git a/src/parse/token.cpp b/src/parse/token.cpp
index 115df135..2e5a61d4 100644
--- a/src/parse/token.cpp
+++ b/src/parse/token.cpp
@@ -207,6 +207,7 @@ Token Token::clone() const
             BUG(m_pos, "Fragment with invalid token type (" << *this << ")");
             break;
         }
+        assert(rv.m_data.is_Fragment());
         )
     )
     return rv;
diff --git a/src/parse/tokenstream.cpp b/src/parse/tokenstream.cpp
index 611df2ff..889c626c 100644
--- a/src/parse/tokenstream.cpp
+++ b/src/parse/tokenstream.cpp
@@ -125,7 +125,7 @@ ProtoSpan TokenStream::start_span() const
 Span TokenStream::end_span(ProtoSpan ps) const
 {
     auto p = this->getPosition();
-    auto rv = Span( ps.filename,  ps.start_line, ps.start_ofs,  p.line, p.ofs );
+    auto rv = Span( ::std::move(ps.filename),  ps.start_line, ps.start_ofs,  p.line, p.ofs );
     rv.outer_span = this->outerSpan();
     return rv;
 }
diff --git a/src/parse/types.cpp b/src/parse/types.cpp
index a07e66f8..ca5b7892 100644
--- a/src/parse/types.cpp
+++ b/src/parse/types.cpp
@@ -61,7 +61,7 @@ TypeRef Parse_Type_Int(TokenStream& lex, bool allow_trait_list)
     case TOK_DOUBLE_LT: {
         PUTBACK(tok, lex);
         auto path = Parse_Path(lex, PATH_GENERIC_TYPE);
-        return TypeRef(TypeRef::TagPath(), lex.end_span(ps), mv$(path));
+        return TypeRef(TypeRef::TagPath(), lex.end_span(mv$(ps)), mv$(path));
         }
     //
     case TOK_RWORD_FOR: {
@@ -122,7 +122,7 @@ TypeRef Parse_Type_Int(TokenStream& lex, bool allow_trait_list)
         else {
             PUTBACK(tok, lex);
         }
-        return TypeRef(TypeRef::TagReference(), lex.end_span(ps), ::std::move(lifetime), is_mut, Parse_Type(lex, false));
+        return TypeRef(TypeRef::TagReference(), lex.end_span(mv$(ps)), ::std::move(lifetime), is_mut, Parse_Type(lex, false));
         }
     // '*' - Raw pointer
     case TOK_STAR:
@@ -131,10 +131,10 @@ TypeRef Parse_Type_Int(TokenStream& lex, bool allow_trait_list)
         {
         case TOK_RWORD_MUT:
             // Mutable pointer
-            return TypeRef(TypeRef::TagPointer(), lex.end_span(ps), true, Parse_Type(lex, false));
+            return TypeRef(TypeRef::TagPointer(), lex.end_span(mv$(ps)), true, Parse_Type(lex, false));
         case TOK_RWORD_CONST:
             // Immutable pointer
-            return TypeRef(TypeRef::TagPointer(), lex.end_span(ps), false, Parse_Type(lex, false));
+            return TypeRef(TypeRef::TagPointer(), lex.end_span(mv$(ps)), false, Parse_Type(lex, false));
         default:
             throw ParseError::Unexpected(lex, tok, {TOK_RWORD_CONST, TOK_RWORD_MUT});
         }
@@ -147,11 +147,11 @@ TypeRef Parse_Type_Int(TokenStream& lex, bool allow_trait_list)
             // Sized array
             AST::Expr array_size = Parse_Expr(lex);
             GET_CHECK_TOK(tok, lex, TOK_SQUARE_CLOSE);
-            return TypeRef(TypeRef::TagSizedArray(), lex.end_span(ps), mv$(inner), array_size.take_node());
+            return TypeRef(TypeRef::TagSizedArray(), lex.end_span(mv$(ps)), mv$(inner), array_size.take_node());
         }
         else if( tok.type() == TOK_SQUARE_CLOSE )
         {
-            return TypeRef(TypeRef::TagUnsizedArray(), lex.end_span(ps), mv$(inner));
+            return TypeRef(TypeRef::TagUnsizedArray(), lex.end_span(mv$(ps)), mv$(inner));
         }
         else {
             throw ParseError::Unexpected(lex, tok/*, "; or ]"*/);
@@ -162,7 +162,7 @@ TypeRef Parse_Type_Int(TokenStream& lex, bool allow_trait_list)
     case TOK_PAREN_OPEN: {
         DEBUG("Tuple");
         if( GET_TOK(tok, lex) == TOK_PAREN_CLOSE )
-            return TypeRef(TypeRef::TagTuple(), lex.end_span(ps), {});
+            return TypeRef(TypeRef::TagTuple(), lex.end_span(mv$(ps)), {});
         PUTBACK(tok, lex);
 
         TypeRef inner = Parse_Type(lex, true);
@@ -185,7 +185,7 @@ TypeRef Parse_Type_Int(TokenStream& lex, bool allow_trait_list)
                 types.push_back( Parse_Type(lex) );
             }
             CHECK_TOK(tok, TOK_PAREN_CLOSE);
-            return TypeRef(TypeRef::TagTuple(), lex.end_span(ps), mv$(types)); }
+            return TypeRef(TypeRef::TagTuple(), lex.end_span(mv$(ps)), mv$(types)); }
         }
     default:
         throw ParseError::Unexpected(lex, tok);
@@ -259,7 +259,7 @@ TypeRef Parse_Type_Fn(TokenStream& lex, ::AST::HigherRankedBounds hrbs)
         PUTBACK(tok, lex);
     }
 
-    return TypeRef(TypeRef::TagFunction(), lex.end_span(ps), mv$(hrbs), is_unsafe, mv$(abi), mv$(args), is_variadic, mv$(ret_type));
+    return TypeRef(TypeRef::TagFunction(), lex.end_span(mv$(ps)), mv$(hrbs), is_unsafe, mv$(abi), mv$(args), is_variadic, mv$(ret_type));
 }
 
 TypeRef Parse_Type_Path(TokenStream& lex, ::AST::HigherRankedBounds hrbs, bool allow_trait_list)
@@ -270,7 +270,7 @@ TypeRef Parse_Type_Path(TokenStream& lex, ::AST::HigherRankedBounds hrbs, bool a
 
     if( hrbs.empty() && !allow_trait_list )
     {
-        return TypeRef(TypeRef::TagPath(), lex.end_span(ps), Parse_Path(lex, PATH_GENERIC_TYPE));
+        return TypeRef(TypeRef::TagPath(), lex.end_span(mv$(ps)), Parse_Path(lex, PATH_GENERIC_TYPE));
     }
     else
     {
@@ -303,11 +303,11 @@ TypeRef Parse_Type_Path(TokenStream& lex, ::AST::HigherRankedBounds hrbs, bool a
         {
             if( lifetimes.empty())
                 lifetimes.push_back(AST::LifetimeRef());
-            return TypeRef(lex.end_span(ps), mv$(traits), mv$(lifetimes));
+            return TypeRef(lex.end_span(mv$(ps)), mv$(traits), mv$(lifetimes));
         }
         else
         {
-            return TypeRef(TypeRef::TagPath(), lex.end_span(ps), mv$(traits.at(0).path));
+            return TypeRef(TypeRef::TagPath(), lex.end_span(mv$(ps)), mv$(traits.at(0).path));
         }
     }
 }
@@ -335,6 +335,6 @@ TypeRef Parse_Type_ErasedType(TokenStream& lex, bool allow_trait_list)
     } while( GET_TOK(tok, lex) == TOK_PLUS );
     PUTBACK(tok, lex);
 
-    return TypeRef(lex.end_span(ps), TypeData::make_ErasedType({ mv$(traits), mv$(lifetimes) }));
+    return TypeRef(lex.end_span(mv$(ps)), TypeData::make_ErasedType({ mv$(traits), mv$(lifetimes) }));
 }
 
diff --git a/src/rc_string.cpp b/src/rc_string.cpp
index 46f36923..4025d8c8 100644
--- a/src/rc_string.cpp
+++ b/src/rc_string.cpp
@@ -21,6 +21,18 @@ RcString::RcString(const char* s, unsigned int len):
         for(unsigned int j = 0; j < len; j ++ )
             data_mut[j] = s[j];
         data_mut[len] = '\0';
+
+        //::std::cout << "RcString(" << m_ptr << " \"" << *this << "\") - " << *m_ptr << " (creation)" << ::std::endl;
+    }
+}
+RcString::RcString(const RcString& x):
+    m_ptr(x.m_ptr),
+    m_len(x.m_len)
+{
+    if( m_ptr )
+    {
+        *m_ptr += 1;
+        //::std::cout << "RcString(" << m_ptr << " \"" << *this << "\") - " << *m_ptr << " refs present (copy)" << ::std::endl;
     }
 }
 RcString::~RcString()
@@ -28,7 +40,7 @@ RcString::~RcString()
     if(m_ptr)
     {
         *m_ptr -= 1;
-        //::std::cout << "RcString(\"" << *this << "\") - " << *m_ptr << " refs left" << ::std::endl;
+        //::std::cout << "RcString(" << m_ptr << " \"" << *this << "\") - " << *m_ptr << " refs left (drop)" << ::std::endl;
         if( *m_ptr == 0 )
         {
             delete[] m_ptr;
diff --git a/src/span.cpp b/src/span.cpp
index eacdc7aa..34f2637e 100644
--- a/src/span.cpp
+++ b/src/span.cpp
@@ -11,15 +11,6 @@
 #include <parse/lex.hpp>
 #include <common.hpp>
 
-Span::Span(const Span& x):
-    outer_span(x.outer_span),
-    filename(x.filename),
-    start_line(x.start_line),
-    start_ofs(x.start_ofs),
-    end_line(x.end_line),
-    end_ofs(x.end_ofs)
-{
-}
 Span::Span(const Position& pos):
     outer_span(),
     filename(pos.filename),