Shift `type` keyword in type declarations to right-hand assign side, for symmetry with function declaration

Signed-off-by: Mel <mel@rnrd.eu>

1 files changed, 32 insertions, 19 deletions

diff --git a/boot/parse.c b/boot/parse.c
index 3da213a..c06c5d3 100644
--- a/boot/parse.c
+++ b/boot/parse.c
@@ -571,6 +571,32 @@ parser_expression_function(struct Parser* p, struct Parser_Error* error)
 }
 
 struct Expression*
+parser_expression_type(struct Parser* p, struct Parser_Error* error)
+{
+    struct Token start_token = parser_peek(p);
+
+    struct Type_Node* type = nil;
+    switch (start_token.kind) {
+    case TOKEN_WORD_TYPE:
+        parser_next(p); // skip the `type` keyword.
+        type = CHECK(parser_node_type(p, error));
+        break;
+    case TOKEN_WORD_VARIANT:
+        type = CHECK(parser_node_type_variant(p, error));
+        break;
+    case TOKEN_WORD_CLASS:
+        type = CHECK(parser_node_type_class(p, error));
+        break;
+    default:
+        failure("expected type signifying keyword");
+    }
+
+    struct Span span = span_merge(start_token.span, type->span);
+    return expression_new(
+        EXPRESSION_TYPE, (union Expression_Value){ .type = { type } }, span, start_token.location);
+}
+
+struct Expression*
 parser_expression_primary(struct Parser* p, struct Parser_Error* error)
 {
     struct Token token = parser_peek(p);
@@ -590,6 +616,12 @@ parser_expression_primary(struct Parser* p, struct Parser_Error* error)
         return parser_expression_primary_group(p, error);
     case TOKEN_WORD_FUN:
         return parser_expression_function(p, error);
+    // `variant` and `class` here are essentially a shortcut, as they already
+    // imply a type, so we don't have to write `type variant` or `type class`.
+    case TOKEN_WORD_TYPE:
+    case TOKEN_WORD_VARIANT:
+    case TOKEN_WORD_CLASS:
+        return parser_expression_type(p, error);
     default:
         *error = parser_error(PARSER_ERROR_EXPECTED_PRIMARY_EXPRESSION);
         return nil;
@@ -1003,23 +1035,6 @@ parser_statement_defer(struct Parser* p, struct Parser_Error* error)
 }
 
 struct Statement*
-parser_statement_type(struct Parser* p, struct Parser_Error* error)
-{
-    struct Token type_token = CHECK(parser_need(p, TOKEN_WORD_TYPE, error));
-
-    // TODO: parse type paths, i.e. `Thing.SubType`
-    struct Token name_token = CHECK(parser_need(p, TOKEN_NAME, error));
-    CHECK(parser_need(p, TOKEN_ASSIGN, error));
-    struct String name = name_token.value.name;
-
-    struct Type_Node* type = CHECK(parser_node_type(p, error));
-
-    struct Span span = span_merge(type_token.span, type->span);
-    union Statement_Value value = { .type = { type, name } };
-    return statement_new(STATEMENT_TYPE, value, span, type_token.location);
-}
-
-struct Statement*
 parser_statement(struct Parser* p, struct Parser_Error* error)
 {
     struct Token token = parser_peek(p);
@@ -1050,8 +1065,6 @@ parser_statement(struct Parser* p, struct Parser_Error* error)
         return parser_statement_continue(p, error);
     case TOKEN_WORD_DEFER:
         return parser_statement_defer(p, error);
-    case TOKEN_WORD_TYPE:
-        return parser_statement_type(p, error);
     default:
         break;
     }