8409238417

Committed 24 Mar 2024 12:20PM UTC coverage: 81.167% (+0.2%) from 80.979%

Build # 8409238417

Build Type

Pull #1507

github

Committed by

web-flow

Commit Message

Merge d81c58226 into caf8c3ae2

Pull Request Pull Request #1507: Import Analyzer and Augmentations

Run Details

3202 of 4350 branches covered (73.61%)

Branch coverage included in aggregate %.

548 of 598 new or added lines in 50 files covered. (91.64%)

18 existing lines in 6 files now uncovered.

10585 of 12636 relevant lines covered (83.77%)

127234.68 hits per line

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

70.88

/src/name-extractor/index.ts

import acorn from 'acorn'
import type es from 'estree'

import type { Context } from '../'
import { UNKNOWN_LOCATION } from '../constants'
import { findAncestors, findIdentifierNode } from '../finder'
import { ModuleConnectionError, ModuleNotFoundError } from '../modules/errors'
import { memoizedGetModuleDocsAsync } from '../modules/loader/moduleLoaderAsync'
import type { ModuleDocsEntry } from '../modules/moduleTypes'
import { isSourceModule } from '../modules/utils'
import syntaxBlacklist from '../parser/source/syntax'
import { getImportedName, getModuleDeclarationSource } from '../utils/ast/helpers'
import { isDeclaration, isImportDeclaration } from '../utils/ast/typeGuards'

export enum DeclarationKind {
  KIND_IMPORT = 'import',
  KIND_FUNCTION = 'func',
  KIND_LET = 'let',
  KIND_PARAM = 'param',
  KIND_CONST = 'const',
  KIND_KEYWORD = 'keyword'
}
import { Node } from '../types'

export interface NameDeclaration {
  name: string
  meta: DeclarationKind
  score?: number
}

type FunctionType = es.FunctionDeclaration | es.ArrowFunctionExpression | es.FunctionExpression
function isFunction(node: Node): node is FunctionType {
  return (
    node.type === 'FunctionDeclaration' ||
    node.type === 'FunctionExpression' ||
    node.type === 'ArrowFunctionExpression'
  )
}

type LoopNode = es.WhileStatement | es.ForStatement
function isLoop(node: Node): node is LoopNode {
  return node.type === 'WhileStatement' || node.type === 'ForStatement'
}

// Update this to use exported check from "acorn-loose" package when it is released
function isDummyName(name: string): boolean {
  return name === '✖'
}

const KEYWORD_SCORE = 20000

// Ensure that keywords are prioritized over names
const keywordsInBlock: { [key: string]: NameDeclaration[] } = {
  FunctionDeclaration: [
    { name: 'function', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }
  ],
  VariableDeclaration: [
    { name: 'const', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }
  ],
  AssignmentExpression: [{ name: 'let', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }],
  WhileStatement: [{ name: 'while', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }],
  IfStatement: [
    { name: 'if', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE },
    { name: 'else', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }
  ],
  ForStatement: [{ name: 'for', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }]
}

const keywordsInLoop: { [key: string]: NameDeclaration[] } = {
  BreakStatement: [{ name: 'break', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }],
  ContinueStatement: [
    { name: 'continue', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }
  ]
}

const keywordsInFunction: { [key: string]: NameDeclaration[] } = {
  ReturnStatement: [{ name: 'return', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }]
}

/**
 * Retrieves keyword suggestions based on what node the cursor is currently over.
 * For example, only suggest `let` when the cursor is over the init part of a for
 * statement
 * @param prog Program to parse
 * @param cursorLoc Current location of the cursor
 * @param context Evaluation context
 * @returns A list of keywords as suggestions
 */
