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

    Function createDataflowPipeline

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

    createParsePipeline, createNormalizePipeline, createSlicePipeline

    • 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 [];
                  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: {};
              },
          >,
      >

    • 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 [];
                      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: {};
                  },
              >,
          >

    Settings

    Member Visibility