Function getSignatureHelp

packages/language-service/src/signature_help.ts:21–138

(
  compiler: NgCompiler,
  tsLS: ts.LanguageService,
  fileName: string,
  position: number,
  options: ts.SignatureHelpItemsOptions | undefined,
)

 * Queries the TypeScript Language Service to get signature help for a template position.
 */
export function getSignatureHelp(
  compiler: NgCompiler,
  tsLS: ts.LanguageService,
  fileName: string,
  position: number,
  options: ts.SignatureHelpItemsOptions | undefined,
): ts.SignatureHelpItems | undefined {
  const typeCheckInfo = getTypeCheckInfoAtPosition(fileName, position, compiler);
  if (typeCheckInfo === undefined) {
    return undefined;
  }

  const targetInfo = getTargetAtPosition(typeCheckInfo.nodes, position);
  if (targetInfo === null) {
    return undefined;
  }

  if (
    targetInfo.context.kind !== TargetNodeKind.RawExpression &&
    targetInfo.context.kind !== TargetNodeKind.CallExpressionInArgContext
  ) {
    // Signature completions are only available in expressions.
    return undefined;
  }

  const symbol = compiler
    .getTemplateTypeChecker()
    .getSymbolOfNode(targetInfo.context.node, typeCheckInfo.declaration);
  if (symbol === null || symbol.kind !== SymbolKind.Expression) {
    return undefined;
  }

  // Determine a shim position to use in the request to the TypeScript Language Service.
  // Additionally, extract the `Call` node for which signature help is being queried, as this
  // is needed to construct the correct span for the results later.
  let shimPosition: number;
  let expr: Call | SafeCall;
  switch (targetInfo.context.kind) {
    case TargetNodeKind.RawExpression:
      // For normal expressions, just use the primary TCB position of the expression.
      shimPosition = symbol.tcbLocation.positionInFile;

      // Walk up the parents of this expression and try to find a
      // `Call` for which signature information is being fetched.
      let callExpr: Call | SafeCall | null = null;
      const parents = targetInfo.context.parents;
      for (let i = parents.length - 1; i >= 0; i--) {
        const parent = parents[i];
        if (parent instanceof Call || parent instanceof SafeCall) {
          callExpr = parent;
          break;
        }
      }

      // If no Call node could be found, then this query cannot be safely
      // answered as a correct span for the results will not be obtainable.
      if (callExpr === null) {
        return undefined;