export function getKeywords(
  prog: Node,
  cursorLoc: es.Position,
  context: Context
): NameDeclaration[] {
  const identifier = findIdentifierNode(prog, context, cursorLoc)
  if (!identifier) {
    return []
  }

  const ancestors = findAncestors(prog, identifier)
  if (!ancestors) {
    return []
  }

  // In the init part of a for statement, `let` is the only valid keyword
  if (ancestors[0].type === 'ForStatement' && identifier === ancestors[0].init) {
    return context.chapter >= syntaxBlacklist.AssignmentExpression
      ? keywordsInBlock.AssignmentExpression
      : []
  }

  const keywordSuggestions: NameDeclaration[] = []
  function addAllowedKeywords(keywords: { [key: string]: NameDeclaration[] }) {
    Object.entries(keywords)
      .filter(([nodeType]) => context.chapter >= syntaxBlacklist[nodeType])
      .forEach(([_nodeType, decl]) => keywordSuggestions.push(...decl))
  }

  // The rest of the keywords are only valid at the beginning of a statement
  if (
    ancestors[0].type === 'ExpressionStatement' &&
    (ancestors[0].loc ?? UNKNOWN_LOCATION).start === (identifier.loc ?? UNKNOWN_LOCATION).start
  ) {
    addAllowedKeywords(keywordsInBlock)
    // Keywords only allowed in functions
    if (ancestors.some(node => isFunction(node))) {
      addAllowedKeywords(keywordsInFunction)
    }

    // Keywords only allowed in loops
    if (ancestors.some(node => isLoop(node))) {
      addAllowedKeywords(keywordsInLoop)
    }
  }

  return keywordSuggestions
}

/**
 * Retrieve the list of names present within the program. If the cursor is within a comment,
 * or when the user is declaring a variable or function arguments, suggestions should not be displayed,
 * indicated by the second part of the return value of this function.
 * @param prog Program to parse for names
 * @param comments Comments found within the program
 * @param cursorLoc Current location of the cursor
 * @returns Tuple consisting of the list of suggestions, and a boolean value indicating if
 * suggestions should be displayed, i.e. `[suggestions, shouldPrompt]`
 */
export async function getProgramNames(
  prog: Node,
  comments: acorn.Comment[],
  cursorLoc: es.Position
): Promise<[NameDeclaration[], boolean]> {
  function before(first: es.Position, second: es.Position) {
    return first.line < second.line || (first.line === second.line && first.column <= second.column)
  }

  function cursorInLoc(nodeLoc: es.SourceLocation | null | undefined) {
    if (nodeLoc === null || nodeLoc === undefined) {
      return false
    }
    return before(nodeLoc.start, cursorLoc) && before(cursorLoc, nodeLoc.end)
  }

  for (const comment of comments) {
    if (cursorInLoc(comment.loc)) {
      // User is typing comments
      return [[], false]
    }
  }

  // BFS to get names
  const queue: Node[] = [prog]
  const nameQueue: Node[] = []

  while (queue.length > 0) {
    // Workaround due to minification problem
    // tslint:disable-next-line
    const node = queue.shift()!
    if (isFunction(node)) {
      // This is the only time we want raw identifiers
      nameQueue.push(...node.params)
    }

    const body = getNodeChildren(node)
    for (const child of body) {
      if (isImportDeclaration(child as any)) {
        nameQueue.push(child)
      }

      if (isDeclaration(child)) {
        nameQueue.push(child)
      }

      if (cursorInLoc(child.loc)) {
        queue.push(child)
      }
    }
  }

  // Do not prompt user if he is declaring a variable
  for (const nameNode of nameQueue) {
    if (cursorInIdentifier(nameNode, n => cursorInLoc(n.loc))) {
      return [[], false]
    }
  }

  // This implementation is order dependent, so we can't
  // use something like Promise.all
  const res: Record<string, NameDeclaration> = {}
  let idx = 0
  for (const node of nameQueue) {
    const names = await getNames(node, n => cursorInLoc(n.loc))
    names.forEach(decl => {
      // Deduplicate, ensure deeper declarations overwrite
      res[decl.name] = { ...decl, score: idx }
      idx++
    })
  }

  return [Object.values(res), true]
}

