1 files changed, 302 insertions, 0 deletions
diff --git a/src/ast/ast_expr.hpp b/src/ast/ast_expr.hpp
new file mode 100644
index 00000000..223d7a4d
--- /dev/null
+++ b/src/ast/ast_expr.hpp
@@ -0,0 +1,302 @@
+/*
+ */
+#ifndef AST_EXPR_INCLUDED
+#define AST_EXPR_INCLUDED
+
+class NodeVisitor;
+
+class ExprNode
+{
+public:
+    virtual ~ExprNode() = 0;
+    
+    virtual void visit(NodeVisitor& nv) = 0;
+};
+
+struct ExprNode_Block:
+    public ExprNode
+{
+    ::std::vector< ::std::unique_ptr<ExprNode> >    m_nodes;
+
+    ExprNode_Block(const ExprNode_Block& x) = delete;
+    ExprNode_Block(::std::vector< ::std::unique_ptr<ExprNode> >&& nodes):
+        m_nodes( move(nodes) )
+    {
+    }
+    virtual ~ExprNode_Block() override;
+    
+    virtual void visit(NodeVisitor& nv) override;
+};
+
+// Return a value
+struct ExprNode_Return:
+    public ExprNode
+{
+    unique_ptr<ExprNode>    m_value;
+
+    ExprNode_Return(unique_ptr<ExprNode>&& value):
+        m_value( move(value) )
+    {
+    }
+    
+    virtual void visit(NodeVisitor& nv) override;
+};
+struct ExprNode_LetBinding:
+    public ExprNode
+{
+    Pattern m_pat;
+    unique_ptr<ExprNode>    m_value;
+
+    ExprNode_LetBinding(Pattern pat, unique_ptr<ExprNode>&& value):
+        m_pat( move(pat) ),
+        m_value( move(value) )
+    {
+    }
+    
+    virtual void visit(NodeVisitor& nv) override;
+};
+struct ExprNode_Assign:
+    public ExprNode
+{
+    unique_ptr<ExprNode>    m_slot;
+    unique_ptr<ExprNode>    m_value;
+
+    ExprNode_Assign(unique_ptr<ExprNode>&& slot, unique_ptr<ExprNode>&& value):
+        m_slot( move(slot) ),
+        m_value( move(value) )
+    {
+    }
+    
+    virtual void visit(NodeVisitor& nv) override;
+};
+struct ExprNode_CallPath:
+    public ExprNode
+{
+    Path    m_path;
+    ::std::vector<unique_ptr<ExprNode>> m_args;
+
+    ExprNode_CallPath(Path&& path, ::std::vector<unique_ptr<ExprNode>>&& args):
+        m_path( move(path) ),
+        m_args( move(args) )
+    {
+    }
+    
+    virtual void visit(NodeVisitor& nv) override;
+};
+// Call an object (Fn/FnMut/FnOnce)
+struct ExprNode_CallObject:
+    public ExprNode
+{
+    unique_ptr<ExprNode>    m_val;
+    ::std::vector<unique_ptr<ExprNode>> m_args;
+
+    ExprNode_CallObject(unique_ptr<ExprNode>&& val, ::std::vector< unique_ptr<ExprNode> >&& args):
+        m_val( move(val) ),
+        m_args( move(args) )
+    {
+    }
+    virtual void visit(NodeVisitor& nv) override;
+};
+
+struct ExprNode_Match:
+    public ExprNode
+{
+    typedef ::std::vector< ::std::pair<Pattern,unique_ptr<ExprNode> > > arm_t;
+    unique_ptr<ExprNode>    m_val;
+    arm_t   m_arms;
+
+    ExprNode_Match(unique_ptr<ExprNode>&& val, arm_t&& arms):
+        m_val( ::std::move(val) ),
+        m_arms( ::std::move(arms) )
+    {
+    }
+    virtual void visit(NodeVisitor& nv) override;
+};
+
+struct ExprNode_If:
+    public ExprNode
+{
+    unique_ptr<ExprNode>    m_cond;
+    unique_ptr<ExprNode>    m_true;
+    unique_ptr<ExprNode>    m_false;
+
+    ExprNode_If(unique_ptr<ExprNode>&& cond, unique_ptr<ExprNode>&& true_code, unique_ptr<ExprNode>&& false_code):
+        m_cond( ::std::move(cond) ),
+        m_true( ::std::move(true_code) ),
+        m_false( ::std::move(false_code) )
+    {
+    }
+    virtual void visit(NodeVisitor& nv) override;
+};
+// Literal integer
+struct ExprNode_Integer:
+    public ExprNode
+{
+    enum eCoreType  m_datatype;
+    uint64_t    m_value;
+
+    ExprNode_Integer(uint64_t value, enum eCoreType datatype):
+        m_datatype(datatype),
+        m_value(value)
+    {
+    }
+    
+    virtual void visit(NodeVisitor& nv) override;
+};
+// Literal structure
+struct ExprNode_StructLiteral:
+    public ExprNode
+{
+    typedef ::std::vector< ::std::pair< ::std::string, unique_ptr<ExprNode> > > t_values;
+    Path    m_path;
+    unique_ptr<ExprNode>    m_base_value;
+    t_values    m_values;
+
+    ExprNode_StructLiteral(Path path, unique_ptr<ExprNode>&& base_value, t_values&& values ):
+        m_path( move(path) ),
+        m_base_value( move(base_value) ),
+        m_values( move(values) )
+    {}
+    
+    virtual void visit(NodeVisitor& nv) override;
+};
+// Variable / Constant
+struct ExprNode_NamedValue:
+    public ExprNode
+{
+    Path    m_path;
+    ExprNode_NamedValue(Path&& path):
+        m_path( ::std::move(path) )
+    {
+    }
+    virtual void visit(NodeVisitor& nv) override;
+};
+// Field dereference
+struct ExprNode_Field:
+    public ExprNode
+{
+    ::std::unique_ptr<ExprNode> m_obj;
+    ::std::string   m_name;
+
+    ExprNode_Field(::std::unique_ptr<ExprNode>&& obj, ::std::string&& name):
+        m_obj( ::std::move(obj) ),
+        m_name( ::std::move(name) )
+    {
+    }
+    virtual void visit(NodeVisitor& nv) override;
+};
+
+// Type cast ('as')
+struct ExprNode_Cast:
+    public ExprNode
+{
+    unique_ptr<ExprNode>    m_value;
+    TypeRef m_type;
+
+    ExprNode_Cast(unique_ptr<ExprNode>&& value, TypeRef&& dst_type):
+        m_value( move(value) ),
+        m_type( move(dst_type) )
+    {
+    }
+    virtual void visit(NodeVisitor& nv) override;
+};
+
+// Binary operation
+struct ExprNode_BinOp:
+    public ExprNode
+{
+    enum Type {
+        CMPEQU,
+        CMPNEQU,
+
+        BITAND,
+        BITOR,
+        BITXOR,
+
+        SHL,
+        SHR,
+    };
+
+    Type    m_type;
+    ::std::unique_ptr<ExprNode> m_left;
+    ::std::unique_ptr<ExprNode> m_right;
+
+    ExprNode_BinOp(Type type, ::std::unique_ptr<ExprNode> left, ::std::unique_ptr<ExprNode> right):
+        m_type(type),
+        m_left( ::std::move(left) ),
+        m_right( ::std::move(right) )
+    {
+    }
+    
+    virtual void visit(NodeVisitor& nv) override;
+};
+
+class NodeVisitor
+{
+public:
+    void visit(const unique_ptr<ExprNode>& cnode) {
+        if(cnode.get())
+            cnode->visit(*this);
+    }
+    
+    virtual void visit(ExprNode_Block& node) {
+        for( auto& child : node.m_nodes )
+            visit(child);
+    }
+    virtual void visit(ExprNode_Return& node) {
+        visit(node.m_value);
+    }
+    virtual void visit(ExprNode_LetBinding& node) {
+        // TODO: Handle recurse into Let pattern
+        visit(node.m_value);
+    }
+    virtual void visit(ExprNode_Assign& node) {
+        visit(node.m_slot);
+        visit(node.m_value);
+    }
+    virtual void visit(ExprNode_CallPath& node) {
+        for( auto& arg : node.m_args )
+            visit(arg);
+    }
+    virtual void visit(ExprNode_CallObject& node) {
+        visit(node.m_val);
+        for( auto& arg : node.m_args )
+            visit(arg);
+    }
+    virtual void visit(ExprNode_Match& node) {
+        visit(node.m_val);
+        for( auto& arm : node.m_arms )
+            visit(arm.second);
+    }
+    virtual void visit(ExprNode_If& node) {
+        visit(node.m_cond);
+        visit(node.m_true);
+        visit(node.m_false);
+    }
+    
+    virtual void visit(ExprNode_Integer& node) {
+        // LEAF
+    }
+    virtual void visit(ExprNode_StructLiteral& node) {
+        visit(node.m_base_value);
+        for( auto& val : node.m_values )
+            visit(val.second);
+    }
+    virtual void visit(ExprNode_NamedValue& node) {
+        // LEAF
+    }
+    
+    virtual void visit(ExprNode_Field& node) {
+        visit(node.m_obj);
+    }
+    virtual void visit(ExprNode_Cast& node) {
+        visit(node.m_value);
+    }
+    virtual void visit(ExprNode_BinOp& node) {
+        visit(node.m_left);
+        visit(node.m_right);
+    }
+};
+
+#endif
+