Created attachment 118637 [details]
misfolded file

Result after View/Code Folding/Fold Toplevel Nodes.

Created attachment 118638 [details]
correctly folded file

After reverting the incriminated commit.

Current versions behave better, thought still some of the folds miss to fold the last line.

Git commit a8013f3085ef2493e1109fd27ac4db608253636c by Christoph Cullmann.
Committed on 13/07/2019 at 18:43.
Pushed by cullmann into branch 'master'.

fix folding of lines with end position at column 0 of a line

the old workaround is no longer needed, the outer level of code handles this
the workaround was broken, too, as it didn't use the right line but plainLine(lines() - 1)

M  +3    -15   src/document/katebuffer.cpp

https://commits.kde.org/ktexteditor/a8013f3085ef2493e1109fd27ac4db608253636c

Created attachment 121587 [details]
expected (left) vs. broken (right) folding

Well, somewhere between 5.52.0 and 5.60.0 the code folding code incurred a regression which breaks folding of patch/diff files again, see the newly attached screenshot (KDevelop, the left session running with the 5.52.0 frameworks and the right session with the 5.60.0 ones).

I think I understand why this happens: the folding now leaves the closing brace visible in C/C++ and apparently it does so by not hiding the last line of the scope-to-be-folded. I liked the old mode (and how you could delete an entire block by folding it and then selecting and deleting 1 apparently line on the screen) but I agree that this new mode is less ambiguous because the opening and closing braces remain visible.

However, this is not appropriate for patch files, nor, for instance, for Python files. Fortunately Python files are folded correctly, so this bug should be easy to fix.

Hmm, the patch below isn't in 5.60, or? Have you tried master?

BTW, there's some weird behaviour if you

