HIR - Few more expression nodes

5 files changed, 104 insertions, 4 deletions

diff --git a/src/hir/expr.cpp b/src/hir/expr.cpp
index 724d1284..bcc42c11 100644
--- a/src/hir/expr.cpp
+++ b/src/hir/expr.cpp
@@ -19,8 +19,11 @@ DEF_VISIT(ExprNode_UniOp)
 DEF_VISIT(ExprNode_Cast)
 
 DEF_VISIT(ExprNode_CallPath)
+DEF_VISIT(ExprNode_CallMethod)
 
 DEF_VISIT(ExprNode_Literal)
+DEF_VISIT(ExprNode_PathValue);
+DEF_VISIT(ExprNode_Variable);
 
 #undef DEF_VISIT
 
diff --git a/src/hir/expr.hpp b/src/hir/expr.hpp
index 3d7abe1a..8dbd6cf9 100644
--- a/src/hir/expr.hpp
+++ b/src/hir/expr.hpp
@@ -181,6 +181,25 @@ struct ExprNode_CallPath:
     
     NODE_METHODS();
 };
+struct ExprNode_CallMethod:
+    public ExprNode
+{
+    ::HIR::ExprNodeP    m_val;
+    ::std::string   m_method;
+    ::HIR::PathParams  m_params;
+    ::std::vector< ::HIR::ExprNodeP>    m_args;
+
+    ExprNode_CallMethod() {}
+    ExprNode_CallMethod(::HIR::ExprNodeP val, ::std::string method_name, ::HIR::PathParams params, ::std::vector< ::HIR::ExprNodeP> args):
+        m_val( mv$(val) ),
+        m_method( mv$(method_name) ),
+        m_params( mv$(params) ),
+        m_args( mv$(args) )
+    {
+    }
+    
+    NODE_METHODS();
+};
 
 struct ExprNode_Literal:
     public ExprNode
@@ -207,6 +226,30 @@ struct ExprNode_Literal:
     
     NODE_METHODS();
 };
+struct ExprNode_PathValue:
+    public ExprNode
+{
+    ::HIR::Path m_path;
+    
+    ExprNode_PathValue(::HIR::Path path):
+        m_path( mv$(path) )
+    {}
+    
+    NODE_METHODS();
+};
+struct ExprNode_Variable:
+    public ExprNode
+{
+    ::std::string   m_name;
+    unsigned int    m_slot;
+    
+    ExprNode_Variable(::std::string name, unsigned int slot):
+        m_name( mv$(name) ),
+        m_slot( slot )
+    {}
+    
+    NODE_METHODS();
+};
 
 #undef NODE_METHODS
 
@@ -227,8 +270,11 @@ public:
     NV(ExprNode_Cast)
     
     NV(ExprNode_CallPath);
+    NV(ExprNode_CallMethod);
 
     NV(ExprNode_Literal);
+    NV(ExprNode_PathValue);
+    NV(ExprNode_Variable);
 };
 
 }
diff --git a/src/hir/from_ast_expr.cpp b/src/hir/from_ast_expr.cpp
index f0284f8a..2ab1507a 100644
--- a/src/hir/from_ast_expr.cpp
+++ b/src/hir/from_ast_expr.cpp
@@ -165,6 +165,21 @@ struct LowerHIR_ExprNode_Visitor:
             ) );
     }
     virtual void visit(::AST::ExprNode_CallMethod& v) override {
+        ::std::vector< ::HIR::ExprNodeP> args;
+        for(const auto& arg : v.m_args)
+            args.push_back( LowerHIR_ExprNode_Inner(*arg) );
+        
+        // TODO: Should this be abstracted?
+        ::HIR::PathParams   params;
+        for(const auto& param : v.m_method.args())
+            params.m_types.push_back( LowerHIR_Type(param) );
+        
+        m_rv.reset( new ::HIR::ExprNode_CallMethod(
+            LowerHIR_ExprNode_Inner(*v.m_val),
+            v.m_method.name(),
+            mv$(params),
+            mv$(args)
+            ) );
     }
     virtual void visit(::AST::ExprNode_CallObject& v) override {
     }
