Function createSlicePipeline

createSlicePipeline(
    parser: TreeSitterExecutor,
    inputs: Omit<
        ParseRequiredInput<string> & NormalizeRequiredInput & SliceRequiredInput & ReconstructRequiredInput,
        "parser",
    >,
): PipelineExecutor<
    Pipeline<
        | {
            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": (df: DataflowInformation) => string;
                "4": (df: DataflowInformation) => string;
                "5": (
                    df: DataflowInformation,
                    config: QuadSerializationConfiguration,
                ) => string;
            };
            processor: (
                results: {
                    normalize?: NormalizedAst<
                        ParentInformation,
                        RNode<ParentInformation>,
                    >;
                },
                input: { parser?: Parser<KnownParserType>; request?: RParseRequests },
            ) => DataflowInformation;
            requiredInput: {};
        }
        | {
            dependencies: readonly ["dataflow"];
            description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
            executed: OncePerRequest;
            humanReadableName: "static slice";
            name: "slice";
            printer: { "0": <Input>(input: Input) => Input };
            processor: (
                results: {
                    dataflow?: DataflowInformation;
                    normalize?: NormalizedAst<ParentInformation, RNode<ParentInformation>>;
                },
                input: Partial<SliceRequiredInput>,
            ) => Readonly<SliceResult>;
            requiredInput: SliceRequiredInput;
        }
        | {
            dependencies: readonly ["slice"];
            description: "Reconstruct R code from the static slice";
            executed: OncePerRequest;
            humanReadableName: "static code reconstruction";
            name: "reconstruct";
            printer: { "0": <Input>(input: Input) => Input };
            processor: (
                results: {
                    normalize?: NormalizedAst<
                        ParentInformation,
                        RNode<ParentInformation>,
                    >;
                    slice?: SliceResult;
                },
                input: Partial<ReconstructRequiredInput>,
            ) => ReconstructionResult;
            requiredInput: ReconstructRequiredInput;
        }
        | {
            dependencies: readonly [];
            description: "Parse the given R code into an AST using tree-sitter";
            executed: OncePerFile;
            humanReadableName: "parse with tree-sitter";
            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 | (string | number)[],
                        space?: string | number,
                    ): string;
                };
            };
            processor: (
                _results: unknown,
                input: Partial<ParseRequiredInput<Tree>>,
            ) => Promise<ParseStepOutput<Tree>>;
            requiredInput: ParseRequiredInput<Tree>;
        }
        | {
            dependencies: readonly ["parse"];
            description: "Normalize the AST to flowR's AST";
            executed: OncePerFile;
            humanReadableName: "normalize tree-sitter tree";
            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?: ParseStepOutputTS },
                input: Partial<NormalizeRequiredInput>,
            ) => NormalizedAst<ParentInformation, RNode<ParentInformation>>;
            requiredInput: NormalizeRequiredInput;
        },
    >,
>

createSlicePipeline(
    parser: RShell,
    inputs: Omit<
        ParseRequiredInput<string> & NormalizeRequiredInput & SliceRequiredInput & ReconstructRequiredInput,
        "parser",
    >,
): PipelineExecutor<
    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 | (string | number)[],
                        space?: string | number,
                    ): string;
                };
                "5": (
                    __namedParameters: ParseStepOutput<string>,
                    config: QuadSerializationConfiguration,
                ) => string;
            };
            processor: (
                _results: unknown,
                input: Partial<ParseRequiredInput<string>>,
            ) => 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, RNode<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": (df: DataflowInformation) => string;
                "4": (df: DataflowInformation) => string;
                "5": (
                    df: DataflowInformation,
                    config: QuadSerializationConfiguration,
                ) => string;
            };
            processor: (
                results: {
                    normalize?: NormalizedAst<
                        ParentInformation,
                        RNode<ParentInformation>,
                    >;
                },
                input: { parser?: Parser<KnownParserType>; request?: RParseRequests },
            ) => DataflowInformation;
            requiredInput: {};
        }
        | {
            dependencies: readonly ["dataflow"];
            description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
            executed: OncePerRequest;
            humanReadableName: "static slice";
            name: "slice";
            printer: { "0": <Input>(input: Input) => Input };
            processor: (
                results: {
                    dataflow?: DataflowInformation;
                    normalize?: NormalizedAst<ParentInformation, RNode<ParentInformation>>;
                },
                input: Partial<SliceRequiredInput>,
            ) => Readonly<SliceResult>;
            requiredInput: SliceRequiredInput;
        }
        | {
            dependencies: readonly ["slice"];
            description: "Reconstruct R code from the static slice";
            executed: OncePerRequest;
            humanReadableName: "static code reconstruction";
            name: "reconstruct";
            printer: { "0": <Input>(input: Input) => Input };
            processor: (
                results: {
                    normalize?: NormalizedAst<
                        ParentInformation,
                        RNode<ParentInformation>,
                    >;
                    slice?: SliceResult;
                },
                input: Partial<ReconstructRequiredInput>,
            ) => ReconstructionResult;
            requiredInput: ReconstructRequiredInput;
        },
    >,