1 fold a patchfile hunk (or C/C++ block
2 select the line with the fold carat but not the line below
3 delete the line

The folded carat remains visible (also if you hit undo and restore the deleted content!) and there be dragons if you click on it, no matter if that's before or after restoring the deleted content. You cannot seem to get rid of that ghost carat without reloading the document, and clicking it makes another section fold.

This ghost carat also remains if you select and delete an entire folded section (= 2 lines on the screen), and is just about as pesky in its behaviour and to get rid of.

(In reply to Christoph Cullmann from comment #6)
> Hmm, the patch below isn't in 5.60, or? Have you tried master?

You mean a8013f3085ef2493e1109fd27ac4db608253636c? Indeed, it's just not in 5.60, somehow I mised that. It seems it addresses the main issues here.

The only naggle that remains is that if you fold a section and then delete it, the carat for the next section becomes greyed-out, even if that section isn't folded. It's as if this is the ghost carat from my previous comment which displays on top of the carat of the next section. When that section is folded too you need to click twice on the carat to unfold the section.

Ok, at fine that at least a part works now.
For the other issue, I have no concrete idea at the moment.

Created attachment 121610 [details]
folded and non-unfoldable code at startup!

I stumbled onto a much more annoying glitch that I already thought to have seen: see the screenshot.

This is a document in a KDevelop session I just started, one of those that are opened on startup.

There is actually code being folded at the indicated location, except that this location is not at all a proper place for a foldable block to start. The folded block contains the end of the current class definition, and most of the following class definition (see below). In other words: `addedContextMenu` is part of the 1st class definition, `endoding` is a member of the other class.

What's really annoying here is that I cannot unfold it by clicking on the folding carat. Fortunately "View/Code Folding/Unfold Toplevel Nodes" had the desired effect.

There is no support for restoring folded sections after closing/reopening a document that I can see, but apparently these sections are preserved across restarts the editor, right? If so this could be an effect of changing the document behind the editor's back.

That is not what can have happened here, but I do notice that folding is preserved when the document is reloaded (automatically or manually) after an external change. Evidently that gives weird results, so it'd be good if you could opt not to preserve folding.

The hidden code (obtained by selecting lines labelled 126-284 in the screenshot:

```
    // can share the same context menu instance.
    QMenu* addedContextMenu;
    QPointer<QMenu> lastShownMenu;
};

class TextDocumentPrivate
{
public:
    explicit TextDocumentPrivate(TextDocument *textDocument, ICore* core)
        : q(textDocument)
    {
        if (!contextMenuData) {
            contextMenuData = new TextDocumentContextMenuData(core->uiController()->activeMainWindow());
        }
    }

    ~TextDocumentPrivate()
    {
        saveSessionConfig();
        delete document;
    }

    void setStatus(KTextEditor::Document* document, bool dirty)
    {
        QIcon statusIcon;

        if (document->isModified())
            if (dirty) {
                state = IDocument::DirtyAndModified;
                statusIcon = QIcon::fromTheme(QStringLiteral("edit-delete"));
            } else {
                state = IDocument::Modified;
                statusIcon = QIcon::fromTheme(QStringLiteral("document-save"));
            }
        else
            if (dirty) {
                state = IDocument::Dirty;
                statusIcon = QIcon::fromTheme(QStringLiteral("document-revert"));
            } else {
                state = IDocument::Clean;
            }

        q->notifyStateChanged();
        Core::self()->uiControllerInternal()->setStatusIcon(q, statusIcon);
    }

    inline KConfigGroup katePartSettingsGroup() const
    {
        return KSharedConfig::openConfig()->group("KatePart Settings");
    }

    inline QString docConfigGroupName() const
    {
        return document->url().toDisplayString(QUrl::PreferLocalFile);
    }

    inline KConfigGroup docConfigGroup() const
    {
        return katePartSettingsGroup().group(docConfigGroupName());
    }

    void saveSessionConfig()
    {
        if(document && document->url().isValid()) {
            // make sure only MAX_DOC_SETTINGS entries are stored
            KConfigGroup katePartSettings = katePartSettingsGroup();
            // ordered list of documents
            QStringList documents = katePartSettings.readEntry("documents", QStringList());
            // ensure this document is "new", i.e. at the end of the list
            documents.removeOne(docConfigGroupName());
            documents.append(docConfigGroupName());
            // remove "old" documents + their group
            while(documents.size() >= MAX_DOC_SETTINGS) {
                katePartSettings.group(documents.takeFirst()).deleteGroup();
            }
            // update order
            katePartSettings.writeEntry("documents", documents);

            // actually save session config
            KConfigGroup group = docConfigGroup();
            document->writeSessionConfig(group);
        }
    }

    void loadSessionConfig()
    {
        if (!document || !katePartSettingsGroup().hasGroup(docConfigGroupName())) {
            return;
        }

        document->readSessionConfig(docConfigGroup(), {QStringLiteral("SkipUrl")});
    }

    // Determines whether the current contents of this document in the editor
    // could be retrieved from the VCS if they were dismissed.
    void queryCanRecreateFromVcs(KTextEditor::Document* document) const {
        IProject* project = nullptr;
        // Find projects by checking which one contains the file's parent directory,
        // to avoid issues with the cmake manager temporarily removing files from a project
        // during reloading.
        KDevelop::Path path(document->url());
        foreach ( KDevelop::IProject* current, Core::self()->projectController()->projects() ) {
            if ( current->path().isParentOf(path) ) {
                project = current;
                break;
            }
        }
        if (!project) {
            return;
        }
        IContentAwareVersionControl* iface;
        iface = qobject_cast< KDevelop::IContentAwareVersionControl* >(project->versionControlPlugin());
        if (!iface) {
            return;
        }
        if ( !qobject_cast<KTextEditor::ModificationInterface*>( document ) ) {
            return;
        }

        CheckInRepositoryJob* req = iface->isInRepository( document );
        if ( !req ) {
            return;
        }
        QObject::connect(req, &CheckInRepositoryJob::finished,
                            q, &TextDocument::repositoryCheckFinished);
        // Abort the request when the user edits the document
        QObject::connect(q->textDocument(), &KTextEditor::Document::textChanged,
                            req, &CheckInRepositoryJob::abort);
    }

    void modifiedOnDisk(KTextEditor::Document *document, bool /*isModified*/,
        KTextEditor::ModificationInterface::ModifiedOnDiskReason reason)
    {
        bool dirty = false;
        switch (reason)
        {
            case KTextEditor::ModificationInterface::OnDiskUnmodified:
                break;
            case KTextEditor::ModificationInterface::OnDiskModified:
            case KTextEditor::ModificationInterface::OnDiskCreated:
            case KTextEditor::ModificationInterface::OnDiskDeleted:
                dirty = true;
                break;
        }

        // In some cases, the VCS (e.g. git) can know whether the old contents are "valuable", i.e.
        // not retrieveable from the VCS. If that is not the case, then the document can safely be
        // reloaded without displaying a dialog asking the user.
        if ( dirty ) {
            queryCanRecreateFromVcs(document);
        }
        setStatus(document, dirty);
    }

    TextDocument * const q;

    QPointer<KTextEditor::Document> document;
    IDocument::DocumentState state = IDocument::Clean;
    QString encoding;
```

This should now be fixed (5.97).