Merge pull request #1466 from DanielXMoore/repl-function-hoist

`repl` directive hoists function and class declarations too, fix one-line declarations in `if`

Author: edemaine

source/parser.hera

@@ -977,10 +977,12 @@ ClassDeclaration
 ClassExpression
   Decorators?:decorators ( Abstract __ )?:abstract Class !":" ClassBinding?:binding ClassHeritage?:heritage ClassBody:body ->
     return {
+      type: "ClassExpression",
       decorators,
       abstract,
       binding,
       id: binding?.[0],
+      name: binding?.[0].name,
       heritage,
       body,
       children: $0,
@@ -2508,7 +2510,7 @@ Block
 
   ThenClause
   # NOTE: !EOS prevents capturing a following unindented Statement
-  _?:ws !EOS Statement:s ->
+  _?:ws !EOS DeclarationOrStatement:s ->
     const expressions = [[ws, s]]
     return {
       type: "BlockStatement",
@@ -5717,6 +5719,7 @@ VariableStatement
       ...$3,
       names: $3.names,
       children: [$1, ...$2, ...$3.children],
+      decl: "var",
     }
 
 # https://262.ecma-international.org/#prod-VariableDeclarationList

source/parser/function.civet

@@ -206,7 +206,7 @@ function processReturnValue(func: FunctionNode)
 
   return true
 
-function patternAsValue(pattern)
+function patternAsValue(pattern): ASTNode
   switch (pattern.type) {
     case "ArrayBindingPattern": {
       const children = [...pattern.children]
@@ -371,36 +371,45 @@ function insertReturn(node: ASTNode, outerNode: ASTNode = node): void
   return if isExit exp
 
   outer := exp
-  {type} .= exp
-  if type is "LabelledStatement"
+  if exp.type is "LabelledStatement"
     exp = exp.statement
-    {type} = exp
 
-  switch type
+  switch exp.type
     when "BreakStatement", "ContinueStatement", "DebuggerStatement", "EmptyStatement", "ReturnStatement", "ThrowStatement"
       return
     when "Declaration"
       value := if exp.bindings?.#
         [" ", patternAsValue(exp.bindings.-1.pattern)]
       else
-        []
-      exp.children.push ["", {
+        [] as ASTNode
+      parent := outer.parent as BlockStatement?
+      index := findChildIndex parent?.expressions, outer
+      assert.notEqual index, -1, "Could not find declaration in parent"
+      parent!.expressions.splice index+1, 0, ["", {
         type: "ReturnStatement"
+        expression: value
         children: [
-          ";return",
-          ...value
+          ";" unless parent!.expressions[index][2] is ";"
+          "return"
+          value
         ]
         parent: exp
       }]
+      braceBlock parent!
       return
     when "FunctionExpression"
       // Add return after function declaration if it has an id to not interfere with hoisting
       if exp.id
-        exp.children.push ["",
+        parent := outer.parent as BlockStatement?
+        index := findChildIndex parent?.expressions, outer
+        assert.notEqual index, -1, "Could not find function declaration in parent"
+        parent!.expressions.splice index+1, 0, ["",
           type: "ReturnStatement"
+          expression: exp.id
           children: [";return ", exp.id]
           parent: exp
         ]
+        braceBlock parent!
         return
       /* c8 ignore next 3 */
       // This is currently never hit because anonymous FunctionExpressions are already wrapped in parens by this point

source/parser/lib.civet

@@ -25,6 +25,7 @@ import type {
   ExpressionNode
   FinallyClause
   ForStatement
+  FunctionExpression
   IfStatement
   IterationStatement
   MemberExpression
@@ -1251,13 +1252,7 @@ function processProgram(root: BlockStatement): void
   adjustAtBindings(statements)
 
   // REPL wants all top-level variables hoisted to outermost scope
-  if config.repl
-    topBlock :=
-      gatherRecursive(rootIIFE!, .type is 'BlockStatement')[0]
-    for each [, statement] of topBlock.expressions
-      if statement is like {type: 'Declaration'}
-        statement.children.shift() // remove const/let/var
-        root.expressions.unshift ['', `var ${statement.names.join ','};`]
+  processRepl root, rootIIFE if config.repl
 
   // Run synchronous versions of async steps in case we're in sync mode
   if getSync()
@@ -1268,8 +1263,34 @@ async function processProgramAsync(root: BlockStatement): Promise<void>
   { expressions: statements } := root
   await processComptime(statements)
 
+function processRepl(root: BlockStatement, rootIIFE: ASTNode): void
+  topBlock :=
+    gatherRecursive(rootIIFE!, .type is "BlockStatement")[0]
+  i .= 0
+  // Hoist top-level declarations and all var declarations
+  for each decl of gatherRecursiveWithinFunction topBlock, .type is "Declaration"
+    if decl.parent is topBlock or decl.decl is "var"
+      decl.children.shift() // remove const/let/var
+      root.expressions.splice i++, 0, ["", `var ${decl.names.join ','};`]
+  // Hoist all function declarations, and hoist values when top-level
+  for each func of gatherRecursive topBlock, .type is "FunctionExpression"
+    if func.name and func.parent?.type is "BlockStatement" // declaration
+      if func.parent is topBlock
+        // Top-level => hoist to beginning
+        replaceNode func, undefined
+        root.expressions.splice i++, 0, ["", func]
+        func.parent = root
+      else
+        func.children.unshift func.name, "="
+        root.expressions.splice i++, 0, ["", `var ${func.name};`]
+  // Hoist top-level class declarations (like `let`)
+  for each classExp of gatherRecursiveWithinFunction topBlock, .type is "ClassExpression"
+    if classExp.name and classExp.parent is topBlock or classExp.parent is like {type: "ReturnStatement", parent: ^topBlock}
+      classExp.children.unshift classExp.name, "="
+      root.expressions.splice i++, 0, ["", `var ${classExp.name};`]
+
 function populateRefs(statements: ASTNode): void {
-  const refNodes = gatherRecursive(statements, ({ type }) => type is "Ref")
+  const refNodes = gatherRecursive(statements, .type is "Ref")
 
   if (refNodes.length) {
     // Find all ids within nested scopes

source/parser/traversal.civet

@@ -19,7 +19,7 @@ function gatherRecursiveWithinFunction<T extends ASTNodeObject>(node: ASTNode, p
  * which is useful for working with e.g. the `expressions` property.
  * Returns -1 if `child` cannot be found.
  */
-function findChildIndex(parent: ASTNodeObject | Children, child: ASTNode)
+function findChildIndex(parent: (ASTNodeObject | Children)?, child: ASTNode)
   return -1 unless parent?
   children := Array.isArray(parent) ? parent : (parent as {children?: Children}).children
   return -1 unless children?

source/parser/types.civet

@@ -41,6 +41,7 @@ export type ExpressionNode =
   | AssignmentExpression
   | BinaryOp
   | CallExpression
+  | ClassExpression
   | ComptimeExpression
   | Existence
   | FunctionNode
@@ -370,29 +371,34 @@ export type CaseBlock
   type: "CaseBlock"
   clauses: (PatternClause | CaseClause | WhenClause | DefaultClause)[]
   children: Children
+  parent?: Parent
 
 export type PatternClause
   type: "PatternClause"
   children: Children
+  parent?: Parent
   patterns: PatternExpression[]
   block: BlockStatement
 
 export type CaseClause
   type: "CaseClause"
   children: Children
+  parent?: Parent
   cases: ASTNode[]
   block: BlockStatement
 
 export type WhenClause
   type: "WhenClause"
   children: Children
+  parent?: Parent
   cases: ASTNode[]
   break: ASTNode
   block: BlockStatement
 
 export type DefaultClause
   type: "DefaultClause"
   children: Children
+  parent?: Parent
   block: BlockStatement
 
 export type EmptyStatement
@@ -456,6 +462,7 @@ export type AtBinding =
   type: "AtBinding"
   ref: ASTRef
   children: Children & [ASTRef]
+  parent?: Parent
 
 export type BlockStatement =
   type: "BlockStatement"
@@ -498,6 +505,7 @@ export type DeclarationStatement =
 export type Binding =
   type: "Binding"
   children: Children
+  parent?: Parent
   names: string[]
   pattern: BindingIdentifier | BindingPattern
   typeSuffix: TypeSuffix?
@@ -638,6 +646,7 @@ export type Placeholder =
 export type PinPattern =
   type: "PinPattern"
   children: Children
+  parent?: Parent
   expression: ExpressionNode
 
 // _?, __
@@ -701,6 +710,7 @@ export type ObjectBindingPatternContent =
 export type ObjectBindingPattern =
   type: "ObjectBindingPattern",
   children: Children & [Whitespace, ASTLeaf, ObjectBindingPatternContent, WSNode, ASTLeaf]
+  parent?: Parent
   names: string[]
   properties: ObjectBindingPatternContent
   typeSuffix?: TypeSuffix?
@@ -747,11 +757,12 @@ export type Argument
   expression: ASTNode
   spread: ASTNode?
 
-export type FunctionExpression =
+export type FunctionExpression
   type: "FunctionExpression"
   children: Children
   parent?: Parent
   name: string
+  id: Identifier
   async: ASTNode[]
   generator: ASTNode[]
   signature: FunctionSignature
@@ -805,6 +816,7 @@ export type FunctionSignature =
   children: Children
   parent?: Parent
   name: string
+  id: Identifier
   optional: unknown
   modifier: MethodModifier
   returnType: ReturnTypeAnnotation?
@@ -817,6 +829,7 @@ export type TypeSuffix =
   nonnull?: ASTNode
   t?: ASTNode
   children: Children
+  parent?: Parent
 
 export type ReturnTypeAnnotation =
   type: "ReturnTypeAnnotation"
@@ -857,8 +870,19 @@ export type TypeParameters = unknown
 
 export type FunctionNode = FunctionExpression | ArrowFunction | MethodDefinition
 
+export type ClassExpression
+  type: "ClassExpression"
+  children: Children
+  parent?: Parent
+  name: string
+  id: Identifier
+  heritage: ASTNode
+  body: ClassBody
+
+export type ClassBody = BlockStatement & { subtype: "ClassBody" }
+
 export type Literal =
-  type: "Literal",
+  type: "Literal"
   subtype?: "NumericLiteral" | "StringLiteral"
   children: Children & [ LiteralContentNode ]
   parent?: Parent

source/parser/util.civet

@@ -24,6 +24,9 @@ assert := {
   equal(a: unknown, b: unknown, msg: string): void
     /* c8 ignore next */
     throw new Error(`Assertion failed [${msg}]: ${a} !== ${b}`) if a !== b
+  notEqual(a: unknown, b: unknown, msg: string): void
+    /* c8 ignore next */
+    throw new Error(`Assertion failed [${msg}]: ${a} === ${b}`) if a === b
 }
 
 /**

test/function.civet

@@ -93,20 +93,6 @@ describe "function", ->
     const x =function() { return a }
   """
 
-  testCase """
-    const declaration as implicit return
-    ---
-    ->
-      fn2 := () ->
-        x
-    ---
-    (function() {
-      const fn2 = function() {
-        return x
-      };return fn2
-    })
-  """
-
   testCase """
     async const declaration
     ---
@@ -555,25 +541,6 @@ describe "function", ->
     }]
   """
 
-  testCase """
-    nested implicit return fat arrow
-    ---
-    function g() {
-      function f() {
-        y((node) =>
-            x)
-      }
-    }
-    ---
-    function g() {
-      function f() {
-        return y((node) => {
-            return x
-        })
-      };return f
-    }
-  """
-
   testCase """
     fat interprets single arg without parens as function application
     ---
@@ -1112,6 +1079,20 @@ describe "function", ->
       (function() { $2.implicit = $1.generated; $2; })
     """
 
+    testCase """
+      const declaration
+      ---
+      ->
+        fn2 := () ->
+          x
+      ---
+      (function() {
+        const fn2 = function() {
+          return x
+        };return fn2
+      })
+    """
+
     testCase """
       renamed declaration
       ---
@@ -1134,6 +1115,33 @@ describe "function", ->
       })
     """
 
+    testCase """
+      nested implicit return fat arrow
+      ---
+      function g() {
+        function f() {
+          y((node) =>
+              x)
+        }
+      }
+      ---
+      function g() {
+        function f() {
+          return y((node) => {
+              return x
+          })
+        };return f
+      }
+    """
+
+    testCase """
+      one-line function adds braces
+      ---
+      (x) => if (x) function f() { x }
+      ---
+      (x) => { if (x) { function f() { return x };return f};return }
+    """
+
     testCase """
       inline multi-statement longhand
       ---