>

createSlicePipeline(
    parser: KnownParser,
    inputs: Omit<
        ParseRequiredInput<string> & NormalizeRequiredInput & SliceRequiredInput & ReconstructRequiredInput,
        "parser",
    >,
):
    | PipelineExecutor<
        Pipeline<
            | {
                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": (df: DataflowInformation) => string;
                    "4": (df: DataflowInformation) => string;
                    "5": (
                        df: DataflowInformation,
                        config: QuadSerializationConfiguration,
                    ) => string;
                };
                processor: (
                    results: {
                        normalize?: NormalizedAst<
                            ParentInformation,
                            RNode<ParentInformation>,
                        >;
                    },
                    input: { parser?: Parser<KnownParserType>; request?: RParseRequests },
                ) => DataflowInformation;
                requiredInput: {};
            }
            | {
                dependencies: readonly ["dataflow"];
                description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
                executed: OncePerRequest;
                humanReadableName: "static slice";
                name: "slice";
                printer: { "0": <Input>(input: Input) => Input };
                processor: (
                    results: {
                        dataflow?: DataflowInformation;
                        normalize?: NormalizedAst<ParentInformation, RNode<ParentInformation>>;
                    },
                    input: Partial<SliceRequiredInput>,
                ) => Readonly<SliceResult>;
                requiredInput: SliceRequiredInput;
            }
            | {
                dependencies: readonly ["slice"];
                description: "Reconstruct R code from the static slice";
                executed: OncePerRequest;
                humanReadableName: "static code reconstruction";
                name: "reconstruct";
                printer: { "0": <Input>(input: Input) => Input };
                processor: (
                    results: {
                        normalize?: NormalizedAst<
                            ParentInformation,
                            RNode<ParentInformation>,
                        >;
                        slice?: SliceResult;
                    },
                    input: Partial<ReconstructRequiredInput>,
                ) => ReconstructionResult;
                requiredInput: ReconstructRequiredInput;
            }
            | {
                dependencies: readonly [];
                description: "Parse the given R code into an AST using tree-sitter";
                executed: OncePerFile;
                humanReadableName: "parse with tree-sitter";
                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 | (string | number)[],
                            space?: string | number,
                        ): string;
                    };
                };
                processor: (
                    _results: unknown,
                    input: Partial<ParseRequiredInput<Tree>>,
                ) => Promise<ParseStepOutput<Tree>>;
                requiredInput: ParseRequiredInput<Tree>;
            }
            | {
                dependencies: readonly ["parse"];
                description: "Normalize the AST to flowR's AST";
                executed: OncePerFile;
                humanReadableName: "normalize tree-sitter tree";
                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?: ParseStepOutputTS },
                    input: Partial<NormalizeRequiredInput>,
                ) => NormalizedAst<ParentInformation, RNode<ParentInformation>>;
                requiredInput: NormalizeRequiredInput;
            },
        >,
    >
    | PipelineExecutor<
        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 | (string | number)[],
                            space?: string | number,
                        ): string;
                    };
                    "5": (
                        __namedParameters: ParseStepOutput<string>,
                        config: QuadSerializationConfiguration,
                    ) => string;
                };
                processor: (
                    _results: unknown,
                    input: Partial<ParseRequiredInput<string>>,
                ) => 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, RNode<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": (df: DataflowInformation) => string;
                    "4": (df: DataflowInformation) => string;
                    "5": (
                        df: DataflowInformation,
                        config: QuadSerializationConfiguration,
                    ) => string;
                };
                processor: (
                    results: {
                        normalize?: NormalizedAst<
                            ParentInformation,
                            RNode<ParentInformation>,
                        >;
                    },
                    input: { parser?: Parser<KnownParserType>; request?: RParseRequests },
                ) => DataflowInformation;
                requiredInput: {};
            }
            | {
                dependencies: readonly ["dataflow"];
                description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
                executed: OncePerRequest;
                humanReadableName: "static slice";
                name: "slice";
                printer: { "0": <Input>(input: Input) => Input };
                processor: (
                    results: {
                        dataflow?: DataflowInformation;
                        normalize?: NormalizedAst<ParentInformation, RNode<ParentInformation>>;
                    },
                    input: Partial<SliceRequiredInput>,
                ) => Readonly<SliceResult>;
                requiredInput: SliceRequiredInput;
            }
            | {
                dependencies: readonly ["slice"];
                description: "Reconstruct R code from the static slice";
                executed: OncePerRequest;
                humanReadableName: "static code reconstruction";
                name: "reconstruct";
                printer: { "0": <Input>(input: Input) => Input };
                processor: (
                    results: {
                        normalize?: NormalizedAst<
                            ParentInformation,
                            RNode<ParentInformation>,
                        >;
                        slice?: SliceResult;
                    },
                    input: Partial<ReconstructRequiredInput>,
                ) => ReconstructionResult;
                requiredInput: ReconstructRequiredInput;
            },
        >,
    >