8960105589

Committed 05 May 2024 05:57PM UTC coverage: 92.828% (-0.002%) from 92.83%

Build # 8960105589

Build Type

Pull #1222

github

Committed by

web-flow

Commit Message

Merge fcffb61ff into 25b68022e

Pull Request Pull Request #1222: comptime else blocks, else refactor

Run Details

2553 of 2783 branches covered (91.74%)

Branch coverage included in aggregate %.

75 of 78 new or added lines in 6 files covered. (96.15%)

29 existing lines in 1 file now uncovered.

14622 of 15719 relevant lines covered (93.02%)

17377.73 hits per line

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

96.7

/source/parser/function.civet

import type {
  ASTNode
  ASTNodeBase
  CallExpression
  FunctionNode
  IterationExpression
  IterationFamily
  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
  type Predicate
} from ./traversal.civet

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

import {
  makeRef
} from ./ref.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 not 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
          braceBlock block
      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 = [
        // { name: value } = ... declares value, not name
        pattern.value ?? 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, semi] .= node
  return if semi?.type is "SemicolonDelimiter"
  return unless exp
  return if isExit 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":
    case "ComptimeStatement":
      wrapIterationReturningResults(exp, outer, collect)
      return
    case "BlockStatement":
      return if node.expressions.some isExit
      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.block, collect)
      else // Add else block pushing undefined if no else block
        exp.children.push([" else {", collect("undefined"), "}"])
      return
    case "PatternMatchingStatement":
      assignResults(exp.children[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
        return if node.expressions.some ([, exp]) => isExit exp
        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
  return if isExit 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":
    case "ComptimeStatement":
      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.block)
      // 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])
      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: IterationFamily,
  outer: { children: StatementTuple[] },
  collect?: (node: ASTNode) => ASTNode
): void
  if statement.type is "DoStatement" or statement.type is "ComptimeStatement"
    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
    superCalls := gatherNodes expressions,
      (is like {type: "CallExpression", children: [ {token: "super"}, ... ]}) as Predicate<CallExpression>
    if superCalls#
      {child} := findAncestor superCalls[0], (is block)
      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" or subtype is "ComptimeStatement"
    // Just wrap with IIFE; insertReturn will apply to the resulting function
    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[]): boolean
  if args.length is 1
    arg0 .= args[0]

    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
  insertReturn
  processFunctions
  processReturn
  skipImplicitArguments
  wrapIterationReturningResults
}

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

DanielXMoore / Civet / 8960105589

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