@eagleoutice/flowr - v2.10.1
    Preparing search index...

    Function createSlicePipeline

    Please use FlowrAnalyzer instead of this directly unless you really know what you are doing. Returns either a DEFAULT_SLICING_PIPELINE or a TREE_SITTER_SLICING_PIPELINE depending on the parser used.

    createParsePipeline, createNormalizePipeline, createDataflowPipeline

    • Parameters

      Returns 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": (
                          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<ParentInformation>,
                          >;
                      },
                      input: {
                          context?: FlowrAnalyzerContext;
                          parser?: Parser<KnownParserType>;
                      },
                  ) => DataflowInformation & {
                      cfgQuick: ControlFlowInformation<CfgVertex>
                      | undefined;
                  };
                  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,
                              RProject<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,
                              RProject<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?: (string | number)[] | null,
                              space?: string | number,
                          ): string;
                      };
                  };
                  processor: (
                      _results: unknown,
                      input: Partial<ParseRequiredInput<T>>,
                  ) => 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?: ParseStepOutput<Tree> },
                      input: Partial<NormalizeRequiredInput>,
                  ) => NormalizedAst<ParentInformation, RProject<ParentInformation>>;
                  requiredInput: NormalizeRequiredInput;
              },
          >,
      >

    • Parameters

      Returns 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?: (string | number)[] | 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<ParentInformation>,
                          >;
                      },
                      input: {
                          context?: FlowrAnalyzerContext;
                          parser?: Parser<KnownParserType>;
                      },
                  ) => DataflowInformation & {
                      cfgQuick: ControlFlowInformation<CfgVertex>
                      | undefined;
                  };
                  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,
                              RProject<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,
                              RProject<ParentInformation>,
                          >;
                          slice?: SliceResult;
                      },
                      input: Partial<ReconstructRequiredInput>,
                  ) => ReconstructionResult;
                  requiredInput: ReconstructRequiredInput;
              },
          >,
      >

    • Parameters

      Returns
          | 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": (
                              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<ParentInformation>,
                              >;
                          },
                          input: {
                              context?: FlowrAnalyzerContext;
                              parser?: Parser<KnownParserType>;
                          },
                      ) => DataflowInformation & {
                          cfgQuick: ControlFlowInformation<CfgVertex>
                          | undefined;
                      };
                      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,
                                  RProject<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,
                                  RProject<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?: (string | number)[] | null,
                                  space?: string | number,
                              ): string;
                          };
                      };
                      processor: (
                          _results: unknown,
                          input: Partial<ParseRequiredInput<T>>,
                      ) => 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?: ParseStepOutput<Tree> },
                          input: Partial<NormalizeRequiredInput>,
                      ) => NormalizedAst<ParentInformation, RProject<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?: (string | number)[] | 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<ParentInformation>,
                              >;
                          },
                          input: {
                              context?: FlowrAnalyzerContext;
                              parser?: Parser<KnownParserType>;
                          },
                      ) => DataflowInformation & {
                          cfgQuick: ControlFlowInformation<CfgVertex>
                          | undefined;
                      };
                      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,
                                  RProject<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,
                                  RProject<ParentInformation>,
                              >;
                              slice?: SliceResult;
                          },
                          input: Partial<ReconstructRequiredInput>,
                      ) => ReconstructionResult;
                      requiredInput: ReconstructRequiredInput;
                  },
              >,
          >

    Settings

    Member Visibility