RFC: Empty Statement Syntax

docs/empty-statement-syntax.md

@@ -0,0 +1,86 @@
+# Empty Statement Syntax
+
+## Summary
+
+Allow for empty statements with semicolons, as introduced in Lua 5.2.
+
+```luau
+;do ; end;
+```
+Would be a syntactically valid document equivalent to:
+```luau
+do end;
+```
+
+## Motivation
+
+The semicolon symbol `;` can be used at the end of a statement, explicitly ending it. This is useful when a statement is ambiguous (especially as line breaks do not end statements), or for visual separation when several statements are in a single line. It is however not valid where the beginning of a statement would be expected, and a statement in a block can only be followed by the beginning of another statement or end of the block. Thus, a semicolon can't be used as an "empty statement" on its own. Users may expect this to be the same as an empty file, but is instead a parsing error:
+
+```luau
+;
+```
+> Error:1: Expected identifier when parsing expression, got ';'
+
+In human-written code, a deliberate empty statement is seemingly "useless", but can have intentional stylistic purposes. Mostly as intentional no-ops, visual separation of code blocks, or placeholders for future code. Lua began allowing empty statement syntax in 5.2: users of Lua may be unpleasantly surprised to find that Luau has not followed suit.
+
+In particular, who this syntax can be very useful for is tools that generate Luau code. Take this example:
+
+```luau
+print("Hello")
+GLOBAL_EVENT "Foo"
+print("World")
+```
+
+A tool may want to replace the statement `GLOBAL_EVENT "Foo"`, with for example `(_G.events["Foo"] :: Event):fire()`. Inserting it naively would cause an error due to the ambiguity of the parentheses: the first two lines are a single statement. Luau currently errors with statements like this, refusing to parse them.
+
+```luau
+print("Hello")
+(_G.events["Foo"] :: Event):fire()
+print("World")
+```
+> Error:2: Ambiguous syntax: this looks like an argument list for a function call, but could also be a start of new statement; use ';' to separate statements
+
+To solve it, the tool will likely want to insert a semicolon at the beginning, and, to be sure, end of the statement. Doing so would also be dangerous, as a syntax error would occur if the statement already had any surrounding semicolons or no statement was preceding it in the block. Tools need to check the context to skip introducing a semicolon where it'd cause an error, adding unnecessary and probably unexpected complexity. If empty statements were allowed, tools could safely surround statements with semicolons, guarding against ambiguity without having to worry about context.
+
+This is especially useful for simple "insert-replace" tools that don't perform a syntactic analysis of the code, such as search-and-replace operations in code editors, where currently each replacement would need review to avoid syntax errors.
+
+Allowing this syntax does not introduce any ambiguities or conflicts with existing valid ones.
+
+## Design
+
+The parser would be updated to make a semicolon in a block its own [`AstStat`](https://github.com/luau-lang/luau/blob/6b787963bc2b590f9909bf33aced826c43328444/Ast/include/Luau/Ast.h#L239), and allow for any amount of semicolon statements after `laststat`. This would be similar to how Lua 5.2 and later handle them. The EBNF grammar would be updated as follows:
+
+```ebnf
+block ::= {stat | ';'} [laststat {';'}]
+```
+
+As already is the case, empty statements have no impact in generated bytecode.
+
+## Drawbacks
+
+Previously erroring code would now parse. This is not considered to be a problem, as such programs were never valid in the first place.
+
+This syntax, when used, is not backwards-compatible. However, it can easily be removed without changing the meaning of code (which isn't the case for many other syntax features introduced by Luau).
+
+This syntax addition technically allows for unusual "ugly" code such as:
+
+```luau
+;;; ;; while x do ; ;;;;; print(x);;foo();; ;x += 1;; ; end return 1,2;;;
+```
+
+Code using unnecessary semicolons is likely computer-generated and not meant to be human-readable, where a formatter would be needed (and probably already used).
+
+Tools parsing Luau code will need to be updated to handle this minor syntax change.
+
+## Alternatives
+
+More generally, similar "void" separators could also be allowed for other list-like syntaxes, such as generic lists, parameters, table constructors, or expression lists:
+
+```luau
+local function test<,,,,A,, B,, C...,,,,>(,,a: A,,,, b: B,, ...: C...,,): (,number,,, string,)
+	local _ = {1,,, 2;;,;, 3;;;;,}
+	return ,,42,,,, "hello",,;
+end
+```
+
+This syntax however, unlike with statement blocks, is considerably confusing and unusual, has an unclear purpose, and is very likely a mistake, with little to no practical use cases. In table constructors, a single trailing separator is already allowed.