feat(ast,parser,type_checker,compiler): remove : from struct literal …

…syntax

compiler/scripts/update_ast.py

@@ -35,12 +35,10 @@
     # Can be abc(), abc(1), abc(1, 2, 3), etc
     #        name->`abc` args->`1, 2, 3` paren_token->`)`
     ("fncall", (("expr*", "name"), ("token*", "paren_token"), ("std::vector<expr*>", "args"))),
-    # Struct literal
-    ("struct_literal", (("token*", "colon"),
-                        ("ykdatatype*", "data_type"), ("token*", "curly_open"), ("std::vector<name_val>", "values"),
-                        ("token*", "curly_close"))),
     # Can be a[1], a[b[1]], etc
     ("square_bracket_access", (("expr*", "name"), ("token*", "sqb_token"), ("expr*", "index_expr"))),
+    ("curly_call", (("expr*", "dt_expr"), ("token*", "curly_open"), ("std::vector<name_val>", "values"),
+                    ("token*", "curly_close"))),
     ("square_bracket_set", (("expr*", "name"), ("token*", "sqb_token"), ("expr*", "index_expr"))),
     # Dot operator is used as both set and get operations
     ("set", (("expr*", "lhs"), ("token*", "dot"), ("token*", "item"))),

compiler/src/ast/ast.cpp

@@ -55,6 +55,19 @@ expr *ast_pool::c_binary_expr(expr* left, token* opr, expr* right) {
   cleanup_expr_.push_back(o);
   return o;
 }
