Require parentheses in array_count, enum_count, embed_file (#1265)

Author: Akuli

compiler/parser.jou

@@ -677,6 +677,40 @@ class Parser:
 
         return result
 
+    def parse_special_function_like_expression(self) -> AstExpression:
+        expr = AstExpression{location = self.tokens.location}
+
+        assert self.tokens.kind == TokenKind.Keyword
+        match (self.tokens++).short_string with strcmp:
+            case "sizeof":
+                expr.kind = AstExpressionKind.SizeOf
+                error = "value after sizeof must be in parentheses, e.g. sizeof(foo)"
+            case "array_count":
+                expr.kind = AstExpressionKind.ArrayCount
+                error = "value after array_count must be in parentheses, e.g. array_count(foo)"
+            case "enum_count":
+                expr.kind = AstExpressionKind.EnumCount
+                error = "enum type after enum_count must be in parentheses, e.g. enum_count(Foo)"
+            case "embed_file":
+                expr.kind = AstExpressionKind.EmbedFile
+                error = "file name after embed_file must be in parentheses, e.g. embed_file(\"foo.txt\")"
+            case _:
+                assert False
+
+        if not self.tokens.is_operator("("):
+            fail(self.tokens.location, error)
+        self.tokens++
+
+        if expr.kind == AstExpressionKind.EnumCount:
+            expr.enumcount.enum_type_ast = self.parse_type()
+        else:
+            expr.operands = malloc(sizeof(expr.operands[0]))
+            assert expr.operands != NULL
+            *expr.operands = self.parse_expression()
+
+        self.eat_operator(")", True, "a ')'")
+        return expr
+
     def parse_elementary_expression(self) -> AstExpression:
         expr = AstExpression{location = self.tokens.location}
 
@@ -730,20 +764,13 @@ class Parser:
                 elif self.tokens.is_operator("["):
                     expr.kind = AstExpressionKind.Array
                     expr.array = self.parse_array()
-                elif self.tokens.is_keyword("sizeof"):
-                    expr.kind = AstExpressionKind.SizeOf
-                    self.eat_keyword("sizeof", False, NULL)
-                    if not self.tokens.is_operator("("):
-                        fail(self.tokens.location, "value after sizeof must be in parentheses, e.g. sizeof(thing)")
-                    self.tokens++
-                    expr.operands = malloc(sizeof(expr.operands[0]))
-                    assert expr.operands != NULL
-                    *expr.operands = self.parse_expression()
-                    self.eat_operator(")", True, "a ')'")
-                elif self.tokens.is_keyword("enum_count"):
-                    expr.kind = AstExpressionKind.EnumCount
-                    self.tokens++
-                    expr.enumcount.enum_type_ast = self.parse_type()
+                elif (
+                    self.tokens.is_keyword("sizeof")
+                    or self.tokens.is_keyword("array_count")
+                    or self.tokens.is_keyword("embed_file")
+                    or self.tokens.is_keyword("enum_count")
+                ):
+                    expr = self.parse_special_function_like_expression()
                 else:
                     # Special error message for e.g. int(x)
                     msg: byte[300]
@@ -845,8 +872,6 @@ class Parser:
             or self.tokens.is_operator("&")
             or self.tokens.is_operator("*")
             or self.tokens.is_operator("~")
-            or self.tokens.is_keyword("embed_file")
-            or self.tokens.is_keyword("array_count")
         ):
             self.tokens++
         prefix_end = self.tokens
@@ -883,10 +908,6 @@ class Parser:
                     kind = AstExpressionKind.AddressOf
                 elif token.is_operator("~"):
                     kind = AstExpressionKind.BitNot
-                elif token.is_keyword("embed_file"):
-                    kind = AstExpressionKind.EmbedFile
-                elif token.is_keyword("array_count"):
-                    kind = AstExpressionKind.ArrayCount
                 else:
                     assert False
 

doc/keywords.md

@@ -14,7 +14,6 @@ Both `foo` and `bar` must be `bool`s, and `bar` is not evaluated at all if `foo`
 ## `array_count`
 
 Use `array_count(array)` to get the number of elements in [an array](types.md#pointers-and-arrays) as `int`.
-The parentheses are optional.
 The number of elements in an array is always known at compile time, and in fact,
 the `array` is not evaluated when the program runs.
 
@@ -26,7 +25,6 @@ import "stdlib/io.jou"
 def main() -> int:
     array: int[10]
     printf("%d\n", array_count(array))  # Output: 10
-    printf("%d\n", array_count array)  # Output: 10
     return 0
 ```
 

tests/should_succeed/array.jou

@@ -25,7 +25,7 @@ def main() -> int:
     foo[1] = 2
     foo[2] = 3
 
-    n = array_count foo
+    n = array_count(foo)
     check_int(&n)
     printf("%d\n", n)  # Output: 3
 

tests/should_succeed/sizeof.jou

@@ -37,7 +37,7 @@ def main() -> int:
 
     # The "array length trick" that was used before array_count() existed
     printf("%d\n", sizeof(arr) / sizeof(arr[0]))  # Output: 100
-    printf("%d\n", array_count arr)  # Output: 100
+    printf("%d\n", array_count(arr))  # Output: 100
 
     # Evaluating a sizeof has no side effects.
     printf("%d\n", sizeof(side_effect()))  # Output: 4

tests/syntax_error/parentheses_array_count.jou

@@ -0,0 +1,3 @@
+def blah() -> None:
+    thing: byte[10]
+    x = array_count thing  # Error: value after array_count must be in parentheses, e.g. array_count(foo)

tests/syntax_error/parentheses_embed_file.jou

@@ -0,0 +1 @@
+global thing = embed_file "data.bin"  # Error: file name after embed_file must be in parentheses, e.g. embed_file("foo.txt")

tests/syntax_error/parentheses_enum_count.jou

@@ -0,0 +1,6 @@
+enum Thing:
+    Blah
+    Bleh
+    Bruh
+
+const x: int = enum_count Thing  # Error: enum type after enum_count must be in parentheses, e.g. enum_count(Foo)

tests/syntax_error/sizeof_parens.jou tests/syntax_error/parentheses_sizeof.joutests/syntax_error/sizeof_parens.jou renamed to tests/syntax_error/parentheses_sizeof.jou

@@ -1,2 +1,2 @@
 def blah() -> None:
-    x = sizeof 1  # Error: value after sizeof must be in parentheses, e.g. sizeof(thing)
+    x = sizeof 1  # Error: value after sizeof must be in parentheses, e.g. sizeof(foo)