function isNotNull<T>(x: T): x is Exclude<T, null> {
  // This function exists to appease the mighty typescript type checker
  return x !== null
}

function isNotNullOrUndefined<T>(x: T): x is Exclude<T, null | undefined> {
  // This function also exists to appease the mighty typescript type checker
  return x !== undefined && isNotNull(x)
}

function getNodeChildren(node: Node): es.Node[] {
  switch (node.type) {
    case 'Program':
      return node.body
    case 'BlockStatement':
      return node.body
    case 'WhileStatement':
      return [node.test, node.body]
    case 'ForStatement':
      return [node.init, node.test, node.update, node.body].filter(isNotNullOrUndefined)
    case 'ExpressionStatement':
      return [node.expression]
    case 'IfStatement':
      const children = [node.test, node.consequent]
      if (isNotNullOrUndefined(node.alternate)) {
        children.push(node.alternate)
      }
      return children
    case 'ReturnStatement':
      return node.argument ? [node.argument] : []
    case 'FunctionDeclaration':
      return [node.body]
    case 'VariableDeclaration':
      return node.declarations.flatMap(getNodeChildren)
    case 'VariableDeclarator':
      return node.init ? [node.init] : []
    case 'ArrowFunctionExpression':
      return [node.body]
    case 'FunctionExpression':
      return [node.body]
    case 'UnaryExpression':
      return [node.argument]
    case 'BinaryExpression':
      return [node.left, node.right]
    case 'LogicalExpression':
      return [node.left, node.right]
    case 'ConditionalExpression':
      return [node.test, node.alternate, node.consequent]
    case 'CallExpression':
      return [...node.arguments, node.callee]
    // case 'Identifier':
    // case 'DebuggerStatement':
    // case 'BreakStatement':
    // case 'ContinueStatement':
    // case 'MemberPattern':
    case 'ArrayExpression':
      return node.elements.filter(isNotNull)
    case 'AssignmentExpression':
      return [node.left, node.right]
    case 'MemberExpression':
      return [node.object, node.property]
    case 'Property':
      return [node.key, node.value]
    case 'ObjectExpression':
      return [...node.properties]
    case 'NewExpression':
      return [...node.arguments, node.callee]
    default:
      return []
  }
}

function cursorInIdentifier(node: Node, locTest: (node: Node) => boolean): boolean {
  switch (node.type) {
    case 'VariableDeclaration':
      for (const decl of node.declarations) {
        if (locTest(decl.id)) {
          return true
        }
      }
      return false
    case 'FunctionDeclaration':
      return node.id ? locTest(node.id) : false
    case 'Identifier':
      return locTest(node)
    default:
      return false
  }
}

function docsToHtml(name: string, obj: ModuleDocsEntry): string {
  switch (obj.kind) {
    case 'function': {
      let paramStr: string

      if (obj.params.length === 0) {
        paramStr = '()'
      } else {
        paramStr = `(${obj.params.map(([name, type]) => `${name}: ${type}`).join(', ')})`
      }

      const header = `${name}${paramStr} → {${obj.retType}}`
      return `<div><h4>${header}</h4><div class="description">${obj.description}</div></div>`
    }
    case 'variable':
      return `<div><h4>${name}: ${obj.type}</h4><div class="description">${obj.description}</div></div>`
    case 'unknown':
      return `<div><h4>${name}: unknown</h4><div class="description">No description available</div></div>`
  }
}

// locTest is a callback that returns whether cursor is in location of node
/**
 * Gets a list of `NameDeclarations` from the given node
 * @param node Node to search for names
 * @param locTest Callback of type `(node: Node) => boolean`. Should return true if the cursor
 * is located within the node, false otherwise
 * @returns List of found names
 */