@@ -179,9 +194,11 @@ struct LowerHIR_ExprNode_Visitor:
     
     virtual void visit(::AST::ExprNode_Integer& v) override {
         struct H {
-            static ::HIR::CoreType get_type(::eCoreType ct) {
+            static ::HIR::CoreType get_type(Span sp, ::eCoreType ct) {
                 switch(ct)
                 {
+                case CORETYPE_ANY:  return ::HIR::CoreType::Str;
+
                 case CORETYPE_I8 :  return ::HIR::CoreType::I8;
                 case CORETYPE_U8 :  return ::HIR::CoreType::U8;
                 case CORETYPE_I16:  return ::HIR::CoreType::I16;
@@ -194,22 +211,36 @@ struct LowerHIR_ExprNode_Visitor:
                 case CORETYPE_INT:  return ::HIR::CoreType::Isize;
                 case CORETYPE_UINT: return ::HIR::CoreType::Usize;
                 default:
-                    return ::HIR::CoreType::Str;
+                    BUG(sp, "Unknown type for integer literal");
                 }
             }
         };
         m_rv.reset( new ::HIR::ExprNode_Literal(
             ::HIR::ExprNode_Literal::Data::make_Integer({
-                H::get_type( v.m_datatype ),
+                H::get_type( Span(v.get_pos()), v.m_datatype ),
                 v.m_value
                 })
             ) );
     }
     virtual void visit(::AST::ExprNode_Float& v) override {
+        ::HIR::CoreType ct;
+        switch(v.m_datatype)
+        {
+        case CORETYPE_ANY:  ct = ::HIR::CoreType::Str;  break;
+        case CORETYPE_F32:  ct = ::HIR::CoreType::F32;  break;
+        case CORETYPE_F64:  ct = ::HIR::CoreType::F64;  break;
+        default:
+            BUG(v.get_pos(), "Unknown type for float literal");
+        }
+        m_rv.reset( new ::HIR::ExprNode_Literal( ::HIR::ExprNode_Literal::Data::make_Float({
+            ct, v.m_value
+            }) ) );
     }
     virtual void visit(::AST::ExprNode_Bool& v) override {
+        m_rv.reset( new ::HIR::ExprNode_Literal( ::HIR::ExprNode_Literal::Data::make_Boolean( v.m_value ) ) );
     }
     virtual void visit(::AST::ExprNode_String& v) override {
+        m_rv.reset( new ::HIR::ExprNode_Literal( ::HIR::ExprNode_Literal::Data::make_String( v.m_value ) ) );
     }
     virtual void visit(::AST::ExprNode_Closure& v) override {
     }
@@ -220,6 +251,13 @@ struct LowerHIR_ExprNode_Visitor:
     virtual void visit(::AST::ExprNode_Tuple& v) override {
     }
     virtual void visit(::AST::ExprNode_NamedValue& v) override {
+        if( v.m_path.is_trivial() ) {
+            auto slot = v.m_path.binding().as_Variable().slot;
+            m_rv.reset( new ::HIR::ExprNode_Variable( v.m_path.nodes()[0].name(), slot ) );
+        }
+        else {
+            m_rv.reset( new ::HIR::ExprNode_PathValue( LowerHIR_Path(v.m_path) ) );
+        }
     }
     
     virtual void visit(::AST::ExprNode_Field& v) override {
diff --git a/src/hir/path.cpp b/src/hir/path.cpp
index 23b9c448..3ea90b9f 100644
--- a/src/hir/path.cpp
+++ b/src/hir/path.cpp
@@ -31,6 +31,10 @@ namespace HIR {
     }
 }
 
+::HIR::PathParams::PathParams()
+{
+}
+
 ::HIR::GenericPath::GenericPath()
 {
 }
diff --git a/src/hir/path.hpp b/src/hir/path.hpp
index 5c9ca101..70d48cc0 100644
--- a/src/hir/path.hpp
+++ b/src/hir/path.hpp
@@ -28,12 +28,21 @@ struct SimplePath
     SimplePath operator+(const ::std::string& s) const;
     friend ::std::ostream& operator<<(::std::ostream& os, const SimplePath& x);
 };
+
+
+struct PathParams
+{
+    ::std::vector<TypeRef>  m_types;
+    
+    PathParams();
+};
+
 /// Generic path - Simple path with one lot of generic params
 class GenericPath
 {
 public:
     SimplePath  m_path;
-    ::std::vector<TypeRef>  m_params;
+    PathParams  m_params;
 
     GenericPath();
     GenericPath(::HIR::SimplePath sp);