8134982617

Committed 04 Mar 2024 02:18AM UTC coverage: 91.881% (+0.01%) from 91.868%

Build # 8134982617

Build Type

Pull #1077

github

Committed by

web-flow

Commit Message

Merge 8fcee0e40 into aa6945014

Pull Request Pull Request #1077: Statement expressions

Run Details

1966 of 2143 branches covered (91.74%)

Branch coverage included in aggregate %.

561 of 569 new or added lines in 7 files covered. (98.59%)

2 existing lines in 1 file now uncovered.

13222 of 14387 relevant lines covered (91.9%)

28282.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.34

/source/parser/function.civet

import type {
  ASTNode
  ASTNodeBase
  DoStatement
  ForStatement
  FunctionNode
  IterationExpression
  IterationStatement
  LabeledStatement
  StatementTuple
  TypeIdentifierNode
  TypeNode
} from ./types.civet

import {
  braceBlock
  getIndent
  makeEmptyBlock
} from ./block.civet

import {
  gatherBindingCode
} from ./binding.civet

import {
  findAncestor
  findChildIndex
  gatherNodes
  gatherRecursiveAll
  gatherRecursiveWithinFunction
} from ./traversal.civet

import {
  assert
  convertOptionalType
  isEmptyBareBlock
  isFunction
  isWhitespaceOrEmpty
  makeRef
  updateParentPointers
  wrapIIFE
  wrapWithReturn
} from ./util.civet

function isVoidType(t?: TypeNode): boolean
  return t?.type is "LiteralType" and t.t.type is "VoidType"

function isPromiseVoidType(t?: TypeIdentifierNode): boolean
  return t?.type is "IdentifierType" and t.raw is "Promise" &&
    t.args?.types?.length is 1 and isVoidType(t.args.types[0])

function isGeneratorVoidType(t?: TypeIdentifierNode): boolean
  return t?.type is "IdentifierType" and
    (t.raw is "Iterator" or t.raw is "Generator") and
    t.args?.types?.length >= 2 and isVoidType(t.args.types[1])

function isAsyncGeneratorVoidType(t?: TypeIdentifierNode): boolean
  return t?.type is "IdentifierType" and
    (t.raw is "AsyncIterator" or t.raw is "AsyncGenerator") and
    t.args?.types?.length >= 2 and isVoidType(t.args.types[1])

// Add implicit block unless followed by a method/function of the same name,
// or block is within an ExportDeclaration.
function implicitFunctionBlock(f): void {
  if (f.abstract or f.block or f.signature?.optional) return

  const { name, parent } = f
  if (parent?.type is "ExportDeclaration") return
  const expressions = parent?.expressions ?? parent?.elements
  const currentIndex = expressions?.findIndex(([, def]) => def is f)
  const following = currentIndex >= 0 and expressions[currentIndex + 1]?.[1]

  if (f.type is following?.type and name and name is following.name) {
    f.ts = true
  } else {
    const block = makeEmptyBlock()
    block.parent = f
    f.block = block
    f.children.push(block)
    f.ts = false
  }
}

function processReturn(f: FunctionNode, implicitReturns: boolean): void
  { returnType } .= f.signature
  if returnType and returnType.optional
    convertOptionalType returnType

  if (!processReturnValue(f) and implicitReturns)
    { signature, block } := f
    { modifier, name, returnType } := signature
    { async, generator, set } := modifier
    isMethod := f.type is "MethodDefinition"
    isConstructor := isMethod and name is "constructor"
    isVoid := (or)
      isVoidType(returnType?.t)
      (and)
        async
        (or)
          isPromiseVoidType(returnType?.t)
          generator and isAsyncGeneratorVoidType(returnType?.t)
      (and)
        not async
        generator
        isGeneratorVoidType(returnType?.t)

    if block?.type is "BlockStatement"
      if isVoid or set or isConstructor
        if block.bare and block.implicitlyReturned
          block.children = [ " {", ...block.children, " }" ]
          block.bare = block.implicitlyReturned = false
      else
        unless block.implicitlyReturned
          insertReturn(block)

/**
 * Support for `return.value` and `return =`
 * for changing automatic return value of function.
 * Returns whether any present (so shouldn't do implicit return).
 */
function processReturnValue(func: FunctionNode)
  { block } := func
  values: ASTNodeBase[] := (gatherRecursiveWithinFunction block,
    ({ type }) => type is "ReturnValue") as ASTNodeBase[]
  return false unless values.length

  ref := makeRef "ret"

  let declaration
  values.forEach (value) =>
    value.children = [ref]

    // Check whether return.value already declared within this function
    { ancestor, child } := findAncestor(value,
      ({ type }) => type is "Declaration",
      isFunction)
    declaration ??= child if ancestor  // remember binding

  // Compute default return type
  returnType .= func.returnType ?? func.signature?.returnType
  if returnType
    { t } := returnType
    switch t.type
      "TypePredicate"
        returnType = ": boolean"
      "AssertsType"
        returnType = undefined

  // Modify existing declaration, or add declaration of return.value after {
  if declaration
    unless declaration.suffix?
      declaration.children[1] = declaration.suffix = returnType
  else
    block.expressions.unshift [
      getIndent block.expressions[0]
    ,
      type: "Declaration"
      children: ["let ", ref, returnType]
      names: []
    ,
      ";"
    ]

  // Transform existing `return` -> `return ret`
  gatherRecursiveWithinFunction block,
    (r) => r.type is "ReturnStatement" and not r.expression
  .forEach (r) =>
    r.expression = ref
    r.children.splice -1, 1, " ", ref

  // Implicit return before }
  unless block.children.-2?.type is "ReturnStatement"
    indent := getIndent(block.expressions.-1) or ";"
    block.expressions.push [
      [indent]
    ,
      type: "ReturnStatement",
      expression: ref,
      children: ["return ", ref]
    ]

  return true