async function getNames(node: Node, locTest: (node: Node) => boolean): Promise<NameDeclaration[]> {
  switch (node.type) {
    case 'ImportDeclaration':
      const specs = node.specifiers.filter(x => !isDummyName(x.local.name))
      const moduleName = getModuleDeclarationSource(node)

      // Don't try to load documentation for local modules
      if (!isSourceModule(moduleName)) return []

      try {
        const docs = await memoizedGetModuleDocsAsync(moduleName)

        if (!docs) {
          return specs.map(spec => ({
            name: spec.local.name,
            meta: DeclarationKind.KIND_IMPORT,
            docHTML: `Unable to retrieve documentation for <code>${spec.local.name}</code> from ${moduleName} module`
          }))
        }

        return specs.map(spec => {
          if (spec.type === 'ImportNamespaceSpecifier') {
            return {
              name: moduleName,
              meta: DeclarationKind.KIND_IMPORT,
              docHTML: `Namespace import ${moduleName}`
            }
          }

          const importedName = getImportedName(spec)

          if (docs[importedName] === undefined) {
            return {
              name: importedName,
              meta: DeclarationKind.KIND_IMPORT,
              docHTML: `No documentation available for <code>${spec.local.name}</code> from ${moduleName} module`
            }
          } else {
            return {
              name: importedName,
              meta: DeclarationKind.KIND_IMPORT,
              docHTML: docsToHtml(importedName, docs[importedName])
            }
          }
        })
      } catch (err) {
        if (!(err instanceof ModuleNotFoundError || err instanceof ModuleConnectionError)) throw err

        return specs.map(spec => ({
          name: spec.local.name,
          meta: DeclarationKind.KIND_IMPORT,
          docHTML: `Unable to retrieve documentation for <code>${spec.local.name}</code> from ${moduleName} module`
        }))
      }
    case 'VariableDeclaration':
      const declarations: NameDeclaration[] = []
      for (const decl of node.declarations) {
        const id = decl.id
        const name = (id as es.Identifier).name
        if (
          !name ||
          isDummyName(name) ||
          (decl.init && !isFunction(decl.init) && locTest(decl.init)) // Avoid suggesting `let foo = foo`, but suggest recursion with arrow functions
        ) {
          continue
        }

        if (node.kind === DeclarationKind.KIND_CONST && decl.init && isFunction(decl.init)) {
          // constant initialized with arrow function will always be a function
          declarations.push({ name, meta: DeclarationKind.KIND_FUNCTION })
        } else {
          declarations.push({ name, meta: node.kind as DeclarationKind })
        }
      }
      return declarations
    case 'FunctionDeclaration':
      return node.id && !isDummyName(node.id.name)
        ? [{ name: node.id.name, meta: DeclarationKind.KIND_FUNCTION }]
        : []
    case 'Identifier': // Function/Arrow function param
      return !isDummyName(node.name) ? [{ name: node.name, meta: DeclarationKind.KIND_PARAM }] : []
    default:
      return []
  }
}

