Function functionSignature

packages/tools/jsdocs/src/Jsdocs.ts:2941–2980

(
  name: string,
  symbol: ts.Symbol,
  location: ts.Node,
  checker: ts.TypeChecker,
  cwd: string
)

}

function functionSignature(
  name: string,
  symbol: ts.Symbol,
  location: ts.Node,
  checker: ts.TypeChecker,
  cwd: string
): string | null {
  const target = resolvedSymbolTarget(symbol, checker)
  const type = checker.getTypeOfSymbolAtLocation(target, location)
  const signatures = checker.getSignaturesOfType(type, ts.SignatureKind.Call)
  if (signatures.length === 0) return null
  const callSignatures: Array<string> = []
  for (const signature of representativeSignatures(signatures, checker, location)) {
    const text = normalizeSignature(
      cwd,
      checker.signatureToString(signature, location, signatureTypeFormatFlags, ts.SignatureKind.Call)
    )
    if (text === null) return null
    callSignatures.push(text)
  }
  const declaration = parseableSignature(
    cwd,
    callSignatures.map((text) => `declare function ${name}${text}`).join("\n")
  )
  if (declaration !== null) return declaration
  const callSignatureAlias = parseableSignature(
    cwd,
    signatureAlias(
      name,
      `{
${callSignatures.map((text) => `  ${text};`).join("\n")}
}`
    )
  )
  if (callSignatureAlias !== null) return callSignatureAlias
  const typeText = normalizeSignature(cwd, checker.typeToString(type, location, signatureTypeFormatFlags))
  if (typeText === null) return null
  return parseableSignature(cwd, `declare const ${name}: ${typeText}`) ??
    parseableSignature(cwd, signatureAlias(name, typeText))
}

function symbolSignature(
  name: string,