function patternAsValue(pattern)
  switch (pattern.type) {
    case "ArrayBindingPattern": {
      const children = [...pattern.children]
      const index = children.indexOf(pattern.elements)
      if (index < 0) throw new Error("failed to find elements in ArrayBindingPattern")
      children[index] = pattern.elements.map((el) => {
        const [ws, e, delim] = el.children
        return { ...el, children: [ws, patternAsValue(e), delim] }
      })
      return { ...pattern, children }
    }
    case "ObjectBindingPattern": {
      const children = [...pattern.children]
      const index = children.indexOf(pattern.properties)
      if (index < 0) throw new Error("failed to find properties in ArrayBindingPattern")
      children[index] = pattern.properties.map(patternAsValue)
      return { ...pattern, children }
    }
    case "Identifier":
    case "BindingProperty": {
      const children = [pattern.name, pattern.delim]
      // Check for leading whitespace
      if (isWhitespaceOrEmpty(pattern.children[0])) {
        children.unshift(pattern.children[0])
      }
      return { ...pattern, children }
    }
    default:
      return pattern
  }

// NOTE: this is almost the same as insertReturn but doesn't remove `breaks` in `when` and
// does construct an else clause pushing undefined in if statements that lack them
// and adds to the beginning and the end of the expression's children.
// Maybe these insertion modifications can be refactored to be more DRY eventually.
function assignResults(node: StatementTuple[] | ASTNode, collect: (node: ASTNode) => ASTNode): void
  if (!node) return
  // TODO: unify this with the `exp` switch
  switch node.type
    case "BlockStatement":
      if node.expressions.length
        assignResults(node.expressions.-1, collect)
      else
        node.expressions.push(["", collect("void 0"), ";"])
      return
    case "CaseBlock":
      node.clauses.forEach (clause) =>
        assignResults(clause, collect)
      return
    when "WhenClause", "DefaultClause", "PatternClause"
      assignResults(node.block, collect)
      return

  return  unless Array.isArray node

  [, exp] .= node
  return unless exp

  outer := exp
  {type} .= exp
  if type is "LabelledStatement"
    exp = (exp as LabeledStatement).statement
    {type} = exp

  switch exp.type
    case "BreakStatement":
    case "ContinueStatement":
    case "DebuggerStatement":
    case "EmptyStatement":
    case "ReturnStatement":
    case "ThrowStatement":
      return
    case "Declaration":
      exp.children.push([
        "", [";", collect(patternAsValue(exp.bindings.-1.pattern)) ]
      ])
      return
    case "ForStatement":
    case "IterationStatement":
    case "DoStatement":
      wrapIterationReturningResults(exp, outer, collect)
      return
    case "BlockStatement":
      assignResults(exp.expressions[exp.expressions.length - 1], collect)
      return
    case "IfStatement":
      // if block
      assignResults(exp.then, collect)
      if exp.then.bare and not exp.then.semicolon
        exp.then.children.push exp.then.semicolon = ";"

      // else block
      if (exp.else)
        assignResults(exp.else[2], collect)
      else // Add else block pushing undefined if no else block
        exp.children.push([" else {", collect("undefined"), "}"])
      return
    case "PatternMatchingStatement":
      assignResults(exp.children[0][0], collect)
      return
    case "SwitchStatement":
      // insert a results.push in each case block
      assignResults(exp.children[2], collect)
      return
    case "TryStatement":
      // NOTE: CoffeeScript doesn't add a push to an empty catch block but does add if there is any statement in the catch block
      // we always add a push to the catch block
      // NOTE: does not insert a push in the finally block
      exp.blocks.forEach((block) => assignResults(block, collect))
      return

  // Don't push if there's a trailing semicolon
  return if node.-1?.type is "SemicolonDelimiter"

  // Insert push wrapping expression
  node[1] = collect(node[1])

