FormBuilder::processForm

public FormBuilder::processForm($form_id, &$form, FormStateInterface &$form_state)

public function processForm($form_id, &$form, FormStateInterface &$form_state) {
  $form_state->setValues([]);

  // With GET, these forms are always submitted if requested.
  if ($form_state->isMethodType('get') && $form_state->getAlwaysProcess()) {
    $input = $form_state->getUserInput();
    if (!isset($input['form_build_id'])) {
      $input['form_build_id'] = $form['#build_id'];
    }
    if (!isset($input['form_id'])) {
      $input['form_id'] = $form_id;
    }
    if (!isset($input['form_token']) && isset($form['#token'])) {
      $input['form_token'] = $this->csrfToken->get($form['#token']);
    }
    $form_state->setUserInput($input);
  }

  // self::doBuildForm() finishes building the form by calling element
  // #process functions and mapping user input, if any, to #value properties,
  // and also storing the values in $form_state->getValues(). We need to
  // retain the unprocessed $form in case it needs to be cached.
  $unprocessed_form = $form;
  $form = $this->doBuildForm($form_id, $form, $form_state);

  // Only process the input if we have a correct form submission.
  if ($form_state->isProcessingInput()) {
    // Form values for programmed form submissions typically do not include a
    // value for the submit button. But without a triggering element, a
    // potentially existing #limit_validation_errors property on the primary
    // submit button is not taken account. Therefore, check whether there is
    // exactly one submit button in the form, and if so, automatically use it
    // as triggering_element.
    $buttons = $form_state->getButtons();
    if ($form_state->isProgrammed() && !$form_state->getTriggeringElement() && count($buttons) == 1) {
      $form_state->setTriggeringElement(reset($buttons));
    }
    $this->formValidator->validateForm($form_id, $form, $form_state);

    // \Drupal\Component\Utility\Html::getUniqueId() maintains a cache of
    // element IDs it has seen, so it can prevent duplicates. We want to be
    // sure we reset that cache when a form is processed, so scenarios that
    // result in the form being built behind the scenes and again for the
    // browser don't increment all the element IDs needlessly.
    if (!FormState::hasAnyErrors()) {
      // In case of errors, do not break HTML IDs of other forms.
      Html::resetSeenIds();
    }

    // If there are no errors and the form is not rebuilding, submit the form.
    if (!$form_state->isRebuilding() && !FormState::hasAnyErrors()) {
      $submit_response = $this->formSubmitter->doSubmitForm($form, $form_state);
      // If this form was cached, delete it from the cache after submission.
      if ($form_state->isCached()) {
        $this->deleteCache($form['#build_id']);
      }
      // If the form submission directly returned a response, return it now.
      if ($submit_response) {
        return $submit_response;
      }
    }

    // Don't rebuild or cache form submissions invoked via self::submitForm().
    if ($form_state->isProgrammed()) {
      return;
    }

    // If $form_state->isRebuilding() has been set and input has been
    // processed without validation errors, we are in a multi-step workflow
    // that is not yet complete. A new $form needs to be constructed based on
    // the changes made to $form_state during this request. Normally, a submit
    // handler sets $form_state->isRebuilding() if a fully executed form
    // requires another step. However, for forms that have not been fully
    // executed (e.g., Ajax submissions triggered by non-buttons), there is no
    // submit handler to set $form_state->isRebuilding(). It would not make
    // sense to redisplay the identical form without an error for the user to
    // correct, so we also rebuild error-free non-executed forms, regardless
    // of $form_state->isRebuilding().
    // @todo Simplify this logic; considering Ajax and non-HTML front-ends,
    //   along with element-level #submit properties, it makes no sense to
    //   have divergent form execution based on whether the triggering element
    //   has #executes_submit_callback set to TRUE.
    if (($form_state->isRebuilding() || !$form_state->isExecuted()) && !FormState::hasAnyErrors()) {
      // Form building functions (e.g., self::handleInputElement()) may use
      // $form_state->isRebuilding() to determine if they are running in the
      // context of a rebuild, so ensure it is set.
      $form_state->setRebuild();
      $form = $this->rebuildForm($form_id, $form_state, $form);
    }
  }

  // After processing the form, the form builder or a #process callback may
  // have called $form_state->setCached() to indicate that the form and form
  // state shall be cached. But the form may only be cached if
  // $form_state->disableCache() is not called. Only cache $form as it was
  // prior to self::doBuildForm(), because self::doBuildForm() must run for
  // each request to accommodate new user input. Rebuilt forms are not cached
  // here, because self::rebuildForm() already takes care of that.
  if (!$form_state->isRebuilding() && $form_state->isCached()) {
    $this->setCache($form['#build_id'], $unprocessed_form, $form_state);
  }
}