Merge pull request #1467 from DanielXMoore/braced-block

One-line braced blocks with single-line statements

Author: edemaine

civet.dev/comparison.md

@@ -168,6 +168,22 @@ if (condition)
 By contrast, in JavaScript, the last indented line would have been
 treated as if it were at the top level.
 
+## Braced Blocks
+
+Civet allows you to wrap your blocks in braces (or not),
+but to avoid conflicts with braced object literals,
+there are some restrictions.
+In particular, a one-line braced block must be on the same line
+as the `if` etc. it's part of:
+
+<Playground>
+// block
+if (x) { y }
+// not a block
+if (x)
+{ y }
+</Playground>
+
 ## Automatic Semicolon Insertion
 
 JavaScript has [complicated rules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#automatic_semicolon_insertion)

source/parser.hera

@@ -764,6 +764,11 @@ FatArrowToken
   "=>" / "⇒" ->
     return { $loc, token: "=>" }
 
+TrailingOperator
+  _? ( BinaryOp / AssignmentOp / Dot / QuestionMark )
+  _ OperatorAssignmentOp
+  TrailingDeclaration
+
 TrailingDeclaration
   _? ( ConstAssignment / LetAssignment )
 
@@ -1093,12 +1098,12 @@ ImplementsTarget
 # https://262.ecma-international.org/#prod-ClassBody
 # NOTE: Nesting and indentation sensitive
 ClassBody
-  __ OpenBrace NestedClassElements?:expressions __ CloseBrace  ->
-    if (!expressions) expressions = $0[2] = []
+  __:ws1 OpenBrace:open AllowAll ClassBracedContent?:expressions RestoreAll __:ws2 CloseBrace:close  ->
+    if (!expressions) expressions = []
     return {
       type: "BlockStatement",
       subtype: "ClassBody",
-      children: $0,
+      children: [ws1, open, expressions, ws2, close],
       expressions,
     }
   InsertOpenBrace NestedClassElements?:expressions InsertNewline InsertIndent InsertCloseBrace ->
@@ -1110,6 +1115,14 @@ ClassBody
       expressions,
     }
 
+# based on BracedContent
+ClassBracedContent
+  NestedClassElements
+  # based on SingleLineStatements
+  ForbidNewlineBinaryOp ( ( _? !EOS ) ClassElement StatementDelimiter )*:stmts RestoreNewlineBinaryOp ->
+    if (!stmts) return $skip
+    return stmts
+
 NestedClassElements
   PushIndent NestedClassElement*:elements PopIndent ->
     if (!elements.length) return $skip
@@ -2473,22 +2486,34 @@ Arrow
     return { $loc, token: "->" }
 
 ExplicitBlock
-  __ OpenBrace __ CloseBrace ->
-    const expressions = []
+  # Allow single-line block only when the block starts on the same line
+  _?:ws1 OpenBrace:open AllowAll ( NestedBlockStatements / SingleLineStatements / EmptyBracedContent )?:block RestoreAll __:ws2 CloseBrace:close ->
+    if (!block) return $skip
     return {
-      type: "BlockStatement",
-      expressions,
-      children: [$1, $2, expressions, $3, $4],
+      ...block,
+      children: [ws1, open, ...block.children, ws2, close],
       bare: false,
-      empty: true,
     }
-  __ OpenBrace NestedBlockStatements:block __ CloseBrace ->
+  # For backward compatibility with JavaScript, allow open brace to start on
+  # the next line, as long as it's followed by a newline or close brace
+  IndentedAtLeast:ws1 OpenBrace:open AllowAll ( NestedBlockStatements / EmptyBracedContent )?:block RestoreAll __:ws2 CloseBrace:close ->
+    if (!block) return $skip
     return {
       ...block,
-      children: [$1, $2, ...block.children, $4, $5],
+      children: [ws1, open, ...block.children, ws2, close],
       bare: false,
     }
 
+EmptyBracedContent
+  &( __ "}" ) ->
+    const expressions = []
+    return {
+      type: "BlockStatement",
+      expressions,
+      children: [expressions],
+      empty: true,
+    }
+
 ImplicitNestedBlock
   # NOTE: Check &EOS needed by eventual PushIndent to skip work if not needed
   &EOS InsertOpenBrace:open AllowAll ( NestedBlockStatements InsertNewline InsertIndent InsertCloseBrace )? RestoreAll ->
@@ -2668,16 +2693,7 @@ NoCommaBracedBlock
     }
 
 NonSingleBracedBlock
-  _?:ws1 OpenBrace:open AllowAll ( BracedContent __ CloseBrace )? RestoreAll ->
-    if (!$4) return $skip
-    const [block, ws2, close] = $4
-    return {
-      type: "BlockStatement",
-      expressions: block.expressions,
-      children: [ws1, open, ...block.children, ws2, close],
-      bare: false,
-    }
-    return block
+  !EOS ExplicitBlock !TrailingOperator -> $2
 
   # NOTE: Added indentation based implied braces
   ImplicitNestedBlock
@@ -2711,10 +2727,7 @@ SingleLineStatements
     }
 
     const children = [expressions]
-
-    if (hasTrailingComment) {
-      children.push("\n")
-    }
+    if (hasTrailingComment) children.push("\n")
 
     return {
       type: "BlockStatement",
@@ -2747,18 +2760,6 @@ PostfixedSingleLineNoCommaStatements
       bare: true,
     }
 
-BracedContent
-  NestedBlockStatements
-  SingleLineStatements
-  # Empty content
-  &( __ "}" ) ->
-    const expressions = []
-    return {
-      type: "BlockStatement",
-      expressions,
-      children: [expressions],
-    }
-
 NestedBlockStatements
   PushIndent NestedBlockStatement*:statements PopIndent ->
     if (!statements.length) return $skip