// [indent, statement, semicolon]
function insertReturn(node: ASTNode, outerNode: ASTNode = node): void
  if (!node) return
  // TODO: unify this with the `exp` switch
  switch node.type
    case "BlockStatement":
      if node.expressions.length
        const last = node.expressions[node.expressions.length - 1]
        insertReturn(last)
      else
        // NOTE: Kind of hacky but I'm too much of a coward to make `->` add an implicit return
        if node.parent.type is "CatchClause"
          node.expressions.push(["return"])
      return
    // NOTE: "CaseClause"s don't get a return statements inserted
    case "WhenClause":
      // Remove inserted `break;` if it hasn't already been removed
      node.children.splice node.children.indexOf(node.break), 1 if node.break
      if node.block.expressions.length
        insertReturn(node.block)
      else
        node.block.expressions.push(wrapWithReturn())
      return
    case "DefaultClause":
      insertReturn(node.block)
      return
  if (!Array.isArray(node)) return

  [, exp, semi] .= node
  return if semi?.type is "SemicolonDelimiter"
  return unless exp

  outer := exp
  {type} .= exp
  if type is "LabelledStatement"
    exp = (exp as LabeledStatement).statement
    {type} = exp

  switch type
    case "BreakStatement":
    case "ContinueStatement":
    case "DebuggerStatement":
    case "EmptyStatement":
    case "ReturnStatement":
    case "ThrowStatement":
      return
    case "Declaration":
      exp.children.push ["", {
        type: "ReturnStatement",
        children: [";return ", patternAsValue(exp.bindings.-1.pattern)],
        parent: exp
      }]
      return
    case "FunctionExpression":
      // Add return after function declaration if it has an id to not interfere with hoisting
      if (exp.id)
        exp.children.push ["",
          type: "ReturnStatement"
          children: [";return ", exp.id]
          parent: exp
        ]
        return
      /* c8 ignore next 3 */
      // This is currently never hit because anonymous FunctionExpressions are already wrapped in parens by this point
      // Add return in normal way for functions without ids
      break
    case "ForStatement":
    case "IterationStatement":
    case "DoStatement":
      wrapIterationReturningResults(exp, outer)
      return
    case "BlockStatement":
      insertReturn(exp.expressions[exp.expressions.length - 1])
      return
    case "IfStatement":
      // if block
      insertReturn(exp.then)
      // else block
      if (exp.else) insertReturn(exp.else[2])
      // Add explicit return after if block if no else block
      else exp.children.push ["", {
        type: "ReturnStatement"
        // NOTE: add a prefixed semi-colon because the if block may not be braced
        children: [";return"]
        parent: exp
      }]
      return
    case "PatternMatchingStatement":
      insertReturn(exp.children[0][0])
      return
    case "SwitchStatement":
      insertSwitchReturns(exp)
      return
    case "TryStatement":
      exp.blocks.forEach((block) => insertReturn(block))
      // NOTE: do not insert a return in the finally block
      return

  // Don't add return if there's a trailing semicolon
  if (node[node.length - 1]?.type is "SemicolonDelimiter") return

  // Insert return after indentation and before expression
  const returnStatement = wrapWithReturn(node[1])
  node.splice(1, 1, returnStatement)

// insert a return in each when/else/default block
// case blocks don't get implicit returns
// maybe default blocks shouldn't either?
function insertSwitchReturns(exp): void
  exp.caseBlock.clauses.forEach (clause) =>
    insertReturn clause

function wrapIterationReturningResults(
  statement: ForStatement | IterationStatement | DoStatement,
  outer: { children: StatementTuple[] },
  collect?: (node: ASTNode) => ASTNode
): void
  if statement.type is "DoStatement"
    if collect
      assignResults(statement.block, collect)
    else
      insertReturn(statement.block, outer)
    return

  assert.equal statement.resultsRef, undefined,
    "wrapIterationReturningResults should not be called twice on the same statement"

  resultsRef := statement.resultsRef = makeRef "results"

  declaration :=
    type: "Declaration"
    children: ["const ", resultsRef, "=[]"]

  outer.children.unshift(["", declaration, ";"])

  assignResults statement.block, (node) =>
    // TODO: real ast node
    [ resultsRef, ".push(", node, ")" ]

  if collect
    statement.children.push collect(resultsRef)
  else
    statement.children.push(";return ", resultsRef, ";")

function processParams(f): void
  const { type, parameters, block } = f
  const isConstructor = f.name is 'constructor'

  // Check for singleton TypeParameters <Foo> before arrow function,
  // which TypeScript (in tsx mode) treats like JSX; replace with <Foo,>
  if (type is "ArrowFunction" and parameters and parameters.tp and parameters.tp.parameters.length is 1) {
    parameters.tp.parameters.push(",")
  }

  if (!block) return
  const { expressions } = block
  if (!expressions) return
  const { blockPrefix } = parameters

  let indent: string
  if (!expressions.length) {
    indent = ""
  } else {
    indent = expressions[0][0]
  }

  const [splices, thisAssignments] = gatherBindingCode(parameters, {
    injectParamProps: isConstructor
  })

  const delimiter = {
    type: "SemicolonDelimiter",
    children: [";"],
  }

  const prefix = splices
    .map (s) => ["let ", s]
    .concat(thisAssignments)
    .map((s) => s.type
      ? {
        // TODO: figure out how to get JS only statement tuples
        ...s,
        children: [indent, ...s.children, delimiter]
      }
      : [indent, s, delimiter]
    )

  if (!prefix.length) return
  // In constructor definition, insert prefix after first super() call
  if (isConstructor) {
    const superCalls = gatherNodes expressions, (exp) =>
      exp.type is "CallExpression" and exp.children[0]?.token is "super"
    if (superCalls.length) {
      const {child} = findAncestor(superCalls[0],
        (ancestor) => ancestor is block)
      const index = findChildIndex(expressions, child)
      if (index < 0) {
        throw new Error("Could not find super call within top-level expressions")
      }
      expressions.splice(index + 1, 0, ...prefix)
      return
    }
  }
  expressions.unshift(...prefix)

function processFunctions(statements, config): void
  gatherRecursiveAll(statements, ({ type }) => type is "FunctionExpression" or type is "ArrowFunction")
  .forEach (f) =>
    if (f.type is "FunctionExpression") implicitFunctionBlock(f)
    processParams(f)
    processReturn(f, config.implicitReturns)

  gatherRecursiveAll(statements, ({ type }) => type is "MethodDefinition")
  .forEach (f) =>
    implicitFunctionBlock(f)
    processParams(f)
    processReturn(f, config.implicitReturns)

