File indexing completed on 2023-09-24 04:11:28

 /*
     SPDX-FileCopyrightText: 2013 Christoph Cullmann <cullmann@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "katetextfolding.h"
 #include "documentcursor.h"
 #include "katedocument.h"
 #include "katetextbuffer.h"
 #include "katetextrange.h"
 
 #include <QJsonObject>
 
 namespace Kate
 {
 TextFolding::FoldingRange::FoldingRange(TextBuffer &buffer, KTextEditor::Range range, FoldingRangeFlags _flags)
     : start(new TextCursor(buffer, range.start(), KTextEditor::MovingCursor::MoveOnInsert))
     , end(new TextCursor(buffer, range.end(), KTextEditor::MovingCursor::MoveOnInsert))
     , parent(nullptr)
     , flags(_flags)
     , id(-1)
 {
 }
 
 TextFolding::FoldingRange::~FoldingRange()
 {
     // kill all our data!
     // this will recurse all sub-structures!
     delete start;
     delete end;
     qDeleteAll(nestedRanges);
 }
 
 TextFolding::TextFolding(TextBuffer &buffer)
     : QObject()
     , m_buffer(buffer)
     , m_idCounter(-1)
 {
     // connect needed signals from buffer
     connect(&m_buffer, &TextBuffer::cleared, this, &TextFolding::clear);
 }
 
 TextFolding::~TextFolding()
 {
     // only delete the folding ranges, the folded ranges and mapped ranges are the same objects
     qDeleteAll(m_foldingRanges);
 }
 
 void TextFolding::clear()
 {
     // reset counter
     m_idCounter = -1;
     clearFoldingRanges();
 }
 
 void TextFolding::clearFoldingRanges()
 {
     // no ranges, no work
     if (m_foldingRanges.isEmpty()) {
         // assert all stuff is consistent and return!
         Q_ASSERT(m_idToFoldingRange.isEmpty());
         Q_ASSERT(m_foldedFoldingRanges.isEmpty());
         return;
     }
 
     // cleanup
     m_idToFoldingRange.clear();
     m_foldedFoldingRanges.clear();
     qDeleteAll(m_foldingRanges);
     m_foldingRanges.clear();
 
     // folding changed!
     Q_EMIT foldingRangesChanged();
 }
 
 qint64 TextFolding::newFoldingRange(KTextEditor::Range range, FoldingRangeFlags flags)
 {
     // sort out invalid and empty ranges
     // that makes no sense, they will never grow again!
     if (!range.isValid() || range.isEmpty()) {
         return -1;
     }
 
     // create new folding region that we want to insert
     // this will internally create moving cursors!
     FoldingRange *newRange = new FoldingRange(m_buffer, range, flags);
 
     // the construction of the text cursors might have invalidated this
     // check and bail out if that happens
     // bail out, too, if it can't be inserted!
     if (!newRange->start->isValid() || !newRange->end->isValid() || !insertNewFoldingRange(nullptr /* no parent here */, m_foldingRanges, newRange)) {
         // cleanup and be done
         delete newRange;
         return -1;
     }
 
     // set id, catch overflows, even if they shall not happen
     newRange->id = ++m_idCounter;
     if (newRange->id < 0) {
         newRange->id = m_idCounter = 0;
     }
 
     // remember the range
     m_idToFoldingRange.insert(newRange->id, newRange);
 
     // update our folded ranges vector!
     bool updated = updateFoldedRangesForNewRange(newRange);
 
     // emit that something may have changed
     // do that only, if updateFoldedRangesForNewRange did not already do the job!
     if (!updated) {
         Q_EMIT foldingRangesChanged();
     }
 
     // all went fine, newRange is now registered internally!
     return newRange->id;
 }
 
 KTextEditor::Range TextFolding::foldingRange(qint64 id) const
 {
     FoldingRange *range = m_idToFoldingRange.value(id);
     if (!range) {
         return KTextEditor::Range::invalid();
     }
 
     return KTextEditor::Range(range->start->toCursor(), range->end->toCursor());
 }
 
 bool TextFolding::foldRange(qint64 id)
 {
     // try to find the range, else bail out
     FoldingRange *range = m_idToFoldingRange.value(id);
     if (!range) {
         return false;
     }
 
     // already folded? nothing to do
     if (range->flags & Folded) {
         return true;
     }
 
     // fold and be done
     range->flags |= Folded;
     updateFoldedRangesForNewRange(range);
     return true;
 }
 
 bool TextFolding::unfoldRange(qint64 id, bool remove)
 {
     // try to find the range, else bail out
     FoldingRange *range = m_idToFoldingRange.value(id);
     if (!range) {
         return false;
     }
 
     // nothing to do?
     // range is already unfolded and we need not to remove it!
     if (!remove && !(range->flags & Folded)) {
         return true;
     }
 
     // do we need to delete the range?
     const bool deleteRange = remove || !(range->flags & Persistent);
 
     // first: remove the range, if forced or non-persistent!
     if (deleteRange) {
         // remove from outside visible mapping!
         m_idToFoldingRange.remove(id);
 
         // remove from folding vectors!
         // FIXME: OPTIMIZE
         FoldingRange::Vector &parentVector = range->parent ? range->parent->nestedRanges : m_foldingRanges;
         FoldingRange::Vector newParentVector;
         for (FoldingRange *curRange : std::as_const(parentVector)) {
             // insert our nested ranges and reparent them
             if (curRange == range) {
                 for (FoldingRange *newRange : std::as_const(range->nestedRanges)) {
                     newRange->parent = range->parent;
                     newParentVector.push_back(newRange);
                 }
 
                 continue;
             }
 
             // else just transfer elements
             newParentVector.push_back(curRange);
         }
         parentVector = newParentVector;
     }
 
     // second: unfold the range, if needed!
     bool updated = false;
     if (range->flags & Folded) {
         range->flags &= ~Folded;
         updated = updateFoldedRangesForRemovedRange(range);
     }
 
     // emit that something may have changed
     // do that only, if updateFoldedRangesForRemoveRange did not already do the job!
     if (!updated) {
         Q_EMIT foldingRangesChanged();
     }
 
     // really delete the range, if needed!
     if (deleteRange) {
         // clear ranges first, they got moved!
         range->nestedRanges.clear();
         delete range;
     }
 
     // be done ;)
     return true;
 }
 
 bool TextFolding::isLineVisible(int line, qint64 *foldedRangeId) const
 {
     // skip if nothing folded
     if (m_foldedFoldingRanges.isEmpty()) {
         return true;
     }
 
     // search upper bound, index to item with start line higher than our one
     FoldingRange::Vector::const_iterator upperBound =
         std::upper_bound(m_foldedFoldingRanges.begin(), m_foldedFoldingRanges.end(), line, compareRangeByStartWithLine);
     if (upperBound != m_foldedFoldingRanges.begin()) {
         --upperBound;
     }
 
     // check if we overlap with the range in front of us
     const bool hidden = (((*upperBound)->end->line() >= line) && (line > (*upperBound)->start->line()));
 
     // fill in folded range id, if needed
     if (foldedRangeId) {
         (*foldedRangeId) = hidden ? (*upperBound)->id : -1;
     }
 
     // visible == !hidden
     return !hidden;
 }
 
 void TextFolding::ensureLineIsVisible(int line)
 {
     // skip if nothing folded
     if (m_foldedFoldingRanges.isEmpty()) {
         return;
     }
 
     // while not visible, unfold
     qint64 foldedRangeId = -1;
     while (!isLineVisible(line, &foldedRangeId)) {
         // id should be valid!
         Q_ASSERT(foldedRangeId >= 0);
 
         // unfold shall work!
         const bool unfolded = unfoldRange(foldedRangeId);
         (void)unfolded;
         Q_ASSERT(unfolded);
     }
 }
 
 int TextFolding::visibleLines() const
 {
     // start with all lines we have
     int visibleLines = m_buffer.lines();
 
     // skip if nothing folded
     if (m_foldedFoldingRanges.isEmpty()) {
         return visibleLines;
     }
 
     // count all folded lines and subtract them from visible lines
     for (FoldingRange *range : m_foldedFoldingRanges) {
         visibleLines -= (range->end->line() - range->start->line());
     }
 
     // be done, assert we did no trash
     Q_ASSERT(visibleLines > 0);
     return visibleLines;
 }
 
 int TextFolding::lineToVisibleLine(int line) const
 {
     // valid input needed!
     Q_ASSERT(line >= 0);
 
     // start with identity
     int visibleLine = line;
 
     // skip if nothing folded or first line
     if (m_foldedFoldingRanges.isEmpty() || (line == 0)) {
         return visibleLine;
     }
 
     // walk over all folded ranges until we reach the line
     // keep track of seen visible lines, for the case we want to convert a hidden line!
     int seenVisibleLines = 0;
     int lastLine = 0;
     for (FoldingRange *range : m_foldedFoldingRanges) {
         // abort if we reach our line!
         if (range->start->line() >= line) {
             break;
         }
 
         // count visible lines
         seenVisibleLines += (range->start->line() - lastLine);
         lastLine = range->end->line();
 
         // we might be contained in the region, then we return last visible line
         if (line <= range->end->line()) {
             return seenVisibleLines;
         }
 
         // subtrace folded lines
         visibleLine -= (range->end->line() - range->start->line());
     }
 
     // be done, assert we did no trash
     Q_ASSERT(visibleLine >= 0);
     return visibleLine;
 }
 
 int TextFolding::visibleLineToLine(int visibleLine) const
 {
     // valid input needed!
     Q_ASSERT(visibleLine >= 0);
 
     // start with identity
     int line = visibleLine;
 
     // skip if nothing folded or first line
     if (m_foldedFoldingRanges.isEmpty() || (visibleLine == 0)) {
         return line;
     }
 
     // last visible line seen, as line in buffer
     int seenVisibleLines = 0;
     int lastLine = 0;
     int lastLineVisibleLines = 0;
     for (FoldingRange *range : m_foldedFoldingRanges) {
         // else compute visible lines and move last seen
         lastLineVisibleLines = seenVisibleLines;
         seenVisibleLines += (range->start->line() - lastLine);
 
         // bail out if enough seen
         if (seenVisibleLines >= visibleLine) {
             break;
         }
 
         lastLine = range->end->line();
     }
 
     // check if still no enough visible!
     if (seenVisibleLines < visibleLine) {
         lastLineVisibleLines = seenVisibleLines;
     }
 
     // compute visible line
     line = (lastLine + (visibleLine - lastLineVisibleLines));
     Q_ASSERT(line >= 0);
     return line;
 }
 
 QVector<QPair<qint64, TextFolding::FoldingRangeFlags>> TextFolding::foldingRangesStartingOnLine(int line) const
 {
     // results vector
     QVector<QPair<qint64, TextFolding::FoldingRangeFlags>> results;
 
     // recursively do binary search
     foldingRangesStartingOnLine(results, m_foldingRanges, line);
 
     // return found results
     return results;
 }
 
 void TextFolding::foldingRangesStartingOnLine(QVector<QPair<qint64, FoldingRangeFlags>> &results,
                                               const TextFolding::FoldingRange::Vector &ranges,
                                               int line) const
 {
     // early out for no folds
     if (ranges.isEmpty()) {
         return;
     }
 
     // first: lower bound of start
     FoldingRange::Vector::const_iterator lowerBound = std::lower_bound(ranges.begin(), ranges.end(), line, compareRangeByLineWithStart);
 
     // second: upper bound of end
     FoldingRange::Vector::const_iterator upperBound = std::upper_bound(ranges.begin(), ranges.end(), line, compareRangeByStartWithLine);
 
     // we may need to go one to the left, if not already at the begin, as we might overlap with the one in front of us!
     if ((lowerBound != ranges.begin()) && ((*(lowerBound - 1))->end->line() >= line)) {
         --lowerBound;
     }
 
     // for all of them, check if we start at right line and recurse
     for (FoldingRange::Vector::const_iterator it = lowerBound; it != upperBound; ++it) {
         // this range already ok? add it to results
         if ((*it)->start->line() == line) {
             results.push_back(qMakePair((*it)->id, (*it)->flags));
         }
 
         // recurse anyway
         foldingRangesStartingOnLine(results, (*it)->nestedRanges, line);
     }
 }
 
 QVector<QPair<qint64, TextFolding::FoldingRangeFlags>> TextFolding::foldingRangesForParentRange(qint64 parentRangeId) const
 {
     // toplevel ranges requested or real parent?
     const FoldingRange::Vector *ranges = nullptr;
     if (parentRangeId == -1) {
         ranges = &m_foldingRanges;
     } else if (FoldingRange *range = m_idToFoldingRange.value(parentRangeId)) {
         ranges = &range->nestedRanges;
     }
 
     // no ranges => nothing to do
     QVector<QPair<qint64, FoldingRangeFlags>> results;
     if (!ranges) {
         return results;
     }
 
     // else convert ranges to id + flags and pass that back
     for (FoldingRange::Vector::const_iterator it = ranges->begin(); it != ranges->end(); ++it) {
         results.append(qMakePair((*it)->id, (*it)->flags));
     }
     return results;
 }
 
 QString TextFolding::debugDump() const
 {
     // dump toplevel ranges recursively
     return QStringLiteral("tree %1 - folded %2").arg(debugDump(m_foldingRanges, true), debugDump(m_foldedFoldingRanges, false));
 }
 
 void TextFolding::debugPrint(const QString &title) const
 {
     // print title + content
     printf("%s\n    %s\n", qPrintable(title), qPrintable(debugDump()));
 }
 
 void TextFolding::editEnd(int startLine, int endLine, std::function<bool(int)> isLineFoldingStart)
 {
     // search upper bound, index to item with start line higher than our one
     auto foldIt = std::upper_bound(m_foldedFoldingRanges.begin(), m_foldedFoldingRanges.end(), startLine, compareRangeByStartWithLine);
     if (foldIt != m_foldedFoldingRanges.begin()) {
         --foldIt;
     }
 
     // handle all ranges until we go behind the last line
     bool anyUpdate = false;
     while (foldIt != m_foldedFoldingRanges.end() && (*foldIt)->start->line() <= endLine) {
         // shall we keep this folding?
         if (isLineFoldingStart((*foldIt)->start->line())) {
             ++foldIt;
             continue;
         }
 
         // else kill it
         m_foldingRanges.removeOne(*foldIt);
         m_idToFoldingRange.remove((*foldIt)->id);
         delete *foldIt;
         foldIt = m_foldedFoldingRanges.erase(foldIt);
         anyUpdate = true;
     }
 
     // ensure we do the proper updates outside
     // we might change some range outside of the lines we edited
     if (anyUpdate) {
         Q_EMIT foldingRangesChanged();
     }
 }
 
 QString TextFolding::debugDump(const TextFolding::FoldingRange::Vector &ranges, bool recurse)
 {
     // dump all ranges recursively
     QString dump;
     for (FoldingRange *range : ranges) {
         if (!dump.isEmpty()) {
             dump += QLatin1Char(' ');
         }
 
         const QString persistent = (range->flags & Persistent) ? QStringLiteral("p") : QString();
         const QString folded = (range->flags & Folded) ? QStringLiteral("f") : QString();
         dump += QStringLiteral("[%1:%2 %3%4 ").arg(range->start->line()).arg(range->start->column()).arg(persistent, folded);
 
         // recurse
         if (recurse) {
             QString inner = debugDump(range->nestedRanges, recurse);
             if (!inner.isEmpty()) {
                 dump += inner + QLatin1Char(' ');
             }
         }
 
         dump += QStringLiteral("%1:%2]").arg(range->end->line()).arg(range->end->column());
     }
     return dump;
 }
 
 bool TextFolding::insertNewFoldingRange(FoldingRange *parent, FoldingRange::Vector &existingRanges, FoldingRange *newRange)
 {
     // existing ranges are non-overlapping and sorted
     // that means, we can search for lower bound of start of range and upper bound of end of range to find all "overlapping" ranges.
 
     // first: lower bound of start
     FoldingRange::Vector::iterator lowerBound = std::lower_bound(existingRanges.begin(), existingRanges.end(), newRange, compareRangeByStart);
 
     // second: upper bound of end
     FoldingRange::Vector::iterator upperBound = std::upper_bound(existingRanges.begin(), existingRanges.end(), newRange, compareRangeByEnd);
 
     // we may need to go one to the left, if not already at the begin, as we might overlap with the one in front of us!
     if ((lowerBound != existingRanges.begin()) && ((*(lowerBound - 1))->end->toCursor() > newRange->start->toCursor())) {
         --lowerBound;
     }
 
     // now: first case, we overlap with nothing or hit exactly one range!
     if (lowerBound == upperBound) {
         // nothing we overlap with?
         // then just insert and be done!
         if ((lowerBound == existingRanges.end()) || (newRange->start->toCursor() >= (*lowerBound)->end->toCursor())
             || (newRange->end->toCursor() <= (*lowerBound)->start->toCursor())) {
             // insert + fix parent
             existingRanges.insert(lowerBound, newRange);
             newRange->parent = parent;
 
             // all done
             return true;
         }
 
         // we are contained in this one range?
         // then recurse!
         if ((newRange->start->toCursor() >= (*lowerBound)->start->toCursor()) && (newRange->end->toCursor() <= (*lowerBound)->end->toCursor())) {
             return insertNewFoldingRange((*lowerBound), (*lowerBound)->nestedRanges, newRange);
         }
 
         // else: we might contain at least this fold, or many more, if this if block is not taken at all
         // use the general code that checks for "we contain stuff" below!
     }
 
     // check if we contain other folds!
     FoldingRange::Vector::iterator it = lowerBound;
     bool includeUpperBound = false;
     FoldingRange::Vector nestedRanges;
     while (it != existingRanges.end()) {
         // do we need to take look at upper bound, too?
         // if not break
         if (it == upperBound) {
             if (newRange->end->toCursor() <= (*upperBound)->start->toCursor()) {
                 break;
             } else {
                 includeUpperBound = true;
             }
         }
 
         // if one region is not contained in the new one, abort!
         // then this is not well nested!
         if (!((newRange->start->toCursor() <= (*it)->start->toCursor()) && (newRange->end->toCursor() >= (*it)->end->toCursor()))) {
             return false;
         }
 
         // include into new nested ranges
         nestedRanges.push_back((*it));
 
         // end reached
         if (it == upperBound) {
             break;
         }
 
         // else increment
         ++it;
     }
 
     // if we arrive here, all is nicely nested into our new range
     // remove the contained ones here, insert new range with new nested ranges we already constructed
     it = existingRanges.erase(lowerBound, includeUpperBound ? (upperBound + 1) : upperBound);
     existingRanges.insert(it, newRange);
     newRange->nestedRanges = nestedRanges;
 
     // correct parent mapping!
     newRange->parent = parent;
     for (FoldingRange *range : std::as_const(newRange->nestedRanges)) {
         range->parent = newRange;
     }
 
     // all nice
     return true;
 }
 
 bool TextFolding::compareRangeByStart(FoldingRange *a, FoldingRange *b)
 {
     return a->start->toCursor() < b->start->toCursor();
 }
 
 bool TextFolding::compareRangeByEnd(FoldingRange *a, FoldingRange *b)
 {
     return a->end->toCursor() < b->end->toCursor();
 }
 
 bool TextFolding::compareRangeByStartWithLine(int line, FoldingRange *range)
 {
     return (line < range->start->line());
 }
 
 bool TextFolding::compareRangeByLineWithStart(FoldingRange *range, int line)
 {
     return (range->start->line() < line);
 }
 
 bool TextFolding::updateFoldedRangesForNewRange(TextFolding::FoldingRange *newRange)
 {
     // not folded? not interesting! we don't need to touch our m_foldedFoldingRanges vector
     if (!(newRange->flags & Folded)) {
         return false;
     }
 
     // any of the parents folded? not interesting, too!
     TextFolding::FoldingRange *parent = newRange->parent;
     while (parent) {
         // parent folded => be done
         if (parent->flags & Folded) {
             return false;
         }
 
         // walk up
         parent = parent->parent;
     }
 
     // ok, if we arrive here, we are a folded range and we have no folded parent
     // we now want to add this range to the m_foldedFoldingRanges vector, just removing any ranges that is included in it!
     // TODO: OPTIMIZE
     FoldingRange::Vector newFoldedFoldingRanges;
     bool newRangeInserted = false;
     for (FoldingRange *range : std::as_const(m_foldedFoldingRanges)) {
         // contained? kill
         if ((newRange->start->toCursor() <= range->start->toCursor()) && (newRange->end->toCursor() >= range->end->toCursor())) {
             continue;
         }
 
         // range is behind newRange?
         // insert newRange if not already done
         if (!newRangeInserted && (range->start->toCursor() >= newRange->end->toCursor())) {
             newFoldedFoldingRanges.push_back(newRange);
             newRangeInserted = true;
         }
 
         // just transfer range
         newFoldedFoldingRanges.push_back(range);
     }
 
     // last: insert new range, if not done
     if (!newRangeInserted) {
         newFoldedFoldingRanges.push_back(newRange);
     }
 
     // fixup folded ranges
     m_foldedFoldingRanges = newFoldedFoldingRanges;
 
     // folding changed!
     Q_EMIT foldingRangesChanged();
 
     // all fine, stuff done, signal emitted
     return true;
 }
 
 bool TextFolding::updateFoldedRangesForRemovedRange(TextFolding::FoldingRange *oldRange)
 {
     // folded? not interesting! we don't need to touch our m_foldedFoldingRanges vector
     if (oldRange->flags & Folded) {
         return false;
     }
 
     // any of the parents folded? not interesting, too!
     TextFolding::FoldingRange *parent = oldRange->parent;
     while (parent) {
         // parent folded => be done
         if (parent->flags & Folded) {
             return false;
         }
 
         // walk up
         parent = parent->parent;
     }
 
     // ok, if we arrive here, we are a unfolded range and we have no folded parent
     // we now want to remove this range from the m_foldedFoldingRanges vector and include our nested folded ranges!
     // TODO: OPTIMIZE
     FoldingRange::Vector newFoldedFoldingRanges;
     for (FoldingRange *range : std::as_const(m_foldedFoldingRanges)) {
         // right range? insert folded nested ranges
         if (range == oldRange) {
             appendFoldedRanges(newFoldedFoldingRanges, oldRange->nestedRanges);
             continue;
         }
 
         // just transfer range
         newFoldedFoldingRanges.push_back(range);
     }
 
     // fixup folded ranges
     m_foldedFoldingRanges = newFoldedFoldingRanges;
 
     // folding changed!
     Q_EMIT foldingRangesChanged();
 
     // all fine, stuff done, signal emitted
     return true;
 }
 
 void TextFolding::appendFoldedRanges(TextFolding::FoldingRange::Vector &newFoldedFoldingRanges, const TextFolding::FoldingRange::Vector &ranges) const
 {
     // search for folded ranges and append them
     for (FoldingRange *range : ranges) {
         // itself folded? append
         if (range->flags & Folded) {
             newFoldedFoldingRanges.push_back(range);
             continue;
         }
 
         // else: recurse!
         appendFoldedRanges(newFoldedFoldingRanges, range->nestedRanges);
     }
 }
 
 QJsonDocument TextFolding::exportFoldingRanges() const
 {
     QJsonObject obj;
     QJsonArray array;
     exportFoldingRanges(m_foldingRanges, array);
     obj.insert(QStringLiteral("ranges"), array);
     obj.insert(QStringLiteral("checksum"), QString::fromLocal8Bit(m_buffer.digest().toHex()));
     QJsonDocument folds;
     folds.setObject(obj);
     return folds;
 }
 
 void TextFolding::exportFoldingRanges(const TextFolding::FoldingRange::Vector &ranges, QJsonArray &folds)
 {
     // dump all ranges recursively
     for (FoldingRange *range : ranges) {
         // construct one range and dump to folds
         QJsonObject rangeMap;
         rangeMap[QStringLiteral("startLine")] = range->start->line();
         rangeMap[QStringLiteral("startColumn")] = range->start->column();
         rangeMap[QStringLiteral("endLine")] = range->end->line();
         rangeMap[QStringLiteral("endColumn")] = range->end->column();
         rangeMap[QStringLiteral("flags")] = (int)range->flags;
         folds.append(rangeMap);
 
         // recurse
         exportFoldingRanges(range->nestedRanges, folds);
     }
 }
 
 void TextFolding::importFoldingRanges(const QJsonDocument &folds)
 {
     clearFoldingRanges();
 
     const auto checksum = QByteArray::fromHex(folds.object().value(QStringLiteral("checksum")).toString().toLocal8Bit());
     if (checksum != m_buffer.digest()) {
         return;
     }
 
     // try to create all folding ranges
     const auto jsonRanges = folds.object().value(QStringLiteral("ranges")).toArray();
     for (const auto &rangeVariant : jsonRanges) {
         // get map
         const auto rangeMap = rangeVariant.toObject();
 
         // construct range start/end
         const KTextEditor::Cursor start(rangeMap[QStringLiteral("startLine")].toInt(), rangeMap[QStringLiteral("startColumn")].toInt());
         const KTextEditor::Cursor end(rangeMap[QStringLiteral("endLine")].toInt(), rangeMap[QStringLiteral("endColumn")].toInt());
 
         // check validity (required when loading a possibly broken folding state from disk)
         if (start >= end
             || (m_buffer.document() && // <-- unit test katetextbuffertest does not have a KTE::Document assigned
                 (!KTextEditor::DocumentCursor(m_buffer.document(), start).isValidTextPosition()
                  || !KTextEditor::DocumentCursor(m_buffer.document(), end).isValidTextPosition()))) {
             continue;
         }
 
         // get flags
         const int rawFlags = rangeMap[QStringLiteral("flags")].toInt();
         FoldingRangeFlags flags;
         if (rawFlags & Persistent) {
             flags = Persistent;
         }
         if (rawFlags & Folded) {
             flags = Folded;
         }
 
         // create folding range
         newFoldingRange(KTextEditor::Range(start, end), flags);
     }
 }
 
 }
 
 #include "moc_katetextfolding.cpp"