[#57] Added parsing for structs with cases

Author: amzamora

src/ast.cpp

@@ -948,14 +948,20 @@ void ast::print(Node* node, PrintContext context) {
         case TypeDef: {
             auto& type = std::get<TypeNode>(*node);
 
-            put_indent_level(context.indent_level, append(context.last, type.fields.size() == 0));
+            put_indent_level(context.indent_level, append(context.last, type.fields.size() == 0 && type.cases.size() == 0));
             std::cout << "type " << type.identifier->value << '\n';
 
             for (size_t i = 0; i < type.fields.size(); i++) {
-                bool is_last = i == type.fields.size() - 1;
+                bool is_last = i == type.fields.size() - 1 && type.cases.size() == 0;
                 print((Node*) type.fields[i], PrintContext{context.indent_level + 1, append(context.last, is_last), context.concrete, context.type_bindings});
             }
 
+            for (size_t i = 0; i < type.cases.size(); i++) {
+                bool is_last = i == type.cases.size() - 1;
+                put_indent_level(context.indent_level + 1,  append(context.last, is_last));
+                std::cout << "case " << type.cases[i]->identifier->value << '\n';
+            }
+
             break;
         }
 

src/ast.hpp

@@ -338,6 +338,7 @@ namespace ast {
 
         IdentifierNode* identifier;
         std::vector<IdentifierNode*> fields;
+        std::vector<TypeNode*> cases;
         std::filesystem::path module_path; // Used in to tell from which module the type comes from
 
         size_t get_index_of_field(std::string field_name);

src/lexer.cpp

@@ -332,6 +332,7 @@ Result<token::Token, Error> lexer::get_identifier(Source& source) {
     if (literal == "interface") return token::Token(token::Interface, "interface", line, column);
     if (literal == "builtin")   return token::Token(token::Builtin, "builtin", line, column);
     if (literal == "type")      return token::Token(token::Type, "type", line, column);
+    if (literal == "case")      return token::Token(token::Case, "case", line, column);
     if (literal == "be")        return token::Token(token::Be, "be", line, column);
     if (literal == "true")      return token::Token(token::True, "true", line, column);
     if (literal == "false")     return token::Token(token::False, "false", line, column);

src/parser.cpp

@@ -31,6 +31,7 @@ struct Parser {
     Result<ast::Node*, Error> parse_extern();
     Result<ast::Node*, Error> parse_link_with();
     Result<ast::Node*, Error> parse_type_definition();
+    Result<Ok, Error> parse_type_definition_body(ast::TypeNode* node);
     Result<ast::Type,  Error> parse_type();
     Result<ast::Node*, Error> parse_interface();
     Result<ast::Node*, Error> parse_statement();
@@ -870,13 +871,26 @@ Result<ast::Node*, Error> Parser::parse_type_definition() {
     if (identifier.is_error()) return identifier;
     type.identifier = (ast::IdentifierNode*) identifier.get_value();
 
+    // Parse body
+    auto body = this->parse_type_definition_body(&type);
+    if (body.is_error()) return body.get_error();
+
+    // return
+    this->ast.push_back(type);
+    return this->ast.last_element();
+}
+
+// type_definition_body →  (("\n"+ IDENTIFIER ": " type)|(CASE IDENTIFIER type_defintion_body))*
+Result<Ok, Error> Parser::parse_type_definition_body(ast::TypeNode* node) {
     // Set new indentation level
+    size_t backup = this->position;
     this->advance_until_next_statement();
     size_t previous = this->current_indentation();
     this->indentation_level.push_back(this->current().column);
     if (previous >= this->current_indentation()) {
-        this->errors.push_back(errors::expecting_new_indentation_level(this->location())); // tested in errors/expecting_new_indentation_level.dm
-        return Error {};
+        this->indentation_level.pop_back();
+        this->position = backup;
+        return Ok{};
     }
 
     while (!this->at_end()) {
@@ -895,28 +909,47 @@ Result<ast::Node*, Error> Parser::parse_type_definition() {
             return Error {};
         }
 
-        // Parse field
-        auto field = this->parse_identifier();
-        if (field.is_error()) return Error {};
+        if (this->current() == token::Identifier) {
+            // Parse field
+            auto field = this->parse_identifier();
+            if (field.is_error()) return Error {};
 
-        // Parse colon
-        auto colon = this->parse_token(token::Colon);
-        if (colon.is_error()) return Error {};
+            // Parse colon
+            auto colon = this->parse_token(token::Colon);
+            if (colon.is_error()) return Error {};
 
-        auto type_annotation = this->parse_type();
-        if (type_annotation.is_error()) return Error {};
+            auto type_annotation = this->parse_type();
+            if (type_annotation.is_error()) return Error {};
 
-        ast::set_type(field.get_value(), type_annotation.get_value());
-
-        this->ast.push_back(*field.get_value());
-        type.fields.push_back((ast::IdentifierNode*) this->ast.last_element());
+            ast::set_type(field.get_value(), type_annotation.get_value());
+            node->fields.push_back((ast::IdentifierNode*) field.get_value());
+        }
+        else if (this->current() == token::Case) {
+            // Parse keyword
+            auto keyword = this->parse_token(token::Case);
+            if (keyword.is_error()) return Error {};
+
+            // Parse identifier
+            auto identifier = this->parse_identifier();
+            if (identifier.is_error()) return Error {};
+
+            // Parse body
+            ast::TypeNode new_case = ast::TypeNode{this->location().line, this->location().column};
+            this->ast.push_back(new_case);
+            node->cases.push_back((ast::TypeNode*) this->ast.last_element());
+            node->cases[node->cases.size() - 1]->identifier = (ast::IdentifierNode*) identifier.get_value();
+            auto body = this->parse_type_definition_body(node->cases[node->cases.size() - 1]);
+            if (body.is_error()) return body.get_error();
+        }
+        else {
+            assert(false);
+        }
     }
 
     // Pop indentation level
     this->indentation_level.pop_back();
 
-    this->ast.push_back(type);
-    return this->ast.last_element();
+    return Ok{};
 }
 
 // type → IDENTIFIER ("[" type (", " type)* "]")*

src/tokens.cpp

@@ -162,6 +162,10 @@ void token::print(std::vector<Token> token) {
                 std::cout << "token::Type";
                 break;
             }
+            case Case: {
+                std::cout << "token::Case";
+                break;
+            }
             case True: {
                 std::cout << "token::True";
                 break;

src/tokens.hpp

@@ -46,6 +46,7 @@ namespace token {
         Interface,
         Builtin,
         Type,
+        Case,
         True,
         False,
         Or,

test/structs_with_cases/structs_with_cases_1.dmd

@@ -0,0 +1,11 @@
+type Weekday
+    case Monday
+    case Tuesday
+    case Wednesday
+    case Thursday
+    case Friday
+    case Saturday
+    case Sunday
+
+--day = Weekday::Monday
+print(day)