function expressionizeIteration(exp: IterationExpression): void
  { async, subtype, block, children, statement } := exp
  i := children.indexOf statement
  if i < 0
    throw new Error("Could not find iteration statement in iteration expression")

  if subtype is "DoStatement"
    // Just wrap with IIFE
    insertReturn(block)
    children.splice(i, 1, ...wrapIIFE(["", statement, undefined], async))
    updateParentPointers exp
    return

  exp.resultsRef ??= makeRef "results"
  { resultsRef } := exp

  // insert `results.push` to gather results array
  assignResults block, (node) =>
    // TODO: real node
    [ resultsRef, ".push(", node, ")" ]
  braceBlock(block)

  // Wrap with IIFE
  children.splice(i,
    1,
    ...wrapIIFE([
      ["", ["const ", resultsRef, "=[]"], ";"],
      ...children.map((c) => ["", c, undefined]),
      ["", wrapWithReturn(resultsRef)],
    ], async)
  )
  updateParentPointers exp

/**
Utility function to check if an implicit function application should be skipped
based on the shape of the arguments.

Don't treat as call if this is a postfix for/while/until/if/unless
*/
function skipImplicitArguments(args: unknown[])
  if args.length is 1
    arg0 .= args[0]
    if Array.isArray arg0
      arg0 = arg0[1] // skip whitespace

    if arg0.type is "StatementExpression"
      arg0 = arg0.statement

    return (and)
      arg0.type is "IterationExpression"
      arg0.subtype !== "DoStatement"
      !arg0.async
      isEmptyBareBlock arg0.block

  return false

export {
  assignResults
  expressionizeIteration
  processFunctions
  skipImplicitArguments
  wrapIterationReturningResults
}

