1 files changed, 29 insertions, 3 deletions

diff --git a/src/parse/token.hpp b/src/parse/token.hpp
index 0a72cec1..25993b2f 100644
--- a/src/parse/token.hpp
+++ b/src/parse/token.hpp
@@ -35,6 +35,17 @@ public:
 };
 extern ::std::ostream& operator<<(::std::ostream& os, const Position& p);
 
+class TypeRef;
+class TokenTree;
+namespace AST {
+    class Pattern;
+    class Path;
+    class ExprNode;
+    class MetaItem;
+};
+
+class InterpolatedFragment;
+
 class Token:
     public Serialisable
 {
@@ -48,13 +59,15 @@ class Token:
     (Float, struct {
         enum eCoreType  m_datatype;
         double  m_floatval;
-        })
+        }),
+    (Fragment, void*)
     );
     
     enum eTokenType m_type;
     Data    m_data;
     Position    m_pos;
 public:
+    virtual ~Token();
     Token();
     Token& operator=(Token&& t)
     {
@@ -80,20 +93,30 @@ public:
         (None,  ),
         (String,    m_data = Data::make_String(e); ),
         (Integer,   m_data = Data::make_Integer(e);),
-        (Float, m_data = Data::make_Float(e);)
+        (Float, m_data = Data::make_Float(e);),
+        (Fragment, assert(!"Copied fragment");)
         )
     }
+    Token clone() const;
     
     Token(enum eTokenType type);
     Token(enum eTokenType type, ::std::string str);
     Token(uint64_t val, enum eCoreType datatype);
     Token(double val, enum eCoreType datatype);
+    Token(InterpolatedFragment& );
 
     enum eTokenType type() const { return m_type; }
     const ::std::string& str() const { return m_data.as_String(); }
     enum eCoreType  datatype() const { TU_MATCH_DEF(Data, (m_data), (e), (assert(!"Getting datatype of invalid token type");), (Integer, return e.m_datatype;), (Float, return e.m_datatype;)) }
     uint64_t intval() const { return m_data.as_Integer().m_intval; }
     double floatval() const { return m_data.as_Float().m_floatval; }
+    
+    TypeRef& frag_type() { assert(m_type == TOK_INTERPOLATED_TYPE); return *reinterpret_cast<TypeRef*>( m_data.as_Fragment() ); }
+    AST::Path& frag_path() { assert(m_type == TOK_INTERPOLATED_PATH); return *reinterpret_cast<AST::Path*>( m_data.as_Fragment() ); }
+    AST::Pattern& frag_pattern() { assert(m_type == TOK_INTERPOLATED_PATTERN); return *reinterpret_cast<AST::Pattern*>( m_data.as_Fragment() ); }
+    AST::MetaItem& frag_meta() { assert(m_type == TOK_INTERPOLATED_META); return *reinterpret_cast<AST::MetaItem*>( m_data.as_Fragment() ); }
+    ::std::unique_ptr<AST::ExprNode> take_frag_node();
+    
     bool operator==(const Token& r) const {
         if(type() != r.type())
             return false;
@@ -101,7 +124,8 @@ public:
         (None, return true;),
         (String, return e == re;),
         (Integer, return e.m_datatype == re.m_datatype && e.m_intval == re.m_intval;),
-        (Float, return e.m_datatype == re.m_datatype && e.m_floatval == re.m_floatval;)
+        (Float, return e.m_datatype == re.m_datatype && e.m_floatval == re.m_floatval;),
+        (Fragment, assert(!"Token equality on Fragment");)
         )
         throw "";
     }
@@ -116,6 +140,8 @@ public:
     static eTokenType typefromstr(const ::std::string& s);
     
     SERIALISABLE_PROTOTYPES();
+
+    friend ::std::ostream&  operator<<(::std::ostream& os, const Token& tok);
 };
 extern ::std::ostream&  operator<<(::std::ostream& os, const Token& tok);