@@ -4928,7 +4929,7 @@ Condition
       children: [open, ws, expression, close],
       expression,
     }
-  ParenthesizedExpression !( _? ( BinaryOp / AssignmentOp / Dot / QuestionMark ) ) !( _ OperatorAssignmentOp ) -> $1
+  ParenthesizedExpression !TrailingOperator -> $1
   # NOTE: DeclarationCondition must come before the ExpressionCondition because we need to look ahead to potentially match `:=` or `.=`
   InsertOpenParen:open DeclarationCondition:expression InsertCloseParen:close ->
     return {
@@ -7963,7 +7964,7 @@ TypeBullet
     return list
 
 TypeWithPostfix
-  TypeConditional:t ( ( _ / IndentedFurther )? TypeIfClause )?:postfix ->
+  TypeConditional:t ( SameLineOrIndentedFurther TypeIfClause )?:postfix ->
     if (!postfix) return t
     return prepend(postfix[0],
       expressionizeTypeIf([ ...postfix[1], $1, undefined ]))
@@ -8044,7 +8045,7 @@ TypeLiteral
     return { $loc, token: "[]" }
 
 InlineInterfaceLiteral
-  InsertInlineOpenBrace InlineBasicInterfaceProperty ( ( IndentedFurther / _? ) InlineBasicInterfaceProperty )* InsertCloseBrace
+  InsertInlineOpenBrace InlineBasicInterfaceProperty ( SameLineOrIndentedFurther InlineBasicInterfaceProperty )* InsertCloseBrace
 
 InlineBasicInterfaceProperty
   # NOTE: Not using TypeSuffix here to require a Colon, and to forbid spaces
@@ -8053,7 +8054,7 @@ InlineBasicInterfaceProperty
 
 InlineInterfacePropertyDelimiter
   ( _? Semicolon ) / CommaDelimiter
-  &( ( IndentedFurther / _? ) InlineBasicInterfaceProperty ) InsertComma -> $2
+  &( SameLineOrIndentedFurther InlineBasicInterfaceProperty ) InsertComma -> $2
   &( __  ( ":" / ")" / "]" / "}" ) )
   &EOS
 
@@ -8651,6 +8652,13 @@ NotDedented
     if ($2) ws.push(...$2)
     return ws.flat(Infinity).filter(Boolean)
 
+SameLineOrIndentedFurther
+  IndentedFurther? _? ->
+    const ws = []
+    if ($1) ws.push(...$1)
+    if ($2) ws.push(...$2)
+    return ws.flat(Infinity).filter(Boolean)
+
 Dedented
   !IndentedAtLeast EOS -> $2
 

test/class.civet

@@ -9,6 +9,14 @@ describe "class", ->
     class X {}
   """
 
+  testCase """
+    one-line
+    ---
+    class X { a = 5; b = 10 }
+    ---
+    class X { a = 5; b = 10 }
+  """
+
   testCase """
     empty statement
     ---

test/do.civet

@@ -124,6 +124,16 @@ describe "do", ->
     let ref;{ref = void 0;};x = ref
   """
 
+  testCase """
+    braces in a single line
+    ---
+    do { x } = y
+    do { x } := y
+    ---
+    { ({ x } = y) }
+    { const { x } = y }
+  """
+
   testCase """
     expression
     ---

test/if.civet

@@ -13,6 +13,28 @@ describe "if", ->
     }
   """
 
+  testCase """
+    if with braces on next line
+    ---
+    if (true)
+    {
+      return false
+    }
+    ---
+    if (true)
+    {
+      return false
+    }
+  """
+
+  testCase """
+    parenthesized and braced one-line
+    ---
+    if (true) { return false }
+    ---
+    if (true) { return false }
+  """
+
   testCase """
     if with braced body that could be object literal
     ---
@@ -25,6 +47,17 @@ describe "if", ->
     }
   """
 
+  testCase """
+    if with braced body that is an object literal
+    ---
+    if true
+      { x }
+    ---
+    if (true) {
+      ({ x })
+    }
+  """
+
   testCase """
     inline parenthesized expression
     ---
@@ -510,6 +543,23 @@ describe "if", ->
         cond2))) { return }
   """
 
+  testCase """
+    postfix if with braced expression after
+    ---
+    =>
+      f(x) if x
+      {
+        x
+      }
+    ---
+    () => {
+      if (x) { f(x) }
+      return ({
+        x
+      })
+    }
+  """
+
   testCase """
     implied parens parethesized expression
     ---

test/object.civet

@@ -269,31 +269,31 @@ describe "object", ->
   throws """
     doesn't allow bare assignments inside
     ---
-    {x=y}
+    obj = {x=y}
     ---
     ParseError
   """
 
   throws """
     doesn't allow update assignments inside
     ---
-    {x+=y}
+    obj = {x+=y}
     ---
     ParseError
   """
 
   throws """
     doesn't allow update assignments inside
     ---
-    {x-=y}
+    obj = {x-=y}
     ---
     ParseError
   """
 
   throws """
     doesn't allow comparisons inside
     ---
-    {x<=y}
+    obj = {x<=y}
     ---
     ParseError
   """
@@ -1208,15 +1208,15 @@ describe "object", ->
     throws """
       no new properties
       ---
-      {new.target}
+      obj = {new.target}
       ---
       ParseError
     """
 
     throws """
       no meta properties
       ---
-      {import.meta}
+      obj = {import.meta}
       ---
       ParseError
     """