Function sanitizeAnalysisResults

Parameters

• results: Partial<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 | (string | number)[], space?: string | number): string;
              };
              5: ((__namedParameters: ParseStepOutput, config: QuadSerializationConfiguration) => string);
          };
          processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
          requiredInput: ParseRequiredInput;
      }
      | {
          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<ParentInformation, RNode<ParentInformation>>) => string);
              3: ((ast: NormalizedAst<ParentInformation, RNode<ParentInformation>>) => string);
              4: ((ast: NormalizedAst<ParentInformation, RNode<ParentInformation>>) => string);
              5: ((ast: NormalizedAst<ParentInformation, RNode<ParentInformation>>, config: QuadSerializationConfiguration) => string);
          };
          processor: ((results: {
              parse?: ParseStepOutput;
          }, 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: {
              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;
      }>>>