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

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

2 files changed, 42 insertions, 32 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;
     }
diff --git a/boot/tree.c b/boot/tree.c
index adee06a..e4d0272 100644
--- a/boot/tree.c
+++ b/boot/tree.c
@@ -671,6 +671,7 @@ enum Expression_Kind
     EXPRESSION_INCREMENT_DECREMENT,
 
     EXPRESSION_FUNCTION,
+    EXPRESSION_TYPE,
 };
 
 struct Expression_Integer_Literal
@@ -748,6 +749,11 @@ struct Expression_Function
     struct Block_Node body;
 };
 
+struct Expression_Type
+{
+    struct Type_Node* type;
+};
+
 union Expression_Value
 {
     struct Expression_Integer_Literal integer_literal;
@@ -763,6 +769,7 @@ union Expression_Value
     struct Expression_Member member;
     struct Expression_Increment_Decrement increment_decrement;
     struct Expression_Function function;
+    struct Expression_Type type;
 };
 
 struct Expression
@@ -900,6 +907,9 @@ expression_print(const struct Expression* expression)
         printf(")");
         break;
     }
+    case EXPRESSION_TYPE:
+        type_node_print(expression->value.type.type);
+        break;
     default:
         failure("unexpected expression kind passed to `expression_print`");
         break;
@@ -920,7 +930,6 @@ enum Statement_Kind
     STATEMENT_BREAK,
     STATEMENT_CONTINUE,
     STATEMENT_DEFER,
-    STATEMENT_TYPE,
 };
 
 struct Statement_Value_Expression
@@ -1006,12 +1015,6 @@ struct Statement_Value_Defer
     struct Block_Node block;
 };
 
-struct Statement_Value_Type
-{
-    struct Type_Node* type;
-    struct String name;
-};
-
 union Statement_Value
 {
     struct Statement_Value_Expression expression;
@@ -1021,7 +1024,6 @@ union Statement_Value
     struct Statement_Value_Loop loop;
     struct Statement_Value_Return return_value;
     struct Statement_Value_Defer defer;
-    struct Statement_Value_Type type;
 };
 
 struct Statement
@@ -1197,11 +1199,6 @@ statement_print(const struct Statement* statement)
         printf(")");
         break;
     }
-    case STATEMENT_TYPE: {
-        printf("(type name %s) ", statement->value.type.name.data);
-        type_node_print(statement->value.type.type);
-        break;
-    }
     default:
         failure("unexpected statement kind passed to `statement_print`");
         break;