fix(variants): require braces in payloadless variant initializer syntax

Author: radovanhorvat

docs/grammar.md

@@ -510,8 +510,7 @@ struct_field ::= identifier "=" expr
 ### Variant Literals
 
 ```ebnf
-variant_literal ::= qualified_identifier "." identifier
-                  | qualified_identifier "." identifier "{" [ expr ] "}"
+variant_literal ::= qualified_identifier "." identifier "{" [ expr ] "}"
 ```
 
 Examples:
@@ -520,7 +519,7 @@ Examples:
 Value.INT{3}
 Value.TEXT{"hi"}[r]
 Value.INT{}
-Value.EOF
+Value.EOF{}
 ```
 
 ### Vector Literals
@@ -555,8 +554,8 @@ These forms are parsed first and refined later:
 
 - `EnumName.VALUE` is initially parsed as member access, then rewritten as an
   enum value during semantic analysis.
-- `VariantName.TAG` is initially parsed as member access, then rewritten during semantic
-  analysis as either a payloadless variant value or a variant tag marker.
+- `VariantName.TAG` is initially parsed as member access, then rewritten as a variant tag marker
+  during semantic analysis. Constructing a variant value always requires braces.
 - `value[VariantName.TAG]` is syntactically a subscript expression and becomes
   variant payload access only after semantic resolution.
 

docs/overview/11-variants.md

@@ -28,7 +28,7 @@ v2 := Value.INT{}
 
 v3 := Value.TEXT{"hello"}
 v4 := Value.NUMS{[10 of 0]}
-v5 := Value.EOF
+v5 := Value.EOF{}
 ```
 
 
@@ -86,9 +86,9 @@ Each `case`:
 - Tests the tag
 - **Binds** the payload to a local name (`v`, `msg`, `vec`).
 
-Tags may omit their payload type. Construct and match those tags without braces, as with
-`Value.EOF`; braces always indicate a payload. If every tag has no payload, declare an `enum`
-instead of a `variant`.
+Tags may omit their payload type. Construct those tags with empty braces, as with
+`Value.EOF{}`, and match them without braces, as with `case Value.EOF:`. If every tag has no
+payload, declare an `enum` instead of a `variant`.
 
 When printed, variants show their type, active tag, and payload when present: for example,
 `<Value INT=7>` and `<Value EOF>`.

examples/variants.jik

@@ -41,7 +41,7 @@ func main():
     show_result(compute(Op.ADD, 2, 3, _))
     show_result(compute(Op.MUL, 4, 5, _))
     show_result(compute(Op.MUL, 7, 0, _))
-    finished := CalcResult.END
+    finished := CalcResult.END{}
     show_result(finished)
     println("done: ", finished.is_done())
 end

src/jik/parser.c