+curly_call_expr::curly_call_expr(expr* dt_expr, token* curly_open, std::vector<name_val> values, token* curly_close)
+    : dt_expr_(dt_expr), curly_open_(curly_open), values_(std::move(values)), curly_close_(curly_close) {}
+void curly_call_expr::accept(expr_visitor *v) {
+  v->visit_curly_call_expr(this);
+}
+ast_type curly_call_expr::get_type() {
+  return ast_type::EXPR_CURLY_CALL;
+}
+expr *ast_pool::c_curly_call_expr(expr* dt_expr, token* curly_open, std::vector<name_val> values, token* curly_close) {
+  auto o = new curly_call_expr(dt_expr, curly_open, std::move(values), curly_close);
+  cleanup_expr_.push_back(o);
+  return o;
+}
 fncall_expr::fncall_expr(expr* name, token* paren_token, std::vector<expr*> args)
     : name_(name), paren_token_(paren_token), args_(std::move(args)) {}
 void fncall_expr::accept(expr_visitor *v) {
@@ -71,7 +84,7 @@ expr *ast_pool::c_fncall_expr(expr* name, token* paren_token, std::vector<expr*>
 get_expr::get_expr(expr* lhs, token* dot, token* item)
     : lhs_(lhs), dot_(dot), item_(item) {}
 void get_expr::accept(expr_visitor *v) {
-  v->visit_get_expr(this);
+   v->visit_get_expr(this);
 }
 ast_type get_expr::get_type() {
   return ast_type::EXPR_GET;
@@ -159,19 +172,6 @@ expr *ast_pool::c_square_bracket_set_expr(expr* name, token* sqb_token, expr* in
   cleanup_expr_.push_back(o);
   return o;
 }
-struct_literal_expr::struct_literal_expr(token* colon, ykdatatype* data_type, token* curly_open, std::vector<name_val> values, token* curly_close)
-    : colon_(colon), data_type_(data_type), curly_open_(curly_open), values_(std::move(values)), curly_close_(curly_close) {}
-void struct_literal_expr::accept(expr_visitor *v) {
-  v->visit_struct_literal_expr(this);
-}
-ast_type struct_literal_expr::get_type() {
-  return ast_type::EXPR_STRUCT_LITERAL;
-}
-expr *ast_pool::c_struct_literal_expr(token* colon, ykdatatype* data_type, token* curly_open, std::vector<name_val> values, token* curly_close) {
-  auto o = new struct_literal_expr(colon, data_type, curly_open, std::move(values), curly_close);
-  cleanup_expr_.push_back(o);
-  return o;
-}
 unary_expr::unary_expr(token* opr, expr* right)
     : opr_(opr), right_(right) {}
 void unary_expr::accept(expr_visitor *v) {
@@ -497,4 +497,4 @@ ast_pool::~ast_pool() {
 ast_pool::ast_pool() {
   cleanup_expr_.reserve(1000);
   cleanup_stmt_.reserve(1000);
-}
+}

compiler/src/ast/ast.h

@@ -16,6 +16,7 @@ struct assign_expr;
 struct assign_arr_expr;
 struct assign_member_expr;
 struct binary_expr;
+struct curly_call_expr;
 struct fncall_expr;
 struct get_expr;
 struct grouping_expr;
@@ -24,7 +25,6 @@ struct logical_expr;
 struct set_expr;
 struct square_bracket_access_expr;
 struct square_bracket_set_expr;
-struct struct_literal_expr;
 struct unary_expr;
 struct variable_expr;
 struct block_stmt;
@@ -55,6 +55,7 @@ enum class ast_type {
   EXPR_ASSIGN_ARR,
   EXPR_ASSIGN_MEMBER,
   EXPR_BINARY,
+  EXPR_CURLY_CALL,
   EXPR_FNCALL,
   EXPR_GET,
   EXPR_GROUPING,
@@ -63,7 +64,6 @@ enum class ast_type {
   EXPR_SET,
   EXPR_SQUARE_BRACKET_ACCESS,
   EXPR_SQUARE_BRACKET_SET,
-  EXPR_STRUCT_LITERAL,
   EXPR_UNARY,
   EXPR_VARIABLE,
   STMT_BLOCK,
@@ -95,6 +95,7 @@ struct expr_visitor {
   virtual void visit_assign_arr_expr(assign_arr_expr *obj) = 0;
   virtual void visit_assign_member_expr(assign_member_expr *obj) = 0;
   virtual void visit_binary_expr(binary_expr *obj) = 0;
+  virtual void visit_curly_call_expr(curly_call_expr *obj) = 0;
   virtual void visit_fncall_expr(fncall_expr *obj) = 0;
   virtual void visit_get_expr(get_expr *obj) = 0;
   virtual void visit_grouping_expr(grouping_expr *obj) = 0;
@@ -103,7 +104,6 @@ struct expr_visitor {
   virtual void visit_set_expr(set_expr *obj) = 0;
   virtual void visit_square_bracket_access_expr(square_bracket_access_expr *obj) = 0;
   virtual void visit_square_bracket_set_expr(square_bracket_set_expr *obj) = 0;
-  virtual void visit_struct_literal_expr(struct_literal_expr *obj) = 0;
   virtual void visit_unary_expr(unary_expr *obj) = 0;
   virtual void visit_variable_expr(variable_expr *obj) = 0;
   virtual ~expr_visitor() = default;
@@ -179,6 +179,15 @@ struct binary_expr : expr {
   token* opr_;
   expr* right_;
 };
+struct curly_call_expr : expr {
+  curly_call_expr(expr* dt_expr, token* curly_open, std::vector<name_val> values, token* curly_close);
+  void accept(expr_visitor *v) override;
+  ast_type get_type() override;
+  expr* dt_expr_;
+  token* curly_open_;
+  std::vector<name_val> values_;
+  token* curly_close_;
+};
 struct fncall_expr : expr {
   fncall_expr(expr* name, token* paren_token, std::vector<expr*> args);
   void accept(expr_visitor *v) override;
@@ -239,16 +248,6 @@ struct square_bracket_set_expr : expr {
   token* sqb_token_;
   expr* index_expr_;
 };
-struct struct_literal_expr : expr {
-  struct_literal_expr(token* colon, ykdatatype* data_type, token* curly_open, std::vector<name_val> values, token* curly_close);
-  void accept(expr_visitor *v) override;
-  ast_type get_type() override;
-  token* colon_;
-  ykdatatype* data_type_;
-  token* curly_open_;
-  std::vector<name_val> values_;
-  token* curly_close_;
-};
 struct unary_expr : expr {
   unary_expr(token* opr, expr* right);
   void accept(expr_visitor *v) override;
@@ -443,6 +442,7 @@ struct ast_pool {
   expr *c_assign_arr_expr(expr* assign_oper, token* opr, expr* right);
   expr *c_assign_member_expr(expr* set_oper, token* opr, expr* right);
   expr *c_binary_expr(expr* left, token* opr, expr* right);
+  expr *c_curly_call_expr(expr* dt_expr, token* curly_open, std::vector<name_val> values, token* curly_close);
   expr *c_fncall_expr(expr* name, token* paren_token, std::vector<expr*> args);
   expr *c_get_expr(expr* lhs, token* dot, token* item);
   expr *c_grouping_expr(expr* expression);
@@ -451,7 +451,6 @@ struct ast_pool {
   expr *c_set_expr(expr* lhs, token* dot, token* item);
   expr *c_square_bracket_access_expr(expr* name, token* sqb_token, expr* index_expr);
   expr *c_square_bracket_set_expr(expr* name, token* sqb_token, expr* index_expr);
-  expr *c_struct_literal_expr(token* colon, ykdatatype* data_type, token* curly_open, std::vector<name_val> values, token* curly_close);
   expr *c_unary_expr(token* opr, expr* right);
   expr *c_variable_expr(token* name);
   stmt *c_block_stmt(std::vector<stmt*> statements);

compiler/src/ast/ast_printer.cpp

@@ -222,8 +222,10 @@ void ast_printer::visit_forendless_stmt(forendless_stmt *obj) {
 void ast_printer::visit_compins_stmt(compins_stmt *obj) {
   // Does not occur in AST
 }
-void ast_printer::visit_struct_literal_expr(struct_literal_expr *obj) {
-  text_ << "(struct " << obj->data_type_->as_string() << " (";
+void ast_printer::visit_curly_call_expr(curly_call_expr *obj) {
+  text_ << "(struct ";
+  obj->dt_expr_->accept(this);
+  text_ << " (";
   for (auto st : obj->values_) {
     text_ << " ";
     text_ << st.name_->token_ << ":";

compiler/src/ast/ast_printer.h

@@ -55,8 +55,7 @@ namespace yaksha {
     void visit_foreach_stmt(foreach_stmt *obj) override;
     void visit_forendless_stmt(forendless_stmt *obj) override;
     void visit_compins_stmt(compins_stmt *obj) override;
-    void visit_struct_literal_expr(struct_literal_expr *obj) override;
-
+    void visit_curly_call_expr(curly_call_expr *obj) override;
 private:
     std::stringstream text_{};
   };

compiler/src/ast/ast_vis.cpp

@@ -342,9 +342,9 @@ void ast_vis::visit_forendless_stmt(forendless_stmt *obj) {
 void ast_vis::visit_compins_stmt(compins_stmt *obj) {
   // Does not occur in AST
 }
-void ast_vis::visit_struct_literal_expr(struct_literal_expr *obj) {
+void ast_vis::visit_curly_call_expr(curly_call_expr *obj) {
   begin_block("struct");
-  field("datatype", obj->data_type_->as_string());
+  field("datatype", obj->dt_expr_);
   for (auto st : obj->values_) {
     field("." + st.name_->token_, st.value_);
   }

compiler/src/ast/ast_vis.h

@@ -59,7 +59,7 @@ namespace yaksha {
     void visit_foreach_stmt(foreach_stmt *obj) override;
     void visit_forendless_stmt(forendless_stmt *obj) override;
     void visit_compins_stmt(compins_stmt *obj) override;
-    void visit_struct_literal_expr(struct_literal_expr *obj) override;
+    void visit_curly_call_expr(curly_call_expr *obj) override;
 
 private:
     std::stringstream text_{};

compiler/src/ast/parser.cpp

@@ -150,6 +150,8 @@ expr *parser::fncall() {
       expr = pool_.c_get_expr(expr, dot_oper, rhs);
     } else if (match({token_type::SQUARE_BRACKET_OPEN})) {
       expr = match_array_access(expr);
+    } else if (match({token_type::CURLY_BRACKET_OPEN})) {
+      expr = match_rest_of_curly_call(expr);
     } else {
       break;
     }
@@ -166,10 +168,28 @@ expr *parser::match_rest_of_fncall(expr *name) {
   return pool_.c_fncall_expr(name, paren_close, args);
 }
 expr *parser::match_array_access(expr *name) {
-  auto arr_member = expression();
+  auto index_expr = expression();
   auto paren_close =
       consume(token_type::SQUARE_BRACKET_CLOSE, "Must end with a ']'");
-  return pool_.c_square_bracket_access_expr(name, paren_close, arr_member);
+  return pool_.c_square_bracket_access_expr(name, paren_close, index_expr);
+}
+expr *parser::match_rest_of_curly_call(expr *data_type_expr) {
+  auto curly_open = previous();
+  std::vector<name_val> values{};
+  if (!check(token_type::CURLY_BRACKET_CLOSE)) {
+    do {
+      auto member_name =
+          consume(token_type::NAME, "Member name must be present");
+      consume(token_type::COLON,
+              "Colon must be present between member name and expression");
+      auto exp = expression();
+      values.emplace_back(name_val{member_name, exp});
+    } while (match({token_type::COMMA}));
+  }
+  auto curly_close = consume(token_type::CURLY_BRACKET_CLOSE,
+                             "struct literal must end with '}'");
+  return pool_.c_curly_call_expr(data_type_expr, curly_open, values,
+                                 curly_close);
 }
 expr *parser::primary() {
   if (match({
@@ -197,27 +217,6 @@ expr *parser::primary() {
     return pool_.c_literal_expr(previous());
   }
   if (match({token_type::NAME})) { return pool_.c_variable_expr(previous()); }
-  if (match({token_type::COLON})) {
-    std::vector<name_val> values{};
-    auto colon_token = previous();
-    auto dt = parse_datatype();
-    auto curly_open = consume(token_type::CURLY_BRACKET_OPEN,
-                              "Expect '}' after :DataType for struct literals");
-    if (!check(token_type::CURLY_BRACKET_CLOSE)) {
-      do {
-        auto member_name =
-            consume(token_type::NAME, "Member name must be present");
-        consume(token_type::COLON,
-                "Colon must be present between member name and expression");
-        auto exp = expression();
-        values.emplace_back(name_val{member_name, exp});
-      } while (match({token_type::COMMA}));
-    }
-    auto curly_close = consume(token_type::CURLY_BRACKET_CLOSE,
-                               "struct literal must end with '}'");
-    return pool_.c_struct_literal_expr(colon_token, dt, curly_open, values,
-                                       curly_close);
-  }
   if (match({token_type::PAREN_OPEN})) {
     expr *ex = expression();
     consume(token_type::PAREN_CLOSE, "Expect ')' after expression");

compiler/src/ast/parser.h

@@ -46,6 +46,7 @@ namespace yaksha {
     expr *fncall();
     expr *match_rest_of_fncall(expr *name);
     expr *match_array_access(expr *name);
+    expr *match_rest_of_curly_call(expr *name);
     expr *primary();
     expr *or_op();
     expr *and_op();