async _prepare(cfg) {
    LogService.debug(`Analyzer "${this.name}": started _prepare method`);
    /** @type {typeof Analyzer} */ (this.constructor).__unwindProvidedResults(cfg);

    if (!cfg.targetProjectResult) {
      this.targetProjectMeta = InputDataService.getProjectMeta(cfg.targetProjectPath);
    } else {
      this.targetProjectMeta = cfg.targetProjectResult.analyzerMeta.targetProject;
    }

    if (cfg.referenceProjectPath && !cfg.referenceProjectResult) {
      this.referenceProjectMeta = InputDataService.getProjectMeta(cfg.referenceProjectPath);
    } else if (cfg.referenceProjectResult) {
      this.referenceProjectMeta = cfg.referenceProjectResult.analyzerMeta.targetProject;
    }

    /**
     * Create a unique hash based on target, reference and configuration
     */
    this.identifier = ReportService.createIdentifier({
      targetProject: this.targetProjectMeta,
      referenceProject: this.referenceProjectMeta,
      analyzerConfig: cfg,
    });

    // If we have a provided result cfg.referenceProjectResult, we assume the providing
    // party provides compatible results for now...
    if (cfg.referenceProjectPath && !cfg.skipCheckMatchCompatibility) {
      const { compatible, reason } = checkForMatchCompatibility(
        cfg.referenceProjectPath,
        cfg.targetProjectPath,
      );

      if (!compatible) {
        if (!cfg.suppressNonCriticalLogs) {
          LogService.info(
            `${LogService.pad(`skipping  ${this.name} (${reason})`)}${displayProjectsInLog(this.identifier)}`,
          );
        }
        return ensureAnalyzerResultFormat(`[${reason}]`, cfg, this);
      }
    }

    /**
     * See if we maybe already have our result in cache in the file-system.
     */
    const cachedResult = Analyzer._getCachedAnalyzerResult({
      analyzerName: this.name,
      identifier: this.identifier,
      cfg,
    });

    if (cachedResult) {
      return cachedResult;
    }

    if (!cfg.suppressNonCriticalLogs) {
      LogService.info(
        `${LogService.pad(`starting ${this.name}`)}${displayProjectsInLog(this.identifier)}`,
      );
    }

    /**
     * Get reference and search-target data
     */
    if (!cfg.targetProjectResult) {
      performance.mark('analyzer--prepare--createDTarg-start');
      this.targetData = await InputDataService.createDataObject(
        [cfg.targetProjectPath],
        cfg.gatherFilesConfig,
      );
      performance.mark('analyzer--prepare--createDTarg-end');
      const m1 = performance.measure(
        'analyzer--prepare--createDTarg',
        'analyzer--prepare--createDTarg-start',
        'analyzer--prepare--createDTarg-end',
      );
      LogService.perf(m1);
    }

    if (cfg.referenceProjectPath) {
      performance.mark('analyzer--prepare--createDRef-start');

      this.referenceData = await InputDataService.createDataObject(
        [cfg.referenceProjectPath],
        cfg.gatherFilesConfigReference || cfg.gatherFilesConfig,
      );
      performance.mark('analyzer--prepare--createDRef-end');
      const m2 = performance.measure(
        'analyzer--prepare--createDRef',
        'analyzer--prepare--createDRef-start',
        'analyzer--prepare--createDRef-end',
      );
      LogService.perf(m2);
    }

    return undefined;
  }
@param {AnalyzerConfig} cfg
@returns {CachedAnalyzerResult|undefined}