void _visit()

in lib/src/solver/failure.dart [186:309]
116 lines of code
23 McCabe index (conditional complexity)

  void _visit(Incompatibility incompatibility,
      Map<String, PackageDetail> detailsForIncompatibility,
      {bool conclusion = false}) {
    // Add explicit numbers for incompatibilities that are written far away
    // from their successors or that are used for multiple derivations.
    var numbered = conclusion || _derivations[incompatibility]! > 1;
    var conjunction = conclusion || incompatibility == _root ? 'So,' : 'And';
    var incompatibilityString =
        log.bold(incompatibility.toString(detailsForIncompatibility));

    var conflictClause = incompatibility.cause as ConflictCause;
    var detailsForCause = _detailsForCause(conflictClause);
    var cause = conflictClause.conflict.cause;
    var otherCause = conflictClause.other.cause;
    if (cause is ConflictCause && otherCause is ConflictCause) {
      var conflictLine = _lineNumbers[conflictClause.conflict];
      var otherLine = _lineNumbers[conflictClause.other];
      if (conflictLine != null && otherLine != null) {
        _write(
            incompatibility,
            'Because ' +
                conflictClause.conflict.andToString(conflictClause.other,
                    detailsForCause, conflictLine, otherLine) +
                ', $incompatibilityString.',
            numbered: numbered);
      } else if (conflictLine != null || otherLine != null) {
        Incompatibility withLine;
        Incompatibility withoutLine;
        int line;
        if (conflictLine != null) {
          withLine = conflictClause.conflict;
          withoutLine = conflictClause.other;
          line = conflictLine;
        } else {
          withLine = conflictClause.other;
          withoutLine = conflictClause.conflict;
          line = otherLine!;
        }

        _visit(withoutLine, detailsForCause);
        _write(
            incompatibility,
            '$conjunction because ${withLine.toString(detailsForCause)} '
            '($line), $incompatibilityString.',
            numbered: numbered);
      } else {
        var singleLineConflict = _isSingleLine(cause);
        var singleLineOther = _isSingleLine(otherCause);
        if (singleLineOther || singleLineConflict) {
          var first =
              singleLineOther ? conflictClause.conflict : conflictClause.other;
          var second =
              singleLineOther ? conflictClause.other : conflictClause.conflict;
          _visit(first, detailsForCause);
          _visit(second, detailsForCause);
          _write(incompatibility, 'Thus, $incompatibilityString.',
              numbered: numbered);
        } else {
          _visit(conflictClause.conflict, {}, conclusion: true);
          _lines.add(Pair('', null));

          _visit(conflictClause.other, detailsForCause);
          _write(
              incompatibility,
              '$conjunction because '
              '${conflictClause.conflict.toString(detailsForCause)} '
              '(${_lineNumbers[conflictClause.conflict]}), '
              '$incompatibilityString.',
              numbered: numbered);
        }
      }
    } else if (cause is ConflictCause || otherCause is ConflictCause) {
      var derived = cause is ConflictCause
          ? conflictClause.conflict
          : conflictClause.other;
      var ext = cause is ConflictCause
          ? conflictClause.other
          : conflictClause.conflict;

      var derivedLine = _lineNumbers[derived];
      if (derivedLine != null) {
        _write(
            incompatibility,
            'Because ' +
                ext.andToString(derived, detailsForCause, null, derivedLine) +
                ', $incompatibilityString.',
            numbered: numbered);
      } else if (_isCollapsible(derived)) {
        var derivedCause = derived.cause as ConflictCause;
        var collapsedDerived = derivedCause.conflict.cause is ConflictCause
            ? derivedCause.conflict
            : derivedCause.other;
        var collapsedExt = derivedCause.conflict.cause is ConflictCause
            ? derivedCause.other
            : derivedCause.conflict;

        detailsForCause = mergeMaps(
            detailsForCause, _detailsForCause(derivedCause),
            value: (detail1, detail2) => detail1.max(detail2));

        _visit(collapsedDerived, detailsForCause);
        _write(
            incompatibility,
            '$conjunction because '
            '${collapsedExt.andToString(ext, detailsForCause)}, '
            '$incompatibilityString.',
            numbered: numbered);
      } else {
        _visit(derived, detailsForCause);
        _write(
            incompatibility,
            '$conjunction because ${ext.toString(detailsForCause)}, '
            '$incompatibilityString.',
            numbered: numbered);
      }
    } else {
      _write(
          incompatibility,
          'Because '
          '${conflictClause.conflict.andToString(conflictClause.other, detailsForCause)}, '
          '$incompatibilityString.',
          numbered: numbered);
    }
  }