Function printDfGraphForCode

printDfGraphForCode(
    parser: KnownParser,
    code: string,
    options: PrintDataflowGraphOptions & { exposeResult: true },
): Promise<
    [
        string,
        PipelineOutput<
            Pipeline<
                | {
                    dependencies: readonly [];
                    description: "Parse the given R code into an AST";
                    executed: OncePerFile;
                    humanReadableName: "parse with R shell";
                    name: "parse";
                    printer: {
                        "0": <Input>(input: Input) => Input;
                        "2": {
                            (
                                value: any,
                                replacer?: (this: any, key: string, value: any) => any,
                                space?: string | number,
                            ): string;
                            (
                                value: any,
                                replacer?: ((...) | (...))[] | null,
                                space?: string | number,
                            ): string;
                        };
                        "5": (
                            p: ParseStepOutput<string>,
                            config: QuadSerializationConfiguration,
                        ) => string;
                    };
                    processor: (
                        _results: unknown,
                        input: Partial<ParseRequiredInput<T>>,
                    ) => Promise<ParseStepOutput<string>>;
                    requiredInput: ParseRequiredInput<string>;
                }
                | {
                    dependencies: readonly ["parse"];
                    description: "Normalize the AST to flowR's AST";
                    executed: OncePerFile;
                    humanReadableName: "normalize";
                    name: "normalize";
                    printer: {
                        "0": <Input>(input: Input) => Input;
                        "2": (ast: NormalizedAst) => string;
                        "3": (ast: NormalizedAst) => string;
                        "4": (ast: NormalizedAst) => string;
                        "5": (
                            ast: NormalizedAst,
                            config: QuadSerializationConfiguration,
                        ) => string;
                    };
                    processor: (
                        results: { parse?: ParseStepOutput<string> },
                        input: Partial<NormalizeRequiredInput>,
                    ) => NormalizedAst<ParentInformation, RProject<ParentInformation>>;
                    requiredInput: NormalizeRequiredInput;
                }
                | {
                    dependencies: readonly ["normalize"];
                    description: "Construct the dataflow graph";
                    executed: OncePerFile;
                    humanReadableName: "dataflow";
                    name: "dataflow";
                    printer: {
                        "0": <Input>(input: Input) => Input;
                        "2": (df: DataflowInformation) => string;
                        "3": (
                            this: void,
                            graph:
                                | DataflowInformation
                                | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
                            includeEnvironments?: boolean,
                            mark?: ReadonlySet<NodeId>,
                            simplified?: boolean,
                        ) => string;
                        "4": (
                            this: void,
                            graph:
                                | DataflowInformation
                                | DataflowGraph<DataflowGraphVertexInfo, DfEdge>,
                            includeEnvironments?: boolean,
                            mark?: ReadonlySet<NodeId>,
                            simplified?: boolean,
                        ) => string;
                        "5": (
                            df: DataflowInformation,
                            config: QuadSerializationConfiguration,
                        ) => string;
                    };
                    processor: (
                        results: {
                            normalize?: NormalizedAst<ParentInformation, RProject<(...)>>;
                        },
                        input: {
                            context?: FlowrAnalyzerContext;
                            parser?: Parser<KnownParserType>;
                        },
                    ) => DataflowInformation & {
                        cfgQuick: ControlFlowInformation<(...)>
                        | undefined;
                    };
                    requiredInput: {};
                },
            >,
        >,
    ],
>

printDfGraphForCode(
    parser: KnownParser,
    code: string,
    options?: PrintDataflowGraphOptions & { exposeResult?: false },
): Promise<string>