@@ -372,19 +372,6 @@ jik_parser_parse_primary(JikParser *p)
             }
         }
         else if (tok->type == TOK_LANG) {
-            if (node->type == NODE_EXPR_MEMBER_ACCESS &&
-                node->val_member_access.node->type == NODE_EXPR_IDENTIFIER &&
-                jik_parser_match_token_sequence(
-                    p, (JikTokenType[]){TOK_LANG, TOK_DOT, TOK_ID, TOK_RANG, TOK_ERROR})) {
-                JikNode *ret = jik_node_new_variant_new(node->val_member_access.node,
-                                                        NULL,
-                                                        node->val_member_access.member_name,
-                                                        jik_parser_current_context(p),
-                                                        node->token);
-                jik_set_alloc_spec(ret, jik_parser_get_region_spec(p));
-                node = ret;
-                continue;
-            }
             JikToken *lang_tok = jik_parser_eat_token(p, TOK_LANG);
             JikNode  *expr     = NULL;
             if (jik_parser_current_token(p)->type != TOK_COLON) {
@@ -1438,16 +1425,11 @@ jik_parser_parse_variant_new(JikParser *p, JikToken *var_name_tok, char *module_
     JikToken *variant = jik_parser_eat_token(p, TOK_ID);
     jik_parser_eat_token(p, TOK_LCURL);
     jik_parser_eat_newlines_if_found(p);
-    if (jik_parser_current_token(p)->type == TOK_RCURL) {
-        jik_parser_eat_token(p, TOK_RCURL);
-        JikNode *ret = jik_node_new_variant_new(
-            id, NULL, variant->lexeme, jik_parser_current_context(p), var_name_tok);
-        ret->val_variant_new.has_initializer_syntax = true;
-        jik_set_alloc_spec(ret, jik_parser_get_region_spec(p));
-        return ret;
+    JikNode *init_expr = NULL;
+    if (jik_parser_current_token(p)->type != TOK_RCURL) {
+        init_expr = jik_parser_parse_expr(p);
+        jik_parser_eat_newlines_if_found(p);
     }
-    JikNode *init_expr = jik_parser_parse_expr(p);
-    jik_parser_eat_newlines_if_found(p);
     jik_parser_eat_token(p, TOK_RCURL);
     JikNode *ret = jik_node_new_variant_new(
         id, init_expr, variant->lexeme, jik_parser_current_context(p), var_name_tok);

src/jik/semantic.c

@@ -197,16 +197,7 @@ jik_semantic_reject_invalid_value_expr(JikNode *nd)
                                                  nd->val_variant_new.name->val_id.module_id,
                                                  nd->token->module_id);
         if (variant && variant->type == NODE_VARIANT &&
-            jik_variant_tag_is_payloadless(variant, nd->val_variant_new.tag)) {
-            jik_diag_fatal_error_if(nd->val_variant_new.has_initializer_syntax,
-                                    "payloadless variant tag cannot use braces",
-                                    JIK_STRING_NCAT("use ",
-                                                    nd->val_variant_new.name->val_id.name,
-                                                    ".",
-                                                    nd->val_variant_new.tag));
-        }
-        else if (variant && variant->type == NODE_VARIANT &&
-                 !nd->val_variant_new.has_initializer_syntax) {
+            !nd->val_variant_new.has_initializer_syntax) {
             jik_diag_fatal_error(JIK_STRING_NCAT("variant tag cannot be used as a value; use ",
                                                  nd->val_variant_new.name->val_id.name,
                                                  ".",
@@ -681,33 +672,6 @@ jik_semantic_resolve_symbols(JikSemanticAnalyzer *sa)
                 *member = *tag;
             }
         }
-        else if (nd->type == NODE_EXPR_SUBSCRIPT_GET &&
-                 nd->val_subscript_get.node->type == NODE_EXPR_MEMBER_ACCESS &&
-                 nd->val_subscript_get.node->val_member_access.node->type ==
-                     NODE_EXPR_IDENTIFIER &&
-                 nd->val_subscript_get.expr->type == NODE_EXPR_IDENTIFIER) {
-            JikNode *member = nd->val_subscript_get.node;
-            JikNode *variant = jik_scope_get_symbol(
-                nd->context,
-                member->val_member_access.node->val_id.name,
-                member->val_member_access.node->val_id.module_id,
-                nd->token->module_id);
-            if (variant && variant->type == NODE_VARIANT &&
-                jik_variant_tag_is_payloadless(variant, member->val_member_access.member_name)) {
-                JikNode *ret = jik_node_new_variant_new(member->val_member_access.node,
-                                                        NULL,
-                                                        member->val_member_access.member_name,
-                                                        nd->context,
-                                                        nd->token);
-                ret->val_variant_new.name->val_id.module_id = variant->token->module_id;
-                jik_set_alloc_spec(ret,
-                                   (JikAllocSpec){.kind = JIK_ALLOC_NAMED_REGION,
-                                                  .src = JIK_ALLOC_SRC_UNKNOWN,
-                                                  .region_name =
-                                                      nd->val_subscript_get.expr->val_id.name});
-                *nd = *ret;
-            }
-        }
         else if (nd->type == NODE_EXPR_MEMBER_ACCESS) {
             if (nd->val_member_access.node->type == NODE_EXPR_IDENTIFIER) {
                 char    *module_id = nd->val_member_access.node->val_id.module_id
@@ -729,31 +693,15 @@ jik_semantic_resolve_symbols(JikSemanticAnalyzer *sa)
                         jik_token_to_text(nd->token));
                 }
                 else if (enum_node && enum_node->type == NODE_VARIANT) {
-                    if (jik_variant_tag_is_payloadless(enum_node,
-                                                       nd->val_member_access.member_name)) {
-                        JikNode *var_new_nd = jik_node_new_variant_new(
-                            nd->val_member_access.node,
-                            NULL,
-                            nd->val_member_access.member_name,
-                            nd->context,
-                            nd->token);
-                        var_new_nd->val_variant_new.name->val_id.module_id = module_id;
-                        jik_set_alloc_spec(var_new_nd,
-                                           (JikAllocSpec){.kind = JIK_ALLOC_LOCAL,
-                                                          .src = JIK_ALLOC_SRC_LOCAL});
-                        *nd = *var_new_nd;
-                    }
-                    else {
-                        JikNode *var_new_nd =
-                            jik_node_new_variant_tag(nd->val_member_access.node,
-                                                     nd->val_member_access.member_name,
-                                                     nd->context,
-                                                     nd->token);
-                        nd->type                 = var_new_nd->type;
-                        nd->jik_type             = var_new_nd->jik_type;
-                        nd->val_variant_tag.name = var_new_nd->val_variant_tag.name;
-                        nd->val_variant_tag.tag  = var_new_nd->val_variant_tag.tag;
-                    }
+                    JikNode *var_new_nd =
+                        jik_node_new_variant_tag(nd->val_member_access.node,
+                                                 nd->val_member_access.member_name,
+                                                 nd->context,
+                                                 nd->token);
+                    nd->type                 = var_new_nd->type;
+                    nd->jik_type             = var_new_nd->jik_type;
+                    nd->val_variant_tag.name = var_new_nd->val_variant_tag.name;
+                    nd->val_variant_tag.tag  = var_new_nd->val_variant_tag.tag;
                 }
             }
         }

test/jik/test_compile_fail_semantic.jik

@@ -456,6 +456,37 @@ end
         "identifier \"_Private\" is reserved by the C backend")
 end
 
+func test_compile_fail_30(ts):
+    utils::assert_compile_fail_source(ts,
+"""
+variant Value:
+    EMPTY
+end
+
+func main():
+    value := Value.EMPTY
+end
+""",
+        "variant tag cannot be used as a value"
+    )
+
+    utils::assert_compile_fail_source(ts,
+"""
+variant Value:
+    EMPTY
+end
+
+func invalid(r: Region):
+    value := Value.EMPTY[r]
+end
+
+func main():
+end
+""",
+        "unsubscriptable type"
+    )
+end
+
 func run_tests(ts):
     test_compile_fail_01(ts)
     test_compile_fail_02(ts)
@@ -486,4 +517,5 @@ func run_tests(ts):
     test_compile_fail_27(ts)
     test_compile_fail_28(ts)
     test_compile_fail_29(ts)
+    test_compile_fail_30(ts)
 end

test/jik/test_table.jik

@@ -114,7 +114,7 @@ func test_table_variant_tags(ts):
     first := Token.IDENT{"first"}
     second := Token.IDENT{"second"}
     number := Token.NUMBER{42}
-    end_token := Token.END
+    end_token := Token.END{}
 
     test::suite_assert(ts, TokenNames[first] == "identifier", site())
     test::suite_assert(ts, TokenNames[second] == "identifier", site())

test/jik/test_variant.jik

@@ -154,11 +154,11 @@ variant Token:
 end
 
 func make_eof(r: Region) -> Token:
-    return Token.EOF[r]
+    return Token.EOF{}[r]
 end
 
 func test_var_07(ts):
-    eof := Token.EOF
+    eof := Token.EOF{}
     test::suite_assert(ts, eof is Token.EOF, site())
 
     match eof:
@@ -168,12 +168,12 @@ func test_var_07(ts):
             test::suite_assert(ts, true, site())
     end
 
-    tokens := [Token.EOF, Token.INTEGER{42}]
+    tokens := [Token.EOF{}, Token.INTEGER{42}]
     test::suite_assert(ts, tokens[0] is Token.EOF, site())
     test::suite_assert(ts, tokens[1][Token.INTEGER] == 42, site())
 
     holder := TokenHolder{}
-    holder.token = Token.EOF[.holder]
+    holder.token = Token.EOF{}[.holder]
     test::suite_assert(ts, holder.token is Token.EOF, site())
 
     holder.token = make_eof(.holder)