Merge "Refactor the code to avoid duplicate logic for silent and non-silent" into main

    packaging_commands_getters = []

    # In order to roll optimizations out differently between test suites and

    # device builds, we have separate flags.

    if (

        'test_suites_zip_test_discovery'

    enable_discovery = ('test_suites_zip_test_discovery'

        in self.build_context.enabled_build_features

        and not self.args.device_build

    ) or (

        'device_zip_test_discovery'

        in self.build_context.enabled_build_features

        and self.args.device_build

    ):

      preliminary_build_targets = self._collect_preliminary_build_targets()

    else:

      preliminary_build_targets = self._legacy_collect_preliminary_build_targets()

      # Keep reporting metrics when test discovery is disabled.

      # To be removed once test discovery is fully rolled out.

      optimization_rationale = ''

      test_discovery_zip_regexes = set()

      try:

        test_discovery_zip_regexes = self._get_test_discovery_zip_regexes()

        logging.info(f'Discovered test discovery regexes: {test_discovery_zip_regexes}')

      except test_discovery_agent.TestDiscoveryError as e:

        optimization_rationale = e.message

        logging.warning(f'Unable to perform test discovery: {optimization_rationale}')

      for target in self.args.extra_targets:

        if optimization_rationale:

          get_metrics_agent().report_unoptimized_target(target, optimization_rationale)

          continue

        if target in REQUIRED_BUILD_TARGETS:

          get_metrics_agent().report_unoptimized_target(target, 'Required build target.')

          continue

        try:

          regex = r'\b(%s.*)\b' % re.escape(target)

          if any(re.search(regex, opt) for opt in test_discovery_zip_regexes):

            get_metrics_agent().report_unoptimized_target(target, 'Test artifact used.')

            continue

          get_metrics_agent().report_optimized_target(target)

        except Exception as e:

          logging.error(f'unable to parse test discovery output: {repr(e)}')

          get_metrics_agent().report_unoptimized_target(target, f'Error in parsing test discovery output for {target}: {repr(e)}')

    )

    logging.info(f'Discovery mode is enabled= {enable_discovery}')

    preliminary_build_targets = self._collect_preliminary_build_targets(enable_discovery)

    for target in preliminary_build_targets:

      target_optimizer_getter = self.target_optimizations.get(target, None)

    return BuildPlan(build_targets, packaging_commands_getters)

  def _collect_preliminary_build_targets(self):

  def _collect_preliminary_build_targets(self, enable_discovery: bool):

    build_targets = set()

    try:

      test_discovery_zip_regexes = self._get_test_discovery_zip_regexes()

          get_metrics_agent().report_unoptimized_target(target, f'Error in parsing test discovery output for {target}: {repr(e)}')

          logging.error(f'unable to parse test discovery output: {repr(e)}')

          break

    # If discovery is not enabled, return the original list

    if not enable_discovery:

      return self._legacy_collect_preliminary_build_targets()

    return build_targets