8929134260

Committed 02 May 2024 07:06PM UTC coverage: 92.973% (+0.009%) from 92.964%

Build # 8929134260

Build Type

Pull #1208

github

Committed by

web-flow

Commit Message

Merge 5e3c6e724 into 061048416

Pull Request Pull Request #1208: Use `is like` in some cases

Run Details

2500 of 2724 branches covered (91.78%)

Branch coverage included in aggregate %.

14 of 15 new or added lines in 4 files covered. (93.33%)

8 existing lines in 2 files now uncovered.

14448 of 15505 relevant lines covered (93.18%)

17435.89 hits per line

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

96.91

/source/parser/function.civet

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

DanielXMoore / Civet / 8929134260

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