1	import type {	1✔
2	ASTNode	1✔
3	ASTNodeBase	1✔
4	DoStatement	1✔
5	ForStatement	1✔
6	FunctionNode	1✔
7	IterationExpression	1✔
8	IterationStatement	1✔
9	LabeledStatement	1✔
10	StatementTuple	1✔
11	TypeIdentifierNode	1✔
12	TypeNode	1✔
13	} from ./types.civet	1✔
14		1✔
15	import {	1✔
16	braceBlock	1✔
17	getIndent	1✔
18	makeEmptyBlock	1✔
19	} from ./block.civet	1✔
20		1✔
21	import {	1✔
22	gatherBindingCode	1✔
23	} from ./binding.civet	1✔
24		1✔
25	import {	1✔
26	findAncestor	1✔
27	findChildIndex	1✔
28	gatherNodes	1✔
29	gatherRecursiveAll	1✔
30	gatherRecursiveWithinFunction	1✔
31	} from ./traversal.civet	1✔
32		1✔
33	import {	1✔
34	assert	1✔
35	convertOptionalType	1✔
36	isEmptyBareBlock	1✔
37	isFunction	1✔
38	isWhitespaceOrEmpty	1✔
39	makeRef	1✔
40	updateParentPointers	1✔
41	wrapIIFE	1✔
42	wrapWithReturn	1✔
43	} from ./util.civet	1✔
44		1✔
45	function isVoidType(t?: TypeNode): boolean	674✔
46	return t?.type is "LiteralType" and t.t.type is "VoidType"	674✔
47		1✔
48	function isPromiseVoidType(t?: TypeIdentifierNode): boolean	46✔
49	return t?.type is "IdentifierType" and t.raw is "Promise" &&	46✔
50	t.args?.types?.length is 1 and isVoidType(t.args.types[0])	46✔
51		1✔
52	function isGeneratorVoidType(t?: TypeIdentifierNode): boolean	17✔
53	return t?.type is "IdentifierType" and	17✔
54	(t.raw is "Iterator" or t.raw is "Generator") and	17✔
55	t.args?.types?.length >= 2 and isVoidType(t.args.types[1])	17✔
56		1✔
57	function isAsyncGeneratorVoidType(t?: TypeIdentifierNode): boolean	7✔
58	return t?.type is "IdentifierType" and	7✔
59	(t.raw is "AsyncIterator" or t.raw is "AsyncGenerator") and	7✔
60	t.args?.types?.length >= 2 and isVoidType(t.args.types[1])	7✔
61		1✔
62	// Add implicit block unless followed by a method/function of the same name,	1✔
63	// or block is within an ExportDeclaration.	1✔
64	function implicitFunctionBlock(f): void {	480✔
65	if (f.abstract or f.block or f.signature?.optional) return	480✔
66		27✔
67	const { name, parent } = f	27✔
68	if (parent?.type is "ExportDeclaration") return	480✔
69	const expressions = parent?.expressions ?? parent?.elements	480✔
70	const currentIndex = expressions?.findIndex(([, def]) => def is f)	480✔
71	const following = currentIndex >= 0 and expressions[currentIndex + 1]?.[1]	480✔
72		480✔
73	if (f.type is following?.type and name and name is following.name) {	480✔
74	f.ts = true	12✔
75	} else {	480✔
76	const block = makeEmptyBlock()	13✔
77	block.parent = f	13✔
78	f.block = block	13✔
79	f.children.push(block)	13✔
80	f.ts = false	13✔
81	}	13✔
82	}	480✔
83		1✔
84	function processReturn(f: FunctionNode, implicitReturns: boolean): void	690✔
85	{ returnType } .= f.signature	690✔
86	if returnType and returnType.optional	690✔
87	convertOptionalType returnType	3✔
88		690✔
89	if (!processReturnValue(f) and implicitReturns)	690✔
90	{ signature, block } := f	690✔
91	{ modifier, name, returnType } := signature	690✔
92	{ async, generator, set } := modifier	690✔
93	isMethod := f.type is "MethodDefinition"	690✔
94	isConstructor := isMethod and name is "constructor"	690✔
95	isVoid := (or)	690✔
96	isVoidType(returnType?.t)	690✔
97	(and)	690✔
98	async	690✔
99	(or)	690✔
100	isPromiseVoidType(returnType?.t)	690✔
101	generator and isAsyncGeneratorVoidType(returnType?.t)	690✔
102	(and)	690✔
103	not async	690✔
104	generator	690✔
105	isGeneratorVoidType(returnType?.t)	690✔
106		690✔
107	if block?.type is "BlockStatement"	690✔
108	if isVoid or set or isConstructor	690✔
109	if block.bare and block.implicitlyReturned	52✔
110	block.children = [ " {", ...block.children, " }" ]	52✔
111	block.bare = block.implicitlyReturned = false	52✔
112	else	690✔
113	unless block.implicitlyReturned	690✔
114	insertReturn(block)	690✔
115		1✔
116	/**	1✔
117	* Support for `return.value` and `return =`	1✔
118	* for changing automatic return value of function.	1✔
119	* Returns whether any present (so shouldn't do implicit return).	1✔
120	*/	1✔
121	function processReturnValue(func: FunctionNode)	690✔
122	{ block } := func	690✔
123	values: ASTNodeBase[] := (gatherRecursiveWithinFunction block,	690✔
124	({ type }) => type is "ReturnValue") as ASTNodeBase[]	690✔
125	return false unless values.length	690✔
126		22✔
127	ref := makeRef "ret"	22✔
128		22✔
129	let declaration	22✔
130	values.forEach (value) =>	22✔
131	value.children = [ref]	32✔
132		32✔
133	// Check whether return.value already declared within this function	32✔
134	{ ancestor, child } := findAncestor(value,	32✔
135	({ type }) => type is "Declaration",	32✔
136	isFunction)	32✔
137	declaration ??= child if ancestor // remember binding	22✔
138		22✔
139	// Compute default return type	22✔
140	returnType .= func.returnType ?? func.signature?.returnType	690✔
141	if returnType	690✔
142	{ t } := returnType	7✔
143	switch t.type	7✔
144	"TypePredicate"	7✔
145	returnType = ": boolean"	7✔
146	"AssertsType"	7✔
147	returnType = undefined	7✔
148		22✔
149	// Modify existing declaration, or add declaration of return.value after {	22✔
150	if declaration	22✔
151	unless declaration.suffix?	10✔
152	declaration.children[1] = declaration.suffix = returnType	10✔
153	else	12✔
154	block.expressions.unshift [	12✔
155	getIndent block.expressions[0]	12✔
156	,	12✔
157	type: "Declaration"	12✔
158	children: ["let ", ref, returnType]	12✔
159	names: []	12✔
160	,	12✔
161	";"	12✔
162	]	12✔
163		22✔
164	// Transform existing `return` -> `return ret`	22✔
165	gatherRecursiveWithinFunction block,	22✔
166	(r) => r.type is "ReturnStatement" and not r.expression	22✔
167	.forEach (r) =>	22✔
168	r.expression = ref	1✔
169	r.children.splice -1, 1, " ", ref	1✔
170		22✔
171	// Implicit return before }	22✔
172	unless block.children.-2?.type is "ReturnStatement"	690✔
173	indent := getIndent(block.expressions.-1) or ";"	22✔
174	block.expressions.push [	22✔
175	[indent]	22✔
176	,	22✔
177	type: "ReturnStatement",	22✔
178	expression: ref,	22✔
179	children: ["return ", ref]	22✔
180	]	22✔
181		22✔
182	return true	22✔
183		1✔
184	function patternAsValue(pattern)	24✔
185	switch (pattern.type) {	24✔
186	case "ArrayBindingPattern": {	24✔
187	const children = [...pattern.children]	1✔
188	const index = children.indexOf(pattern.elements)	1✔
189	if (index < 0) throw new Error("failed to find elements in ArrayBindingPattern")	1!
190	children[index] = pattern.elements.map((el) => {	1✔
191	const [ws, e, delim] = el.children	3✔
192	return { ...el, children: [ws, patternAsValue(e), delim] }	3✔
193	})	1✔
194	return { ...pattern, children }	1✔
195	}	1✔
196	case "ObjectBindingPattern": {	24✔
197	const children = [...pattern.children]	2✔
198	const index = children.indexOf(pattern.properties)	2✔
199	if (index < 0) throw new Error("failed to find properties in ArrayBindingPattern")	2!
200	children[index] = pattern.properties.map(patternAsValue)	2✔
201	return { ...pattern, children }	2✔
202	}	2✔
203	case "Identifier":	24✔
204	case "BindingProperty": {	24✔
205	const children = [pattern.name, pattern.delim]	19✔
206	// Check for leading whitespace	19✔
207	if (isWhitespaceOrEmpty(pattern.children[0])) {	19✔
208	children.unshift(pattern.children[0])	5✔
209	}	5✔
210	return { ...pattern, children }	19✔
211	}	19✔
212	default:	24✔
213	return pattern	2✔
214	}	24✔
215		1✔
216	// NOTE: this is almost the same as insertReturn but doesn't remove `breaks` in `when` and	1✔
217	// does construct an else clause pushing undefined in if statements that lack them	1✔
218	// and adds to the beginning and the end of the expression's children.	1✔
219	// Maybe these insertion modifications can be refactored to be more DRY eventually.	1✔
220	function assignResults(node: StatementTuple[] \| ASTNode, collect: (node: ASTNode) => ASTNode): void	262✔
221	if (!node) return	262!
222	// TODO: unify this with the `exp` switch	262✔
223	switch node.type	262✔
224	case "BlockStatement":	262✔
225	if node.expressions.length	108✔
226	assignResults(node.expressions.-1, collect)	102✔
227	else	6✔
228	node.expressions.push(["", collect("void 0"), ";"])	6✔
229	return	108✔
230	case "CaseBlock":	262✔
231	node.clauses.forEach (clause) =>	6✔
232	assignResults(clause, collect)	18✔
233	return	6✔
234	when "WhenClause", "DefaultClause", "PatternClause"	262✔
235	assignResults(node.block, collect)	262✔
236	return	262✔
237		130✔
238	return unless Array.isArray node	130✔
239		130✔
240	[, exp] .= node	130✔
241	return unless exp	130✔
242		130✔
243	outer := exp	130✔
244	{type} .= exp	130✔
245	if type is "LabelledStatement"	130✔
246	exp = (exp as LabeledStatement).statement	1✔
247	{type} = exp	1✔
248		130✔
249	switch exp.type	130✔
250	case "BreakStatement":	262!
251	case "ContinueStatement":	262!
252	case "DebuggerStatement":	262✔
253	case "EmptyStatement":	262✔
254	case "ReturnStatement":	262✔
255	case "ThrowStatement":	262✔
256	return	4✔
257	case "Declaration":	262✔
258	exp.children.push([	1✔
259	"", [";", collect(patternAsValue(exp.bindings.-1.pattern)) ]	1✔
260	])	1✔
261	return	1✔
262	case "ForStatement":	262✔
263	case "IterationStatement":	262✔
264	case "DoStatement":	262✔
265	wrapIterationReturningResults(exp, outer, collect)	6✔
266	return	6✔
267	case "BlockStatement":	262!
268	assignResults(exp.expressions[exp.expressions.length - 1], collect)	×
269	return	×
270	case "IfStatement":	262✔
271	// if block	20✔
272	assignResults(exp.then, collect)	20✔
273	if exp.then.bare and not exp.then.semicolon	20✔
274	exp.then.children.push exp.then.semicolon = ";"	1✔
275		20✔
276	// else block	20✔
277	if (exp.else)	20✔
278	assignResults(exp.else[2], collect)	16✔
279	else // Add else block pushing undefined if no else block	4✔
280	exp.children.push([" else {", collect("undefined"), "}"])	4✔
281	return	20✔
282	case "PatternMatchingStatement":	262!
UNCOV 283	assignResults(exp.children[0][0], collect)	×
UNCOV 284	return	×
285	case "SwitchStatement":	262✔
286	// insert a results.push in each case block	6✔
287	assignResults(exp.children[2], collect)	6✔
288	return	6✔
289	case "TryStatement":	262✔
290	// NOTE: CoffeeScript doesn't add a push to an empty catch block but does add if there is any statement in the catch block	8✔
291	// we always add a push to the catch block	8✔
292	// NOTE: does not insert a push in the finally block	8✔
293	exp.blocks.forEach((block) => assignResults(block, collect))	8✔
294	return	8✔
295		262✔
296	// Don't push if there's a trailing semicolon	262✔
297	return if node.-1?.type is "SemicolonDelimiter"	262✔
298		84✔
299	// Insert push wrapping expression	84✔
300	node[1] = collect(node[1])	84✔
301		1✔
302	// [indent, statement, semicolon]	1✔
303	function insertReturn(node: ASTNode, outerNode: ASTNode = node): void	1,201✔
304	if (!node) return	1,201✔
305	// TODO: unify this with the `exp` switch	1,192✔
306	switch node.type	1,192✔
307	case "BlockStatement":	1,201✔
308	if node.expressions.length	599✔
309	const last = node.expressions[node.expressions.length - 1]	566✔
310	insertReturn(last)	566✔
311	else	33✔
312	// NOTE: Kind of hacky but I'm too much of a coward to make `->` add an implicit return	33✔
313	if node.parent.type is "CatchClause"	33✔
314	node.expressions.push(["return"])	33✔
315	return	599✔
316	// NOTE: "CaseClause"s don't get a return statements inserted	1,201✔
317	case "WhenClause":	1,201✔
318	// Remove inserted `break;` if it hasn't already been removed	22✔
319	node.children.splice node.children.indexOf(node.break), 1 if node.break	22✔
320	if node.block.expressions.length	22✔
321	insertReturn(node.block)	21✔
322	else	1✔
323	node.block.expressions.push(wrapWithReturn())	1✔
324	return	22✔
325	case "DefaultClause":	1,201✔
326	insertReturn(node.block)	5✔
327	return	5✔
328	if (!Array.isArray(node)) return	566!
329		566✔
330	[, exp, semi] .= node	566✔
331	return if semi?.type is "SemicolonDelimiter"	1,201✔
332	return unless exp	544✔
333		544✔
334	outer := exp	544✔
335	{type} .= exp	544✔
336	if type is "LabelledStatement"	544✔
337	exp = (exp as LabeledStatement).statement	1✔
338	{type} = exp	1✔
339		544✔
340	switch type	544✔
341	case "BreakStatement":	1,201!
342	case "ContinueStatement":	1,201!
343	case "DebuggerStatement":	1,201✔
344	case "EmptyStatement":	1,201✔
345	case "ReturnStatement":	1,201✔
346	case "ThrowStatement":	1,201✔
347	return	116✔
348	case "Declaration":	1,201✔
349	exp.children.push ["", {	16✔
350	type: "ReturnStatement",	16✔
351	children: [";return ", patternAsValue(exp.bindings.-1.pattern)],	16✔
352	parent: exp	16✔
353	}]	16✔
354	return	16✔
355	case "FunctionExpression":	1,201✔
356	// Add return after function declaration if it has an id to not interfere with hoisting	3✔
357	if (exp.id)	3✔
358	exp.children.push ["",	3✔
359	type: "ReturnStatement"	3✔
360	children: [";return ", exp.id]	3✔
361	parent: exp	3✔
362	]	3✔
363	return	3✔
364	/* c8 ignore next 3 */	1✔
365	// This is currently never hit because anonymous FunctionExpressions are already wrapped in parens by this point	1✔
366	// Add return in normal way for functions without ids	1✔
367	break	1✔
368	case "ForStatement":	1,201✔
369	case "IterationStatement":	1,201✔
370	case "DoStatement":	1,201✔
371	wrapIterationReturningResults(exp, outer)	12✔
372	return	12✔
373	case "BlockStatement":	1,201✔
374	insertReturn(exp.expressions[exp.expressions.length - 1])	2✔
375	return	2✔
376	case "IfStatement":	1,201✔
377	// if block	50✔
378	insertReturn(exp.then)	50✔
379	// else block	50✔
380	if (exp.else) insertReturn(exp.else[2])	50✔
381	// Add explicit return after if block if no else block	14✔
382	else exp.children.push ["", {	14✔
383	type: "ReturnStatement"	14✔
384	// NOTE: add a prefixed semi-colon because the if block may not be braced	14✔
385	children: [";return"]	14✔
386	parent: exp	14✔
387	}]	14✔
388	return	50✔
389	case "PatternMatchingStatement":	1,201✔
390	insertReturn(exp.children[0][0])	4✔
391	return	4✔
392	case "SwitchStatement":	1,201✔
393	insertSwitchReturns(exp)	7✔
394	return	7✔
395	case "TryStatement":	1,201✔
396	exp.blocks.forEach((block) => insertReturn(block))	4✔
397	// NOTE: do not insert a return in the finally block	4✔
398	return	4✔
399		330✔
400	// Don't add return if there's a trailing semicolon	330✔
401	if (node[node.length - 1]?.type is "SemicolonDelimiter") return	1,201!
402		330✔
403	// Insert return after indentation and before expression	330✔
404	const returnStatement = wrapWithReturn(node[1])	330✔
405	node.splice(1, 1, returnStatement)	330✔
406		1✔
407	// insert a return in each when/else/default block	1✔
408	// case blocks don't get implicit returns	1✔
409	// maybe default blocks shouldn't either?	1✔
410	function insertSwitchReturns(exp): void	7✔
411	exp.caseBlock.clauses.forEach (clause) =>	7✔
412	insertReturn clause	27✔
413		1✔
414	function wrapIterationReturningResults(	29✔
415	statement: ForStatement \| IterationStatement \| DoStatement,	29✔
416	outer: { children: StatementTuple[] },	29✔
417	collect?: (node: ASTNode) => ASTNode	29✔
418	): void	29✔
419	if statement.type is "DoStatement"	29✔
420	if collect	7✔
421	assignResults(statement.block, collect)	3✔
422	else	4✔
423	insertReturn(statement.block, outer)	4✔
424	return	7✔
425		22✔
426	assert.equal statement.resultsRef, undefined,	22✔
427	"wrapIterationReturningResults should not be called twice on the same statement"	22✔
428		22✔
429	resultsRef := statement.resultsRef = makeRef "results"	22✔
430		22✔
431	declaration :=	22✔
432	type: "Declaration"	22✔
433	children: ["const ", resultsRef, "=[]"]	22✔
434		22✔
435	outer.children.unshift(["", declaration, ";"])	22✔
436		22✔
437	assignResults statement.block, (node) =>	22✔
438	// TODO: real ast node	28✔
439	[ resultsRef, ".push(", node, ")" ]	28✔
440		22✔
441	if collect	22✔
442	statement.children.push collect(resultsRef)	14✔
443	else	29✔
444	statement.children.push(";return ", resultsRef, ";")	29✔
445		1✔
446	function processParams(f): void	690✔
447	const { type, parameters, block } = f	690✔
448	const isConstructor = f.name is 'constructor'	690✔
449		690✔
450	// Check for singleton TypeParameters <Foo> before arrow function,	690✔
451	// which TypeScript (in tsx mode) treats like JSX; replace with <Foo,>	690✔
452	if (type is "ArrowFunction" and parameters and parameters.tp and parameters.tp.parameters.length is 1) {	690✔
453	parameters.tp.parameters.push(",")	3✔
454	}	3✔
455		690✔
456	if (!block) return	690✔
457	const { expressions } = block	673✔
458	if (!expressions) return	673!
459	const { blockPrefix } = parameters	673✔
460		673✔
461	let indent: string	673✔
462	if (!expressions.length) {	690✔
463	indent = ""	45✔
464	} else {	690✔
465	indent = expressions[0][0]	628✔
466	}	628✔
467		673✔
468	const [splices, thisAssignments] = gatherBindingCode(parameters, {	673✔
469	injectParamProps: isConstructor	673✔
470	})	673✔
471		673✔
472	const delimiter = {	673✔
473	type: "SemicolonDelimiter",	673✔
474	children: [";"],	673✔
475	}	673✔
476		673✔
477	const prefix = splices	673✔
478	.map (s) => ["let ", s]	673✔
479	.concat(thisAssignments)	673✔
480	.map((s) => s.type	673✔
481	? {	50✔
482	// TODO: figure out how to get JS only statement tuples	10✔
483	...s,	10✔
484	children: [indent, ...s.children, delimiter]	10✔
485	}	10✔
486	: [indent, s, delimiter]	50✔
487	)	673✔
488		673✔
489	if (!prefix.length) return	673✔
490	// In constructor definition, insert prefix after first super() call	28✔
491	if (isConstructor) {	690✔
492	const superCalls = gatherNodes expressions, (exp) =>	9✔
493	exp.type is "CallExpression" and exp.children[0]?.token is "super"	33✔
494	if (superCalls.length) {	9✔
495	const {child} = findAncestor(superCalls[0],	1✔
496	(ancestor) => ancestor is block)	1✔
497	const index = findChildIndex(expressions, child)	1✔
498	if (index < 0) {	1!
499	throw new Error("Could not find super call within top-level expressions")	×
500	}	×
501	expressions.splice(index + 1, 0, ...prefix)	1✔
502	return	1✔
503	}	1✔
504	}	9✔
505	expressions.unshift(...prefix)	27✔
506		1✔
507	function processFunctions(statements, config): void	2,200✔
508	gatherRecursiveAll(statements, ({ type }) => type is "FunctionExpression" or type is "ArrowFunction")	2,200✔
509	.forEach (f) =>	2,200✔
510	if (f.type is "FunctionExpression") implicitFunctionBlock(f)	566✔
511	processParams(f)	566✔
512	processReturn(f, config.implicitReturns)	566✔
513		2,200✔
514	gatherRecursiveAll(statements, ({ type }) => type is "MethodDefinition")	2,200✔
515	.forEach (f) =>	2,200✔
516	implicitFunctionBlock(f)	124✔
517	processParams(f)	124✔
518	processReturn(f, config.implicitReturns)	124✔
519		1✔
520	function expressionizeIteration(exp: IterationExpression): void	21✔
521	{ async, subtype, block, children, statement } := exp	21✔
522	i := children.indexOf statement	21✔
523	if i < 0	21✔
524	throw new Error("Could not find iteration statement in iteration expression")	×
525		21✔
526	if subtype is "DoStatement"	21✔
527	// Just wrap with IIFE	8✔
528	insertReturn(block)	8✔
529	children.splice(i, 1, ...wrapIIFE(["", statement, undefined], async))	8✔
530	updateParentPointers exp	8✔
531	return	8✔
532		13✔
533	exp.resultsRef ??= makeRef "results"	13✔
534	{ resultsRef } := exp	21✔
535		21✔
536	// insert `results.push` to gather results array	21✔
537	assignResults block, (node) =>	21✔
538	// TODO: real node	13✔
539	[ resultsRef, ".push(", node, ")" ]	13✔
540	braceBlock(block)	21✔
541		21✔
542	// Wrap with IIFE	21✔
543	children.splice(i,	21✔
544	1,	21✔
545	...wrapIIFE([	21✔
546	["", ["const ", resultsRef, "=[]"], ";"],	21✔
547	...children.map((c) => ["", c, undefined]),	21✔
548	["", wrapWithReturn(resultsRef)],	21✔
549	], async)	21✔
550	)	21✔
551	updateParentPointers exp	21✔
552		1✔
553	/**	1✔
554	Utility function to check if an implicit function application should be skipped	1✔
555	based on the shape of the arguments.	1✔
556		1✔
557	Don't treat as call if this is a postfix for/while/until/if/unless	1✔
558	*/	1✔
559	function skipImplicitArguments(args: unknown[])	654✔
560	if args.length is 1	654✔
561	arg0 .= args[0]	497✔
562	if Array.isArray arg0	497✔
563	arg0 = arg0[1] // skip whitespace	497✔
564		497✔
565	if arg0.type is "StatementExpression"	497✔
566	arg0 = arg0.statement	9✔
567		497✔
568	return (and)	497✔
569	arg0.type is "IterationExpression"	497✔
570	arg0.subtype !== "DoStatement"	497✔
571	!arg0.async	497✔
572	isEmptyBareBlock arg0.block	497✔
573		157✔
574	return false	157✔
575		1✔
576	export {	1✔
577	assignResults	1✔
578	expressionizeIteration	1✔
579	processFunctions	1✔
580	skipImplicitArguments	1✔
581	wrapIterationReturningResults	1✔
582	}	1✔

DanielXMoore / Civet / 8134982617

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous