export function processFunction()

in tools/apiview/parsers/rust-api-parser/src/process-items/processFunction.ts [61:181]
100 lines of code
12 McCabe index (conditional complexity)

export function processFunction(item: Item): ReviewLine[] {
  if (!isFunctionItem(item)) return [];
  const reviewLines: ReviewLine[] = item.docs ? createDocsReviewLines(item) : [];

  // Create the ReviewLine object
  const reviewLine: ReviewLine = {
    LineId: item.id.toString(),
    Tokens: [],
    Children: [],
  };

  reviewLine.Tokens.push({
    Kind: TokenKind.Keyword,
    Value: "pub",
  });

  // Process function header modifiers and ABI
  processFunctionHeader(item.inner.function.header, reviewLine);

  reviewLine.Tokens.push({
    Kind: TokenKind.Keyword,
    Value: "fn",
  });

  reviewLine.Tokens.push({
    Kind: TokenKind.MemberName,
    Value: item.name || "unknown_fn",
    HasSuffixSpace: false,
    RenderClasses: ["method"],
    NavigateToId: item.id.toString(),
    NavigationDisplayName: item.name || undefined,
  });

  const genericsTokens = processGenerics(item.inner.function.generics);
  // Add generics params if present
  if (item.inner.function.generics) {
    reviewLine.Tokens.push(...genericsTokens.params);
  }

  // Process function parameters
  reviewLine.Tokens.push({
    Kind: TokenKind.Punctuation,
    Value: "(",
    HasSuffixSpace: false,
    HasPrefixSpace: false,
  });

  // Add function parameters
  if (item.inner.function.sig.inputs.length > 0) {
    item.inner.function.sig.inputs.forEach((input: [string, Type], index: number) => {
      if (index > 0) {
        reviewLine.Tokens.push({
          Kind: TokenKind.Punctuation,
          Value: ", ",
          HasSuffixSpace: false,
        });
      }

      if (input[0] === "self") {
        reviewLine.Tokens.push({
          Kind: TokenKind.StringLiteral,
          Value: `&${input[0]}`,
          HasSuffixSpace: false,
        });
      } else {
        reviewLine.Tokens.push({
          Kind: TokenKind.StringLiteral,
          Value: input[0],
          HasSuffixSpace: false,
        });

        reviewLine.Tokens.push({
          Kind: TokenKind.Punctuation,
          Value: ": ",
          HasSuffixSpace: false,
        });
        reviewLine.Tokens.push(...typeToReviewTokens(input[1]));
      }
    });
  }

  reviewLine.Tokens.push({
    Kind: TokenKind.Punctuation,
    Value: ")",
    HasPrefixSpace: false,
    HasSuffixSpace: false,
  });

  // Add return type if present
  if (item.inner.function.sig.output) {
    reviewLine.Tokens.push({
      Kind: TokenKind.Punctuation,
      Value: "->",
      HasPrefixSpace: true,
    });
    reviewLine.Tokens.push(...typeToReviewTokens(item.inner.function.sig.output));
  }

  // Add generics where clauses if present
  if (item.inner.function.generics) {
    reviewLine.Tokens.push(...genericsTokens.wherePredicates);
  }

  if (item.inner.function.has_body) {
    reviewLine.Tokens.push({
      Kind: TokenKind.Punctuation,
      Value: "{}",
      HasSuffixSpace: false,
      HasPrefixSpace: true,
    });
  } else {
    reviewLine.Tokens.push({
      Kind: TokenKind.Punctuation,
      Value: ";",
      HasSuffixSpace: false,
    });
  }
  reviewLines.push(reviewLine);
  lineIdMap.set(item.id.toString(), `function_${item.name}`);
  return reviewLines;
}