1	import acorn from 'acorn'
2	import type es from 'estree'
3
4	import type { Context } from '../'
5	import { UNKNOWN_LOCATION } from '../constants'	68✔
6	import { findAncestors, findIdentifierNode } from '../finder'	68✔
7	import { ModuleConnectionError, ModuleNotFoundError } from '../modules/errors'	68✔
8	import { memoizedGetModuleDocsAsync } from '../modules/loader/moduleLoaderAsync'	68✔
9	import type { ModuleDocsEntry } from '../modules/moduleTypes'
10	import { isSourceModule } from '../modules/utils'	68✔
11	import syntaxBlacklist from '../parser/source/syntax'	68✔
12	import { getImportedName, getModuleDeclarationSource } from '../utils/ast/helpers'	68✔
13	import { isDeclaration, isImportDeclaration } from '../utils/ast/typeGuards'	68✔
14
15	export enum DeclarationKind {	68✔
16	KIND_IMPORT = 'import',	68✔
17	KIND_FUNCTION = 'func',	68✔
18	KIND_LET = 'let',	68✔
19	KIND_PARAM = 'param',	68✔
20	KIND_CONST = 'const',	68✔
21	KIND_KEYWORD = 'keyword'	68✔
22	}
23	import { Node } from '../types'
24
25	export interface NameDeclaration {
26	name: string
27	meta: DeclarationKind
28	score?: number
29	}
30
31	type FunctionType = es.FunctionDeclaration \| es.ArrowFunctionExpression \| es.FunctionExpression
32	function isFunction(node: Node): node is FunctionType {
33	return (	142✔
34	node.type === 'FunctionDeclaration' \|\|	404✔
35	node.type === 'FunctionExpression' \|\|
36	node.type === 'ArrowFunctionExpression'
37	)
38	}
39
40	type LoopNode = es.WhileStatement \| es.ForStatement
41	function isLoop(node: Node): node is LoopNode {
42	return node.type === 'WhileStatement' \|\| node.type === 'ForStatement'	16✔
43	}
44
45	// Update this to use exported check from "acorn-loose" package when it is released
46	function isDummyName(name: string): boolean {
47	return name === '✖'	57✔
48	}
49
50	const KEYWORD_SCORE = 20000	68✔
51
52	// Ensure that keywords are prioritized over names
53	const keywordsInBlock: { [key: string]: NameDeclaration[] } = {	68✔
54	FunctionDeclaration: [
55	{ name: 'function', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }
56	],
57	VariableDeclaration: [
58	{ name: 'const', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }
59	],
60	AssignmentExpression: [{ name: 'let', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }],
61	WhileStatement: [{ name: 'while', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }],
62	IfStatement: [
63	{ name: 'if', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE },
64	{ name: 'else', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }
65	],
66	ForStatement: [{ name: 'for', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }]
67	}
68
69	const keywordsInLoop: { [key: string]: NameDeclaration[] } = {	68✔
70	BreakStatement: [{ name: 'break', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }],
71	ContinueStatement: [
72	{ name: 'continue', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }
73	]
74	}
75
76	const keywordsInFunction: { [key: string]: NameDeclaration[] } = {	68✔
77	ReturnStatement: [{ name: 'return', meta: DeclarationKind.KIND_KEYWORD, score: KEYWORD_SCORE }]
78	}
79
80	/**
81	* Retrieves keyword suggestions based on what node the cursor is currently over.
82	* For example, only suggest `let` when the cursor is over the init part of a for
83	* statement
84	* @param prog Program to parse
85	* @param cursorLoc Current location of the cursor
86	* @param context Evaluation context
87	* @returns A list of keywords as suggestions
88	*/
89	export function getKeywords(	68✔
90	prog: Node,
91	cursorLoc: es.Position,
92	context: Context
93	): NameDeclaration[] {
94	const identifier = findIdentifierNode(prog, context, cursorLoc)	29✔
95	if (!identifier) {	29✔
96	return []	22✔
97	}
98
99	const ancestors = findAncestors(prog, identifier)	7✔
100	if (!ancestors) {	7!
101	return []	×
102	}
103
104	// In the init part of a for statement, `let` is the only valid keyword
105	if (ancestors[0].type === 'ForStatement' && identifier === ancestors[0].init) {	7!
UNCOV 106	return context.chapter >= syntaxBlacklist.AssignmentExpression	×
107	? keywordsInBlock.AssignmentExpression
108	: []
109	}
110
111	const keywordSuggestions: NameDeclaration[] = []	7✔
112	function addAllowedKeywords(keywords: { [key: string]: NameDeclaration[] }) {
113	Object.entries(keywords)	9✔
114	.filter(([nodeType]) => context.chapter >= syntaxBlacklist[nodeType])	41✔
115	.forEach(([_nodeType, decl]) => keywordSuggestions.push(...decl))	32✔
116	}
117
118	// The rest of the keywords are only valid at the beginning of a statement
119	if (	7✔
120	ancestors[0].type === 'ExpressionStatement' &&	13✔
121	(ancestors[0].loc ?? UNKNOWN_LOCATION).start === (identifier.loc ?? UNKNOWN_LOCATION).start	12!
122	) {
123	addAllowedKeywords(keywordsInBlock)	6✔
124	// Keywords only allowed in functions
125	if (ancestors.some(node => isFunction(node))) {	17✔
126	addAllowedKeywords(keywordsInFunction)	1✔
127	}
128
129	// Keywords only allowed in loops
130	if (ancestors.some(node => isLoop(node))) {	16✔
131	addAllowedKeywords(keywordsInLoop)	2✔
132	}
133	}
134
135	return keywordSuggestions	7✔
136	}
137
138	/**
139	* Retrieve the list of names present within the program. If the cursor is within a comment,
140	* or when the user is declaring a variable or function arguments, suggestions should not be displayed,
141	* indicated by the second part of the return value of this function.
142	* @param prog Program to parse for names
143	* @param comments Comments found within the program
144	* @param cursorLoc Current location of the cursor
145	* @returns Tuple consisting of the list of suggestions, and a boolean value indicating if
146	* suggestions should be displayed, i.e. `[suggestions, shouldPrompt]`
147	*/
148	export async function getProgramNames(	68✔
149	prog: Node,
150	comments: acorn.Comment[],
151	cursorLoc: es.Position
152	): Promise<[NameDeclaration[], boolean]> {
153	function before(first: es.Position, second: es.Position) {
154	return first.line < second.line \|\| (first.line === second.line && first.column <= second.column)	382✔
155	}
156
157	function cursorInLoc(nodeLoc: es.SourceLocation \| null \| undefined) {
158	if (nodeLoc === null \|\| nodeLoc === undefined) {	219!
159	return false	×
160	}
161	return before(nodeLoc.start, cursorLoc) && before(cursorLoc, nodeLoc.end)	219✔
162	}
163
164	for (const comment of comments) {	29✔
165	if (cursorInLoc(comment.loc)) {	×
166	// User is typing comments
167	return [[], false]	×
168	}
169	}
170
171	// BFS to get names
172	const queue: Node[] = [prog]	29✔
173	const nameQueue: Node[] = []	29✔
174
175	while (queue.length > 0) {	29✔
176	// Workaround due to minification problem
177	// tslint:disable-next-line
178	const node = queue.shift()!	92✔
179	if (isFunction(node)) {	92✔
180	// This is the only time we want raw identifiers
181	nameQueue.push(...node.params)	13✔
182	}
183
184	const body = getNodeChildren(node)	92✔
185	for (const child of body) {	92✔
186	if (isImportDeclaration(child as any)) {	133✔
187	nameQueue.push(child)	1✔
188	}
189
190	if (isDeclaration(child)) {	133✔
191	nameQueue.push(child)	51✔
192	}
193
194	if (cursorInLoc(child.loc)) {	133✔
195	queue.push(child)	63✔
196	}
197	}
198	}
199
200	// Do not prompt user if he is declaring a variable
201	for (const nameNode of nameQueue) {	29✔
202	if (cursorInIdentifier(nameNode, n => cursorInLoc(n.loc))) {	58✔
203	return [[], false]	1✔
204	}
205	}
206
207	// This implementation is order dependent, so we can't
208	// use something like Promise.all
209	const res: Record<string, NameDeclaration> = {}	28✔
210	let idx = 0	28✔
211	for (const node of nameQueue) {	28✔
212	const names = await getNames(node, n => cursorInLoc(n.loc))	57✔
213	names.forEach(decl => {	57✔
214	// Deduplicate, ensure deeper declarations overwrite
215	res[decl.name] = { ...decl, score: idx }	57✔
216	idx++	57✔
217	})
218	}
219
220	return [Object.values(res), true]	28✔
221	}
222
223	function isNotNull<T>(x: T): x is Exclude<T, null> {
224	// This function exists to appease the mighty typescript type checker
225	return x !== null	15✔
226	}
227
228	function isNotNullOrUndefined<T>(x: T): x is Exclude<T, null \| undefined> {
229	// This function also exists to appease the mighty typescript type checker
230	return x !== undefined && isNotNull(x)	15✔
231	}
232
233	function getNodeChildren(node: Node): es.Node[] {
234	switch (node.type) {	100!
235	case 'Program':
236	return node.body	29✔
237	case 'BlockStatement':
238	return node.body	23✔
239	case 'WhileStatement':
240	return [node.test, node.body]	1✔
241	case 'ForStatement':
242	return [node.init, node.test, node.update, node.body].filter(isNotNullOrUndefined)	3✔
243	case 'ExpressionStatement':
244	return [node.expression]	6✔
245	case 'IfStatement':
246	const children = [node.test, node.consequent]	3✔
247	if (isNotNullOrUndefined(node.alternate)) {	3✔
248	children.push(node.alternate)	2✔
249	}
250	return children	3✔
251	case 'ReturnStatement':
UNCOV 252	return node.argument ? [node.argument] : []	×
253	case 'FunctionDeclaration':
254	return [node.body]	10✔
255	case 'VariableDeclaration':
256	return node.declarations.flatMap(getNodeChildren)	8✔
257	case 'VariableDeclarator':
258	return node.init ? [node.init] : []	8!
259	case 'ArrowFunctionExpression':
260	return [node.body]	3✔
261	case 'FunctionExpression':
262	return [node.body]	×
263	case 'UnaryExpression':
264	return [node.argument]	×
265	case 'BinaryExpression':
266	return [node.left, node.right]	×
267	case 'LogicalExpression':
268	return [node.left, node.right]	×
269	case 'ConditionalExpression':
270	return [node.test, node.alternate, node.consequent]	×
271	case 'CallExpression':
272	return [...node.arguments, node.callee]	×
273	// case 'Identifier':
274	// case 'DebuggerStatement':
275	// case 'BreakStatement':
276	// case 'ContinueStatement':
277	// case 'MemberPattern':
278	case 'ArrayExpression':
279	return node.elements.filter(isNotNull)	×
280	case 'AssignmentExpression':
281	return [node.left, node.right]	×
282	case 'MemberExpression':
283	return [node.object, node.property]	×
284	case 'Property':
285	return [node.key, node.value]	×
286	case 'ObjectExpression':
287	return [...node.properties]	×
288	case 'NewExpression':
289	return [...node.arguments, node.callee]	×
290	default:
291	return []	6✔
292	}
293	}
294
295	function cursorInIdentifier(node: Node, locTest: (node: Node) => boolean): boolean {
296	switch (node.type) {	58✔
297	case 'VariableDeclaration':
298	for (const decl of node.declarations) {	33✔
299	if (locTest(decl.id)) {	33✔
300	return true	1✔
301	}
302	}
303	return false	32✔
304	case 'FunctionDeclaration':
305	return node.id ? locTest(node.id) : false	17!
306	case 'Identifier':
307	return locTest(node)	7✔
308	default:
309	return false	1✔
310	}
311	}
312
313	function docsToHtml(name: string, obj: ModuleDocsEntry): string {
314	switch (obj.kind) {	1!
315	case 'function': {
316	let paramStr: string
317
NEW 318	if (obj.params.length === 0) {	×
NEW 319	paramStr = '()'	×
320	} else {
NEW 321	paramStr = `(${obj.params.map(([name, type]) => `${name}: ${type}`).join(', ')})`	×
322	}
323
NEW 324	const header = `${name}${paramStr} → {${obj.retType}}`	×
NEW 325	return `<div><h4>${header}</h4><div class="description">${obj.description}</div></div>`	×
326	}
327	case 'variable':
NEW 328	return `<div><h4>${name}: ${obj.type}</h4><div class="description">${obj.description}</div></div>`	×
329	case 'unknown':
NEW 330	return `<div><h4>${name}: unknown</h4><div class="description">No description available</div></div>`	×
331	}
332	}
333
334	// locTest is a callback that returns whether cursor is in location of node
335	/**
336	* Gets a list of `NameDeclarations` from the given node
337	* @param node Node to search for names
338	* @param locTest Callback of type `(node: Node) => boolean`. Should return true if the cursor
339	* is located within the node, false otherwise
340	* @returns List of found names
341	*/
342	async function getNames(node: Node, locTest: (node: Node) => boolean): Promise<NameDeclaration[]> {
343	switch (node.type) {	57!
344	case 'ImportDeclaration':
345	const specs = node.specifiers.filter(x => !isDummyName(x.local.name))	1✔
346	const moduleName = getModuleDeclarationSource(node)	1✔
347
348	// Don't try to load documentation for local modules
349	if (!isSourceModule(moduleName)) return []	1!
350
351	try {	1✔
352	const docs = await memoizedGetModuleDocsAsync(moduleName)	1✔
353
354	if (!docs) {	1!
355	return specs.map(spec => ({	×
356	name: spec.local.name,
357	meta: DeclarationKind.KIND_IMPORT,
358	docHTML: `Unable to retrieve documentation for <code>${spec.local.name}</code> from ${moduleName} module`
359	}))
360	}
361
362	return specs.map(spec => {	1✔
363	if (spec.type === 'ImportNamespaceSpecifier') {	1!
NEW 364	return {	×
365	name: moduleName,
366	meta: DeclarationKind.KIND_IMPORT,
367	docHTML: `Namespace import ${moduleName}`
368	}
369	}
370
371	const importedName = getImportedName(spec)	1✔
372
373	if (docs[importedName] === undefined) {	1!
UNCOV 374	return {	×
375	name: importedName,
376	meta: DeclarationKind.KIND_IMPORT,
377	docHTML: `No documentation available for <code>${spec.local.name}</code> from ${moduleName} module`
378	}
379	} else {
380	return {	1✔
381	name: importedName,
382	meta: DeclarationKind.KIND_IMPORT,
383	docHTML: docsToHtml(importedName, docs[importedName])
384	}
385	}
386	})
387	} catch (err) {
388	if (!(err instanceof ModuleNotFoundError \|\| err instanceof ModuleConnectionError)) throw err	×
389
390	return specs.map(spec => ({	×
391	name: spec.local.name,
392	meta: DeclarationKind.KIND_IMPORT,
393	docHTML: `Unable to retrieve documentation for <code>${spec.local.name}</code> from ${moduleName} module`
394	}))
395	}
396	case 'VariableDeclaration':
397	const declarations: NameDeclaration[] = []	32✔
398	for (const decl of node.declarations) {	32✔
399	const id = decl.id	32✔
400	const name = (id as es.Identifier).name	32✔
401	if (	32!
402	!name \|\|	157✔
403	isDummyName(name) \|\|
404	(decl.init && !isFunction(decl.init) && locTest(decl.init)) // Avoid suggesting `let foo = foo`, but suggest recursion with arrow functions
405	) {
406	continue	×
407	}
408
409	if (node.kind === DeclarationKind.KIND_CONST && decl.init && isFunction(decl.init)) {	32!
410	// constant initialized with arrow function will always be a function
NEW 411	declarations.push({ name, meta: DeclarationKind.KIND_FUNCTION })	×
412	} else {
413	declarations.push({ name, meta: node.kind as DeclarationKind })	32✔
414	}
415	}
416	return declarations	32✔
417	case 'FunctionDeclaration':
418	return node.id && !isDummyName(node.id.name)	17!
419	? [{ name: node.id.name, meta: DeclarationKind.KIND_FUNCTION }]
420	: []
421	case 'Identifier': // Function/Arrow function param
422	return !isDummyName(node.name) ? [{ name: node.name, meta: DeclarationKind.KIND_PARAM }] : []	7!
423	default:
424	return []	×
425	}
426	}

source-academy / js-slang / 8409238417

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