SYMBOL INDEX (1506 symbols across 106 files)

FILE: crate/src/main.rs
  function main (line 1) | fn main() {

FILE: extension/src/index.ts
  function activate (line 10) | async function activate(context: ExtensionContext) {
  function format (line 34) | function format(document: TextDocument, config: Config) {
  function tryFormat (line 54) | function tryFormat(doc: TextDocument, config: prettier.Config) {
  function createOutputChannel (line 75) | function createOutputChannel(name: string) {
  function unstyle (line 92) | function unstyle(str: string) {
  function cmd (line 96) | function cmd(filepath: string | undefined, frompath = "") {
  function normPath (line 99) | function normPath(filepath: string) {

FILE: scripts/dev.format.ts
  function format (line 6) | function format(code: string, filepath: string) {

FILE: src/format/comments.ts
  function addCommentHelper (line 56) | function addCommentHelper(node: Node, comment: AnyComment, leading = fal...
  function addLeadingComment (line 62) | function addLeadingComment(node: Node, comment: AnyComment) {
  function addDanglingComment (line 65) | function addDanglingComment(node: Node, comment: AnyComment, marker: DCM) {
  function addTrailingComment (line 69) | function addTrailingComment(node: Node, comment: AnyComment) {
  function setPrettierIgnoreTarget (line 72) | function setPrettierIgnoreTarget(node: Node, comment: AnyComment) {
  function hasComments (line 78) | function hasComments<T extends Node>(node: T): node is NodeWithComments<...
  function printDanglingComments (line 82) | function printDanglingComments(enclosingNode: Node, sameIndent: boolean,...
  function needsHardlineAfterDanglingComment (line 99) | function needsHardlineAfterDanglingComment(node: Node) {
  function setDidPrintComment (line 104) | function setDidPrintComment(comment: AnyComment) {
  function printComment (line 108) | function printComment(comment: AnyComment) {
  function isPreviousLineEmpty (line 115) | function isPreviousLineEmpty(node: Node) {
  function hasBreaklineBefore (line 122) | function hasBreaklineBefore(node: Node) {
  function hasBreaklineAfter (line 126) | function hasBreaklineAfter(node: Node) {
  function printCommentsSeparately (line 130) | function printCommentsSeparately(ignored?: Set<AnyComment>) {
  function getPostLeadingComment (line 187) | function getPostLeadingComment(comment: AnyComment) {
  function withComments (line 199) | function withComments<D extends Doc>(node: Node, printed: D, ignored?: S...
  function getComments (line 206) | function getComments(node: Node, ...args: Parameters<typeof getCommentTe...
  function getFirstComment (line 218) | function getFirstComment(node: Node, flags: CF, fn?: (comment: AnyCommen...
  function escapeComments (line 223) | function escapeComments(flags: number, fn?: (comment: AnyComment) => boo...
  type CF (line 229) | const enum CF {
  function isPrettierIgnoreComment (line 239) | function isPrettierIgnoreComment(comment: AnyComment) {
  function isPrettierIgnoreAttribute (line 242) | function isPrettierIgnoreAttribute(node: Node): node is MutatedAttribute {
  function getCommentTestFunction (line 245) | function getCommentTestFunction(flags: CF, fn?: (comment: AnyComment) =>...
  function hasComment (line 262) | function hasComment(node: Node, flags: number = 0, fn?: (comment: AnyCom...
  function hasNewlineInRange (line 268) | function hasNewlineInRange(leftIndex: number, rightIndex: number) {
  function isNextLineEmpty (line 274) | function isNextLineEmpty(node: Node) {
  function isNextLineEmptyAfterIndex (line 277) | function isNextLineEmptyAfterIndex(index: number | false) {
  function hasNewline (line 293) | function hasNewline(index: number | false, backwards = false) {
  function skipLineComment (line 298) | function skipLineComment(index: number | false) {
  function skipBlockComment (line 305) | function skipBlockComment(index: number | false) {
  function skipNewline (line 324) | function skipNewline(index: number | false, backwards = false) {
  function skipParens (line 338) | function skipParens(index: number | false, backwards = false) {
  function getNextNonSpaceNonCommentCharacterIndex (line 346) | function getNextNonSpaceNonCommentCharacterIndex(node: Node) {
  function getNextNonSpaceNonCommentCharacterIndexWithStartIndex (line 349) | function getNextNonSpaceNonCommentCharacterIndexWithStartIndex(i: number) {
  function getNextNonSpaceNonCommentCharacter (line 362) | function getNextNonSpaceNonCommentCharacter(node: Node) {
  type CommentContext (line 366) | interface CommentContext {
  function handled (line 377) | function handled(comment: AnyComment) {
  function handleCommon (line 380) | function handleCommon(ctx: CommentContext): boolean {
  function handleOwnLineComment (line 475) | function handleOwnLineComment(ctx: CommentContext) {
  function handleEndOfLineComment (line 478) | function handleEndOfLineComment(ctx: CommentContext) {
  function handleRemainingComment (line 502) | function handleRemainingComment(ctx: CommentContext) {
  function handleStructLiteralComments (line 506) | function handleStructLiteralComments({ enclosingNode, followingNode, com...
  function handleVariableDeclaratorComments (line 512) | function handleVariableDeclaratorComments({ enclosingNode, followingNode...
  function handleMixedInOuterAttributeComments (line 534) | function handleMixedInOuterAttributeComments({ precedingNode, enclosingN...
  function handleAttributeComments (line 561) | function handleAttributeComments({ precedingNode, enclosingNode, followi...
  function handleBadComments (line 604) | function handleBadComments({ precedingNode, enclosingNode, followingNode...
  function is_ABI_Comment (line 622) | function is_ABI_Comment({ precedingNode, enclosingNode, comment }: Comme...
  function handleFlowControlComments (line 628) | function handleFlowControlComments({ precedingNode, enclosingNode, follo...
  function handleFunctionComments (line 635) | function handleFunctionComments(ctx: CommentContext) {
  function handleMacroRuleComments (line 675) | function handleMacroRuleComments(ctx: CommentContext) {
  function handleStatementComments (line 694) | function handleStatementComments(ctx: CommentContext) {
  function addCommentToBlock (line 701) | function addCommentToBlock(block: NodeWithBodyOrCases, comment: AnyComme...
  function handleIfBlockExpressionComments (line 711) | function handleIfBlockExpressionComments(ctx: CommentContext) {
  function handleMemberExpressionComments (line 729) | function handleMemberExpressionComments({ comment, precedingNode, enclos...
  function handleDanglingComments (line 739) | function handleDanglingComments({ comment, enclosingNode }: CommentConte...
  function canAttachCommentInLocArray (line 753) | function canAttachCommentInLocArray(arr: LocArray) {
  function isOwnLine (line 757) | function isOwnLine(comment: AnyComment) {
  function isStartOfLine (line 760) | function isStartOfLine(comment: AnyComment) {
  function isEndOfLine (line 763) | function isEndOfLine(comment: AnyComment) {
  function isDangling (line 766) | function isDangling(comment: AnyComment) {
  function isLeading (line 770) | function isLeading(comment: AnyComment) {
  function isTrailing (line 774) | function isTrailing(comment: AnyComment) {
  function print_comment (line 779) | function print_comment(comment: CommentOrDocComment) {

FILE: src/format/complexity.ts
  constant DEPTH (line 32) | let DEPTH = 0;
  constant ANCESTRY (line 33) | const ANCESTRY: Node[] = [];
  constant LONE_SHORT_ARGUMENT_THRESHOLD_RATE (line 34) | const LONE_SHORT_ARGUMENT_THRESHOLD_RATE = 0.25;
  function withCheckContext (line 36) | function withCheckContext<R>(fn: () => R): R {
  function is_short (line 50) | function is_short(str: string) {
  function print (line 53) | function print(target: Node) {
  function IsSimpleFunction (line 66) | function IsSimpleFunction<T extends Node>(fn: (node: T) => boolean): (no...
  function HasComplexFunction (line 84) | function HasComplexFunction<T extends Node>(fn: (node: T) => boolean): (...
  function isSimpleTypeNamespaceTargetNoSelector (line 189) | function isSimpleTypeNamespaceTargetNoSelector(node: TypeNamespaceTarget...

FILE: src/format/core.ts
  function isNoopExpressionStatement (line 220) | function isNoopExpressionStatement(node: Node) {
  function getLastNotNoopExpressionStatement (line 224) | function getLastNotNoopExpressionStatement(parent: MaybeBlockBody) {
  function is_xVariableEqualishLike (line 228) | function is_xVariableEqualishLike(node: Node) {
  function is_BinaryishExpression (line 242) | function is_BinaryishExpression(node: Node): node is OrExpression | AndE...
  type StructSpread (line 254) | type StructSpread = StructLiteralPropertySpread | StructLiteralRestUnass...
  function is_StructSpread (line 255) | function is_StructSpread(node: Node): node is StructSpread {
  type ArrayLikeNode (line 266) | type ArrayLikeNode = Exclude<Extract<Node, { items: Node[] }>, UnionPatt...
  function isConciselyPrintedArray (line 267) | function isConciselyPrintedArray(node: ArrayLikeNode) {
  function printCommentsInsideEmptyArray (line 278) | function printCommentsInsideEmptyArray(path: AstPath<Node>) {
  function printNumber (line 287) | function printNumber(rawNumber: string) {
  function printOnOwnLine (line 297) | function printOnOwnLine(node: Node, printed: Doc) {
  function maybeEmptyLine (line 300) | function maybeEmptyLine(node: Node) {
  function printBodyOrCases (line 304) | function printBodyOrCases<T extends NodeWithBodyOrCases | BlockLikeMacro...
  function printMacroRules (line 345) | function printMacroRules<T extends MacroDeclaration | MacroRulesDeclarat...
  function is_unary_token (line 352) | function is_unary_token(item: MacroMatchSegment | undefined) {
  function can_unary (line 367) | function can_unary(node: MacroMatchSegment) {
  function is_optional_token (line 370) | function is_optional_token(item: MacroMatchSegment | undefined): item is...
  function is_optional_unary (line 373) | function is_optional_unary(item: MacroMatchSegment | undefined) {
  function is_optional_segment (line 377) | function is_optional_segment(item: Node): item is MacroGroup {
  function printRuleMatch (line 381) | function printRuleMatch<T extends MacroRuleDeclaration | MacroInlineRule...
  function printRuleTransform (line 637) | function printRuleTransform<T extends MacroRuleDeclaration | MacroInline...
  function is_AssignmentOrVariableDeclarator (line 684) | function is_AssignmentOrVariableDeclarator(node: Node): boolean {
  function hasLeadingOwnLineComment (line 687) | function hasLeadingOwnLineComment(node: Node): boolean {
  function isComplexDestructuring (line 697) | function isComplexDestructuring(node: Node): boolean {
  function isArrowFunctionVariableDeclarator (line 730) | function isArrowFunctionVariableDeclarator(node: Node) {
  function isObjectPropertyWithShortKey (line 733) | function isObjectPropertyWithShortKey(node: Node, keyDoc: Doc) {
  function print_CallExpression_end (line 740) | function print_CallExpression_end(print: print<CallExpression>, node: Ca...
  function printCallExpression (line 744) | function printCallExpression(print: print<CallExpression>, node: CallExp...
  function printTypeAnnotation (line 758) | function printTypeAnnotation<T extends Extract<Node, MaybeTypeAnnotation...
  function printAnnotatedPattern (line 761) | function printAnnotatedPattern<T extends Extract<Node, MaybeTypeAnnotati...
  function isLoneShortArgument (line 765) | function isLoneShortArgument(node: Node) {
  type Layout (line 783) | const enum Layout {
  function printMemberExpression (line 794) | function printMemberExpression(print: print<MemberExpression>, node: Mem...
  function shouldInlineMemberExpression (line 806) | function shouldInlineMemberExpression(node: MemberExpression, objectDoc:...
  function printAssignment (line 828) | function printAssignment(leftDoc: Doc, operator: string, rightPropertyNa...
  function is_MemberExpression_with_RangeOrLiteral_Property (line 980) | function is_MemberExpression_with_RangeOrLiteral_Property(node: Node | u...
  function is_Literal_or_SimpleRangeLiteral (line 985) | function is_Literal_or_SimpleRangeLiteral(node: Node) {
  function printMemberLookup (line 992) | function printMemberLookup(print: print<MemberExpression>, node: MemberE...
  function shouldPrint_CallExpression_chain (line 1000) | function shouldPrint_CallExpression_chain(node: CallExpression) {
  function is_MemberAccessLike (line 1003) | function is_MemberAccessLike(node: Node): node is ExpressionPath | Membe...
  type ChainItem (line 1012) | type ChainItem = { node: Node; printed: Doc; needsParens: boolean };
  function printMemberChain (line 1013) | function printMemberChain(print: print<CallExpression>, node: CallExpres...
  function isSimpleCallArgument (line 1240) | function isSimpleCallArgument(node: Node, depth: number) {
  function isLongCurriedCallExpression (line 1299) | function isLongCurriedCallExpression(node: Node) {
  function printTypeArguments (line 1310) | function printTypeArguments<T extends Extract<Node, MaybeGenericArgsTarg...
  function printLtParameters (line 1328) | function printLtParameters<T extends Extract<Node, ForLtParametersBody>>...
  function printGenerics (line 1346) | function printGenerics<T extends DeclarationNode>(print: print<T>, node:...
  function getPrintedTypeBounds (line 1364) | function getPrintedTypeBounds<T extends Extract<Node, TypeBoundsConstain...
  function printTypeBounds (line 1378) | function printTypeBounds<T extends Extract<Node, TypeBoundsConstaint>>(o...
  function printLtBounds (line 1390) | function printLtBounds<T extends Extract<Node, MaybeHasLtBounds>>(left: ...
  function printWhereBounds (line 1400) | function printWhereBounds<T extends DeclarationNode>(print: print<T>, no...
  function printDeclarationTypeBounds (line 1408) | function printDeclarationTypeBounds<T extends Extract<DeclarationNode, T...
  function printImplTraitForType (line 1415) | function printImplTraitForType(
  function adjustDeclarationClause (line 1424) | function adjustDeclarationClause(node: DeclarationNode, clause: ":" | " ...
  function hasNonWhereHeritageClause (line 1449) | function hasNonWhereHeritageClause(node: DeclarationNode) {
  function hasAnyHeritageClause (line 1483) | function hasAnyHeritageClause(node: DeclarationNode) {
  function hasMultipleHeritage (line 1487) | function hasMultipleHeritage(node: DeclarationNode) {
  function createGroupIdMapper (line 1495) | function createGroupIdMapper(description: string) {
  function printDanglingCommentsForInline (line 1500) | function printDanglingCommentsForInline(node: Node, marker?: DCM) {
  function isFormatLikeCall (line 1514) | function isFormatLikeCall(node: CallExpression | CallLikeMacroInvocation) {
  class ArgExpansionBailout (line 1524) | class ArgExpansionBailout extends Error {}
  function printCallArguments (line 1526) | function printCallArguments<T extends CallExpression | CallLikeMacroInvo...
  function shouldHugFunctionParameters (line 1620) | function shouldHugFunctionParameters(node: Extract<Node, FunctionLike>) {
  function shouldGroupFunctionParameters (line 1638) | function shouldGroupFunctionParameters(functionNode: FunctionDeclaration...
  function printBlockBody (line 1656) | function printBlockBody<T extends NodeWithBodyOrCases | BlockLikeMacroIn...
  function printMaybeBlockBody (line 1671) | function printMaybeBlockBody<T extends (NodeWithBodyOrCases | BlockLikeM...
  function printArrowFunction (line 1678) | function printArrowFunction<T extends ClosureFunctionExpression>(print: ...
  function printArrowChain (line 1734) | function printArrowChain(signatures: Doc[], shouldBreak: boolean, bodyDo...
  function printArrowFunctionSignature (line 1755) | function printArrowFunctionSignature<T extends ClosureFunctionExpression...
  function printGenerics_x_whereBounds (line 1776) | function printGenerics_x_whereBounds<T extends DeclarationNode>(print: p...
  function adjustClause (line 1788) | function adjustClause(
  function printParametersAndReturnType (line 1800) | function printParametersAndReturnType(node: FunctionNode | TypeFunctionN...
  function printFlowControlExpression (line 1808) | function printFlowControlExpression<T extends ReturnExpression | BreakEx...
  function flowControlExpressionNeedsOuterParens (line 1828) | function flowControlExpressionNeedsOuterParens(flow: ReturnExpression | ...
  function getLeftSide (line 1843) | function getLeftSide(node, includeAttributes = false) {
  function hasNakedLeftSide (line 1860) | function hasNakedLeftSide(node: Node) {
  function printReturnType (line 1871) | function printReturnType<T extends Extract<Node, MaybeReturnTypeConstrai...
  function printFunctionParameters (line 1879) | function printFunctionParameters<T extends FunctionNode | TypeFunctionNo...
  function path_try (line 1921) | function path_try<T>(callback: () => T): T {
  function shouldGroupFirstArg (line 1931) | function shouldGroupFirstArg(args: LocArray<ExpressionNode>): boolean {
  function shouldGroupLastArg (line 1942) | function shouldGroupLastArg(args: LocArray<ExpressionNode>): boolean {
  function couldGroupArg (line 1955) | function couldGroupArg(arg: Node, arrowChainRecursion = false): boolean {
  function isNonEmptyBlockStatement (line 1970) | function isNonEmptyBlockStatement(node: Node) {
  function isFunctionCompositionArgs (line 1974) | function isFunctionCompositionArgs(args) {
  function printBinaryishExpression (line 1993) | function printBinaryishExpression<T extends AndExpression | OrExpression...
  function shouldInlineLogicalExpression (line 2090) | function shouldInlineLogicalExpression(node: Node) {
  function printUnaryExpression (line 2098) | function printUnaryExpression<T extends UnaryExpression>(leftDoc: Doc, n...
  function printIfBlock (line 2109) | function printIfBlock<T extends IfBlockExpression>(print: print<T>, node...
  function printIfBlockCondition (line 2134) | function printIfBlockCondition<T extends IfBlockExpression | MatchExpres...
  function printCondition (line 2145) | function printCondition<T extends IfBlockExpression | MatchExpressionCas...
  function parenthesize_if_break (line 2158) | function parenthesize_if_break(doc: Doc) {
  function unwrapParenthesized (line 2161) | function unwrapParenthesized(doc: Doc) {
  function withParensIdentOnBreak (line 2168) | function withParensIdentOnBreak(node: Node, printed: Doc) {
  function isSimplePattern (line 2174) | function isSimplePattern(node: PatternNode | undefined) {
  function printUnionPattern (line 2202) | function printUnionPattern<T extends UnionPattern>(print: print<T>, node...
  function printArrayLike (line 2220) | function printArrayLike<T extends ArrayLikeNode>(print: print<T>, node: ...
  function printObject (line 2286) | function printObject<T extends ObjectNode>(print: print<T>, node: T): Doc {
  function printEnumBody (line 2340) | function printEnumBody<T extends EnumDeclaration>(print: print<T>, node:...

FILE: src/format/external.ts
  type CustomOptions (line 60) | interface CustomOptions extends ParserOptions<Node> {
  type NodeWithComments (line 72) | type NodeWithComments<T extends Node> = T & { comments: AnyComment[] };
  type MutatedComment (line 73) | interface MutatedComment extends Comment, PrettierCommentInfo {}
  type MutatedAttribute (line 74) | interface MutatedAttribute extends Attribute, PrettierCommentInfo {}
  type MutatedDocComment (line 75) | interface MutatedDocComment extends DocCommentAttribute, PrettierComment...
  type AnyComment (line 76) | type AnyComment = MutatedComment | MutatedAttribute | MutatedDocComment;
  type keyofDelimitedArrayProps (line 78) | type keyofDelimitedArrayProps<T> = T extends never ? never : keyof PickP...
  type DCM (line 82) | enum DCM {
  type PrettierCommentInfo (line 100) | interface PrettierCommentInfo {
  type AstPath (line 110) | interface AstPath<T = Node> {

FILE: src/format/plugin.ts
  function is_printing_macro (line 46) | function is_printing_macro() {
  function assertPathAtNode (line 50) | function assertPathAtNode(name: string, node: Node, ...ctx: any[]) {
  function f (line 55) | function f(...args: [strings: TemplateStringsArray, ...values: Doc[]]) {
  function sg_single (line 64) | function sg_single(s: TemplateStringsArray, v_0: Doc) {
  function sg_duo (line 67) | function sg_duo(s: TemplateStringsArray, v_0: Doc, v_1: Doc) {
  function pathCall (line 97) | function pathCall<T extends Node, K extends keyof NodeProps<T> & keyof T...
  function pathCallEach (line 101) | function pathCallEach<T extends Node, K extends AK<T>>(
  function pathCallAtParent (line 110) | function pathCallAtParent<T extends Node, R>(parent: T, fn: (parent: T) ...
  function pathCallParentOf (line 116) | function pathCallParentOf<T extends Node, R>(child: Node, fn: (parent: T...
  function pathCallTopMostIfBlockExpression (line 121) | function pathCallTopMostIfBlockExpression<R>(node: IfBlockExpression, fn...
  function print (line 126) | function print(property?: any, args?: any): Doc | Doc[] {
  function b (line 134) | function b(property: string, res = `${property} `): Doc {
  function map (line 137) | function map(property: string, mapItem?: MapFn<any, any>): Doc[] {
  function join (line 140) | function join(property: string, sep: SepFn<any, any> | Doc, trailingSep:...
  function map_join (line 143) | function map_join(
  type SepFn (line 162) | type SepFn<T extends Node = Node, K extends AK<T> = AK<T>> = <A extends ...
  type MapFn (line 163) | type MapFn<T extends Node = Node, K extends AK<T> = AK<T>> = <A extends ...
  type TrailingSepFn (line 164) | type TrailingSepFn<T extends Node = Node, K extends AK<T> = AK<T>> = <A ...
  type AV (line 165) | type AV<T extends Node, K extends keyof T> = Extract<NonNullable<T[K]>, ...
  type AK (line 166) | type AK<T extends Node> = keyof ArrayProps<T> & keyof T;
  type print (line 169) | interface print<T extends Node> {
  function genericPrint (line 181) | function genericPrint() {
  function canAttachComment (line 246) | function canAttachComment(n: Node) {
  method parse (line 270) | parse(code, parsers, options: CustomOptions) {
  method print (line 297) | print(path, options, print, args) {
  function devEndCheck (line 344) | function devEndCheck(printed: Doc) {

FILE: src/format/printer.ts
  type nPrint (line 65) | type nPrint<T extends Node> = (print: print<T>, node: T) => Doc | never;
  method [NodeType.MissingNode] (line 68) | [NodeType.MissingNode](print, node) {
  method [NodeType.SourceFile] (line 71) | [NodeType.SourceFile](print, node) {
  method [NodeType.Shebang] (line 78) | [NodeType.Shebang](print, node) {
  method [NodeType.Program] (line 81) | [NodeType.Program](print, node) {
  method [NodeType.Snippet] (line 84) | [NodeType.Snippet](print, node) {
  method [NodeType.Identifier] (line 87) | [NodeType.Identifier](print, node) {
  method [NodeType.Index] (line 90) | [NodeType.Index](print, node) {
  method [NodeType.LbIdentifier] (line 93) | [NodeType.LbIdentifier](print, node) {
  method [NodeType.McIdentifier] (line 96) | [NodeType.McIdentifier](print, node) {
  method [NodeType.LtIdentifier] (line 99) | [NodeType.LtIdentifier](print, node) {
  method [NodeType.PunctuationToken] (line 102) | [NodeType.PunctuationToken](print, node) {
  method [NodeType.DelimGroup] (line 105) | [NodeType.DelimGroup](print, node) {
  method [NodeType.Literal] (line 108) | [NodeType.Literal](print, node) {
  method [NodeType.ItemPath] (line 113) | [NodeType.ItemPath](print, node) {
  method [NodeType.ExpressionPath] (line 116) | [NodeType.ExpressionPath](print, node) {
  method [NodeType.TypePath] (line 119) | [NodeType.TypePath](print, node) {
  method [NodeType.Comment] (line 122) | [NodeType.Comment](print, node) {
  method [NodeType.DocCommentAttribute] (line 125) | [NodeType.DocCommentAttribute](print, node) {
  method [NodeType.Attribute] (line 128) | [NodeType.Attribute](print, node) {
  method [NodeType.MacroInvocation] (line 137) | [NodeType.MacroInvocation](print, node) {
  method [NodeType.MacroRulesDeclaration] (line 160) | [NodeType.MacroRulesDeclaration](print, node) {
  method [NodeType.MacroRuleDeclaration] (line 163) | [NodeType.MacroRuleDeclaration](print, node) {
  method [NodeType.MacroDeclaration] (line 166) | [NodeType.MacroDeclaration](print, node) {
  method [NodeType.MacroInlineRuleDeclaration] (line 169) | [NodeType.MacroInlineRuleDeclaration](print, node) {
  method [NodeType.MacroGroup] (line 172) | [NodeType.MacroGroup](print, node) {
  method [NodeType.MacroParameterDeclaration] (line 175) | [NodeType.MacroParameterDeclaration](print, node) {
  method [NodeType.PubSpecifier] (line 178) | [NodeType.PubSpecifier](print, node) {
  method [NodeType.ExternSpecifier] (line 195) | [NodeType.ExternSpecifier](print, node) {
  method [NodeType.ExpressionStatement] (line 198) | [NodeType.ExpressionStatement](print, node) {
  method [NodeType.UseStatement] (line 201) | [NodeType.UseStatement](print, node) {
  method [NodeType.DestructuredImport] (line 204) | [NodeType.DestructuredImport](print, node) {
  method [NodeType.AmbientImport] (line 218) | [NodeType.AmbientImport](print, node) {
  method [NodeType.AnonymousImport] (line 221) | [NodeType.AnonymousImport](print, node) {
  method [NodeType.NamedImport] (line 224) | [NodeType.NamedImport](print, node) {
  method [NodeType.ExternCrateStatement] (line 227) | [NodeType.ExternCrateStatement](print, node) {
  method [NodeType.TypeAliasDeclaration] (line 230) | [NodeType.TypeAliasDeclaration](print, node) {
  method [NodeType.LetVariableDeclaration] (line 242) | [NodeType.LetVariableDeclaration](print, node) {
  method [NodeType.ConstVariableDeclaration] (line 254) | [NodeType.ConstVariableDeclaration](print, node) {
  method [NodeType.StaticVariableDeclaration] (line 266) | [NodeType.StaticVariableDeclaration](print, node) {
  method [NodeType.ModuleDeclaration] (line 278) | [NodeType.ModuleDeclaration](print, node) {
  method [NodeType.ExternBlockDeclaration] (line 287) | [NodeType.ExternBlockDeclaration](print, node) {
  method [NodeType.FunctionDeclaration] (line 296) | [NodeType.FunctionDeclaration](print, node) {
  method [NodeType.FunctionSelfParameterDeclaration] (line 308) | [NodeType.FunctionSelfParameterDeclaration](print, node) {
  method [NodeType.FunctionParameterDeclaration] (line 311) | [NodeType.FunctionParameterDeclaration](print, node) {
  method [NodeType.FunctionSpread] (line 314) | [NodeType.FunctionSpread](print, node) {
  method [NodeType.StructDeclaration] (line 317) | [NodeType.StructDeclaration](print, node) {
  method [NodeType.StructPropertyDeclaration] (line 320) | [NodeType.StructPropertyDeclaration](print, node) {
  method [NodeType.TupleStructDeclaration] (line 323) | [NodeType.TupleStructDeclaration](print, node) {
  method [NodeType.TupleStructItemDeclaration] (line 326) | [NodeType.TupleStructItemDeclaration](print, node) {
  method [NodeType.UnionDeclaration] (line 329) | [NodeType.UnionDeclaration](print, node) {
  method [NodeType.EnumDeclaration] (line 332) | [NodeType.EnumDeclaration](print, node) {
  method [NodeType.EnumMemberDeclaration] (line 335) | [NodeType.EnumMemberDeclaration](print, node) {
  method [NodeType.EnumMemberTupleDeclaration] (line 345) | [NodeType.EnumMemberTupleDeclaration](print, node) {
  method [NodeType.EnumMemberStructDeclaration] (line 355) | [NodeType.EnumMemberStructDeclaration](print, node) {
  method [NodeType.TraitDeclaration] (line 365) | [NodeType.TraitDeclaration](print, node) {
  method [NodeType.AutoTraitDeclaration] (line 374) | [NodeType.AutoTraitDeclaration](print, node) {
  method [NodeType.TraitAliasDeclaration] (line 384) | [NodeType.TraitAliasDeclaration](print, node) {
  method [NodeType.ImplDeclaration] (line 393) | [NodeType.ImplDeclaration](print, node) {
  method [NodeType.NegativeImplDeclaration] (line 402) | [NodeType.NegativeImplDeclaration](print, node) {
  method [NodeType.ExpressionTypeSelector] (line 411) | [NodeType.ExpressionTypeSelector](print, node) {
  method [NodeType.ExpressionTypeCast] (line 414) | [NodeType.ExpressionTypeCast](print, node) {
  method [NodeType.ExpressionAsTypeCast] (line 417) | [NodeType.ExpressionAsTypeCast](print, node) {
  method [NodeType.ReturnExpression] (line 420) | [NodeType.ReturnExpression](print, node) {
  method [NodeType.BreakExpression] (line 423) | [NodeType.BreakExpression](print, node) {
  method [NodeType.ContinueExpression] (line 426) | [NodeType.ContinueExpression](print, node) {
  method [NodeType.YieldExpression] (line 429) | [NodeType.YieldExpression](print, node) {
  method [NodeType.RangeLiteral] (line 432) | [NodeType.RangeLiteral](print, node) {
  method [NodeType.CallExpression] (line 435) | [NodeType.CallExpression](print, node) {
  method [NodeType.MemberExpression] (line 438) | [NodeType.MemberExpression](print, node) {
  method [NodeType.AwaitExpression] (line 441) | [NodeType.AwaitExpression](print, node) {
  method [NodeType.UnwrapExpression] (line 444) | [NodeType.UnwrapExpression](print, node) {
  method [NodeType.ParenthesizedExpression] (line 447) | [NodeType.ParenthesizedExpression](print, node) {
  method [NodeType.MinusExpression] (line 453) | [NodeType.MinusExpression](print, node) {
  method [NodeType.NotExpression] (line 456) | [NodeType.NotExpression](print, node) {
  method [NodeType.OrExpression] (line 459) | [NodeType.OrExpression](print, node) {
  method [NodeType.AndExpression] (line 462) | [NodeType.AndExpression](print, node) {
  method [NodeType.ReassignmentExpression] (line 465) | [NodeType.ReassignmentExpression](print, node) {
  method [NodeType.UnassignedExpression] (line 468) | [NodeType.UnassignedExpression](print, node) {
  method [NodeType.OperationExpression] (line 471) | [NodeType.OperationExpression](print, node) {
  method [NodeType.ReassignmentOperationExpression] (line 474) | [NodeType.ReassignmentOperationExpression](print, node) {
  method [NodeType.ComparisonExpression] (line 477) | [NodeType.ComparisonExpression](print, node) {
  method [NodeType.LetScrutinee] (line 480) | [NodeType.LetScrutinee](print, node) {
  method [NodeType.ClosureFunctionExpression] (line 483) | [NodeType.ClosureFunctionExpression](print, node) {
  method [NodeType.ClosureFunctionParameterDeclaration] (line 486) | [NodeType.ClosureFunctionParameterDeclaration](print, node) {
  method [NodeType.BlockExpression] (line 489) | [NodeType.BlockExpression](print, node) {
  method [NodeType.LoopBlockExpression] (line 499) | [NodeType.LoopBlockExpression](print, node) {
  method [NodeType.WhileBlockExpression] (line 502) | [NodeType.WhileBlockExpression](print, node) {
  method [NodeType.ForInBlockExpression] (line 505) | [NodeType.ForInBlockExpression](print, node) {
  method [NodeType.IfBlockExpression] (line 508) | [NodeType.IfBlockExpression](print, node) {
  method [NodeType.TryBlockExpression] (line 511) | [NodeType.TryBlockExpression](print, node) {
  method [NodeType.MatchExpression] (line 514) | [NodeType.MatchExpression](print, node) {
  method [NodeType.MatchExpressionCase] (line 533) | [NodeType.MatchExpressionCase](print, node) {
  method [NodeType.StructLiteral] (line 551) | [NodeType.StructLiteral](print, node) {
  method [NodeType.StructLiteralPropertyShorthand] (line 554) | [NodeType.StructLiteralPropertyShorthand](print, node) {
  method [NodeType.StructLiteralProperty] (line 557) | [NodeType.StructLiteralProperty](print, node) {
  method [NodeType.StructLiteralPropertySpread] (line 560) | [NodeType.StructLiteralPropertySpread](print, node) {
  method [NodeType.StructLiteralRestUnassigned] (line 563) | [NodeType.StructLiteralRestUnassigned](print, node) {
  method [NodeType.ArrayLiteral] (line 566) | [NodeType.ArrayLiteral](print, node) {
  method [NodeType.SizedArrayLiteral] (line 569) | [NodeType.SizedArrayLiteral](print, node) {
  method [NodeType.TupleLiteral] (line 572) | [NodeType.TupleLiteral](print, node) {
  method [NodeType.ReferenceExpression] (line 575) | [NodeType.ReferenceExpression](print, node) {
  method [NodeType.RawReferenceExpression] (line 578) | [NodeType.RawReferenceExpression](print, node) {
  method [NodeType.DereferenceExpression] (line 581) | [NodeType.DereferenceExpression](print, node) {
  method [NodeType.BoxExpression] (line 584) | [NodeType.BoxExpression](print, node) {
  method [NodeType.UnionPattern] (line 587) | [NodeType.UnionPattern](print, node) {
  method [NodeType.ParenthesizedPattern] (line 590) | [NodeType.ParenthesizedPattern](print, node) {
  method [NodeType.RestPattern] (line 594) | [NodeType.RestPattern](print, node) {
  method [NodeType.WildcardPattern] (line 597) | [NodeType.WildcardPattern](print, node) {
  method [NodeType.PatternVariableDeclaration] (line 600) | [NodeType.PatternVariableDeclaration](print, node) {
  method [NodeType.StructPattern] (line 603) | [NodeType.StructPattern](print, node) {
  method [NodeType.StructPatternPropertyDestructured] (line 606) | [NodeType.StructPatternPropertyDestructured](print, node) {
  method [NodeType.StructPatternPropertyShorthand] (line 609) | [NodeType.StructPatternPropertyShorthand](print, node) {
  method [NodeType.TuplePattern] (line 612) | [NodeType.TuplePattern](print, node) {
  method [NodeType.ArrayPattern] (line 615) | [NodeType.ArrayPattern](print, node) {
  method [NodeType.ReferencePattern] (line 618) | [NodeType.ReferencePattern](print, node) {
  method [NodeType.BoxPattern] (line 621) | [NodeType.BoxPattern](print, node) {
  method [NodeType.MinusPattern] (line 624) | [NodeType.MinusPattern](print, node) {
  method [NodeType.RangePattern] (line 627) | [NodeType.RangePattern](print, node) {
  method [NodeType.TypeCall] (line 630) | [NodeType.TypeCall](print, node) {
  method [NodeType.TypeCallNamedArgument] (line 633) | [NodeType.TypeCallNamedArgument](print, node) {
  method [NodeType.TypeCallNamedBound] (line 636) | [NodeType.TypeCallNamedBound](print, node) {
  method [NodeType.LtElided] (line 639) | [NodeType.LtElided](print, node) {
  method [NodeType.LtStatic] (line 642) | [NodeType.LtStatic](print, node) {
  method [NodeType.TypeNever] (line 645) | [NodeType.TypeNever](print, node) {
  method [NodeType.TypeInferred] (line 648) | [NodeType.TypeInferred](print, node) {
  method [NodeType.GenericTypeParameterDeclaration] (line 651) | [NodeType.GenericTypeParameterDeclaration](print, node) {
  method [NodeType.ConstTypeParameterDeclaration] (line 658) | [NodeType.ConstTypeParameterDeclaration](print, node) {
  method [NodeType.GenericLtParameterDeclaration] (line 668) | [NodeType.GenericLtParameterDeclaration](print, node) {
  method [NodeType.WhereTypeBoundDeclaration] (line 671) | [NodeType.WhereTypeBoundDeclaration](print, node) {
  method [NodeType.WhereLtBoundDeclaration] (line 674) | [NodeType.WhereLtBoundDeclaration](print, node) {
  method [NodeType.TypeTraitBound] (line 677) | [NodeType.TypeTraitBound](print, node) {
  method [NodeType.TypeDynBounds] (line 680) | [NodeType.TypeDynBounds](print, node) {
  method [NodeType.TypeImplBounds] (line 683) | [NodeType.TypeImplBounds](print, node) {
  method [NodeType.TypeFnPointer] (line 686) | [NodeType.TypeFnPointer](print, node) {
  method [NodeType.TypeFnPointerParameter] (line 689) | [NodeType.TypeFnPointerParameter](print, node) {
  method [NodeType.TypeFunction] (line 692) | [NodeType.TypeFunction](print, node) {
  method [NodeType.TypeTuple] (line 695) | [NodeType.TypeTuple](print, node) {
  method [NodeType.TypeSizedArray] (line 698) | [NodeType.TypeSizedArray](print, node) {
  method [NodeType.TypeSlice] (line 702) | [NodeType.TypeSlice](print, node) {
  method [NodeType.TypeReference] (line 706) | [NodeType.TypeReference](print, node) {
  method [NodeType.TypeDereferenceConst] (line 709) | [NodeType.TypeDereferenceConst](print, node) {
  method [NodeType.TypeDereferenceMut] (line 712) | [NodeType.TypeDereferenceMut](print, node) {
  method [NodeType.TypeParenthesized] (line 715) | [NodeType.TypeParenthesized](print, node) {

FILE: src/format/styling.ts
  function needsOuterSoftbreakParens (line 114) | function needsOuterSoftbreakParens(node: Node) {
  function needsInnerParens (line 165) | function needsInnerParens(node: Node) {
  function precedenceNeedsParens (line 308) | function precedenceNeedsParens(node: LeftRightExpression | ClosureFuncti...
  function shouldFlatten (line 361) | function shouldFlatten(parent: ExpressionNode | ConditionExpression, nod...
  function needsParens (line 376) | function needsParens(node: Node) {
  function stmtNeedsSemi (line 380) | function stmtNeedsSemi(stmt: ExpressionStatement, disregardExprType = fa...
  function needsSemi (line 386) | function needsSemi(parent: NodeWithBody, stmt: ExpressionStatement, disr...
  function canInlineBlockBody (line 448) | function canInlineBlockBody(node: NodeWithBodyOrCases | BlockLikeMacroIn...
  function canInlineInlineable (line 495) | function canInlineInlineable(node: ExpressionWithBody) {
  type NodeWithBracketContent (line 545) | type NodeWithBracketContent =
  function emptyContent (line 557) | function emptyContent(node: NodeWithBracketContent): Doc {
  function is_insideScrutinee (line 598) | function is_insideScrutinee(target: Node) {
  function withPathAt (line 617) | function withPathAt<T extends Node, R>(target: T, callback: (target: T) ...
  function shouldPrintOuterAttributesAbove (line 626) | function shouldPrintOuterAttributesAbove(node: Node) {

FILE: src/transform/custom/attribute.ts
  type SimpleAttrItem (line 20) | type SimpleAttrItem =
  function transform_simpleAttrSyntax (line 28) | function transform_simpleAttrSyntax(segments: MacroInvocation["segments"...

FILE: src/transform/custom/cfg_if.ts
  function transform_macro_cfg_if (line 19) | function transform_macro_cfg_if(segments: MacroInvocation["segments"]) {

FILE: src/transform/custom/utils.ts
  function isIdent (line 4) | function isIdent(node: Segment | undefined, name?: string): node is Iden...
  function isToken (line 7) | function isToken(node: Segment | undefined, tk?: TK): node is Punctuatio...
  function isGroup (line 10) | function isGroup<D extends DelimKind>(node: Segment | undefined, dk?: D)...
  function isCallLike (line 14) | function isCallLike(tk_1: Segment | undefined, tk_2: Segment | undefined...

FILE: src/transform/index.ts
  type ExpressionLikeAttribute (line 90) | interface ExpressionLikeAttribute extends Attribute {
  type CallLikeMacroInvocation (line 94) | interface CallLikeMacroInvocation extends MacroInvocation {
  type BlockLikeMacroInvocation (line 102) | interface BlockLikeMacroInvocation extends MacroInvocation {
  function is_CallLikeMacroInvocation (line 108) | function is_CallLikeMacroInvocation(node: Node): node is CallLikeMacroIn...
  function is_BlockLikeMacroInvocation (line 112) | function is_BlockLikeMacroInvocation(node: Node): node is BlockLikeMacro...
  function is_CallExpression_or_CallLikeMacroInvocation (line 116) | function is_CallExpression_or_CallLikeMacroInvocation(node: any): node i...
  constant IGNORED_MACROS (line 120) | const IGNORED_MACROS = new Set([
  constant HARDCODED_MACRO_DELIMS (line 126) | const HARDCODED_MACRO_DELIMS = new Map<string, MacroInvocation["segments...
  function transform_ast (line 178) | function transform_ast(options: CustomOptions) {
  function maybe_transform_node (line 193) | function maybe_transform_node<T extends Node, S extends Snippet>(
  function isTransformed (line 209) | function isTransformed(node: Node) {
  method [NodeType.Attribute] (line 214) | [NodeType.Attribute](node) {
  method [NodeType.MacroInlineRuleDeclaration] (line 222) | [NodeType.MacroInlineRuleDeclaration](node) {
  method [NodeType.MacroInvocation] (line 226) | [NodeType.MacroInvocation](node) {
  method [NodeType.CallExpression] (line 282) | [NodeType.CallExpression](node) {
  method [NodeType.AutoTraitDeclaration] (line 294) | [NodeType.AutoTraitDeclaration](node) {
  method [NodeType.NegativeImplDeclaration] (line 297) | [NodeType.NegativeImplDeclaration](node) {
  method [NodeType.StructLiteral] (line 301) | [NodeType.StructLiteral](node) {
  method [NodeType.StructPattern] (line 304) | [NodeType.StructPattern](node) {
  function moveSpreadsToEnd (line 309) | function moveSpreadsToEnd(node: StructLiteral | StructPattern) {
  function mockBodyNoBody (line 324) | function mockBodyNoBody(node: NodeWithBodyNoBody) {
  function transformMacroDelim (line 329) | function transformMacroDelim(name: string, node: MacroInvocation): 1 | 2...
  function transformNode (line 347) | function transformNode<T extends Node>(node: T, parent?: Node, key?: str...
  function insert_blocks (line 367) | function insert_blocks(node: Node, parent?: Node, key?: string, index?: ...
  function flatten_typeBounds (line 403) | function flatten_typeBounds(topNode: Node) {
  function transform_nodeAttributes (line 454) | function transform_nodeAttributes(node: Node) {
  function registerPogramLike (line 494) | function registerPogramLike(program: Extract<Node, ProgramLike>) {
  function getCommentChildNodes (line 517) | function getCommentChildNodes(n: any): Node[] {

FILE: src/utils/common.ts
  type ErrorConstructor (line 5) | interface ErrorConstructor {
  type ImportMeta (line 10) | interface ImportMeta {
  function Narrow (line 15) | function Narrow<T extends R, R = unknown>(value: R): asserts value is T {}
  function AssertTypesEq (line 16) | function AssertTypesEq<A extends B, B>(...args: [B] extends [A] ? [] : [...
  type indexof (line 19) | type indexof<A> = A extends readonly any[] ? A extends 0 ? any : keyof A...
  type valueof (line 22) | type valueof<A> = A extends ReadonlyArray<infer U> ? A extends 0 ? any :...
  type vObject (line 25) | type vObject<V extends unknown = unknown, K extends unknown = unknown> =...
  type itfn (line 26) | type itfn<A, R> = (value: valueof<A>, key: indexof<A>) => R;
  type anySet (line 27) | type anySet<V extends unknown = unknown> = Set<V>;
  type anyMap (line 28) | type anyMap<K extends unknown = unknown, V extends unknown = unknown> = ...
  type anyfunction (line 29) | type anyfunction<A extends any[] = unknown[], R = unknown> = (...args: A...
  type objlike (line 30) | type objlike = object | anyfunction;
  type anymap (line 31) | type anymap<K extends unknown = unknown, V extends unknown = unknown> = ...
  function exit (line 33) | function exit(message: string, ...ctx: any[]): never {
  function assert (line 40) | function assert(predicate: boolean, err?: string, ...ctx: any[]): assert...
  function Identity (line 44) | function Identity<T>(v: T): T {
  function last_of (line 48) | function last_of<T extends ArrayLike<any>>(arr: T): T extends readonly [...
  function maybe_last_of (line 52) | function maybe_last_of<T extends readonly any[] | undefined>(
  function normPath (line 58) | function normPath(filepath: string) {
  function print_string (line 62) | function print_string(str: string) {
  function isArrayLike (line 72) | function isArrayLike(value: any): value is ArrayLike<unknown> {
  function oisArrayLike (line 76) | function oisArrayLike(value: {}): value is ArrayLike<unknown> {
  function binarySearchIn (line 80) | function binarySearchIn<T extends {}>(array: ArrayLike<T>, target: numbe...
  function getTerminalWidth (line 98) | function getTerminalWidth(fallbackWidth = 200) {
  function Map_get (line 128) | function Map_get<K, V>(map: anymap<K, V>, key: K, init: (key: K) => V): V {
  function isEmpty (line 132) | function isEmpty(array: ArrayLike<any>): boolean {
  function Array_splice (line 136) | function Array_splice<T extends any[]>(array: T, target: T[number], inde...
  function Array_replace (line 143) | function Array_replace<T extends any[]>(array: T, target: T[number], ......
  function has_key_defined (line 149) | function has_key_defined<T extends object, K extends T extends never ? n...
  function is_object (line 162) | function is_object(data: unknown): data is object | ({ [key: string]: un...
  function is_array (line 166) | function is_array(data: unknown): data is any[] {
  function ois_vobject (line 170) | function ois_vobject(data: any) {
  function each (line 184) | function each(data: any, callback: (value: any, index: any) => void): vo...
  function iLast (line 196) | function iLast(index: number, array: any[]) {
  function find_last (line 200) | function find_last<T>(arr: T[], test: itfn<T[], boolean>): T | undefined {
  function try_eval (line 204) | function try_eval<T>(fn: () => T): T | undefined {
  function clamp (line 212) | function clamp(min: number, max: number, value: number) {
  type MaybeFlatten (line 216) | type MaybeFlatten<T> = T extends ReadonlyArray<infer U> ? MaybeFlatten<E...
  type FlatArray (line 217) | type FlatArray<T> = MaybeFlatten<T>[];
  function flat (line 218) | function flat<T extends readonly any[]>(arr: T): FlatArray<T> {
  function flatMap (line 221) | function flatMap<T extends readonly any[], R>(arr: T, mapFn: (item: T[nu...
  function joinln (line 225) | function joinln(...arr: string[]): string {
  function join_lines (line 229) | function join_lines(fn: () => Generator<string, void, void>): string {
  function reduce_tagged_template (line 233) | function reduce_tagged_template<T>(args: [strings: TemplateStringsArray,...
  function map_tagged_template (line 238) | function map_tagged_template<T, R>(args: [strings: TemplateStringsArray,...
  function spliceAll (line 244) | function spliceAll<T extends any[]>(array: T): [...T] {
  function spread (line 250) | function spread<R>(fn: () => Iterable<R>): R[] {

FILE: src/utils/debug.ts
  function normPath_strip_cwd (line 5) | function normPath_strip_cwd(filepath: string) {
  type StackStyleFn (line 10) | type StackStyleFn = (callee: string, item: StackItem) => (str: string) =...
  type Stack (line 11) | interface Stack extends Array<StackItem> {
  class StackLine (line 16) | class StackLine {
    method constructor (line 24) | constructor(raw: string) {
  function getPrintWidth (line 40) | function getPrintWidth() {
  class StackItem (line 44) | class StackItem extends StackLine {
    method constructor (line 45) | constructor(private readonly stack: Stack, readonly i: number, raw: st...
    method hide (line 49) | hide() {
    method hideNext (line 53) | hideNext(n: number) {
    method hideWhileTrue (line 56) | hideWhileTrue(test: (line: StackItem) => boolean) {
    method at (line 60) | at(relIndex: number) {
    method next (line 63) | next() {
    method toString (line 66) | toString() {
  function createStack (line 75) | function createStack(message: string, Error_stack: string, style: Stack[...
  function composeStack (line 80) | function composeStack(stack: Stack) {
  function get_caller_cmd (line 87) | function get_caller_cmd(offset = 0) {
  function custom_prepareStackTrace (line 96) | function custom_prepareStackTrace(err, calls) {
  function overrideDefaultError (line 100) | function overrideDefaultError(silent = false) {
  function createCustomError (line 107) | function createCustomError({
  function compose2Cols (line 139) | function compose2Cols(left: string, right: string, len = 64, min = 1) {

FILE: tests/output-ext/expressions/block.f.rs
  function f (line 1) | fn f() {

FILE: tests/output-ext/expressions/closure.f.rs
  function main (line 1) | fn main() {
  function f (line 160) | fn f(_n: isize) -> isize {
  function f (line 163) | fn f() {
  type A (line 168) | struct A {
  type E (line 176) | enum E {
  type Ty (line 187) | type Ty = [

FILE: tests/output-ext/expressions/expr.f.rs
  function main (line 1) | fn main() {
  function f (line 253) | fn f() {
  function f (line 261) | fn f() {
  function public_expr (line 271) | pub fn public_expr(_: [u8; a(0).0]) {}
  function f (line 272) | pub fn f() {
  function f (line 275) | fn f() -> isize {
  function f (line 285) | fn f(x: Box<isize>) -> Box<(Box<isize>, Box<isize>)> {
  function f (line 288) | fn f<F>(f: F) -> isize where F: FnOnce(isize) -> isize {}
  function f (line 289) | fn f() {
  function f (line 297) | fn f() {
  function f (line 301) | fn f<T: ToString>(arg: T) -> String {
  function f (line 304) | fn f<A: Clone + 'static>(a: A, b: u16) -> Box<dyn Invokable<A> + 'static> {
  function f (line 307) | fn f() {
  type Foo (line 317) | pub trait Foo: Iterator<Item = <Self as Foo>::Key> {}
  function f (line 318) | fn f() {

FILE: tests/output-ext/expressions/flow_expr.f.rs
  function main (line 1) | pub fn main() {

FILE: tests/output-ext/expressions/ident.f.rs
  function bare_crate (line 1) | fn bare_crate(_: crate::a);
  function bare_global (line 2) | fn bare_global(_: ::a);
  function u8 (line 3) | fn u8(u8: u8) {
  function u8 (line 26) | pub fn u8<'u8: 'u8 + 'u8>(u8: &'u8 u8) -> &'u8 u8 {

FILE: tests/output-ext/expressions/literal.f.rs
  function f (line 155) | fn f() {

FILE: tests/output-ext/expressions/parens.f.rs
  function main (line 1) | fn main() {
  function cvgsk_nichqsd_bhvior (line 126) | fn cvgsk_nichqsd_bhvior() {
  method call_once (line 137) | extern "rust-call" fn call_once(mut self, arg: (&'a &'b [u16],)) -> (u8,...
  method call_once123 (line 140) | extern "rust-call" fn call_once123(
  method call_mut (line 146) | extern "rust-call" fn call_mut(
  function call_is_not_empty (line 154) | pub fn call_is_not_empty() {
  function x (line 165) | fn x() {

FILE: tests/output-ext/expressions/precedence.f.rs
  function main (line 1) | fn main() {
  type o (line 72) | type o = (
  function f (line 77) | pub extern "ABI" fn f() {
  function f (line 239) | fn f<T>() {

FILE: tests/output-ext/expressions/range.f.rs
  function q (line 1) | fn q() {
  function f (line 163) | fn f() {
  function f (line 166) | fn f() {
  function f (line 169) | fn f() {
  function foo (line 172) | fn foo(-128..=127: i8) {}

FILE: tests/output-ext/features/arbitrary_enum_discriminant.f.rs
  type Enum (line 3) | enum Enum {
  type Enum (line 9) | enum Enum {
  type E2 (line 18) | enum E2 {
  type E3 (line 23) | enum E3 {
  type E4 (line 28) | enum E4 {
  type ADT (line 32) | enum ADT {
  type CLike1 (line 36) | enum CLike1 {
  type CLike2 (line 42) | enum CLike2 {
  type CLike3 (line 49) | enum CLike3 {
  type ADT (line 55) | enum ADT {
  type NullablePointer (line 59) | enum NullablePointer {
  type Mixed (line 64) | enum Mixed {
  type MyWeirdOption (line 72) | enum MyWeirdOption<T> {
  type Test (line 76) | enum Test {
  type Foo (line 80) | pub enum Foo {
  type Bar (line 83) | pub enum Bar {
  type Size (line 88) | pub enum Size {
  type Signed (line 94) | enum Signed {
  type Unsigned (line 103) | enum Unsigned {

FILE: tests/output-ext/features/associated_type_bounds.f.rs
  type X (line 3) | type X = A<B: C>;
  function f (line 5) | fn f<F>(_: F) where F: for<'a> Trait<Output: 'a> {}
  function f (line 6) | fn f<'b, F>() where for<'a> F: Iterator<Item: 'a> + 'b {}
  type A (line 8) | trait A: MP {
    method f (line 9) | fn f<IM>(&self) -> i32 where for<'a> IM: T<T: U<<Self as MP>::T<'a>>>;

FILE: tests/output-ext/features/auto_traits.f.rs
  type T (line 3) | trait T {}
  type T (line 4) | unsafe auto trait T {}
  type T (line 5) | pub auto trait T {}
  type T (line 6) | pub unsafe auto trait T {}
  type T (line 8) | trait T {
  type T (line 13) | trait T {

FILE: tests/output-ext/features/const_generics_defaults.f.rs
  type Foo (line 3) | struct Foo<const N: usize = 1, const N2: usize = 2>;
  type Bar (line 4) | struct Bar<const N: usize, const N2: usize = { N + 1 }>;
  type Lots (line 5) | struct Lots<
  type Lott (line 9) | struct Lott<
  type NamesRHard (line 16) | struct NamesRHard<const N: usize = { 1 + 1 + 1 + 1 + 1 + 1 }>;
  type FooBar (line 17) | struct FooBar<
  type FooBarrrrrrrr (line 42) | struct FooBarrrrrrrr<

FILE: tests/output-ext/features/const_trait_impl.f.rs
  function foo (line 15) | fn foo() -> u8 where Self: ~const Bar {}
  type S (line 16) | struct S {
  type S (line 22) | struct S<
  type F (line 26) | trait F {
    method bar (line 27) | fn bar() where Self: ~const Foo;
    method c (line 28) | fn c<T: ~const Bar>();
  function qux (line 30) | const fn qux<T: ~const Foo>() {}
  function test1 (line 31) | const fn test1<T: ~const Foo + Bar>() {}
  function test2 (line 32) | const fn test2<T: ~const Foo + ~const Bar>() {}

FILE: tests/output-ext/features/destructuring_assignment.f.rs
  function main (line 3) | fn main() {

FILE: tests/output-ext/features/if_let_guard.f.rs
  function main (line 3) | fn main() {

FILE: tests/output-ext/features/inline_const.f.rs
  function f (line 3) | fn f() {

FILE: tests/output-ext/features/inline_const_pat.f.rs
  function f (line 3) | fn f() {

FILE: tests/output-ext/features/let_chains.f.rs
  function f (line 3) | fn f() {

FILE: tests/output-ext/macro/attributes.f.rs
  function a (line 4) | fn a() {}
  function b (line 6) | fn b() {
  function c (line 16) | fn c() {}
  function d (line 25) | fn d() {}
  function e (line 27) | fn e() {
  function f (line 45) | fn f() {}
  type A (line 70) | pub type A = Vec<B>;
    method f (line 416) | fn f(#[a1] self, #[a2] a: u8);
    method f (line 418) | fn f(#[a1] &self, #[a2] a: u8);
    method f (line 420) | fn f<'a>(#[a1] &'a mut self, #[a2] a: u8);
    method f (line 422) | fn f<'a>(#[a1] self: Box<Self>, #[a2] a: u8, #[a3] b: Vec<u8>);
    method f (line 424) | fn f(#[a1] #[a2] a: u8, #[a3] b: u8);
  function attr_3_3a_target (line 81) | fn attr_3_3a_target() {
  type foo_C (line 90) | trait foo_C {
  function main (line 96) | fn main() {
  constant C (line 300) | const C: C = C { #[attr] field: 0, #[attr] field: 1 };
  type S (line 302) | struct S;
  type I (line 304) | struct I {
  type I (line 309) | struct I(#[attr] u8, #[attr] pub u8);
  type BreaksWithComment (line 311) | struct BreaksWithComment(
  type C (line 316) | struct C {
  type Q (line 321) | struct Q {
  type A (line 324) | struct A<#[attr] 'a>();
    method f (line 416) | fn f(#[a1] self, #[a2] a: u8);
    method f (line 418) | fn f(#[a1] &self, #[a2] a: u8);
    method f (line 420) | fn f<'a>(#[a1] &'a mut self, #[a2] a: u8);
    method f (line 422) | fn f<'a>(#[a1] self: Box<Self>, #[a2] a: u8, #[a3] b: Vec<u8>);
    method f (line 424) | fn f(#[a1] #[a2] a: u8, #[a3] b: u8);
  type A (line 325) | struct A<#[attr] I>(I);
    method f (line 416) | fn f(#[a1] self, #[a2] a: u8);
    method f (line 418) | fn f(#[a1] &self, #[a2] a: u8);
    method f (line 420) | fn f<'a>(#[a1] &'a mut self, #[a2] a: u8);
    method f (line 422) | fn f<'a>(#[a1] self: Box<Self>, #[a2] a: u8, #[a3] b: Vec<u8>);
    method f (line 424) | fn f(#[a1] #[a2] a: u8, #[a3] b: u8);
  type E (line 326) | enum E {
  type E (line 329) | enum E<#[attr] 'b> {}
  type E (line 330) | enum E<#[attr] J> {}
  type T (line 331) | trait T {
  type T (line 334) | trait T<#[attr] 'c> {}
  type T (line 335) | trait T<#[attr] K> {}
  type Y (line 336) | type Y<#[attr] 'd> = ();
  type Y (line 337) | type Y<#[attr] L> = ();
  type A (line 339) | type A = fn(#[a1] u8, #[a2] ...);
    method f (line 416) | fn f(#[a1] self, #[a2] a: u8);
    method f (line 418) | fn f(#[a1] &self, #[a2] a: u8);
    method f (line 420) | fn f<'a>(#[a1] &'a mut self, #[a2] a: u8);
    method f (line 422) | fn f<'a>(#[a1] self: Box<Self>, #[a2] a: u8, #[a3] b: Vec<u8>);
    method f (line 424) | fn f(#[a1] #[a2] a: u8, #[a3] b: u8);
  function f (line 351) | fn f() {}
  function f (line 353) | fn f(#[a1] a: u8) {
  function f (line 356) | fn f<#[attr] 'g>() {}
  function f (line 357) | fn f<'e, #[attr] 'g>() {}
  function f (line 358) | fn f<#[attr] G>() {}
  function f (line 359) | fn f<E, #[attr] G>() {}
  function f (line 360) | fn f() where for<#[attr] 'i> X: for<#[attr] 'i> Y {}
  function f (line 361) | fn f(#[d(true)] a: i32, #[a2] b: i32, #[what = "how"] c: u32) {}
  function f (line 362) | fn f(#[a1] #[a2] a: i32, #[what = "how"] b: i32, #[e(true)] c: u32) {}
  function b (line 363) | fn b(#[cfg(x)] x: i32, y: i32) -> i32 {}
  function f (line 364) | fn f(
  function c (line 370) | fn c(#[cfg(foo)] &mut self, #[deny(C)] b: i32) {}
  function f (line 380) | pub fn f() {}
  function ffi (line 396) | fn ffi(#[a1] a: i32, #[a2] ...);
  function f (line 399) | unsafe extern "C" fn f(a: i32, #[a1] mut args: ...) {}
  method f (line 403) | fn f(#[a1] self, #[a2] a: u8) {}
  method f (line 405) | fn f(#[a1] &self, #[a2] a: u8) {}
  method f (line 407) | fn f<'a>(#[a1] &'a mut self, #[a2] a: u8) {}
  method f (line 409) | fn f<'a>(#[a1] self: Box<Self>, #[a2] a: u8) {}
  method f (line 411) | fn f(#[a1] #[a2] a: u8, #[a3] b: u8) {}
  type A (line 414) | trait A {
    method f (line 416) | fn f(#[a1] self, #[a2] a: u8);
    method f (line 418) | fn f(#[a1] &self, #[a2] a: u8);
    method f (line 420) | fn f<'a>(#[a1] &'a mut self, #[a2] a: u8);
    method f (line 422) | fn f<'a>(#[a1] self: Box<Self>, #[a2] a: u8, #[a3] b: Vec<u8>);
    method f (line 424) | fn f(#[a1] #[a2] a: u8, #[a3] b: u8);
  method foo (line 462) | fn foo(&mut self) -> isize {}
  method f2 (line 471) | pub fn f2(self) {
  method f3 (line 476) | fn f3(self) -> Q {}
  method f4 (line 485) | fn f4(self) -> A {}
  method f5 (line 489) | fn f5(self) -> X {}
  type Foo (line 492) | struct Foo {
  function f (line 511) | fn f() {}
  function f (line 513) | fn f() {
  function f (line 522) | fn f() {
  function f (line 531) | fn f() {}
  function f (line 538) | fn f() {
  type HP (line 596) | pub struct HP(pub u8);
  type A (line 599) | struct A {
    method f (line 416) | fn f(#[a1] self, #[a2] a: u8);
    method f (line 418) | fn f(#[a1] &self, #[a2] a: u8);
    method f (line 420) | fn f<'a>(#[a1] &'a mut self, #[a2] a: u8);
    method f (line 422) | fn f<'a>(#[a1] self: Box<Self>, #[a2] a: u8, #[a3] b: Vec<u8>);
    method f (line 424) | fn f(#[a1] #[a2] a: u8, #[a3] b: u8);
  function foo (line 606) | pub fn foo() {}
  function foo (line 611) | pub fn foo() {}
  type Params (line 616) | pub struct Params {
  type Os (line 659) | type Os = NoSource;
  function stmt_expr_attributes (line 661) | fn stmt_expr_attributes() {
  function a (line 667) | fn a() {
  function x (line 674) | fn x() {
  type Foo (line 687) | struct Foo {
  type Foo (line 694) | struct Foo;
  constant MIN_ALIGN (line 710) | const MIN_ALIGN: usize = 16;

FILE: tests/output-ext/macro/macro.invocation.f.rs
  function aux (line 20) | fn aux<Xs: HList, Ys: HList>(xs: Xs, ys: Ys) -> Expr!(Xs + Ys) where Xs:...
  function main (line 31) | fn main() {

FILE: tests/output-ext/macro/macro.tokens.f.rs
  function f (line 383) | fn f() {

FILE: tests/output-ext/macro/macro.transform.f.rs
  function $ident (line 3378) | fn $ident(arg: u32) -> u32;
  type S (line 3382) | struct S;
  type S (line 3389) | struct S;

FILE: tests/output-ext/miscellaneous/ast-program-locs-attr-dangling.f.rs
  type T (line 3) | struct T;

FILE: tests/output-ext/miscellaneous/ast-program-locs-attr.f.rs
  type T (line 4) | struct T;

FILE: tests/output-ext/miscellaneous/ast-program-locs.f.rs
  type T (line 3) | struct T;

FILE: tests/output-ext/patterns/pattern.f.rs
  function a (line 1) | fn a() {

FILE: tests/output-ext/patterns/rest.f.rs
  function b (line 1) | fn b() {

FILE: tests/output-ext/patterns/union.f.rs
  function fw1 (line 1) | fn fw1(H(Ok(mut x) | &Err(mut x)): H<R<'_>>) {}
  function f1 (line 2) | fn f1((Ok(mut x) | &Err(mut x)): R<'_>) {}
  function fw2 (line 3) | fn fw2(H(&(Ok(x) | Err(x))): H<R<'_>>) {}
  function fw3 (line 4) | fn fw3(H(Ok(x) | Err(x)): H<R<'_>>) {}
  function f2 (line 5) | fn f2(&(Ok(x) | Err(x)): R<'_>) {}
  function f3 (line 6) | fn f3((Ok(x) | Err(x)): R<'_>) {}
  function fun (line 7) | fn fun((A | B): _) {}
  function f (line 8) | fn f(x @ (A::R(_) | D::E(_)): Q) {}
  function x (line 10) | fn x() {

FILE: tests/output-ext/specifiers/extern.f.rs
  type funky_func (line 1) | type funky_func = extern "C" fn(
  function sup (line 11) | extern "C" fn sup() {}
  function some_fn (line 13) | fn some_fn() -> ();
  function quux (line 16) | fn quux() -> ();
  function syscall (line 17) | fn syscall(
  function foo (line 21) | unsafe fn foo() -> *mut Bar;
  function foo (line 22) | pub(super) const fn foo() -> *mut Bar;
  function foo (line 23) | pub(crate) unsafe fn foo() -> *mut Bar;

FILE: tests/output-ext/specifiers/pub.f.rs
  type E (line 1) | enum E {
  method f (line 9) | pub fn f() {}
  constant C (line 10) | pub const C: u8 = 0;
  type T (line 11) | pub type T = u8;
  method f (line 12) | pub(in foo) fn f(&self) -> i32 {
  type Pub (line 16) | pub struct Pub(Priv2);
  type Sized (line 20) | pub trait Sized {}
  constant MAIN (line 21) | const MAIN: u8 = {
  function f (line 47) | pub(super) fn f(_: Priv) {}
  function g (line 48) | pub(crate) fn g(_: Priv) {}
  function h (line 49) | crate fn h(_: Priv) {}
  type S1 (line 50) | pub(crate) struct S1;
  type S2 (line 51) | pub(super) struct S2;
  type S3 (line 52) | pub(self) struct S3;
  type S4 (line 53) | pub(in ::core) struct S4;
  type S5 (line 54) | pub(in a::b) struct S5;
  type Bar (line 58) | struct Bar(pub ());
  type C (line 59) | pub struct C(pub isize, isize);
  type D (line 60) | pub struct D(pub isize);
  type bool (line 61) | pub struct bool;
  type Pub (line 62) | pub struct Pub<T = Alias>(pub T);
  type S (line 67) | pub struct S {
  type Z (line 72) | pub(in Self::f) struct Z;

FILE: tests/output-ext/statements/const.f.rs
  constant X (line 1) | const X: u8;
  constant A (line 3) | const A: u8;
  constant A (line 4) | pub const A: Self::AssocTy = 1;
  constant FOO (line 5) | const FOO: dyn Fn() -> _ = "";
  constant FOO (line 6) | pub const FOO: &'static *const i32 = &(&0 as _);
  constant TEST (line 7) | const TEST: fn() -> _ = 1;
  constant MY_A (line 8) | const MY_A: A = A {

FILE: tests/output-ext/statements/enum.f.rs
  type E (line 1) | enum E {}
  type E (line 3) | enum E {
  type E (line 9) | enum E {
  type A (line 18) | enum A {
  type A (line 25) | enum A {
  type B (line 28) | enum B {
  type C (line 31) | enum C {
  type E (line 35) | enum E {
  type E (line 43) | enum E<T> {
  type E (line 47) | enum E<W: ?Sized, X: ?Sized, Y: ?Sized, Z: ?Sized> {
  type E (line 94) | enum E<'a, 'b, 'c: 'b> {
  type X (line 100) | pub enum X<D> where D: Copy + Debug + Eq {}

FILE: tests/output-ext/statements/impl.f.rs
  method f (line 3) | fn f();
  method f (line 4) | fn f() {}
  method foo (line 9) | fn foo() {

FILE: tests/output-ext/statements/self.f.rs
  function f (line 1) | fn f(self) {}
  function f (line 2) | fn f(&self) {}
  function f (line 3) | fn f(mut self) {}
  function f (line 4) | fn f(&mut self) {}
  function f (line 5) | fn f(&'a self) {}
  function f (line 6) | fn f(&'a mut self) {}
  function f (line 7) | fn f(self: u8) {}
  function f (line 8) | fn f(mut self: u8) {}
  type X (line 9) | type X = fn(self);
  type X (line 10) | type X = fn(&self);
  type X (line 12) | type X = fn(&mut self);
  type X (line 13) | type X = fn(&'a self);
  type X (line 14) | type X = fn(&'a mut self);
  type X (line 15) | type X = fn(self: u8);
  function foo (line 17) | async fn foo<'b>(self: &'b Foo<'a>) -> &() {
  function f (line 20) | fn f<'b>(self: &'b Foo<'a>) -> &() {
  function f (line 23) | fn f<'a>(self: &Alias, arg: &'a ()) -> &() {
  function f (line 26) | fn f(&mut self) -> u32;
  function f (line 27) | fn f(mut self: Box<Self>);
  function f (line 28) | fn f(self: _) {}
  function f (line 29) | fn f(self: &_) {}
  function f (line 30) | fn f(&self) -> Self;

FILE: tests/output-ext/statements/spread.f.rs
  function main (line 1) | fn main() {}
  function f1_1 (line 2) | fn f1_1(x: isize, ...) {}
  function f1_2 (line 3) | fn f1_2(...) {}
  function f2_1 (line 4) | extern "C" fn f2_1(x: isize, ...) {}
  function f2_2 (line 5) | extern "C" fn f2_2(...) {}
  function f2_3 (line 6) | extern "C" fn f2_3(..., x: isize) {}
  function f3_1 (line 7) | extern fn f3_1(x: isize, ...) {}
  function f3_2 (line 8) | extern fn f3_2(...) {}
  function f3_3 (line 9) | extern fn f3_3(..., x: isize) {}
  function e_f1 (line 11) | fn e_f1(...);
  function e_f2 (line 12) | fn e_f2(..., x: isize);
  type X (line 14) | struct X;
    method i_f1 (line 16) | fn i_f1(x: isize, ...) {}
    method i_f2 (line 17) | fn i_f2(...) {}
    method i_f3 (line 18) | fn i_f3(..., x: isize, ...) {}
    method i_f4 (line 19) | fn i_f4(..., x: isize, ...) {}
  type T (line 21) | trait T {
    method t_f1 (line 22) | fn t_f1(x: isize, ...) {}
    method t_f2 (line 23) | fn t_f2(x: isize, ...);
    method t_f3 (line 24) | fn t_f3(...) {}
    method t_f4 (line 25) | fn t_f4(...);
    method t_f5 (line 26) | fn t_f5(..., x: isize) {}
    method t_f6 (line 27) | fn t_f6(..., x: isize);
  function foo (line 31) | pub fn foo(x: i32, ...);

FILE: tests/output-ext/statements/statements.f.rs
  constant _ (line 1) | const _: () = {
  function bar (line 14) | fn bar();
  function foo (line 16) | fn foo() {}
  type T (line 17) | type T = extern r#"C"# fn();
  function foo (line 18) | extern "\x43" fn foo() {}
  function bar (line 20) | fn bar();
  type T (line 22) | type T = extern "\x43" fn();
  function f1 (line 27) | fn f1();
  function f2 (line 28) | fn f2() {}
  function f3 (line 29) | fn f3();
  type X (line 31) | trait X {
    method f (line 32) | fn f();
    method f (line 33) | fn f() {}
    constant Y (line 34) | const Y: u8;
  function f (line 38) | fn f();
  function f (line 39) | fn f();
  type A (line 46) | type A = u8;
  type A (line 47) | type A<'a: 'static, T: Ord + 'static>
  function test (line 51) | const async fn test() {}
  function test (line 52) | async unsafe fn test() {}
  function test (line 53) | const unsafe fn test() {}
  function test (line 54) | unsafe extern fn test() {}
  function f (line 55) | fn f() {
  function f (line 62) | const fn f(a: *const i32, b: i32) -> bool {}
  function f (line 63) | unsafe fn f(&self) -> u32;
  function f (line 64) | const unsafe fn f(v: u32) -> u32 {}
  function f (line 65) | unsafe fn f(func: unsafe fn() -> ()) -> () {}
  type Range (line 66) | struct Range<
  function f (line 72) | fn f(d: [u8; 1 + 1]) -> A<T, [u8; 1 + 1]>
  function f (line 74) | fn f<'a, 'b, 'c, T>(x: foo::X<'a, T, 'b, 'c>) {}
  function f (line 75) | fn f() -> Option<fn() -> Option<bool>> {
  function a (line 78) | fn a() {
  type Test3 (line 86) | enum Test3 {
  type E (line 93) | enum E {
  function foobar (line 100) | fn foobar<F, G>() -> usize where (): Foobar<F, G> {}
  function free (line 104) | pub fn free(x: *const u8);
  type C (line 113) | trait C<A> {
    method D (line 114) | fn D<B, F>(&self, f: F) where F: FnMut(A) -> Q<B>;
  type A (line 116) | trait A<T: B = Self> {}
  type A (line 117) | trait A: B::C {}
  type A (line 118) | trait A<T>: B::C {}
  function f (line 119) | fn f() -> () {}
  function f (line 120) | fn f<T: X<Y<()> = i32>>() {}
  function f (line 121) | fn f<F>(mut f: F) where F: FnMut(&mut R, bool) {}
  function f (line 122) | fn f<F>(f: F) where F: for<'a> Fn(&'a isize, &'a isize) -> isize {}
  function f (line 123) | fn f<F>(f: F) -> isize where F: Fn() -> isize {
  function g (line 126) | async fn g(((ref a, ref mut b), (ref mut c, ref d)): ((A, A), (A, A))) {}
  function bar (line 127) | pub unsafe extern "C" fn bar(_: i32, mut ap: ...) -> usize {}
  function f (line 128) | unsafe fn f(&self, x: &usize) {
  function f (line 131) | fn f<B: ?Sized + Q>() {}
  function f (line 132) | fn f<A, F: for<'a> F<(&'a A,)>>(_: F) {}
  function f (line 133) | fn f<M>(a: M) where M: A, M::B: C {}
  function f (line 134) | fn f<T, A>(t: fn(&A)) where fn(&A): for<'a> F<(&'a A,)> {}
  function rust_no_mangle (line 136) | pub extern "C" fn rust_no_mangle() -> i32 {}
  function foo (line 137) | pub fn foo<'a, 'b>(x: Foo<'a, 'b>, _o: Option<&&()>) {
  constant x (line 140) | const x: &'static dyn Fn() = &(|| e!("q"));
  function foo (line 141) | const fn foo() -> i32 {}
  function foo (line 142) | extern "\x43" fn foo() {}
  function bar (line 145) | fn bar();
  type T (line 148) | type T = extern "\x43" fn();
  function foo (line 149) | fn foo() {}
  function bar (line 152) | fn bar();
  type T (line 155) | type T = extern r#"C"# fn();

FILE: tests/output-ext/statements/struct.f.rs
  type S (line 1) | struct S<A: ?for<'a> Q, B: 'a + Q, C: 'a, G: Q + 'a, H: Q, I:>;
  type Empty1 (line 2) | struct Empty1 {}
  type Empty2 (line 3) | struct Empty2;
  type Empty7 (line 4) | struct Empty7();
  type Align8Many (line 5) | struct Align8Many {
  type A (line 11) | struct A<T>([T]);
  type A (line 12) | struct A<T>(T);
  type cat (line 13) | struct cat {
  type Test3 (line 17) | struct Test3<'a, 'b, 'c> {
  type Test4 (line 26) | struct Test4<'a, 'b: 'a> {
  type Test6 (line 29) | struct Test6<'a, 'b: 'a> {
  type Foo (line 32) | struct Foo<'a> {
  type X (line 35) | struct X;
  type U (line 36) | struct U {}
  type P (line 37) | struct P<T>(T);
  type A (line 38) | struct A<U> where U: E(U);
  type A (line 39) | struct A<U> where U: E(U) -> R;
  type A (line 40) | struct A<U>(U) where U: Eq;
  type K (line 41) | struct K<'a>(&'a ());
  type A (line 42) | pub struct A([u8; 1]);
  type S (line 43) | pub(crate) struct S<'a, I, E>(I, &'a E);
  type A (line 44) | pub struct A<T: B>(C);
  type A (line 45) | pub struct A<T = u8>(T);
  type Table (line 46) | pub struct Table<T, const N: usize>([Option<T>; N]);
  type B (line 47) | struct B;
  type A (line 48) | struct A<T: ?Sized>(C<T>, ());
  type A (line 49) | struct A<T = i32, U = i32>(B<T, U>) where B<T, U>: Marker;
  type A (line 50) | struct A<T = u32, U = i32>(T, U) where B<T, U>: Marker;
  type A (line 51) | struct A<'a, S: B<'a> = i32>(S, &'a ());
  type S1 (line 52) | struct S1(pub(in foo) (), pub T, pub(crate) (), pub ((), T));
  type G (line 53) | struct G<T, U>(*const T, *const U);
  type Unique (line 54) | pub struct Unique<T: ?Sized> {
  type A (line 58) | pub struct A(u32, ::b::Q);
  type S (line 59) | struct S(<AT as A<DT>>::AS);
  type A (line 60) | pub struct A<I> where I: B<C: D> {

FILE: tests/output-ext/statements/trait.f.rs
  type A (line 1) | trait A {}
  type A (line 2) | trait A<B: C> {}
  type T2 (line 3) | trait T2<'x, 'y>: T1<'x> {}
  type A (line 4) | trait T<E, R> = S<A> where <Self as B<D>>::T: H<R>;
  type A (line 6) | trait A<S: B<C = S>>: D<S> {}
  type A (line 7) | trait A = B<C = D>;
  type A (line 10) | trait A = std::fmt::Display + std::fmt::Debug;
  type A (line 20) | trait A<X: ?Sized> {}
  type A (line 21) | trait A<X: ?Sized, Y> {}
  type A (line 22) | trait A<Y, X: ?Sized> {}
  type A (line 23) | trait A<X: ?Sized, Y: ?Sized> {}
  type A (line 24) | trait A<X: ?Sized + T2> {}
  type A (line 25) | trait A<X: T2 + ?Sized> {}
  type A (line 27) | pub trait A {}
  type A (line 29) | pub trait A<R: D>: Sized {}

FILE: tests/output-ext/statements/union.f.rs
  type union (line 6) | struct union;
  function new (line 9) | pub fn new() -> Self {
  function main (line 14) | fn main() {

FILE: tests/output-ext/statements/use.f.rs
  type Foo (line 34) | crate struct Foo;
  function test (line 98) | fn test() {

FILE: tests/output-ext/types/cast.f.rs
  function a (line 1) | fn a() {
  constant A (line 36) | const A: *const u8 = &0 as *const _ as *const Q as *const u8;

FILE: tests/output-ext/types/never.f.rs
  function a (line 1) | fn a() {
  function a (line 7) | fn a(x: !) -> ! {
  function foo (line 10) | fn foo(never: !) {}
  function a (line 11) | fn a(x: !) {}
  function a (line 12) | fn a(ref x: !) {}
  function a (line 13) | fn a(x: &[!]) {}
  function a (line 14) | fn a(x: B<(), !>) {}
  method c (line 17) | fn c(&self, d: &!) -> E {}
  type A (line 20) | type A = !;

FILE: tests/output-ext/types/types.f.rs
  type A (line 1) | type A where 'a: 'b + 'c = u8;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 2) | type A where 'a: 'b + 'c = u8;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 3) | type A where 'a: 'b = u8;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 4) | type A where 'a: 'b = u8;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 7) | type A = u8;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 11) | type A = for<'a: 'b> fn();
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 12) | type A = for<'a: 'b> fn();
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 13) | type A = for<'a: > fn();
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 14) | type A = for<'a: > fn();
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 15) | type A = for<'a> fn();
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 16) | type A = for<> fn();
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 18) | type A = Box<dyn (Fn(u8) -> u8) + 'static + Send + Sync>;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 19) | type A = impl B;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 21) | type A = u8;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 22) | type A where for<'a> dyn for<'b> Trait1 + ?Trait2: 'a + Trait = u8;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 24) | type A where T: Trait = u8;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 25) | type A where T: Trait + Trait = u8;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 26) | type A where T: Trait = u8;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 29) | type A = <m::Alias as m::Trait>::X;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 31) | pub type A<T> where T: B = T;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type B (line 34) | type B: Ord = u8;
    constant B (line 386) | const B: u8 = 0;
  type E (line 37) | type E<_T>: Ord = u8;
  type Y (line 40) | type Y<T> where Self: Sized = u32;
  constant FN (line 43) | pub const FN: &'static fn() = &(fop::<i32> as fn());
  constant A (line 44) | const A: &&&u32 = &&&42;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  constant CONST1 (line 45) | const CONST1: &[bool; 1] = &[true];
  constant CONST (line 46) | const CONST: &[Option<()>; 1] = &[Some(())];
  constant A (line 47) | const A: [u32; 1] = [4];
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  constant F (line 48) | const F: &'static dyn PartialEq<u32> = &7u32;
  type R (line 49) | struct R<'a> {
  function g (line 52) | fn g() -> impl Tr2<m::Alias> {}
  function leak_dyn_nonprincipal (line 53) | fn leak_dyn_nonprincipal() -> Box<dyn PubPrincipal + PrivNonPrincipal> {}
  function method (line 54) | fn method() -> Self::Pub {}
  function f (line 55) | fn f<T: PrivTr>(arg: T) {}
  function unused (line 56) | pub fn unused<const T: usize>() -> usize {}
  function start (line 57) | fn start(_: isize, _: *const *const u8) -> isize {}
  function as_ptr (line 58) | fn as_ptr(&self) -> *const Self::Item;
  function as_mut_ptr (line 59) | fn as_mut_ptr(&mut self) -> *mut Self::Item;
  function as_ptr (line 60) | fn as_ptr(&self) -> *const T {
  function as_mut_ptr (line 63) | fn as_mut_ptr(&mut self) -> *mut T {
  function y_uses_f (line 66) | fn y_uses_f(f: impl Fn()) {}
  function infer (line 67) | fn infer<T: a::B>(c: T) -> T {
  function f1 (line 70) | fn f1<'a, 'b, 'c>(_x: &'a u32, _y: &'b u32, _z: &'c u32) where 'c: 'a + ...
  function syntax (line 71) | fn syntax() {
  function A (line 148) | fn A(x: Option<fn(i32)>) -> Option<unsafe fn(i32)> {}
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  function f (line 149) | fn f(x: fn(i32)) -> unsafe fn(i32) {}
  function f (line 150) | fn f<'b, L: X<&'b Q<K>>>() {}
  type A (line 151) | struct A<T, U = [u8; a::<T>()]>(T, U);
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type Q (line 153) | trait Q<P = Self> {}
  type Q (line 154) | trait Q<P: Sized = [Self]> {}
  type H (line 155) | trait H<'d, 'e>: for<'f> I<'d, 'f, 'e> + 'd {}
  type F (line 156) | trait F<'f>: for<'a> A<'a> + for<'e> E<'e> {}
  type Q (line 157) | struct Q<A = S, T>(A, T);
  type Q (line 158) | struct Q<A, B = Vec<C>, C>(A, B, C);
  function f (line 160) | fn f<T: B<'a>>(self) -> &'a str {}
  function A (line 162) | extern "C" fn A<T: Add>(a: T, b: T) -> T::Output {
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  function f (line 166) | pub fn f<'a>(x: &'a i32);
  function f (line 167) | pub fn f<'b>(x: &'a i32, y: &'b i32);
  function f (line 168) | pub fn f<'a>(x: &'a i32, y: &i32) -> &'a i32;
  function f (line 169) | pub fn f<'b>(x: for<'c> fn(&'a i32));
  function f (line 170) | pub fn f<'b>(x: for<'c> fn(&'b i32));
  function f (line 171) | pub fn f<'b>(x: for<'c> fn(&'c i32));
  function f (line 172) | pub fn f<'b>() -> for<'c> fn(&'a i32);
  function f (line 173) | pub fn f<'b>() -> for<'c> fn(&'b i32);
  function f (line 174) | pub fn f<'b>() -> for<'c> fn(&'c i32);
  type X (line 176) | struct X<'x, 'y> {
  type G (line 180) | struct G<T> where for<'f> T: F<'f, As: E<'f>> + 'f {
  type D (line 183) | struct D<T> where T: for<'c> C<'c, As: A<'c>> {
  function f (line 186) | fn f<T>() where T: A, T::U: B {}
  function f (line 187) | fn f(a: isize, b: *const *const u8) -> isize {}
  function f (line 188) | fn f<G: FnMut(A, A) -> A>(mut a: G, b: A, c: A) -> A {}
  function f (line 189) | fn f<T: A<B = T> + C>(x: T) -> T {}
  function f (line 190) | fn f<A, B: a<A>>(x: B) -> C<A> {}
  type Whitespace (line 191) | struct Whitespace<T: Clone = ()> {
  type TokenSplit (line 194) | struct TokenSplit<T: Clone = ()> {
  function f (line 197) | fn f<'a, 'b, T>(t: T) -> isize where T: 'a, 'a: 'b, T: Eq {
  function f (line 201) | fn f() where T: for<'a> A<'a> + 'a {}
  function f (line 202) | fn f() where T: for<'g> H<'g, 'g, As: for<'h> H<'h, 'g> + 'g> {}
  function f (line 203) | fn f()
  function f (line 210) | fn f()
  function f (line 217) | fn f()
  function f (line 224) | fn f() where T: Fn(&(), &()) {}
  function f (line 225) | fn f() where T: Fn(&'a (), &()) {}
  function f (line 226) | fn f() where T: Fn(&(), Box<dyn Fn(&())>) {}
  function f (line 227) | fn f() where T: Fn(&(), fn(&())) {}
  function f (line 228) | fn f() where T: Fn(&(), for<'a> fn(&'a ())) {}
  function f (line 229) | fn f() where T: Fn(&(), Box<dyn Fn(&())>, &(), fn(&(), &())) {}
  function f (line 230) | fn f() where T: for<'a> Fn(&'a (), &()) {}
  function f (line 231) | fn f() where T: for<'a> Fn(&(), &'a ()) {}
  function f (line 232) | fn f() where T: for<'a> Fn(&'a (), &'a ()) {}
  function f (line 233) | fn f() where T: for<'a> Fn(&'a (), Box<dyn Fn(&())>) {}
  function f (line 234) | fn f() where T: for<'a> Fn(&(), Box<dyn Fn(&())>, &'a (), fn(&(), &())) {}
  function f (line 235) | fn f() where T: A, F: FnOnce(B<T>) -> bool {}
  function f (line 236) | fn f() -> impl std::borrow::Borrow<<u8 as A>::S> {}
  function f (line 237) | fn f(_: <() as A<Self::B>>::C) {}
  type S (line 238) | struct S<>;
  type T (line 239) | trait T<> {}
  type E (line 240) | enum E<> {
  function f (line 244) | fn f<'a>(x: for<'b, 'c: 'a + 'b> fn(&'a A, &'b B) -> &'c C)
  type S (line 248) | struct S<F: for<'a, 'b: 'a> Fn(&'a A, &'b B) -> &'c C>(F);
  type S (line 249) | struct S<F>(F) where F: for<'a, 'b: 'a> Fn(&'a A, &'b B) -> &'c C;
  type S (line 250) | struct S(dyn for<'a, 'b: 'a> Fn(&'a A, &'b B) -> &'c C);
  type T (line 251) | type T = Box<dyn for<'a, 'b: 'a> Fn(&'a A, &'b B) -> &'c C>;
  type L8 (line 252) | type L8<T> = L<L<L<L<L<L<L<L<T>>>>>>>>;
  type L64 (line 253) | type L64<T> = L8<L8<L8<L8<T>>>>;
  type Y (line 258) | type Y<'a> = &'a ();
  type Z (line 274) | type Z = dyn for<'x> Send;
  type A (line 275) | type A = (*const E::R, D);
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  function f (line 276) | fn f(&self) -> Pin<Box<dyn Future<Output = Self::B> + '_>>;
  function f (line 277) | fn f(&self) -> Self::Y<'_> {}
  function f (line 278) | fn f(x: &()) -> &() {}
  function f (line 279) | fn f(x: &impl for<'a> X<Y<'a> = &'a ()>) -> &() {}
  function f (line 280) | fn f<'a, T: for<'b> Fun<F<'b> = T>>(t: T) -> T::F<'a> {}
  function f (line 281) | fn f<'a, T: Fun<F<'a> = T>>(t: T) -> T::F<'a> {}
  function f (line 282) | fn f<T: ?for<'a> Sized>() {}
  function f (line 283) | fn f<'a, T1: X<Y = T1>>(t: T1) -> T1::Y<'a>;
  function f (line 284) | fn f<'a>(s: Box<dyn X<Y<'a> = &'a ()>>) {}
  function f (line 285) | fn f<'a>(t: Self::Y<'a>) -> Self::Y<'a>;
  function f (line 286) | fn f<T: for<'a> X<Y<'a> = &'a ()>>(x: &T) -> &() {}
  function f (line 287) | fn f<'a, T: ?Sized + Fun<F<'a> = [u8]>>(_: Box<T>) -> &'static T::F<'a> {}
  function f (line 288) | fn f<'a>(t: &'a Self::F<'a>) -> &'a Self::F<'a> {}
  function f (line 289) | fn f<T>() where T: S, for<'a> T::Item<'a>: Q {}
  function f (line 290) | fn f<'c, 'd>(s: Box<dyn X<Y = (&'c u32, &'d u32)>>) {}
  function f (line 291) | fn f(e: &impl for<'a> X<Y<'a> = &'a ()>) -> &'static () {}
  function f (line 292) | fn f<T: for<'a> X<Y<'a> = &'a ()>>(x: &T) -> &'static () {}
  function f (line 293) | fn f(x: &mut dyn for<'a> E<R<'a> = &'a i32>) -> usize {}
  function f (line 294) | fn f() where 'static: 'static, dyn 'static: 'static + Copy {}
  function f (line 295) | fn f() where 'static: 'static, dyn 'static + ::Foo: 'static + Copy {}
  function f (line 296) | fn f<F: A>() where F::B: Copy {}
  function f (line 297) | fn f<F: A>() where <F as A>::B: Copy {}
  function f (line 298) | fn f<F: A<B: A>>() where F::B: Copy {}
  function f (line 299) | fn f<T: S<<Self as A>::Q>>(&self, r: &T) -> u64;
  function f (line 300) | fn f() -> impl Default {}
  function f (line 301) | fn f(t: Box<dyn for<'a> Get<i32, i32>>) {}
  function f (line 302) | fn f(t: Box<dyn for<'a> Fn(i32) -> i32>) {}
  function f (line 303) | fn f(t: for<'a> fn(i32) -> i32) {}
  function f (line 304) | fn f(t: for<'a> unsafe fn(i32) -> i32) {}
  function f (line 305) | fn f(t: for<'a> extern "C" fn(i32) -> i32) {}
  function f (line 306) | fn f(t: for<'a> unsafe extern "C" fn(i32) -> i32) {}
  function f (line 309) | async fn f(_: impl for<'a> Add<&'a u8>, _: impl for<'b> Add<&'b u8>) {}
  function f (line 310) | async fn f<'a>(_: &'a ()) -> impl A<dyn B> {}
  function f (line 311) | fn f<D: A>() where D::S: {}
  type R (line 313) | struct R<'a> {
  function f (line 316) | fn f() -> [u8; 4 * 1024 * 1024 * 1024 * 1024] {}
  type Foo (line 317) | trait Foo where T: Borrow<U> + ?Sized, U: ?Sized + 'b, 'a: 'b, Box<T>: {}
  type Map (line 318) | trait Map
  type S (line 321) | trait S: A + AsRef<Self::B> {}
  type Bar (line 322) | struct Bar<const N: u8>([u8; (N + 2) as usize]) where [(); (N + 2) as us...
  function f (line 323) | fn f<const N: u8>() where D<{ N as usize as u16 }>: {}
  function f (line 324) | fn f<T>()
  function f (line 330) | fn f<'u, 'a, F>()
  function f (line 332) | fn f(&self, db: &<Q as QueryDb<'_>>::DynDb) {}
  function f (line 333) | pub fn f<'a, I>() -> impl B<I, D = (), C = impl S + 'a>
  type S (line 335) | type S<T: A<B: for<'a> C<&'a u8>>> = D;
  type A (line 337) | type A = a::b!();
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  function f (line 339) | fn f(&self, a: &!) {}
  type S (line 341) | type S<'a, T: Debug + 'a>: ?Sized = dyn Iterator<Item = T>;
  type S (line 342) | type S<'x> where T: 'x = &'x ();
  type S (line 343) | type S<'u, 'v> where 'u: 'v = &'v &'u ();
  type S (line 344) | type S where Self: Q + S = E;
  type S (line 345) | type S<'a: 'b, 'b> = (&'a (), &'b ());
  type S (line 346) | type S<'a> where Self: 'static = &'a ();
  type S (line 347) | type S<'a, 'b> where 'b: 'a = (&'a (), &'b ());
  type S (line 351) | type S<'a> = &'a ();
  type S (line 354) | type S<'a> where <A as B>::T: 'a, <A as B>::T: 'a = R<&'a S::T, &'a E::T>;
  type S (line 355) | type S<T> = Self::E<'static, T>;
  type S (line 356) | type S = Self::E<'static, 'static>;
  type S (line 361) | type S = Q<<T as R>::E>;
  type B (line 362) | struct B<'a, T: for<'r> X<Y<'r> = &'r ()>> {
    constant B (line 386) | const B: u8 = 0;
  type E (line 365) | enum E<'a> {
  type T (line 368) | pub type T<P: Send + Send + Send> = P;
  type S (line 369) | type S<'b, 'a: 'b + 'b> = (&'b u32, Vec<&'a i32>);
  type S (line 370) | type S<'b, T: 'b + 'b> = (&'b u32, Vec<T>);
  type S (line 371) | type S<'b, T> where T: 'b, T: 'b = (&'b u32, Vec<T>);
  type A (line 372) | type A = dyn S + ?Sized + ?Sized;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type R (line 373) | type R = dyn ?Sized + A;
  type Q (line 374) | type Q = dyn for<'a> E<'a> + for<'b> R<'b>;
  type S (line 375) | type S = dyn Q<for<'a> fn(&'a u8)> + G<for<'b> fn(&'b u8)>;
  type A (line 376) | type A = dyn ?Sized;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 377) | type A = <S as Tr>::A::f<u8>;
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type A (line 378) | trait A: B<i32> + std::fmt::Debug + Send + Sync {}
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type R (line 379) | struct R<Z: ?Sized = E<i32, i32>>(Z);
  type A (line 381) | trait A {
    type C (line 255) | type C<'a> = <T as D>::E<'a, 'static>;
    constant A (line 382) | const A: u8 = 0;
  type B (line 385) | pub trait B {
    constant B (line 386) | const B: u8 = 0;
  type C (line 389) | pub trait C: A + B {
    constant C (line 390) | const C: u8 = 0;
  type b (line 398) | pub type b = Box<dyn t + sync::Send + sync::Sync + 'static>;
  type b (line 399) | pub type b = Box<dyn for<'tcx> e<'tcx> + sync::Send + sync::Sync + 'stat...

FILE: tests/output/comments/assignment.f.rs
  constant a (line 222) | const A { a /* 0_______ */: 1 } = b;
  constant c (line 224) | const A { c: 1 /* 1_______ */ } = d;
  function foo (line 268) | fn foo() {

FILE: tests/output/comments/blocks.f.rs
  function f (line 241) | fn f() {
  function f (line 246) | fn f() {
  function d (line 252) | fn d() {/* _______ */}
  function f (line 254) | fn f() {
  function f (line 265) | fn f() {
  function f (line 270) | fn f() {
  function f (line 275) | fn f() {
  function f (line 280) | fn f() {
  function foo (line 299) | fn foo() {

FILE: tests/output/comments/dangling.f.rs
  function a (line 46) | fn a(/* comment */) {
  type A (line 54) | trait A {/* comment */}
  type A (line 55) | enum A {/* comment */}
  type A (line 56) | struct A(/* comment */);
  type A (line 57) | struct A {/* comment */}
  type A (line 72) | struct A;
  type A (line 76) | struct A;
  type A (line 81) | struct A;
  type A (line 86) | struct A;
  type A (line 92) | struct A;
  type A (line 98) | struct A;

FILE: tests/output/comments/functions.f.rs
  function a (line 1) | fn a(/* _______ */) {}
  function b (line 2) | fn b() {}
  function c (line 3) | fn c(/* _______ */ argA, argB, argC) {}
  function a (line 4) | fn a(a /*_______*/) {}
  function b (line 5) | fn b(a /*_______*/) {}
  function d (line 6) | fn d(a /*_______*/, b /*_______*/, c /*_______*/, d /*_______*/) {}
  function d (line 7) | fn d(a /*_______*/, b /*_______*/, c /*_______*/, d /*_______*/) {/*____...
  function c (line 9) | fn c(a /*_______*/
  function d (line 12) | fn d(
  function e (line 19) | fn e(
  function f1 (line 26) | fn f1 /* _______ */() {}
  function f2 (line 27) | fn f2(/* _______ */) {}
  function f3 (line 28) | fn f3() {/* _______ */}
  function f4 (line 29) | fn f4 /* _______ */(/* _______ */) {/* _______ */}
  function f5 (line 30) | fn f5(/* _______ */ /* _______ */ a) {}
  function f6 (line 31) | fn f6(/* _______ */ a /* _______ */) {}
  function f7 (line 32) | fn f7(/* _______ */ /* _______ */ a) {/* _______ */}

FILE: tests/output/comments/ignore.attr.f.rs
  function no (line 3) | fn no() {
  function f (line 14) | fn   f()    {

FILE: tests/output/comments/ignore.f.rs
  function f (line 25) | fn f() {
  constant bar (line 70) | const A {
  constant bar3 (line 82) | const A {
  constant bar4 (line 87) | const A {
  constant bar5 (line 92) | const A {

FILE: tests/output/comments/ignore.file.f.rs
  function unformatted (line 5) | fn unformatted () {

FILE: tests/output/common/arrays.f.rs
  function isUnusedDiagnostic (line 234) | fn isUnusedDiagnostic(code) {

FILE: tests/output/common/assignments.f.rs
  constant accessibilityModule (line 119) | const A {
  type foo (line 170) | trait foo {
    method bar (line 171) | fn bar() {
  function f (line 215) | async fn f() {
  constant hello__ (line 246) | const t = A {
  constant _id (line 267) | const A { _id: id3 } =

FILE: tests/output/common/binaryish.f.rs
  function f (line 1) | fn f() {
  function f2 (line 11) | fn f2() {
  constant state (line 248) | const obj = A {
  constant state (line 342) | const obj = A {
  function foo (line 354) | fn foo() {
  constant somethingThatsAReallyLongPropName (line 507) | const o = A {

FILE: tests/output/common/chains.f.rs
  function a (line 4) | fn a() {
  function a (line 15) | fn a() {
  function theFunction (line 214) | fn theFunction(action, store) {
  function f (line 231) | fn f() {
  function palindrome (line 331) | fn palindrome(a, b) {
  function HelloWorld (line 376) | fn HelloWorld() {
  type X (line 435) | trait X {
    method y (line 436) | fn y() {
  function assert (line 485) | fn assert(pet) {
  function someFunction (line 644) | fn someFunction(url) {
  type A (line 732) | trait A {
    method compose (line 733) | fn compose() {

FILE: tests/output/common/chains.last-argument-expansion.f.rs
  function searchUsers (line 1) | crate fn searchUsers(action) {
  function mySagas (line 128) | fn mySagas() {
  function mySagas2 (line 137) | fn mySagas2() {

FILE: tests/output/common/closures.f.rs
  function a (line 1) | fn a() {

FILE: tests/output/common/destructuring.f.rs
  function f (line 14) | fn f(A { data: A { name } }) {}

FILE: tests/output/common/types.f.rs
  constant anodyneCondosMalateOverateRetinol (line 165) | const bifornCringerMoshedPerplexSawder =
  function foo (line 185) | fn foo() {
  constant listAuthorizedSitesForDefaultHandler (line 192) | pub const listAuthorizedSitesForDefaultHandler: ListAuthorizedSitesForHa...
  function countriesReceived (line 195) | pub fn countriesReceived(countries: Array<Country>) -> CountryActionType {
  constant findByDate (line 202) | const findByDate: Resolver<void, [Recipe], D> = |_, A { date }, A { req ...
  constant findByDate (line 207) | const findByDate: Resolver<void, [Recipe], D> = |_, A { date }, A { req }|
  constant durabilityMetricsSelectable (line 210) | const durabilityMetricsSelectable: Immutable::OrderedSet<SomeReportingMe...
  constant enviromentProdValues (line 214) | pub(crate) const enviromentProdValues: EnvironmentValues =
  constant myLongVariableName (line 225) | const myLongVariableName: dyn MyLongTypeName + null =
  constant firestorePersonallyIdentifiablePaths (line 231) | const firestorePersonallyIdentifiablePaths: Array<Collections::Users::En...
  constant call (line 234) | const foo = call::<
  constant call (line 245) | const foo = call::<
  constant map (line 253) | const map: Map<
  type X (line 283) | type X = fn(
  constant firestorePersonallyIdentifiablePaths (line 308) | const firestorePersonallyIdentifiablePaths: Array<
  constant SUPPORTED_VEHICLE_TYPES (line 312) | crate const SUPPORTED_VEHICLE_TYPES: Array<Collections::VehiclesStates::...
  type AddAssetHtmlPlugin (line 315) | pub trait AddAssetHtmlPlugin {
    method apply (line 316) | fn apply(compiler: WebpackCompilerType) {
  constant Array (line 372) | const baz = Array::<
  type RequestNextDealAction (line 377) | crate type RequestNextDealAction =
  constant ffff (line 381) | const ffff: fn(typee: Type) -> Provider<Prop> = memoize(

FILE: tests/output/issues/0.f.rs
  type Inner (line 26) | struct Inner {
  function bar (line 44) | fn bar() {
  type S1 (line 52) | struct S1 {
  function main (line 61) | fn main() {
  type S (line 73) | struct S {
    method f (line 878) | fn f() {
  function f (line 103) | fn f() {
  function f (line 136) | fn f() {
  function f (line 147) | fn f() {
  function f (line 158) | fn f() {
  function delete_upload_session (line 163) | pub fn delete_upload_session(&self, sess: &UploadSession) -> Result<()> {
  function very_very_very_very_very_long_fun_name (line 171) | fn very_very_very_very_very_long_fun_name(x: i32) -> Vec<i32> {
  function main (line 175) | fn main() {
  function f (line 190) | fn f() {
  function main (line 243) | fn main() {
  function speak_raw (line 286) | fn speak_raw(
  function f (line 333) | fn f() -> Vec<u32> {
  function foo (line 369) | fn foo() {
  type Iter (line 401) | pub type Iter<'a, D> =
  type Iter (line 406) | pub type Iter<'a, D>: BoundDoubleEndedIterator<Item = SomethingSomething...
  type Iter (line 410) | pub type Iter<'a, D>: BoundDoubleEndedIterator<Item = SomethingSomething...
  function f1 (line 433) | fn f1() -> Box<
  function f2 (line 439) | fn f2() -> Box<
  method parse (line 457) | pub fn parse(value: &str) -> Option<Self> {
  method to_str (line 468) | pub fn to_str(&self) -> &'static str {
  type PrettyPrinter (line 478) | pub trait PrettyPrinter<'tcx>: Printer<
  type PrettyPrinter (line 490) | pub trait PrettyPrinter<'tcx>: Printer<
  type X (line 506) | struct X<'a>(
    constant SOMETHING (line 390) | pub const SOMETHING: usize =
    method ident (line 2227) | pub fn ident(&self) -> Option<Ident> {
  type Foo (line 513) | enum Foo {
    method foo (line 845) | fn foo(&self) -> Box<FnMut(i64) -> i64> {
    method foo (line 1080) | fn foo() {
    method map_pixel_to_coords (line 1836) | fn map_pixel_to_coords(&self, point: &Vector2i, view: &View) -> Vector...
    method stuff (line 2029) | fn stuff(data: Leet) -> Result<Self> {
  type Kilometers (line 523) | type Kilometers = /*comment*/ i32;
  function test_datetime (line 526) | fn test_datetime() {
  function main (line 546) | fn main() {
  type Bar (line 552) | struct Bar(());
  type Foo (line 553) | struct Foo(Bar);
    method foo (line 845) | fn foo(&self) -> Box<FnMut(i64) -> i64> {
    method foo (line 1080) | fn foo() {
    method map_pixel_to_coords (line 1836) | fn map_pixel_to_coords(&self, point: &Vector2i, view: &View) -> Vector...
    method stuff (line 2029) | fn stuff(data: Leet) -> Result<Self> {
  function main (line 555) | fn main() {
  function main (line 592) | fn main() {
  function test (line 602) | fn test() {
  function main (line 606) | fn main() {
  function main (line 616) | fn main() {
  function printsomething (line 621) | fn printsomething() {
  constant USAGE (line 628) | const USAGE: &'static str =
  function main (line 643) | fn main() {
  constant USAGE (line 657) | const USAGE: &'static str = "
  function main (line 773) | fn main() {
  function default_user_agent_string (line 823) | fn default_user_agent_string(agent: UserAgent) -> String {
  function uumain (line 867) | pub fn uumain(args: Vec<String>) -> i32 {
  function foo (line 931) | fn foo() -> () {}
  function main (line 969) | fn main() {
  type Foo (line 985) | struct Foo {
    method foo (line 845) | fn foo(&self) -> Box<FnMut(i64) -> i64> {
    method foo (line 1080) | fn foo() {
    method map_pixel_to_coords (line 1836) | fn map_pixel_to_coords(&self, point: &Vector2i, view: &View) -> Vector...
    method stuff (line 2029) | fn stuff(data: Leet) -> Result<Self> {
  type Foo (line 991) | struct Foo {
    method foo (line 845) | fn foo(&self) -> Box<FnMut(i64) -> i64> {
    method foo (line 1080) | fn foo() {
    method map_pixel_to_coords (line 1836) | fn map_pixel_to_coords(&self, point: &Vector2i, view: &View) -> Vector...
    method stuff (line 2029) | fn stuff(data: Leet) -> Result<Self> {
  type Ctx (line 1035) | type Ctx = C;
  type Event (line 1036) | type Event = Vec<Target>;
  function main (line 1045) | fn main() {
  function build_sorted_static_get_entry_names (line 1049) | fn build_sorted_static_get_entry_names(
  function main (line 1059) | fn main() {
  function f (line 1068) | fn f() -> Box<
  type Foo (line 1075) | trait Foo {}
    method foo (line 845) | fn foo(&self) -> Box<FnMut(i64) -> i64> {
    method foo (line 1080) | fn foo() {
    method map_pixel_to_coords (line 1836) | fn map_pixel_to_coords(&self, point: &Vector2i, view: &View) -> Vector...
    method stuff (line 2029) | fn stuff(data: Leet) -> Result<Self> {
  type Bar (line 1076) | struct Bar {}
  function test (line 1085) | fn test() {
  function main (line 1101) | fn main() {
  function handles_mid_demangling (line 1113) | fn handles_mid_demangling() {
  function main (line 1123) | fn main() {
  function test (line 1128) | fn test<const T: i8>() -> i8 {
  function main (line 1148) | fn main() {
  function foo (line 1159) | pub fn foo(config: &Config) {
  function main (line 1172) | fn main() {
  function main (line 1182) | fn main() {
  function main (line 1387) | fn main() {
  function x (line 1825) | fn x() {
  function GetConsoleHistoryInfo (line 1850) | pub fn GetConsoleHistoryInfo(
  function variadic_fn (line 1853) | pub fn variadic_fn(
  function deconstruct (line 1860) | fn deconstruct(
  function needs_paren (line 1883) | fn needs_paren(op: AssocOp, other: AssocOp, dir: Associativity) -> bool {
  function peel_blocks (line 1892) | pub fn peel_blocks<'a>(mut expr: &'a Expr<'a>) -> &'a Expr<'a> {
  function target_features (line 1909) | pub fn target_features(sess: &Session) -> Vec<Symbol> {
  function a (line 1927) | fn a() {
  function g (line 1930) | fn g<'a>(&self, x: usize, y: usize) -> Box<dyn (Fn(bool) -> usize) + 'a> {
  type Compose (line 1935) | struct Compose<F, G>(F, G);
  type Output (line 1940) | type Output = G::Output;
  function call_once (line 1941) | extern "rust-call" fn call_once(self, (x,): (T,)) -> G::Output {
  function build_sorted_static_get_entry_names (line 1946) | fn build_sorted_static_get_entry_names(
  function qcxbfds (line 1955) | fn qcxbfds() {
  constant GATED_CFGS (line 1985) | const GATED_CFGS: &[GatedCfg] = &[
  method c (line 2061) | fn c() {}
  function clock (line 2096) | fn clock() {
  function shutdown (line 2118) | pub(super) fn shutdown(self) {
  function inlining_last_if_else_block_is_awkward (line 2129) | fn inlining_last_if_else_block_is_awkward() {
  function vtable (line 2143) | pub(super) fn vtable<T: Future, S: Schedule>() -> &'static Vtable {
  type Float (line 2166) | pub trait Float: Copy +
    constant BITS (line 2183) | const BITS: usize;
  function space_before_where (line 2188) | fn space_before_where</**/>(_: F) where F: X {}
  function noop_visit_constraint (line 2215) | pub fn noop_visit_constraint<T: MutVisitor>(
  type Foo (line 2284) | pub enum Foo {
    method foo (line 845) | fn foo(&self) -> Box<FnMut(i64) -> i64> {
    method foo (line 1080) | fn foo() {
    method map_pixel_to_coords (line 1836) | fn map_pixel_to_coords(&self, point: &Vector2i, view: &View) -> Vector...
    method stuff (line 2029) | fn stuff(data: Leet) -> Result<Self> {
  function c (line 2300) | fn c() {}
  type Expect_Parenthesized_dyn (line 2320) | type Expect_Parenthesized_dyn = Pin<&mut (dyn Future<Output = T> + Send)>;

FILE: tests/output/issues/21/fn_comment.f.rs
  function eof (line 1) | fn eof() {}

FILE: tests/output/issues/21/fn_fn.f.rs
  function eof1 (line 1) | fn eof1() {}
  function eof2 (line 2) | fn eof2() {}

FILE: tests/output/issues/21/fn_ln.f.rs
  function eof (line 1) | fn eof() {}

FILE: tests/output/issues/21/ln_fn_ln.f.rs
  function eof (line 1) | fn eof() {}

FILE: tests/output/issues/22.f.rs
  function preserve_last_semicolon (line 1) | fn preserve_last_semicolon() {
  function a (line 10) | fn a() {
  function b (line 15) | fn b() {
  function c (line 27) | fn c() {
  function d (line 33) | fn d() {
  function e (line 38) | fn e() {
  function f (line 43) | fn f() {
  function g (line 48) | fn g() {
  function h (line 54) | fn h() {
  function i (line 61) | fn i() {
  function inner_attr (line 68) | fn inner_attr() {

FILE: tests/output/issues/25.f.rs
  function nums (line 2) | fn nums() {
  function f (line 33) | fn f() {}

FILE: tests/output/styling/needsSemi.f.rs
  function f (line 1) | fn f() {

FILE: tests/samples/comments/assignment.rs
  constant a (line 207) | const A{ a /* 0_______ */ : 1 } = b;
  function foo (line 253) | fn foo() {

FILE: tests/samples/comments/blocks.rs
  function f (line 185) | fn f() {
  function f (line 190) | fn f() {
  function d (line 196) | fn d() {
  function f (line 200) | fn f() {
  function f (line 212) | fn f()
  function f (line 218) | fn f() // _______
  function f (line 223) | fn f() { // _______
  function f (line 227) | fn f() {
  function foo (line 247) | fn foo() {

FILE: tests/samples/comments/dangling.rs
  function a (line 37) | fn a(/* comment */) /* comment */ {/* comment */}
  type A (line 42) | trait A {/* comment */}
  type A (line 43) | enum A {/* comment */}
  type A (line 44) | struct A(/* comment */)
  type A (line 45) | struct A{/* comment */}

FILE: tests/samples/comments/functions.rs
  function a (line 2) | fn a(/* _______ */) {}
  function b (line 3) | fn b() {}
  function c (line 4) | fn c(/* _______ */ argA, argB, argC) {}
  function a (line 5) | fn a(a /*_______*/) {}
  function b (line 6) | fn b(a /*_______*/
  function d (line 8) | fn d(
  function d (line 14) | fn d(
  function c (line 21) | fn c(a /*_______*/
  function d (line 24) | fn d(
  function e (line 31) | fn e(
  function f1 (line 38) | fn f1 /* _______ */() {}
  function f2 (line 39) | fn f2 (/* _______ */) {}
  function f3 (line 40) | fn f3 () /* _______ */ {}
  function f4 (line 41) | fn f4 /* _______ */(/* _______ */) /* _______ */ {}
  function f5 (line 42) | fn f5 /* _______ */(/* _______ */ a) {}
  function f6 (line 43) | fn f6 /* _______ */(a /* _______ */) {}
  function f7 (line 44) | fn f7 /* _______ */(/* _______ */ a) /* _______ */ {}

FILE: tests/samples/comments/ignore.attr.rs
  function no (line 3) | fn no() {
  function f (line 14) | fn   f()    {

FILE: tests/samples/comments/ignore.file.rs
  function unformatted (line 5) | fn unformatted () {

FILE: tests/samples/comments/ignore.rs
  function f (line 26) | fn f() {

FILE: tests/samples/common/arrays.rs
  function isUnusedDiagnostic (line 147) | fn isUnusedDiagnostic(code) {

FILE: tests/samples/common/assignments.rs
  constant accessibilityModule (line 97) | const A { accessibilityModule: FooAccessibilityModule, accessibilityModu...
  type foo (line 133) | trait foo {
    method bar (line 134) | fn bar() {
  function f (line 162) | async fn f() {
  constant _id (line 211) | const A {_id:id3} = data.createTestMessageWithAReallyLongName.someVeryLo...

FILE: tests/samples/common/binaryish.rs
  function f (line 1) | fn f() {
  function f2 (line 7) | fn f2() {
  constant state (line 232) | const obj = A {
  constant state (line 322) | const obj = A {
  function foo (line 334) | fn foo() {
  constant somethingThatsAReallyLongPropName (line 439) | const o = A {

FILE: tests/samples/common/chains.last-argument-expansion.rs
  function searchUsers (line 1) | crate fn searchUsers(action) {
  function mySagas (line 109) | fn mySagas() {
  function mySagas2 (line 121) | fn mySagas2() {

FILE: tests/samples/common/chains.rs
  function a (line 4) | fn a() {
  function a (line 14) | fn a() {
  function f (line 166) | fn f() {
  function assert (line 403) | fn assert(pet) {
  function someFunction (line 543) | fn someFunction(url) {
  type A (line 625) | trait A {
    method compose (line 626) | fn compose() {

FILE: tests/samples/common/closures.rs
  function a (line 1) | fn a() {

FILE: tests/samples/common/destructuring.rs
  function f (line 12) | fn f(A { data: A { name } }) {}

FILE: tests/samples/common/types.rs
  constant listAuthorizedSitesForDefaultHandler (line 151) | pub const listAuthorizedSitesForDefaultHandler: ListAuthorizedSitesForHa...
  function countriesReceived (line 153) | pub fn countriesReceived(countries: Array<Country>) -> CountryActionType {
  constant findByDate (line 160) | const findByDate: Resolver<void, [Recipe], D> =
  constant findByDate (line 166) | const findByDate: Resolver<void, [Recipe], D> =
  constant durabilityMetricsSelectable (line 169) | const durabilityMetricsSelectable: Immutable::OrderedSet<
  constant enviromentProdValues (line 173) | pub(crate) const enviromentProdValues: EnvironmentValues = assign::<Envi...
  constant myLongVariableName (line 183) | const myLongVariableName: MyLongTypeName + null = myLongFunctionCallHere();
  constant firestorePersonallyIdentifiablePaths (line 188) | const firestorePersonallyIdentifiablePaths: Array<Collections::Users::En...
  constant call (line 190) | const foo =
  constant call (line 194) | const foo =
  constant map (line 203) | const map: Map<Function, FunctionFunctionFunctionFunctionffFunction> =
  type X (line 232) | type X = fn(options: AbstractCompositeThingamabobberFactoryProvidereeeee...
  constant firestorePersonallyIdentifiablePaths (line 265) | const firestorePersonallyIdentifiablePaths: Array<
  constant SUPPORTED_VEHICLE_TYPES (line 269) | crate const SUPPORTED_VEHICLE_TYPES: Array<
  type AddAssetHtmlPlugin (line 273) | pub trait AddAssetHtmlPlugin {
    method apply (line 274) | fn apply(compiler: WebpackCompilerType) {
  constant Array (line 314) | const baz = Array::<
  type RequestNextDealAction (line 319) | crate type RequestNextDealAction = BaseAction<DealsActionTypes::REQUEST_...
  constant ffff (line 322) | const ffff: fn(typee: Type) -> Provider<Prop> = memoize(|ty: ObjectType|...

FILE: tests/samples/issues/0.rs
  type Inner (line 23) | struct Inner {
  function bar (line 36) | fn bar() {
  type S1 (line 43) | struct S1 {
  function main (line 52) | fn main() {
  type S (line 63) | struct S {
    method f (line 685) | fn f() {
  function f (line 90) | fn f() {
  function f (line 117) | fn f() {
  function f (line 124) | fn f() {
  function f (line 134) | fn f() {
  function delete_upload_session (line 139) | pub fn delete_upload_session(&self, sess: &UploadSession) -> Result<()> {
  function very_very_very_very_very_long_fun_name (line 149) | fn very_very_very_very_very_long_fun_name(x: i32) -> Vec<i32> {
  function main (line 153) | fn main() {
  function f (line 168) | fn f() {
  function main (line 214) | fn main() {
  function speak_raw (line 241) | fn speak_raw(
  function f (line 263) | fn f() -> Vec<u32> {
  function foo (line 301) | fn foo() {
  type Iter (line 319) | pub type Iter<'a, D> = impl DoubleEndedIterator<Item = (SomethingSomethi...
  type Iter (line 321) | pub type Iter<'a, D>: BoundDoubleEndedIterator<Item = (SomethingSomethin...
  type Iter (line 323) | pub type Iter<'a, D>: BoundDoubleEndedIterator<Item = (SomethingSomethin...
  function f1 (line 332) | fn f1() -> Box<
  function f2 (line 339) | fn f2() -> Box<
  method parse (line 357) | pub fn parse(value: &str) -> Option<Self> {
  method to_str (line 368) | pub fn to_str(&self) -> &'static str {
  type PrettyPrinter (line 378) | pub trait PrettyPrinter<'tcx>:
  type PrettyPrinter (line 391) | pub trait PrettyPrinter<'tcx>:
  type X (line 406) | struct X<'a>(
    constant SOMETHING (line 309) | pub const SOMETHING: usize = mem::size_of::<i64>() // field A
    method ident (line 1836) | pub fn ident(&self) -> Option<Ident> {
  type Foo (line 412) | enum Foo {
    method foo (line 647) | fn foo(&self) -> Box<FnMut(i64) -> i64> {
    method foo (line 871) | fn foo() {
    method map_pixel_to_coords (line 1511) | fn map_pixel_to_coords(&self, point: &Vector2i, view: &View) -> Vector...
    method stuff (line 1667) | fn stuff(data: Leet) -> Result<Self> {
  type Kilometers (line 423) | type Kilometers =/*comment*/i32;
  function test_datetime (line 426) | fn test_datetime() {
  function main (line 445) | fn main() {
  type Bar (line 451) | struct Bar(());
  type Foo (line 452) | struct Foo(Bar);
    method foo (line 647) | fn foo(&self) -> Box<FnMut(i64) -> i64> {
    method foo (line 871) | fn foo() {
    method map_pixel_to_coords (line 1511) | fn map_pixel_to_coords(&self, point: &Vector2i, view: &View) -> Vector...
    method stuff (line 1667) | fn stuff(data: Leet) -> Result<Self> {
  function main (line 454) | fn main() {
  function main (line 491) | fn main() {
  function test (line 509) | fn test() {
  function main (line 513) | fn main() {
  function main (line 521) | fn main() {
  function printsomething (line 525) | fn printsomething() {
  constant USAGE (line 534) | const USAGE: &'static str = "
  function main (line 548) | fn main() {
  constant USAGE (line 560) | const USAGE: &'static str = "
  function main (line 593) | fn main() {
  function default_user_agent_string (line 628) | fn default_user_agent_string(agent: UserAgent) -> String {
  function uumain (line 675) | pub fn uumain(args: Vec<String>) -> i32 {
  function foo (line 735) | fn foo() -> () where {}
  function main (line 765) | fn main() {
  type Foo (line 779) | struct Foo {
    method foo (line 647) | fn foo(&self) -> Box<FnMut(i64) -> i64> {
    method foo (line 871) | fn foo() {
    method map_pixel_to_coords (line 1511) | fn map_pixel_to_coords(&self, point: &Vector2i, view: &View) -> Vector...
    method stuff (line 1667) | fn stuff(data: Leet) -> Result<Self> {
  type Foo (line 785) | struct Foo {
    method foo (line 647) | fn foo(&self) -> Box<FnMut(i64) -> i64> {
    method foo (line 871) | fn foo() {
    method map_pixel_to_coords (line 1511) | fn map_pixel_to_coords(&self, point: &Vector2i, view: &View) -> Vector...
    method stuff (line 1667) | fn stuff(data: Leet) -> Result<Self> {
  type Ctx (line 827) | type Ctx = C;
  type Event (line 828) | type Event = Vec<Target>;
  function main (line 837) | fn main() {
  function build_sorted_static_get_entry_names (line 841) | fn build_sorted_static_get_entry_names(
  function main (line 852) | fn main() {
  function f (line 861) | fn f() -> Box<
  type Foo (line 866) | trait Foo where {}
    method foo (line 647) | fn foo(&self) -> Box<FnMut(i64) -> i64> {
    method foo (line 871) | fn foo() {
    method map_pixel_to_coords (line 1511) | fn map_pixel_to_coords(&self, point: &Vector2i, view: &View) -> Vector...
    method stuff (line 1667) | fn stuff(data: Leet) -> Result<Self> {
  type Bar (line 867) | struct Bar where {}
  function test (line 876) | fn test() {
  function main (line 891) | fn main() {
  function handles_mid_demangling (line 902) | fn handles_mid_demangling() {
  function main (line 909) | fn main() {
  function test (line 914) | fn test<const T: i8>() -> i8 {
  function main (line 938) | fn main() {
  function foo (line 948) | pub fn foo(config: &Config) {
  function main (line 962) | fn main() {
  function main (line 972) | fn main() {
  function main (line 1158) | fn main() {
  function x (line 1505) | fn x() {
  function GetConsoleHistoryInfo (line 1519) | pub fn GetConsoleHistoryInfo(console_history_info: *mut ConsoleHistoryIn...
  function variadic_fn (line 1520) | pub fn variadic_fn(first_parameter: FirstParameterType,
  function deconstruct (line 1525) | fn deconstruct(foo: Bar) -> (SocketAddr, Header, Method, RequestUri, Htt...
  function needs_paren (line 1539) | fn needs_paren(op: AssocOp, other: AssocOp, dir: Associativity) -> bool {
  function peel_blocks (line 1548) | pub fn peel_blocks<'a>(mut expr: &'a Expr<'a>) -> &'a Expr<'a> {
  function target_features (line 1564) | pub fn target_features(sess: &Session) -> Vec<Symbol> {
  function a (line 1581) | fn a() { Arc::new(|_| { Ok(()) })}
  function g (line 1582) | fn g<'a>(&self, x: usize, y:usize) -> Box<dyn Fn(bool) -> usize + 'a> {
  type Compose (line 1587) | struct Compose<F, G>(F, G);
  type Output (line 1593) | type Output = G::Output;
  function call_once (line 1594) | extern "rust-call" fn call_once(self, (x,): (T,)) -> G::Output {
  function build_sorted_static_get_entry_names (line 1599) | fn build_sorted_static_get_entry_names(
  function qcxbfds (line 1609) | fn qcxbfds() {
  constant GATED_CFGS (line 1633) | const GATED_CFGS: &[GatedCfg] = &[
  method c (line 1696) | fn c() {}
  function clock (line 1735) | fn clock(){
  function shutdown (line 1744) | pub(super) fn shutdown(self) {
  function inlining_last_if_else_block_is_awkward (line 1752) | fn inlining_last_if_else_block_is_awkward() {
  function vtable (line 1766) | pub(super) fn vtable<T: Future, S: Schedule>() -> &'static Vtable {
  type Float (line 1788) | pub trait Float:
    constant BITS (line 1805) | const BITS: usize;
  function space_before_where (line 1810) | fn space_before_where</**/>(_: F) where F: X {}
  function noop_visit_constraint (line 1824) | pub fn noop_visit_constraint<T: MutVisitor>(
  type Foo (line 1893) | pub enum Foo {
    method foo (line 647) | fn foo(&self) -> Box<FnMut(i64) -> i64> {
    method foo (line 871) | fn foo() {
    method map_pixel_to_coords (line 1511) | fn map_pixel_to_coords(&self, point: &Vector2i, view: &View) -> Vector...
    method stuff (line 1667) | fn stuff(data: Leet) -> Result<Self> {
  function c (line 1908) | fn c() {}
  type Expect_Parenthesized_dyn (line 1929) | type Expect_Parenthesized_dyn = Pin<&mut (dyn Future<Output = T> + Send)>;

FILE: tests/samples/issues/21/fn_comment.rs
  function eof (line 1) | fn eof() {}

FILE: tests/samples/issues/21/fn_fn.rs
  function eof1 (line 1) | fn eof1() {}
  function eof2 (line 2) | fn eof2() {}

FILE: tests/samples/issues/21/fn_ln.rs
  function eof (line 1) | fn eof() {}

FILE: tests/samples/issues/21/ln_fn_ln.rs
  function eof (line 2) | fn eof(){}

FILE: tests/samples/issues/22.rs
  function preserve_last_semicolon (line 1) | fn preserve_last_semicolon() {
  function a (line 10) | fn a() {
  function b (line 14) | fn b() {
  function c (line 26) | fn c() {
  function d (line 31) | fn d() {
  function e (line 35) | fn e() {
  function f (line 39) | fn f() {
  function g (line 46) | fn g() {
  function h (line 54) | fn h() {
  function i (line 59) | fn i() {
  function inner_attr (line 64) | fn inner_attr() {

FILE: tests/samples/issues/25.rs
  function nums (line 2) | fn nums() {
  function f (line 37) | fn f() {}

FILE: tests/samples/styling/needsSemi.rs
  function f (line 1) | fn f() {